Merge pull request #689 from MDA2AV/site-echo-pipe

Add echo-ws-pipeline test

Author: MDA2AV

site/content/_index.md

@@ -68,7 +68,7 @@ html.dark .test-card-endpoint { color: #64748b; }
 </style>
 
 <div class="tests-section">
-<h2>27 Test Profiles Across H/1.1, H/2, H/3, gRPC and WebSocket</h2>
+<h2>28 Test Profiles Across H/1.1, H/2, H/3, gRPC and WebSocket</h2>
 <p class="tests-sub">Every framework is tested under diverse, realistic workloads — from raw throughput to JSON processing, gRPC unary calls, and WebSocket echo.</p>
 
 <div class="tests-proto">
@@ -245,6 +245,11 @@ html.dark .test-card-endpoint { color: #64748b; }
     <div class="test-card-desc">WebSocket echo throughput — upgrade, send pipelined text messages, receive echoes. Measures frame processing performance.</div>
     <div class="test-card-endpoint">WS /ws (echo)</div>
   </a>
+  <a class="test-card" href="docs/test-profiles/ws/echo-pipeline">
+    <div class="test-card-title">Echo Pipelined</div>
+    <div class="test-card-desc">Same WebSocket echo with 16 messages in flight per connection — measures frame batching and read-buffer draining under burst load.</div>
+    <div class="test-card-endpoint">WS /ws (echo, p=16)</div>
+  </a>
 </div>
 </div>
 

site/content/docs/test-profiles/ws/_index.md

@@ -7,4 +7,5 @@ WebSocket test profiles measure framework performance for real-time bidirectiona
 
 {{< cards >}}
   {{< card link="echo" title="Echo" subtitle="WebSocket echo throughput — upgrade, send messages, receive echoes." icon="globe-alt" >}}
+  {{< card link="echo-pipeline" title="Echo Pipelined (16x)" subtitle="WebSocket echo with 16 messages in flight per connection — measures frame batching and read-buffer draining." icon="fast-forward" >}}
 {{< /cards >}}

site/content/docs/test-profiles/ws/echo-pipeline/_index.md

@@ -0,0 +1,10 @@
+---
+title: Echo Pipelined (WebSocket)
+---
+
+Measures WebSocket echo throughput with pipelining. Each connection upgrades via HTTP/1.1, then sends 16 messages back-to-back before waiting for the echoes.
+
+{{< cards >}}
+  {{< card link="implementation" title="Implementation Guidelines" subtitle="Endpoint specification, expected request/response format, and type-specific rules." icon="code" >}}
+  {{< card link="validation" title="Validation" subtitle="All checks executed by the validation script for this test profile." icon="check-circle" >}}
+{{< /cards >}}

site/content/docs/test-profiles/ws/echo-pipeline/implementation.md

@@ -0,0 +1,55 @@
+---
+title: Implementation Guidelines
+---
+{{< type-rules production="Must use the framework standard WebSocket API with default buffer sizes. No custom batching or read-ahead optimizations." tuned="May optimize WebSocket frame handling, buffer sizes, and use custom frame parsers or batched read paths." engine="No specific rules. Ranked separately from frameworks." >}}
+
+
+Measures WebSocket echo throughput with pipelining. Each connection upgrades via HTTP/1.1, then sends 16 text messages back-to-back before waiting for the echoes. Each echo counts as one completed response.
+
+**Connections:** 512, 4,096, 16,384
+**Pipeline:** 16 (16 messages in flight per connection — send batch, drain echoes, repeat)
+
+## Workload
+
+1. Open TCP connection to port 8080
+2. Send HTTP/1.1 upgrade request to `/ws`
+3. After receiving `101 Switching Protocols`, switch to WebSocket framing
+4. Send 16 text frames containing `"hello"` back-to-back, then read 16 echo frames
+5. Measure messages per second
+
+## What it measures
+
+- WebSocket frame parsing efficiency under burst load
+- Frameworks that drain multiple frames from a single read buffer gain a major advantage
+- Frameworks processing one frame at a time per connection see minimal improvement over the non-pipelined echo
+- Write coalescing and syscall reduction on the send path
+
+## Expected upgrade request/response
+
+```
+GET /ws HTTP/1.1
+Host: localhost:8080
+Upgrade: websocket
+Connection: Upgrade
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
+Sec-WebSocket-Version: 13
+```
+
+```
+HTTP/1.1 101 Switching Protocols
+Upgrade: websocket
+Connection: Upgrade
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
+```
+
+## Parameters
+
+| Parameter | Value |
+|-----------|-------|
+| Endpoint | `/ws` (WebSocket upgrade) |
+| Connections | 512, 4,096, 16,384 |
+| Pipeline | 16 (16 messages in flight per connection) |
+| Message | `"hello"` (5 bytes, text frame) |
+| Duration | 5s |
+| Runs | 3 (best taken) |
+| Load generator | gcannon `--ws -p 16` |

site/content/docs/test-profiles/ws/echo-pipeline/validation.md

@@ -0,0 +1,7 @@
+---
+title: Validation
+---
+
+The same `validate-ws.py` checks executed for the [Echo](../echo/validation/) profile apply here — pipelining is a load-generator behavior, not a separate server contract. The endpoint and frame semantics are identical, so a server that passes the Echo validation passes for Echo Pipelined as well.
+
+See the [Echo validation page](../echo/validation/) for the full list of checks (handshake, accept header, text/binary echo, multi-message echo, clean close, non-upgrade rejection, post-validation health check).

site/layouts/shortcodes/leaderboard-composite.html

@@ -26,6 +26,7 @@
   (dict "id" "baseline-h3" "label" "Baseline" "sublabel" "H/3" "proto" "h3" "conns" (slice 64) "scored" true "engineScored" true "infraScored" false)
   (dict "id" "static-h3" "label" "Static" "sublabel" "H/3" "proto" "h3" "conns" (slice 64) "scored" true "engineScored" true "infraScored" false)
   (dict "id" "echo-ws" "label" "Echo" "sublabel" "WebSocket" "proto" "ws" "conns" (slice 512 4096 16384) "scored" true "engineScored" true "infraScored" false)
+  (dict "id" "echo-ws-pipeline" "label" "Echo Pipelined" "sublabel" "WebSocket" "proto" "ws" "conns" (slice 512 4096 16384) "scored" true "engineScored" true "infraScored" false)
 }}
 
 {{/* Build a clean JSON blob: array of {profile, framework, rps, language} entries */}}

