CopyMode enum must be public

Author: sbSteveK

runners/s3-benchrunner-java/src/main/java/com/example/s3benchrunner/Main.java

@@ -5,7 +5,6 @@
 
 import com.example.s3benchrunner.crtjava.CRTJavaBenchmarkRunner;
 import com.example.s3benchrunner.ffmjava.FFMJavaBenchmarkRunner;
-import com.example.s3benchrunner.ffmjava.FFMJavaTask;
 import com.example.s3benchrunner.sdkjava.SDKJavaBenchmarkRunner;
 
 public class Main {
@@ -75,11 +74,11 @@ public static void main(String[] args) throws Exception {
             // FFM with explicit copy to GC-managed byte[] — simulates an app that needs
             // a Java-owned copy of downloaded data (same destination as JNI, but via FFM)
             case "ffm-java-copy-heap" -> new FFMJavaBenchmarkRunner(config, bucket, region, targetThroughputGbps,
-                    FFMJavaTask.CopyMode.HEAP_COPY);
+                    FFMJavaBenchmarkRunner.CopyMode.HEAP_COPY);
             // FFM with explicit copy to pre-allocated off-heap MemorySegment — simulates
             // an app that needs an owned copy but wants to avoid GC pressure entirely
             case "ffm-java-copy-offheap" -> new FFMJavaBenchmarkRunner(config, bucket, region, targetThroughputGbps,
-                    FFMJavaTask.CopyMode.OFFHEAP_COPY);
+                    FFMJavaBenchmarkRunner.CopyMode.OFFHEAP_COPY);
             case "sdk-java-client-crt" ->
                 new SDKJavaBenchmarkRunner(config, bucket, region, targetThroughputGbps, false, true);
             case "sdk-java-tm-crt" ->

runners/s3-benchrunner-java/src/main/java/com/example/s3benchrunner/ffmjava/FFMJavaBenchmarkRunner.java

@@ -31,6 +31,21 @@
  */
 public class FFMJavaBenchmarkRunner extends BenchmarkRunner {
 
+    /**
+     * Controls what happens with downloaded data in the FFM response body callback.
+     * Exposed as a public nested enum so that {@code Main.java} (in a different
+     * package) can reference it without needing access to the package-private
+     * {@code FFMJavaTask} class.
+     */
+    public enum CopyMode {
+        /** Discard data immediately — zero-copy, no allocation. */
+        NONE,
+        /** Copy into a GC-managed {@code byte[]} on every callback. */
+        HEAP_COPY,
+        /** Copy into a pre-allocated off-heap {@link java.lang.foreign.MemorySegment}. */
+        OFFHEAP_COPY,
+    }
+
     // CRT boilerplate
     EventLoopGroup eventLoopGroup;
     HostResolver hostResolver;
@@ -43,14 +58,14 @@ public class FFMJavaBenchmarkRunner extends BenchmarkRunner {
     String endpoint;
 
     // Controls what happens with downloaded data in the response body callback
-    FFMJavaTask.CopyMode copyMode;
+    CopyMode copyMode;
 
     public FFMJavaBenchmarkRunner(BenchmarkConfig config, String bucket, String region, double targetThroughputGbps) {
-        this(config, bucket, region, targetThroughputGbps, FFMJavaTask.CopyMode.NONE);
+        this(config, bucket, region, targetThroughputGbps, CopyMode.NONE);
     }
 
     public FFMJavaBenchmarkRunner(BenchmarkConfig config, String bucket, String region, double targetThroughputGbps,
-            FFMJavaTask.CopyMode copyMode) {
+            CopyMode copyMode) {
 
         super(config, bucket, region);
 

runners/s3-benchrunner-java/src/main/java/com/example/s3benchrunner/ffmjava/FFMJavaTask.java

@@ -32,38 +32,25 @@
  *       object allocation).</li>
  * </ul>
  * <p>
- * The {@link CopyMode} controls what happens with downloaded data in the
- * response body callback:
+ * The {@link FFMJavaBenchmarkRunner.CopyMode} controls what happens with
+ * downloaded data in the response body callback:
  * <ul>
- *   <li>{@link CopyMode#NONE} — data is discarded (zero-copy, benchmark
- *       measures pure download throughput with no data processing)</li>
- *   <li>{@link CopyMode#HEAP_COPY} — data is copied into a GC-managed
- *       {@code byte[]} (simulates an application that needs a Java-owned copy)</li>
- *   <li>{@link CopyMode#OFFHEAP_COPY} — data is copied into a pre-allocated
- *       off-heap {@link MemorySegment} (simulates an application that needs an
- *       owned copy but wants to avoid GC pressure)</li>
+ *   <li>{@link FFMJavaBenchmarkRunner.CopyMode#NONE} — data is discarded
+ *       (zero-copy, benchmark measures pure download throughput)</li>
+ *   <li>{@link FFMJavaBenchmarkRunner.CopyMode#HEAP_COPY} — data is copied
+ *       into a GC-managed {@code byte[]}</li>
+ *   <li>{@link FFMJavaBenchmarkRunner.CopyMode#OFFHEAP_COPY} — data is copied
+ *       into a pre-allocated off-heap {@link MemorySegment}</li>
  * </ul>
  */
 class FFMJavaTask implements S3MetaRequestResponseHandler {
 
-    /**
-     * Controls what happens with downloaded data in the response body callback.
-     */
-    enum CopyMode {
-        /** Discard data immediately — zero-copy, no allocation. */
-        NONE,
-        /** Copy into a GC-managed {@code byte[]} on every callback. */
-        HEAP_COPY,
-        /** Copy into a pre-allocated off-heap {@link MemorySegment}. */
-        OFFHEAP_COPY,
-    }
-
     FFMJavaBenchmarkRunner runner;
     int taskI;
     TaskConfig config;
     S3MetaRequest metaRequest;
     CompletableFuture<Void> doneFuture;
-    final CopyMode copyMode;
+    final FFMJavaBenchmarkRunner.CopyMode copyMode;
 
     /**
      * Pre-allocated off-heap buffer for {@link CopyMode#OFFHEAP_COPY}.
@@ -73,15 +60,15 @@ enum CopyMode {
     private final MemorySegment offheapCopyBuffer;
     private static final long OFFHEAP_BUFFER_SIZE = 8L * 1024 * 1024; // 8 MiB
 
-    FFMJavaTask(FFMJavaBenchmarkRunner runner, int taskI, CopyMode copyMode) {
+    FFMJavaTask(FFMJavaBenchmarkRunner runner, int taskI, FFMJavaBenchmarkRunner.CopyMode copyMode) {
         this.runner = runner;
         this.taskI = taskI;
         this.config = runner.config.tasks.get(taskI);
         this.copyMode = copyMode;
         doneFuture = new CompletableFuture<Void>();
 
         // Pre-allocate off-heap buffer if needed
-        if (copyMode == CopyMode.OFFHEAP_COPY) {
+        if (copyMode == FFMJavaBenchmarkRunner.CopyMode.OFFHEAP_COPY) {
             offheapCopyBuffer = Arena.ofAuto().allocate(OFFHEAP_BUFFER_SIZE);
         } else {
             offheapCopyBuffer = null;