Introduce Mode enum (NON_VIRTUAL_NETTY, REACTIVE, VIRTUAL_NETTY, NETTY_SCHEDULER), add mockless mode, and simplify benchmark runner configuration

Author: franz1981

benchmark-runner/README.md

@@ -64,10 +64,9 @@ All configuration is via environment variables:
 |----------|---------|-------------|
 | `SERVER_PORT` | 8081 | Server port |
 | `SERVER_THREADS` | 2 | Number of event loop threads |
-| `SERVER_REACTIVE` | false | Use reactive handler with Reactor |
-| `SERVER_USE_CUSTOM_SCHEDULER` | false | Use custom Netty scheduler |
+| `SERVER_MODE` | NON_VIRTUAL_NETTY | Server mode: NON_VIRTUAL_NETTY, REACTIVE, VIRTUAL_NETTY, NETTY_SCHEDULER |
+| `SERVER_MOCKLESS` | false | Skip mock server; do Jackson work inline |
 | `SERVER_IO` | epoll | I/O type: epoll, nio, or io_uring |
-| `SERVER_NO_TIMEOUT` | false | Disable HTTP client timeout |
 | `SERVER_TASKSET` | 2,3 | CPU affinity (e.g., "2-5") |
 | `SERVER_JVM_ARGS` | | Additional JVM arguments |
 | `SERVER_POLLER_MODE` | 3 | jdk.pollerMode value: 1, 2, or 3 |
@@ -153,17 +152,16 @@ perf stat uses `PROFILING_DELAY_SECONDS` and `PROFILING_DURATION_SECONDS`.
 
 ## Example Runs
 
-### Basic comparison: custom vs default scheduler
+### Basic comparison: modes
 
 ```bash
-# With custom scheduler
+# Custom scheduler mode
 JAVA_HOME=/path/to/jdk \
-SERVER_USE_CUSTOM_SCHEDULER=true \
+SERVER_MODE=NETTY_SCHEDULER \
 ./run-benchmark.sh
 
-# With default scheduler  
+# Default split topology
 JAVA_HOME=/path/to/jdk \
-SERVER_USE_CUSTOM_SCHEDULER=false \
 ./run-benchmark.sh
 ```
 
@@ -175,7 +173,7 @@ MOCK_TASKSET="0" \
 SERVER_TASKSET="1-4" \
 LOAD_GEN_TASKSET="5-7" \
 SERVER_THREADS=4 \
-SERVER_USE_CUSTOM_SCHEDULER=true \
+SERVER_MODE=NETTY_SCHEDULER \
 ./run-benchmark.sh
 ```
 
@@ -186,7 +184,7 @@ JAVA_HOME=/path/to/jdk \
 ENABLE_PROFILER=true \
 ASYNC_PROFILER_PATH=/path/to/async-profiler \
 PROFILER_EVENT=cpu \
-SERVER_USE_CUSTOM_SCHEDULER=true \
+SERVER_MODE=NETTY_SCHEDULER \
 WARMUP_DURATION=15s \
 TOTAL_DURATION=45s \
 ./run-benchmark.sh
@@ -198,7 +196,7 @@ TOTAL_DURATION=45s \
 JAVA_HOME=/path/to/jdk \
 ENABLE_JFR=true \
 JFR_EVENTS=NettyRunIo,VirtualThreadTaskRuns \
-SERVER_USE_CUSTOM_SCHEDULER=true \
+SERVER_MODE=NETTY_SCHEDULER \
 ./run-benchmark.sh
 ```
 
@@ -213,6 +211,15 @@ WARMUP_DURATION=15s \
 ./run-benchmark.sh
 ```
 
+### Netty on ForkJoinPool mode
+
+```bash
+JAVA_HOME=/path/to/jdk \
+SERVER_MODE=VIRTUAL_NETTY \
+SERVER_THREADS=2 \
+./run-benchmark.sh
+```
+
 ### With pidstat monitoring
 
 ```bash
@@ -260,7 +267,7 @@ java -cp benchmark-runner/target/benchmark-runner.jar \
   8080 1    # port, thinkTimeMs (threads defaults to available processors)
 ```
 
-### Handoff Server (with custom scheduler)
+### Handoff Server (custom scheduler mode)
 
 ```bash
 java \
@@ -275,11 +282,11 @@ java \
   --port 8081 \
   --mock-url http://localhost:8080/fruits \
   --threads 2 \
-  --use-custom-scheduler true \
+  --mode netty_scheduler \
   --io epoll
 ```
 
-### Handoff Server (with default scheduler)
+### Handoff Server (default split topology)
 
 ```bash
 java \
@@ -292,6 +299,5 @@ java \
   --port 8081 \
   --mock-url http://localhost:8080/fruits \
   --threads 2 \
