Perf test - try in windows runners

.github/workflows/pipeline-perf-test-windows.yml

@@ -0,0 +1,138 @@
+name: Pipeline Performance Tests - Windows
+permissions:
+  contents: read
+
+on:
+  pull_request:
+    paths:
+      - '.github/workflows/pipeline-perf-test-windows.yml'
+      - 'rust/otap-dataflow/**'
+      - 'tools/pipeline_perf_test/**'
+  workflow_dispatch:
+
+jobs:
+  pipeline-perf-test-windows:
+    runs-on: windows-latest
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@a90bcbc6539c36a85cdfeb73f7e2f433735f215b # v2.15.0
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          submodules: true
+
+      - name: Free disk space
+        shell: pwsh
+        run: |
+          Write-Host "disk usage before"
+          Get-PSDrive -PSProvider FileSystem | Select-Object Name, @{Name='Used(GB)';Expression={[math]::Round($_.Used/1GB,2)}}, @{Name='Free(GB)';Expression={[math]::Round($_.Free/1GB,2)}}
+          if (Test-Path "C:\Android") { Remove-Item -Recurse -Force "C:\Android" }
+          if (Test-Path "C:\SeleniumWebDrivers") { Remove-Item -Recurse -Force "C:\SeleniumWebDrivers" }
+          if (Test-Path "C:\imagemagick") { Remove-Item -Recurse -Force "C:\imagemagick" }
+          Write-Host "disk usage after"
+          Get-PSDrive -PSProvider FileSystem | Select-Object Name, @{Name='Used(GB)';Expression={[math]::Round($_.Used/1GB,2)}}, @{Name='Free(GB)';Expression={[math]::Round($_.Free/1GB,2)}}
+
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Start Docker service
+        shell: pwsh
+        run: |
+          Start-Service docker
+          docker info
+
+      - uses: dtolnay/rust-toolchain@efa25f7f19611383d5b0ccf2d1c8914531636bf9
+        with:
+          toolchain: stable
+
+      - name: Build df_engine.exe
+        shell: pwsh
+        working-directory: ./rust/otap-dataflow
+        run: cargo build --release --features mimalloc
+        env:
+          RUSTFLAGS: "-C target-cpu=native -C target-feature=+crt-static"
+
+      - name: Build Windows Docker image
+        shell: pwsh
+        working-directory: ./rust/otap-dataflow
+        run: docker build -f Dockerfile.windows -t df_engine_win .
+
+      - name: Verify Docker image
+        shell: pwsh
+        run: |
+          docker images df_engine_win
+          docker run --rm df_engine_win --version
+
+      - name: Install Python dependencies
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        run: |
+          # Use plain requirements.txt (not .lock.txt) on Windows because the
+          # lock files contain --hash directives that trigger pip hash-checking
+          # mode, which rejects the Windows-only transitive dep pywin32 (not in
+          # the Linux-generated lock file).
+          python -m pip install --user -r tools/pipeline_perf_test/orchestrator/requirements.txt
+          python -m pip install --user -r tools/pipeline_perf_test/load_generator/requirements.txt
+
+      - name: Run idle state test (1 core)
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        run: |
+          cd tools/pipeline_perf_test
+          python orchestrator/run_orchestrator.py --config test_suites/integration/nightly-windows/idle-state-docker.yaml
+
+      - name: Run idle state test (2 cores)
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        run: |
+          cd tools/pipeline_perf_test
+          python orchestrator/run_orchestrator.py --config test_suites/integration/nightly-windows/idle-state-2cores-docker.yaml
+
+      - name: Run idle state test (4 cores)
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        run: |
+          cd tools/pipeline_perf_test
+          python orchestrator/run_orchestrator.py --config test_suites/integration/nightly-windows/idle-state-4cores-docker.yaml
+
+      - name: Analyze memory scaling
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        env:
+          PYTHONUTF8: "1"
+        run: |
+          python .github/workflows/scripts/analyze-idle-state-scaling.py `
+            tools/pipeline_perf_test/results `
+            tools/pipeline_perf_test/results/windows-idle-memory-scaling.json `
+            | Tee-Object -Variable scalingReport
+          # Add to job summary
+          echo "### Windows Idle State Memory Scaling Analysis" >> $env:GITHUB_STEP_SUMMARY
+          echo '```' >> $env:GITHUB_STEP_SUMMARY
+          $scalingReport >> $env:GITHUB_STEP_SUMMARY
+          echo '```' >> $env:GITHUB_STEP_SUMMARY
+
+      - name: Run 100kLRPS OTLP-OTLP test
+        if: ${{ !cancelled() }}
+        shell: pwsh
+        run: |
+          cd tools/pipeline_perf_test
+          python orchestrator/run_orchestrator.py --config test_suites/integration/nightly-windows/100klrps-docker.yaml
+
+      - name: Upload idle state results
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: windows-idle-state-results
+          path: |
+            tools/pipeline_perf_test/results/windows_idle_state_*/gh-actions-benchmark/*.json
+            tools/pipeline_perf_test/results/windows-idle-memory-scaling.json
+
+      - name: Upload 100kLRPS results
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: windows-100klrps-results
+          path: tools/pipeline_perf_test/results/windows_100klrps/gh-actions-benchmark/*.json

.github/workflows/scripts/analyze-idle-state-scaling.py

@@ -262,11 +262,11 @@ def main():
     # Find idle state result directories
     memory_data: dict[int, float] = {}
 
-    # Look for directories matching idle_state_* pattern
-    idle_dirs = list(results_base.glob("idle_state_*"))
+    # Look for directories matching idle_state_* or windows_idle_state_* pattern
+    idle_dirs = list(results_base.glob("idle_state_*")) + list(results_base.glob("windows_idle_state_*"))
 
     if not idle_dirs:
-        print("No idle state test results found (looking for idle_state_* directories)", file=sys.stderr)
+        print("No idle state test results found (looking for *idle_state_* directories)", file=sys.stderr)
         sys.exit(0)
 
     print(f"Found {len(idle_dirs)} idle state result directories", file=sys.stderr)

rust/otap-dataflow/.dockerignore

@@ -1,4 +1,5 @@
 target
+!target/release/df_engine.exe
 Cargo.lock
 docs
 configs

rust/otap-dataflow/Dockerfile.windows

@@ -0,0 +1,23 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+
+# This Dockerfile packages a pre-built df_engine.exe into a Windows container.
+# The binary must be built on the host before building this image.
+#
+# Build steps from the rust/otap-dataflow directory:
+#   cargo build --release --features mimalloc
+#   docker build -f Dockerfile.windows -t df_engine_win .
+#
+# The binary is expected at target/release/df_engine.exe relative to the build
+# context (the rust/otap-dataflow directory).
+#
+# The base image tag must match the Windows version on the host. GitHub Actions
+# windows-latest uses Windows Server 2025 which requires ltsc2025.
+
+FROM mcr.microsoft.com/windows/servercore:ltsc2025
+
+WORKDIR C:\\dataflow
+
+COPY target/release/df_engine.exe C:/dataflow/df_engine.exe
+
+ENTRYPOINT ["C:\\dataflow\\df_engine.exe"]

tools/pipeline_perf_test/orchestrator/lib/impl/strategies/deployment/docker.py

@@ -276,6 +276,35 @@ def stop(self, component: Component, ctx: StepContext):
 # Helpers
 
 
+def _reassemble_drive_letter_parts(parts: List[str]) -> List[str]:
+    """Reassemble parts split on ':' that may contain Windows drive letters.
+
+    A Windows drive letter is a single alpha character immediately followed
+    (after the split) by a segment starting with '/' or '\\'.
+
+    Examples (after split on ':'):
+        ['host', 'C', '/container', 'ro']  ->  ['host', 'C:/container', 'ro']
+        ['C', '/host', 'C', '/container']  ->  ['C:/host', 'C:/container']
+        ['host', '/container', 'ro']       ->  ['host', '/container', 'ro']  (unchanged)
+    """
+    result: List[str] = []
+    i = 0
+    while i < len(parts):
+        if (
+            len(parts[i]) == 1
+            and parts[i].isalpha()
+            and i + 1 < len(parts)
+            and parts[i + 1][:1] in ("/", "\\")
+        ):
+            # Drive letter detected - merge with the following path segment.
+            result.append(parts[i] + ":" + parts[i + 1])
+            i += 2
+        else:
+            result.append(parts[i])
+            i += 1
+    return result
+
+
 def build_volume_bindings(
     volume_mounts: Optional[List[Union[str, DockerVolumeMapping]]],
 ) -> Dict[str, Dict[str, str]]:
@@ -291,7 +320,9 @@ def build_volume_bindings(
     for vm in volume_mounts:
         if isinstance(vm, str):
             # Parse string format: /host:/container[:ro|rw]
-            parts = vm.split(":")
+            # Also supports Windows drive-letter paths, e.g.
+            #   relative/host:C:/container/path:ro
+            parts = _reassemble_drive_letter_parts(vm.split(":"))
             if len(parts) < 2 or len(parts) > 3:
                 raise ValueError(f"Invalid volume mount string: '{vm}'")
 

tools/pipeline_perf_test/orchestrator/lib/impl/strategies/monitoring/docker_component.py

@@ -335,20 +335,32 @@ def monitor(
                     cpu_stats["cpu_usage"]["total_usage"]
                     - precpu_stats["cpu_usage"]["total_usage"]
                 )
-                system_delta = (
-                    cpu_stats["system_cpu_usage"] - precpu_stats["system_cpu_usage"]
-                )
 
                 cpu_usage = 0.0
-                if system_delta > 0.0 and cpu_delta > 0.0:
-                    num_cpus = (
-                        len(cpu_stats["cpu_usage"].get("percpu_usage", []))
-                        or cpu_stats["online_cpus"]
+                # Windows containers do not report system_cpu_usage.
+                # Use a time-based approximation instead.
+                if "system_cpu_usage" in cpu_stats:
+                    system_delta = (
+                        cpu_stats["system_cpu_usage"]
+                        - precpu_stats["system_cpu_usage"]
                     )
-                    cpu_usage = (cpu_delta / system_delta) * num_cpus
+                    if system_delta > 0.0 and cpu_delta > 0.0:
+                        num_cpus = (
+                            len(cpu_stats["cpu_usage"].get("percpu_usage", []))
+                            or cpu_stats.get("online_cpus", 1)
+                        )
+                        cpu_usage = (cpu_delta / system_delta) * num_cpus
+                else:
+                    # Windows: cpu_delta is in 100-nanosecond units.
+                    # Convert to number-of-cores over the poll interval.
+                    num_cpus = cpu_stats.get("online_cpus", 1)
+                    if cpu_delta > 0 and interval > 0:
+                        # 10_000_000 = 100-ns units per second
+                        cpu_usage = cpu_delta / (interval * 10_000_000)
 
                 # Memory usage in Bytes
-                mem_usage = stat_data["memory_stats"]["usage"]
+                mem_stats = stat_data.get("memory_stats", {})
+                mem_usage = mem_stats.get("usage", mem_stats.get("privateworkingset", 0))
                 cpu_usage_gauge.set(cpu_usage, labels)
                 memory_usage_gauge.set(mem_usage, labels)
 

tools/pipeline_perf_test/test_suites/integration/continuous/idle-state-template-windows.yaml.j2

@@ -0,0 +1,125 @@
+# Template for idle state performance test on Windows Docker containers.
+# This template is used to generate both single-core and full-cores tests.
+# Differences from the Linux template:
+#   - Uses df_engine_win:latest (Windows container image)
+#   - Volume mounts the config directory (Windows containers cannot bind-mount files)
+name: Continuous - Idle State Performance (Windows) - {{core_label}}
+components:
+  df-engine:
+    deployment:
+      docker:
+        image: df_engine_win:latest
+        network: testbed
+        ports:
+          - "{{port}}:8080"
+        volumes:
+          - 'test_suites/integration/configs/engine:C:/dataflow/config:ro'
+        command:
+          - "--config"
+          - "C:/dataflow/config/config.rendered.yaml"
+{% if core_range is defined %}
+          - "--core-id-range"
+          - "{{core_range}}"
+{% endif %}
+          - "--http-admin-bind"
+          - "0.0.0.0:8080"
+    monitoring:
+{% if allocated_cores is defined %}
+      docker_component:
+        allocated_cores: {{allocated_cores}}
+{% else %}
+      docker_component: {}
+{% endif %}
+      prometheus:
+        endpoint: http://localhost:{{port}}/telemetry/metrics?format=prometheus&reset=false
+
+tests:
+  - name: Idle State Baseline (Windows) - {{core_label}}
+    steps:
+      - name: Deploy Dataflow Engine
+        action:
+          component_action:
+            phase: deploy
+            target: df-engine
+        hooks:
+          run:
+            pre:
+              - render_template:
+                  template_path: 'test_suites/integration/templates/configs/engine/continuous/otlp-attr-otlp.yaml'
+                  output_path: ./test_suites/integration/configs/engine/config.rendered.yaml
+                  variables:
+                    backend_hostname: localhost
+            post:
+              - ready_check_http:
+                  url: http://localhost:{{port}}/telemetry/metrics?reset=false
+                  method: GET
+                  expected_status_code: 200
+                  max_retries: 30
+                  retry_interval: 2
+
+      - name: Wait for Startup Stabilization
+        action:
+          wait:
+            delay_seconds: 5
+        hooks:
+          run:
+            pre:
+              - record_event:
+                  name: stabilization_start
+            post:
+              - record_event:
+                  name: stabilization_complete
+
+      - name: Monitor Engine
+        action:
+          component_action:
+            phase: start_monitoring
+            target: df-engine
+
+      - name: Observe Idle State
+        action:
+          wait:
+            delay_seconds: 15
+        hooks:
+          run:
+            pre:
+              - record_event:
+                  name: observation_start
+            post:
+              - record_event:
+                  name: observation_stop
+
+      - name: Stop Monitoring
+        action:
+          component_action:
+            phase: stop_monitoring
+            target: df-engine
+
+      - name: Destroy Engine
+        action:
+          component_action:
+            phase: destroy
+            target: df-engine
+
+      - name: Run Report
+        action:
+          wait:
+            delay_seconds: 0
+        hooks:
+          run:
+            post:
+              - print_container_logs: {}
+              - sql_report:
+                  name: Idle State Performance Report (Windows) - {{core_label}}
+                  report_config_file: ./test_suites/integration/configs/idle_state_report.yaml
+                  output:
+                    - format:
+                        template: {}
+                      destination:
+                        console: {}
+                    - format:
+                        template:
+                          path: ./test_suites/integration/templates/reports/gh-action-sqlreport.j2
+                      destination:
+                        file:
+                          directory: results/windows_idle_state_{{result_subdir}}/gh-actions-benchmark