SBK 10.7

What's new in SBK 10.7

SBK 10.7 is a measurement-integrity and object-storage benchmarking release.
It makes successful benchmark output substantially more trustworthy under
asynchronous completion and saturated shutdown, gives Dell ECS, ObjectScale,
MinIO, and other S3-compatible systems a deeper workload-control surface, and
keeps the successful record path focused on low latency and high throughput.

Highlight: results you can trust at the end of a run

Timed, asynchronous, and distributed benchmarks now preserve a stronger
end-to-end result contract.

• SBK quiesces writers and readers before PerL receives its terminal marker,
  allowing already accepted asynchronous completions to reach the recorder.
• PerL drains producer-quiesced queue shards before publishing Total; a
  terminal marker no longer causes queued measurements to be silently dropped.
• Timed Total duration remains the requested benchmark duration. Cleanup and
  terminal-marker processing no longer dilute reported throughput.
• A run cannot exit successfully without a clean final PerL completion. If the
  bounded cleanup deadline expires before final results are available, SBK
  exits nonzero rather than reporting an empty successful benchmark.
• Queue ownership remains correct during bounded shutdown: lifecycle code no
  longer clears a live MPSC queue owned by the recorder consumer.
• Normal File driver shutdown is recognized correctly when Java reports
  ClosedByInterruptException after clearing the interrupt flag.

These improvements address the cases that matter most in production: a
backend may complete requests late, a client may be saturated, and shutdown
may race with in-flight I/O. A successful SBK 10.7 run now has a stronger
guarantee that its final measurements were actually recorded.

Highlight: complete S3 and ECS/ObjectScale benchmark controls

The MinIO driver is now a broad S3-compatible benchmark engine, validated
against multi-node Dell ECS/ObjectScale clusters while retaining a minimal
write/read hot path.

• Endpoint pools are validated strictly, credentials cannot be embedded in
  endpoint URLs, and optional all-endpoint preflight identifies a bad node
  before timing starts.
• Endpoint metrics report operation, byte, retry, and failure distribution,
  making round-robin node coverage visible in a clustered run.
• PUT, GET, verified GET, range GET, COPY, STAT, DELETE, tagging, multipart,
  versioning, checksums, request headers, and bucket lifecycle workflows are
  available with explicit validation.
• Range reads support fixed, sequential, and deterministic random aligned
  offsets. LIST workloads support V1/V2, delimiter, start-after/marker,
  owner, metadata, and entry-limit controls.
• Real S3 workload mixes reject duplicate operations and validate finite
  catalog and producer/consumer requirements before a run can stall.
• Mixed reads default to the prepared catalog. The old published-object mode
  is rejected because it can wait indefinitely when writers finish first.
• Retry scheduling provides capped exponential backoff with full jitter, while
  retry totals are surfaced without adding per-success bookkeeping.
• Run manifests are valid JSON and deliberately exclude endpoint URLs,
  credentials, and extra-header values.

The driver also corrects CRC-64/NVME initialization and finalization. Backends
that validate this checksum now accept -checksum crc64nvme writes correctly.

Highlight: accurate metadata and low-rate measurements

Several silent measurement errors are corrected across the framework.

• LIST operations no longer report listed object payload sizes as transferred
  bytes. Metadata benchmarks now report zero object-content bytes rather than
  fabricated bandwidth.
• Byte conversion constants correctly define a GiB, preventing oversized CSV
  rotation limits and incorrect memory-size display.
• Throughput and aggregate-record targets that would truncate below one record
  per worker are rejected instead of silently becoming unlimited saturation.
• Boolean and thread-mode arguments are parsed strictly, so misspellings no
  longer quietly change benchmark behavior.
• CSV numeric output uses a locale-independent decimal separator, preserving
  the header/data column contract in comma-decimal locales.
• Pending request reporting no longer produces negative read/write values, and
  read pending record/byte fields are emitted in their intended order.

Highlight: exact latency recording with transparent trade-offs

SBK continues to retain exact latency values rather than sampling them. 10.7
adds repeatable JMH evidence rather than making unqualified performance claims.

• The PerL benchmark matrix compares exact array and primitive-map recorders
  with HdrHistogram across sequential and clustered-lognormal workloads and
  from 32 KiB through 32 MiB latency ranges.
• The documentation states the public-API lifecycle difference explicitly:
  PerL extracts configured percentiles and clears occupied array slots in one
  traversal, while normal HdrHistogram use asks for each percentile separately.