-  --use-custom-scheduler false \
   --io epoll
 ```

benchmark-runner/scripts/run-benchmark.sh

@@ -30,14 +30,14 @@ MOCK_TASKSET="${MOCK_TASKSET:-4,5}"  # CPUs for mock server
 # Handoff server configuration
 SERVER_PORT="${SERVER_PORT:-8081}"
 SERVER_THREADS="${SERVER_THREADS:-2}"
-SERVER_USE_CUSTOM_SCHEDULER="${SERVER_USE_CUSTOM_SCHEDULER:-false}"
 SERVER_IO="${SERVER_IO:-epoll}"
 SERVER_TASKSET="${SERVER_TASKSET:-2,3}"  # CPUs for handoff server
 SERVER_JVM_ARGS="${SERVER_JVM_ARGS:-}"
-SERVER_POLLER_MODE="${SERVER_POLLER_MODE:-3}"  # jdk.pollerMode value (1, 2, or 3)
+SERVER_POLLER_MODE="${SERVER_POLLER_MODE:-}"  # jdk.pollerMode value (1, 2, or 3); empty = JVM default, NETTY_SCHEDULER defaults to 3
 SERVER_FJ_PARALLELISM="${SERVER_FJ_PARALLELISM:-}"  # ForkJoinPool parallelism (empty = JVM default)
-SERVER_NO_TIMEOUT="${SERVER_NO_TIMEOUT:-false}"  # Disable HTTP client timeout
-SERVER_REACTIVE="${SERVER_REACTIVE:-false}"  # Use reactive handler with Project Reactor
+SERVER_FJ_AFFINITY="${SERVER_FJ_AFFINITY:-false}"  # ForkJoinPool virtual thread scheduler affinity
+SERVER_MODE="${SERVER_MODE:-NON_VIRTUAL_NETTY}"  # Server mode: NON_VIRTUAL_NETTY, REACTIVE, VIRTUAL_NETTY
+SERVER_MOCKLESS="${SERVER_MOCKLESS:-false}"  # Skip mock server; do Jackson work inline
 
 # Load generator configuration
 LOAD_GEN_TASKSET="${LOAD_GEN_TASKSET:-0,1}"  # CPUs for load generator
@@ -57,6 +57,7 @@ PROFILING_DURATION_SECONDS="${PROFILING_DURATION_SECONDS:-10}"
 # Profiling configuration
 ENABLE_PROFILER="${ENABLE_PROFILER:-false}"
 PROFILER_EVENT="${PROFILER_EVENT:-cpu}"
+PROFILER_FORMAT="${PROFILER_FORMAT:-flamegraph}"  # Output format: flamegraph, collapsed, jfr
 PROFILER_OUTPUT="${PROFILER_OUTPUT:-profile.html}"
 ASYNC_PROFILER_PATH="${ASYNC_PROFILER_PATH:-}"  # Path to async-profiler
 
@@ -382,15 +383,27 @@ start_handoff_server() {
     jvm_args="$jvm_args -XX:-DoJVMTIVirtualThreadTransitions"
     jvm_args="$jvm_args -Djdk.trackAllThreads=false"
 
-    if [[ "$SERVER_USE_CUSTOM_SCHEDULER" == "true" ]]; then
-        jvm_args="$jvm_args -Djdk.virtualThreadScheduler.implClass=io.netty.loom.NettyScheduler"
-        jvm_args="$jvm_args -Djdk.pollerMode=$SERVER_POLLER_MODE"
+    # Mode-specific JVM args
+    local poller_mode="$SERVER_POLLER_MODE"
+    case "$SERVER_MODE" in
+        NETTY_SCHEDULER)
+            jvm_args="$jvm_args -Djdk.virtualThreadScheduler.implClass=io.netty.loom.NettyScheduler"
+            # Default pollerMode to 3 for custom scheduler if not explicitly set
+            poller_mode="${poller_mode:-3}"
+            ;;
+    esac
+
+    # Apply pollerMode if set (explicitly or via mode default)
+    if [[ -n "$poller_mode" ]]; then
+        jvm_args="$jvm_args -Djdk.pollerMode=$poller_mode"
     fi
 
     if [[ -n "$SERVER_FJ_PARALLELISM" ]]; then
         jvm_args="$jvm_args -Djdk.virtualThreadScheduler.parallelism=$SERVER_FJ_PARALLELISM"
     fi
 
+    jvm_args="$jvm_args -Djdk.virtualThreadScheduler.affinity=$SERVER_FJ_AFFINITY"
+
     # Add debug non-safepoints if profiling is enabled
     if [[ "$ENABLE_PROFILER" == "true" ]]; then
         jvm_args="$jvm_args -XX:+UnlockDiagnosticVMOptions"
@@ -402,15 +415,19 @@ start_handoff_server() {
         jvm_args="$jvm_args $SERVER_JVM_ARGS"
     fi
 
+    local mockless_flag=""
+    if [[ "$SERVER_MOCKLESS" == "true" ]]; then
+        mockless_flag="--mockless"
+    fi
+
     local cmd="$taskset_cmd $java_cmd $JAVA_OPTS $jvm_args -cp $RUNNER_JAR \
         io.netty.loom.benchmark.runner.HandoffHttpServer \
         --port $SERVER_PORT \
         --mock-url http://localhost:$MOCK_PORT/fruits \
         --threads $SERVER_THREADS \
-        --use-custom-scheduler $SERVER_USE_CUSTOM_SCHEDULER \
         --io $SERVER_IO \
-        --no-timeout $SERVER_NO_TIMEOUT \
-        --reactive $SERVER_REACTIVE \
+        --mode $SERVER_MODE \
+        $mockless_flag \
         --silent"
 
     log "Handoff server command: $cmd"
@@ -467,7 +484,8 @@ start_profiler() {
 
     (
         sleep "$PROFILING_DELAY_SECONDS"
-        "$asprof" --threads -e "$PROFILER_EVENT" -o flamegraph -d "$PROFILING_DURATION_SECONDS" -f "$output_file" "$SERVER_PID"
+        # --record-cpu
+        "$asprof" --threads -e "$PROFILER_EVENT" -o "$PROFILER_FORMAT" -d "$PROFILING_DURATION_SECONDS" -f "$output_file" "$SERVER_PID"
     ) &
     PROFILER_PID=$!
 
@@ -700,12 +718,12 @@ print_config() {
     log "Handoff Server:"
     log "  Port:           $SERVER_PORT"
     log "  Threads:        $SERVER_THREADS"
-    log "  Reactive:       $SERVER_REACTIVE"
-    log "  Custom Sched:   $SERVER_USE_CUSTOM_SCHEDULER"
+    log "  Mode:           $SERVER_MODE"
+    log "  Mockless:       $SERVER_MOCKLESS"
     log "  I/O Type:       $SERVER_IO"
-    log "  No Timeout:     $SERVER_NO_TIMEOUT"
     log "  Poller Mode:    $SERVER_POLLER_MODE"
     log "  FJ Parallelism: ${SERVER_FJ_PARALLELISM:-<default>}"
+    log "  FJ Affinity:    $SERVER_FJ_AFFINITY"
     log "  CPU Affinity:   ${SERVER_TASKSET:-<none>}"
     log "  Extra JVM Args: ${SERVER_JVM_ARGS:-<none>}"
     log ""
@@ -786,14 +804,14 @@ Mock Server:
 Handoff Server:
   SERVER_PORT               Server port (default: 8081)
   SERVER_THREADS            Number of event loop threads (default: 2)
-  SERVER_REACTIVE           Use reactive handler with Reactor (default: false)
-  SERVER_USE_CUSTOM_SCHEDULER  Use custom Netty scheduler (default: false)
+  SERVER_MODE               Server mode: NON_VIRTUAL_NETTY, REACTIVE, VIRTUAL_NETTY, NETTY_SCHEDULER (default: NON_VIRTUAL_NETTY)
+  SERVER_MOCKLESS           Skip mock server; do Jackson work inline (default: false)
   SERVER_IO                 I/O type: epoll, nio, or io_uring (default: epoll)
-  SERVER_NO_TIMEOUT         Disable HTTP client timeout (default: false)
   SERVER_TASKSET            CPU affinity range (default: "2,3")
   SERVER_JVM_ARGS           Additional JVM arguments
   SERVER_POLLER_MODE        jdk.pollerMode value: 1, 2, or 3 (default: 3)
   SERVER_FJ_PARALLELISM     ForkJoinPool parallelism (empty = JVM default)
+  SERVER_FJ_AFFINITY        ForkJoinPool scheduler affinity (default: false)
 
 Load Generator:
   LOAD_GEN_CONNECTIONS      Number of connections (default: 100)
@@ -847,8 +865,8 @@ General:
 
 Examples:
 
-  # Basic run with custom scheduler
-  JAVA_HOME=/path/to/jdk SERVER_USE_CUSTOM_SCHEDULER=true ./run-benchmark.sh
+  # Custom scheduler mode
+  JAVA_HOME=/path/to/jdk SERVER_MODE=NETTY_SCHEDULER ./run-benchmark.sh
 
   # Run with CPU pinning and profiling
   JAVA_HOME=/path/to/jdk \
@@ -866,12 +884,24 @@ Examples:
   WARMUP_DURATION=15s \
   ./run-benchmark.sh
 
-  # Reactive handler test
+  # Reactive mode
+  JAVA_HOME=/path/to/jdk \
+  SERVER_MODE=REACTIVE \
+  SERVER_THREADS=2 \
+  ./run-benchmark.sh
+
+  # Netty on ForkJoinPool mode
   JAVA_HOME=/path/to/jdk \
-  SERVER_REACTIVE=true \
+  SERVER_MODE=VIRTUAL_NETTY \
   SERVER_THREADS=2 \
   ./run-benchmark.sh
 
+  # Mockless mode (no mock server, inline Jackson work)
+  JAVA_HOME=/path/to/jdk \
+  SERVER_MODE=VIRTUAL_NETTY \
+  SERVER_MOCKLESS=true \
+  SERVER_THREADS=2 \
+  ./run-benchmark.sh
 EOF
                 exit 0
                 ;;
@@ -898,7 +928,11 @@ EOF
     build_jars
 
     # Start servers
-    start_mock_server
+    if [[ "$SERVER_MOCKLESS" != "true" ]]; then
+        start_mock_server
+    else
+        log "Mockless mode: skipping mock server"
+    fi
     start_handoff_server
 
     # Run warmup (no profiling/pidstat)