site/layouts/shortcodes/leaderboard-ws.html

@@ -1,5 +1,6 @@
 {{ $profiles := slice
   (dict "id" "echo-ws" "label" "Echo (WebSocket)" "conns" (slice 512 4096 16384) "desc" "WebSocket echo test — upgrade to WebSocket on <code>/ws</code>, then send one message at a time and wait for the echo before sending the next. Measures single-message round-trip throughput. Benchmarked with <code>gcannon --ws -p 1</code>. Container pinned to 64 CPU threads (cores 0-31, 64-95). <a href='/docs/test-profiles/ws/echo/' class='lb-desc-link'>Learn more &rarr;</a>")
+  (dict "id" "echo-ws-pipeline" "label" "Echo Pipelined (WebSocket)" "conns" (slice 512 4096 16384) "desc" "WebSocket echo test with pipelining — upgrade to WebSocket on <code>/ws</code>, then send 16 messages back-to-back per connection before waiting for the echoes. Measures batched round-trip throughput and how efficiently a framework drains the read buffer. Benchmarked with <code>gcannon --ws -p 16</code>. Container pinned to 64 CPU threads (cores 0-31, 64-95). <a href='/docs/test-profiles/ws/echo/' class='lb-desc-link'>Learn more &rarr;</a>")
 }}
 
 {{/* Build JSON data blob for round switching */}}