• The results identify the real crossover: dense exact arrays are excellent
  for narrow, cache-resident ranges, while HdrHistogram has bounded-footprint
  advantages at broad clustered ranges. The task reports evidence; it does not
  conflate performance with the semantic difference between exact retention
  and quantization.
• PerL and queue microbenchmarks remain available to protect record-path
  latency, allocation, and producer throughput.

Highlight: safe, driver-scoped containers

SBK containers are opt-in and can be built for one selected driver rather than
shipping every enabled SDK.

• prepareContainerBuild produces a deterministic, driver-scoped build
  context and explicit target-to-role/driver mappings.
• Buildx Bake builds SBK, SBM, SBK-YAL, and SBK-GEM-YAL images from that
  context. The standard build, check, release qualification, and publication
  paths remain container-independent.
• JRE bases are used where a compiler is not required; the GEM controller uses
  the JDK base required for remote Java provisioning modules.
• Image entrypoints validate allowed roles and installed launchers, preserve
  a source-archive-friendly revision fallback, and document shutdown behavior
  accurately.

Highlight: lifecycle resilience from client to SBM and GEM

• SBM drains all queue shards before stopping its consumer and fails bounded
  cleanup rather than silently discarding queued aggregate measurements.
• SBM control-plane callbacks run outside its service monitor, avoiding a slow
  registering client blocking other lifecycle operations.
• PerL executors are closed on orderly completion; recorder shutdown is
  bounded and interruption-aware.
• SBK-GEM preserves remote deployment and benchmark lifecycle diagnostics,
  while normal distributed result output distinguishes complete and failed
  node sets clearly.
• Callback-based readers retain their callback control model; unsupported
  rate-controlled combinations are not silently accepted as valid pacing.

Engineering quality and contributor safeguards

• docs/HOT_PATHS.md is an enforced inventory of per-operation,
  per-measurement, per-window, and lifecycle-critical code paths across PerL,
  SBK, SBM, and SBK-GEM.
• Every supported agent entry point routes contributors to the hot-path policy.
  Changes that add coordination, branching, allocations, or dispatch work to
  the successful record path require explicit developer approval and measured
  evidence.
• Gradle verifies documentation routing, generated artifact packaging, and
  sensitivity-map coverage so guidance cannot silently drift.
• New regression, stress, and release-functional coverage protects queue
  lifecycle ownership, final-result publication, File EOF behavior, shutdown
  interruption handling, generated documentation, and S3 correctness.

Compatibility notes

• JDK 25 remains the required build and runtime baseline.
• SBP remains at major version 4. Distributed SBK clients and SBM must use
  compatible protocol versions.
• MinIO SDK 8.5.17 remains pinned for compatibility with older ECS,
  ObjectScale, and Ceph S3 implementations. Do not upgrade to MinIO SDK 9.x
  without backend compatibility validation.
• MinIO endpoint configuration is pool-based; obsolete endpoint aliases are
  rejected rather than accepted ambiguously.
• -mixed-read-source published is intentionally unavailable because it can
  produce an unbounded reader stall. Use the default catalog source.
• A nonzero exit status means benchmark cleanup or a worker failed. Do not use
  a Total line from a failed run as an accepted performance result.

Installation

1. Download sbk-10.7.tar or sbk-10.7.zip from this release.
2. Verify the archive against SHA256SUMS.
3. Extract it, for example: tar -xvf sbk-10.7.tar.
4. Run <extracted-directory>/bin/sbk -help.

Standalone SBM and SBK Web Console archives are attached. Container users can
pull kmgowda/sbk:10.7 or ghcr.io/kmgowda/sbk:10.7 after publication.

Included pull requests

• #501 Harden bounded SBK shutdown lifecycle
• #502 Consolidate MinIO endpoint configuration
• #503 Harden MinIO S3 performance workloads
• #504 Preserve forced-shutdown result integrity
• #505 Document MinIO ECS/ObjectScale benchmark operations
• #506 Add driver-scoped Docker builds
• #507 Harden MinIO benchmark configuration
• #508 Complete MinIO S3 benchmark controls
• #509 Benchmark PerL percentiles against HdrHistogram
• #510 Correct byte units and callback controls
• #511 Harden benchmark configuration and lifecycle
• #512 Preserve core benchmark result integrity
• #513 Document hot-path agent guardrails
• #514 Strengthen core result-integrity coverage
• #515 Preserve end-to-end benchmark result conservation

Full changelog: v10.6...v10.7