NornicDB

MaxConcurrentStreams Comparison: 100 vs 250 ​

Last Updated: February 2026

HTTP Write Performance with Different MaxConcurrentStreams Settings. Configuration: HTTP/2, no auth, 100 concurrent connections, 50,000 requests (Go 1.26.0) with executor caching and search service reuse enabled.

Test Configuration ​

  • Requests: 50,000
  • Concurrency: 100 goroutines
  • Database: nornic
  • Warmup: 10 requests
  • HTTP/2: Enabled (h2c cleartext mode)
  • Authentication: Disabled (-auth "")
  • Memory Optimizations: Executor caching + Search service reuse

Results Comparison ​

Apple M3 Max

MaxConcurrentStreams = 100 ​

MetricValue
Throughput37,450.73 req/s
Average Latency2.67ms
P50 (median)2.62ms
P953.25ms
P994.12ms
P99.99.16ms
Max12.00ms
Min0.18ms
Success Rate100%

MaxConcurrentStreams = 250 (Go Default) ​

MetricValue
Throughput37,092.65 req/s
Average Latency6.72ms
P50 (median)6.43ms
P958.95ms
P9910.18ms
P99.929.19ms
Max31.16ms
Min0.29ms
Success Rate100%

Performance Impact ​

Throughput ​

  • 100 streams: 37,450.73 req/s
  • 250 streams: 37,092.65 req/s
  • Difference: 100 streams is +1.0% faster

Latency ​

  • Average: 100: 2.67ms vs 250: 6.72ms
  • P50: 100: 2.62ms vs 250: 6.43ms
  • P95: 100: 3.25ms vs 250: 8.95ms
  • P99: 100: 4.12ms vs 250: 10.18ms
  • P99.9: 100: 9.16ms vs 250: 29.19ms

Analysis ​

Key Findings ​

With memory optimizations (executor caching + search service reuse) enabled:

  • 100 streams provides slightly higher throughput (37,450 req/s vs 37,093 req/s for 250)
  • Significantly better tail latency (P99: 4.12ms vs 10.18ms for 250)
  • Lower high-percentile latency under load (P95/P99/P99.9 all improved)
  • Much better median and average latency (P50/avg both improved by ~60%)
  • No errors - 100% success rate maintained
  • 89% reduction in memory growth during load

Why 100 Streams Performs Best ​

With 100 concurrent connections:

  • Each connection can handle up to 100 streams (with MaxStreams=100)
  • Total potential: 100 × 100 = 10,000 concurrent streams
  • Actual usage: ~50,000 requests total, distributed across 100 connections
  • 100 streams provides optimal balance - sufficient capacity without overhead

The performance advantage of 100 streams comes from:

  1. Lower memory overhead - fewer stream buffers per connection
  2. Better resource utilization - optimal for this workload size
  3. Reduced queuing - streams complete faster, reducing tail latency
  4. Memory optimizations eliminate per-request overhead (executor + search service caching)

Tail Latency Improvement ​

The 59.5% improvement in P99 latency (10.18ms → 4.12ms) with 100 streams is the most significant benefit:

  • Fewer requests waiting for stream availability
  • Better load distribution across connections
  • Reduced queuing when connection limits are hit
  • Sub-5ms P99 latency - excellent for high-concurrency workloads

Recommendations ​

For High-Concurrency Workloads ​

Use MaxConcurrentStreams = 100 when:

  • Best performance - highest throughput and lowest latency
  • Optimal for 100 concurrent connections - as tested
  • Lower memory usage - fewer stream buffers
  • Better security - DoS protection with lower limits
  • Standard web workloads - sufficient for most use cases

Use MaxConcurrentStreams = 250 when:

  • You need Go's default behavior (matches standard library)
  • You have many more concurrent clients (200+)
  • Each client makes many parallel requests
  • Memory usage is not a concern

Current Default: 250 ​

The default is 250 (Go's internal default) to:

  • Match standard library behavior
  • Provide good balance for most workloads
  • Allow flexibility for high-concurrency scenarios

However, for optimal performance with ~100 concurrent connections, 100 streams provides better results.

Conclusion ​

MaxConcurrentStreams = 100 (with memory optimizations) provides stronger tail-latency performance:

  • Slightly higher throughput (37,451 req/s vs 37,093 req/s for 250)
  • 59.5% P99 latency improvement (4.12ms vs 10.18ms for 250) - most significant
  • 63.7% P95 latency improvement (3.25ms vs 8.95ms for 250)
  • 60.3% average latency improvement (2.67ms vs 6.72ms for 250)
  • 89% reduction in memory growth during load
  • No performance regressions
  • 100% success rate maintained

The combination of MaxConcurrentStreams = 100 and memory optimizations (executor caching + search service reuse) provides stronger tail-latency behavior for high-concurrency database workloads. The sub-5ms P99 latency (4.12ms) demonstrates excellent performance. While the default is 250 (matching Go's standard library), 100 streams is recommended when tail latency is the priority with ~100 concurrent connections.

Analytics privacy