[foreign-memaccess+abi] RFR: Add test for resource scope acquire with bulk operation

[Maurizio Cimadamore]

This patch adds a test for a bulk segment mismatch inside an acquire block. This benchmark measures the relative overhead of the acquier operation, relative to the cost of the bulk mismatch. Results for large segments are as follows:


Benchmark                                           (scopeKind)  Mode  Cnt      Score     Error  Units
BulkMismatchAcquire.mismatch_large_segment             CONFINED  avgt   30  37662.474 ? 579.201  ns/op
BulkMismatchAcquire.mismatch_large_segment               SHARED  avgt   30  37583.186 ? 427.663  ns/op
BulkMismatchAcquire.mismatch_large_segment             IMPLICIT  avgt   30  37577.151 ? 474.734  ns/op
BulkMismatchAcquire.mismatch_large_segment_acquire     CONFINED  avgt   30  37801.227 ? 515.459  ns/op
BulkMismatchAcquire.mismatch_large_segment_acquire       SHARED  avgt   30  37159.676 ? 369.788  ns/op
BulkMismatchAcquire.mismatch_large_segment_acquire     IMPLICIT  avgt   30  37854.949 ? 464.150  ns/op


Here, we can see that the cost of the acquire is, in all cases, negligible, compared with the cost of the underlying bulk operation. We expect this to be the use case where resource scope handles are used the most.

For completeness, here's the same benchmark, but with a smaller segment size:


Benchmark                                           (scopeKind)  Mode  Cnt   Score   Error  Units
BulkMismatchAcquire.mismatch_small_segment             CONFINED  avgt   30   5.826 ? 0.091  ns/op
BulkMismatchAcquire.mismatch_small_segment               SHARED  avgt   30   5.160 ? 0.072  ns/op
BulkMismatchAcquire.mismatch_small_segment             IMPLICIT  avgt   30   5.274 ? 0.090  ns/op
BulkMismatchAcquire.mismatch_small_segment_acquire     CONFINED  avgt   30   7.386 ? 0.035  ns/op
BulkMismatchAcquire.mismatch_small_segment_acquire       SHARED  avgt   30  15.130 ? 0.649  ns/op
BulkMismatchAcquire.mismatch_small_segment_acquire     IMPLICIT  avgt   30   6.877 ? 0.083  ns/op


In this case, we see that for implicit and confined scope the cost is low; for shared segments we have a spike (which is related to the CAS logic in the shared handle). We believe this to be an acceptable compromise, and an unavoidable consequence of having true, deterministic shared segments.

In addition to adding the benchmark - the patch also does two other things:

* Fixes a bug in the NonCloseableScope::acquire logic (the polarity of the null check is wrong, and this was causing NPEs on the benchmark - whoops)
* Fixes the unrelated test issue with SpliteratorTest - this was also fixed by PR/494, but seeing that it's not converging, I'd like to get the tests fixed sooner rather than later

-------------

Commit messages:
 - Initial push

Changes: https://git.openjdk.java.net/panama-foreign/pull/503/files
 Webrev: https://webrevs.openjdk.java.net/?repo=panama-foreign&pr=503&range=00
  Stats: 175 lines in 3 files changed: 173 ins; 0 del; 2 mod
  Patch: https://git.openjdk.java.net/panama-foreign/pull/503.diff
  Fetch: git fetch https://git.openjdk.java.net/panama-foreign pull/503/head:pull/503

PR: https://git.openjdk.java.net/panama-foreign/pull/503