quicsilver 0.2.0 → 0.4.0

data/benchmarks/components.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+# Component micro-benchmarks using benchmark-ips.
+# No server needed — pure in-process measurements.
+#
+# Usage: ruby benchmarks/components.rb
+
+require "bundler/setup"
+require "quicsilver"
+require "benchmark/ips"
+
+# --- Varint ---
+
+puts "=" * 60
+puts "Varint encode/decode"
+puts "=" * 60
+
+small  = 6
+medium = 1_000
+large  = 1_000_000
+
+encoded_small  = Quicsilver::Protocol.encode_varint(small)
+encoded_medium = Quicsilver::Protocol.encode_varint(medium)
+encoded_large  = Quicsilver::Protocol.encode_varint(large)
+
+Benchmark.ips do |x|
+  x.config(warmup: 1, time: 3)
+
+  x.report("encode small (#{small})")     { Quicsilver::Protocol.encode_varint(small) }
+  x.report("encode medium (#{medium})")   { Quicsilver::Protocol.encode_varint(medium) }
+  x.report("encode large (#{large})")     { Quicsilver::Protocol.encode_varint(large) }
+  x.report("decode small")   { Quicsilver::Protocol.decode_varint(encoded_small.bytes, 0) }
+  x.report("decode medium")  { Quicsilver::Protocol.decode_varint(encoded_medium.bytes, 0) }
+  x.report("decode large")   { Quicsilver::Protocol.decode_varint(encoded_large.bytes, 0) }
+
+  x.compare!
+end
+
+# --- Huffman ---
+
+puts
+puts "=" * 60
+puts "Huffman encode/decode"
+puts "=" * 60
+
+huffman_inputs = [
+  "www.example.com",
+  "application/json",
+  "text/html; charset=utf-8",
+  "GET",
+  "/api/v1/users?page=1&limit=50"
+]
+
+encoded_huffman = huffman_inputs.map { |s| Quicsilver::Protocol::Qpack::Huffman.encode(s) }
+
+Benchmark.ips do |x|
+  x.config(warmup: 1, time: 3)
+
+  huffman_inputs.each do |input|
+    x.report("encode #{input[0..20]}") { Quicsilver::Protocol::Qpack::Huffman.encode(input) }
+  end
+  encoded_huffman.each_with_index do |enc, i|
+    x.report("decode #{huffman_inputs[i][0..20]}") { Quicsilver::Protocol::Qpack::Huffman.decode(enc) }
+  end
+
+  x.compare!
+end
+
+# --- QPACK Encoder ---
+
+puts
+puts "=" * 60
+puts "QPACK Encoder"
+puts "=" * 60
+
+headers = [
+  [":method", "GET"],
+  [":path", "/api/v1/users"],
+  [":scheme", "https"],
+  [":authority", "example.com"],
+  ["accept", "application/json"],
+  ["user-agent", "quicsilver-bench/1.0"],
+  ["accept-encoding", "gzip, deflate"]
+]
+
+encoder_huffman = Quicsilver::Protocol::Qpack::Encoder.new(huffman: true)
+encoder_raw     = Quicsilver::Protocol::Qpack::Encoder.new(huffman: false)
+
+Benchmark.ips do |x|
+  x.config(warmup: 1, time: 3)
+
+  x.report("encode (huffman on)")  { encoder_huffman.encode(headers) }
+  x.report("encode (huffman off)") { encoder_raw.encode(headers) }
+
+  x.compare!
+end
+
+# --- QPACK Decoder ---
+
+puts
+puts "=" * 60
+puts "QPACK Decoder (string decoding)"
+puts "=" * 60
+
+# Build payloads for decode_qpack_string
+huffman_payload = Quicsilver::Protocol::Qpack::Huffman.encode("application/json")
+huffman_bytes = [0x80 | huffman_payload.bytesize] + huffman_payload.bytes  # Huffman flag set
+
+raw_string = "application/json"
+raw_bytes = [raw_string.bytesize] + raw_string.bytes  # No Huffman flag
+
+# Include the decoder module in a throwaway object
+decoder = Object.new
+decoder.extend(Quicsilver::Protocol::Qpack::Decoder)
+
+Benchmark.ips do |x|
+  x.config(warmup: 1, time: 3)
+
+  x.report("decode huffman string") { decoder.decode_qpack_string(huffman_bytes, 0) }
+  x.report("decode raw string")     { decoder.decode_qpack_string(raw_bytes, 0) }
+
+  x.compare!
+end
+
+# --- Request Parser ---
+
+puts
+puts "=" * 60
+puts "Request Parser"
+puts "=" * 60
+
+# Build a realistic GET request frame
+request_encoder = Quicsilver::Protocol::Qpack::Encoder.new(huffman: true)
+request_headers_payload = request_encoder.encode([
+  [":method", "GET"],
+  [":path", "/api/v1/users?page=1"],
+  [":scheme", "https"],
+  [":authority", "example.com"],
+  ["accept", "application/json"],
+  ["user-agent", "quicsilver-bench/1.0"]
+])
+
+# HEADERS frame: type=0x01, varint length, payload
+request_frame = Quicsilver::Protocol.encode_varint(0x01) +
+  Quicsilver::Protocol.encode_varint(request_headers_payload.bytesize) +
+  request_headers_payload
+
+Benchmark.ips do |x|
+  x.config(warmup: 1, time: 3)
+
+  x.report("parse GET request") do
+    parser = Quicsilver::Protocol::RequestParser.new(request_frame)
+    parser.parse
+  end
+
+  x.compare!
+end
+
+# --- Response Parser ---
+
+puts
+puts "=" * 60
+puts "Response Parser"
+puts "=" * 60
+
+# Build a realistic 200 response with body
+response_encoder = Quicsilver::Protocol::Qpack::Encoder.new(huffman: true)
+response_headers_payload = response_encoder.encode([
+  [":status", "200"],
+  ["content-type", "application/json"],
+  ["server", "quicsilver"]
+])
+
+body = '{"users":[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]}'
+
+response_frame = Quicsilver::Protocol.encode_varint(0x01) +
+  Quicsilver::Protocol.encode_varint(response_headers_payload.bytesize) +
+  response_headers_payload +
+  Quicsilver::Protocol.encode_varint(0x00) +
+  Quicsilver::Protocol.encode_varint(body.bytesize) +
+  body
+
+Benchmark.ips do |x|
+  x.config(warmup: 1, time: 3)
+
+  x.report("parse 200 response + body") do
+    parser = Quicsilver::Protocol::ResponseParser.new(response_frame)
+    parser.parse
+  end
+
+  x.compare!
+end

data/benchmarks/concurrent.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# Concurrency benchmark: tests HTTP/3 multiplexing and multi-connection overhead.
+#
+# Self-contained:
+#   ruby benchmarks/concurrent.rb
+#
+# External server:
+#   HOST=127.0.0.1 PORT=4433 ruby benchmarks/concurrent.rb
+
+require_relative "helpers"
+require "benchmark"
+
+MULTIPLEX_REQUESTS = ENV.fetch("MULTIPLEX_REQUESTS", "50").to_i
+NUM_CLIENTS        = ENV.fetch("NUM_CLIENTS", "20").to_i
+REQUESTS_PER_CLIENT = ENV.fetch("REQUESTS_PER_CLIENT", "5").to_i
+HOST = ENV["HOST"]
+PORT = ENV["PORT"]&.to_i
+
+def test_multiplexing(host, port)
+  Benchmarks::Helpers.print_header(
+    "Test 1: Single-connection multiplexing",
+    requests: MULTIPLEX_REQUESTS
+  )
+
+  request_times = []
+  mutex = Mutex.new
+
+  client = Quicsilver::Client.new(host, port, unsecure: true)
+  client.open_connection
+
+  elapsed = Benchmark.realtime do
+    threads = MULTIPLEX_REQUESTS.times.map do |i|
+      Thread.new do
+        start = Time.now
+        client.get("/multiplex/#{i}")
+        req_time = Time.now - start
+        mutex.synchronize { request_times << req_time }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  client.disconnect
+
+  concurrency_factor = request_times.any? ? (request_times.sum / elapsed).round(2) : 0
+  puts "  Wall clock:          #{(elapsed * 1000).round(2)}ms"
+  puts "  Avg request time:    #{(request_times.sum / request_times.size * 1000).round(2)}ms"
+  puts "  Throughput:          #{(MULTIPLEX_REQUESTS / elapsed).round(2)} req/s"
+  puts "  Concurrency factor:  #{concurrency_factor}x"
+  Benchmarks::Helpers.print_stats("Latency", request_times)
+end
+
+def test_concurrent_clients(host, port)
+  Benchmarks::Helpers.print_header(
+    "Test 2: Concurrent clients",
+    clients:            NUM_CLIENTS,
+    requests_per_client: REQUESTS_PER_CLIENT
+  )
+
+  request_times = []
+  mutex = Mutex.new
+  successful = 0
+
+  elapsed = Benchmark.realtime do
+    threads = NUM_CLIENTS.times.map do |i|
+      Thread.new do
+        client = Quicsilver::Client.new(host, port, unsecure: true)
+        client.open_connection
+
+        REQUESTS_PER_CLIENT.times do |req|
+          start = Time.now
+          client.get("/client#{i}/request#{req}")
+          req_time = Time.now - start
+          mutex.synchronize { request_times << req_time }
+        end
+
+        client.disconnect
+        mutex.synchronize { successful += 1 }
+      rescue => e
+        $stderr.puts "  Client #{i} error: #{e.message}"
+      end
+    end
+    threads.each(&:join)
+  end
+
+  total_requests = request_times.size
+  concurrency_factor = request_times.any? ? (request_times.sum / elapsed).round(2) : 0
+
+  puts "  Successful clients:  #{successful}/#{NUM_CLIENTS}"
+  puts "  Total requests:      #{total_requests}"
+  puts "  Wall clock:          #{(elapsed * 1000).round(2)}ms"
+  puts "  Avg request time:    #{request_times.any? ? (request_times.sum / request_times.size * 1000).round(2) : "N/A"}ms"
+  puts "  Throughput:          #{(total_requests / elapsed).round(2)} req/s"
+  puts "  Concurrency factor:  #{concurrency_factor}x"
+  Benchmarks::Helpers.print_stats("Latency", request_times)
+end
+
+def run_all(host, port)
+  test_multiplexing(host, port)
+  test_concurrent_clients(host, port)
+end
+
+if HOST && PORT
+  run_all(HOST, PORT)
+else
+  puts "Booting inline server..."
+  Benchmarks::Helpers.with_server(Benchmarks::Helpers.benchmark_app) do |port|
+    run_all("127.0.0.1", port)
+  end
+end

data/benchmarks/helpers.rb

@@ -0,0 +1,88 @@
+require "bundler/setup"
+require "quicsilver"
+require "localhost/authority"
+
+module Benchmarks
+  module Helpers
+    # Boot a Quicsilver server on a random port, yield the port, then tear down.
+    def self.with_server(app, &block)
+      authority = Localhost::Authority.fetch
+      config = Quicsilver::Transport::Configuration.new(
+        authority.certificate_path,
+        authority.key_path
+      )
+
+      port = random_port
+      server = Quicsilver::Server.new(port, app: app, server_configuration: config)
+      server_thread = Thread.new { server.start }
+      sleep 0.5 # let listener settle
+
+      yield port
+    ensure
+      server&.stop rescue nil
+      server_thread&.join(2)
+    end
+
+    # Compute latency stats from an array of float durations (in seconds).
+    # Returns a Hash with :avg, :min, :max, :p50, :p95, :p99 (all in ms).
+    def self.stats(times)
+      return nil if times.empty?
+
+      sorted = times.sort
+      n = sorted.size
+      {
+        count: n,
+        avg:   (times.sum / n * 1000).round(2),
+        min:   (sorted.first * 1000).round(2),
+        max:   (sorted.last * 1000).round(2),
+        p50:   (sorted[n / 2] * 1000).round(2),
+        p95:   (sorted[(n * 0.95).to_i] * 1000).round(2),
+        p99:   (sorted[(n * 0.99).to_i] * 1000).round(2)
+      }
+    end
+
+    def self.print_header(title, **opts)
+      puts
+      puts "=" * 60
+      puts title
+      puts "=" * 60
+      opts.each { |k, v| puts "  #{k}: #{v}" }
+      puts "-" * 60
+    end
+
+    def self.print_stats(label, times)
+      s = stats(times)
+      unless s
+        puts "  #{label}: no data"
+        return
+      end
+      puts "  #{label}: #{s[:count]} reqs | avg=#{s[:avg]}ms p50=#{s[:p50]}ms p95=#{s[:p95]}ms p99=#{s[:p99]}ms (min=#{s[:min]}ms max=#{s[:max]}ms)"
+    end
+
+    def self.print_results(total_time:, total_requests:, times:, failed: 0, latency: false)
+      s = stats(times)
+      puts "-" * 60
+      puts "  Total time:  #{total_time.round(3)}s"
+      puts "  Requests:    #{total_requests} (#{failed} failed)"
+      puts "  Throughput:  #{(total_requests / total_time).round(2)} req/s"
+      if latency && s
+        puts "  Latency:     avg=#{s[:avg]}ms p50=#{s[:p50]}ms p95=#{s[:p95]}ms p99=#{s[:p99]}ms"
+        puts "               min=#{s[:min]}ms max=#{s[:max]}ms"
+      end
+      puts "=" * 60
+    end
+
+    def self.random_port
+      server = TCPServer.new("127.0.0.1", 0)
+      server.addr[1]
+    ensure
+      server&.close
+    end
+
+    def self.benchmark_app
+      ->(env) {
+        [200, { "content-type" => "text/plain" }, ["OK"]]
+      }
+    end
+  end
+end

data/benchmarks/quicsilver_server.rb

@@ -26,7 +26,7 @@ authority = Localhost::Authority.fetch
 cert_file = authority.certificate_path
 key_file = authority.key_path
 
-config = ::Quicsilver::ServerConfiguration.new(cert_file, key_file)
+config = ::Quicsilver::Transport::Configuration.new(cert_file, key_file)
 
 server = ::Quicsilver::Server.new(
   port.to_i,

data/benchmarks/rails.rb

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+# Rails benchmark: concurrent POST, GET, DELETE against a Rails app.
+# Multiplexes requests within each connection (HTTP/3 streams),
+# capped by CONCURRENCY to stay within the server's stream limit.
+#
+# Start blogz first:
+#   cd ../blogz && bundle exec rackup -s quicsilver -p 4433
+#
+# Usage:
+#   CONNECTIONS=5 ITERATIONS=100 ruby benchmarks/rails.rb
+#   CONCURRENCY=8 CONNECTIONS=3 ITERATIONS=200 ruby benchmarks/rails.rb
+
+require "bundler/setup"
+require "quicsilver"
+require "json"
+require "benchmark"
+
+require_relative "helpers"
+
+HOST        = ENV.fetch("HOST", "127.0.0.1")
+PORT        = ENV.fetch("PORT", "4433").to_i
+CONNECTIONS = ENV.fetch("CONNECTIONS", "5").to_i
+ITERATIONS  = ENV.fetch("ITERATIONS", "100").to_i
+CONCURRENCY = ENV.fetch("CONCURRENCY", "8").to_i  # max in-flight per connection
+
+total_requests = CONNECTIONS * ITERATIONS
+
+Benchmarks::Helpers.print_header(
+  "Rails Concurrent Benchmark (multiplexed)",
+  target:      "#{HOST}:#{PORT}",
+  connections: CONNECTIONS,
+  "reqs/conn": ITERATIONS,
+  concurrency: "#{CONCURRENCY} streams/conn",
+  total:       "#{total_requests * 3} (POST + GET + DELETE)"
+)
+
+mutex = Mutex.new
+results = { post: [], get: [], delete: [] }
+all_created_ids = []
+
+# Fire N requests with at most `concurrency` in-flight at a time on a shared connection.
+def multiplex(count, concurrency:)
+  queue = Queue.new
+  count.times { |i| queue << i }
+
+  threads = concurrency.times.map do
+    Thread.new do
+      while (i = queue.pop(true) rescue nil)
+        yield i
+      end
+    end
+  end
+  threads.each(&:join)
+end
+
+# Phase 1: Concurrent multiplexed POSTs
+puts "\nPhase 1: POST /posts.json (#{CONNECTIONS} conns x #{ITERATIONS}, #{CONCURRENCY} in-flight)..."
+post_elapsed = Benchmark.realtime do
+  conn_threads = CONNECTIONS.times.map do |conn_id|
+    Thread.new do
+      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+      client.open_connection
+
+      local_times = []
+      local_ids = []
+
+      multiplex(ITERATIONS, concurrency: CONCURRENCY) do |i|
+        start = Time.now
+        response = client.post(
+          "/posts.json",
+          headers: { "content-type" => "application/json" },
+          body: { post: { name: "Author #{conn_id}-#{i}", title: "Post #{conn_id}-#{i}" } }.to_json
+        )
+        elapsed = Time.now - start
+
+        if response && response[:status] == 201
+          body = JSON.parse(response[:body]) rescue {}
+          mutex.synchronize do
+            local_times << elapsed
+            local_ids << body["id"] if body["id"]
+          end
+        end
+      end
+
+      client.disconnect
+      mutex.synchronize do
+        results[:post].concat(local_times)
+        all_created_ids.concat(local_ids)
+      end
+    end
+  end
+  conn_threads.each(&:join)
+end
+puts "  #{results[:post].size} created in #{post_elapsed.round(2)}s (#{(results[:post].size / post_elapsed).round(1)} req/s)"
+
+# Phase 2: Concurrent multiplexed GETs
+puts "\nPhase 2: GET /posts.json (#{CONNECTIONS} conns x #{ITERATIONS}, #{CONCURRENCY} in-flight)..."
+get_elapsed = Benchmark.realtime do
+  conn_threads = CONNECTIONS.times.map do
+    Thread.new do
+      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+      client.open_connection
+
+      local_times = []
+
+      multiplex(ITERATIONS, concurrency: CONCURRENCY) do |_i|
+        start = Time.now
+        response = client.get("/posts.json")
+        elapsed = Time.now - start
+
+        if response && response[:status] == 200
+          mutex.synchronize { local_times << elapsed }
+        end
+      end
+
+      client.disconnect
+      mutex.synchronize { results[:get].concat(local_times) }
+    end
+  end
+  conn_threads.each(&:join)
+end
+puts "  #{results[:get].size} fetched in #{get_elapsed.round(2)}s (#{(results[:get].size / get_elapsed).round(1)} req/s)"
+
+# Phase 3: Concurrent multiplexed DELETEs
+delete_count = all_created_ids.size
+puts "\nPhase 3: DELETE /posts/:id (#{delete_count} across #{CONNECTIONS} conns, #{CONCURRENCY} in-flight)..."
+delete_elapsed = Benchmark.realtime do
+  id_chunks = all_created_ids.each_slice((all_created_ids.size.to_f / CONNECTIONS).ceil).to_a
+
+  conn_threads = id_chunks.map do |ids|
+    Thread.new do
+      next if ids.empty?
+
+      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+      client.open_connection
+
+      local_times = []
+
+      multiplex(ids.size, concurrency: CONCURRENCY) do |i|
+        start = Time.now
+        response = client.delete("/posts/#{ids[i]}.json")
+        elapsed = Time.now - start
+
+        if response && response[:status] == 204
+          mutex.synchronize { local_times << elapsed }
+        end
+      end
+
+      client.disconnect
+      mutex.synchronize { results[:delete].concat(local_times) }
+    end
+  end
+  conn_threads.each(&:join)
+end
+puts "  #{results[:delete].size} deleted in #{delete_elapsed.round(2)}s (#{(results[:delete].size / delete_elapsed).round(1)} req/s)"
+
+# Summary
+total_elapsed = post_elapsed + get_elapsed + delete_elapsed
+total_completed = results.values.sum(&:size)
+
+puts
+puts "=" * 70
+puts "RESULTS"
+puts "=" * 70
+Benchmarks::Helpers.print_stats("POST   /posts.json", results[:post])
+Benchmarks::Helpers.print_stats("GET    /posts.json", results[:get])
+Benchmarks::Helpers.print_stats("DELETE /posts/:id ", results[:delete])
+puts "-" * 70
+puts "  Total: #{total_completed} requests in #{total_elapsed.round(2)}s (#{(total_completed / total_elapsed).round(2)} req/s)"
+puts "=" * 70

data/benchmarks/throughput.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# Throughput benchmark: measures req/sec and latency percentiles.
+# Tests both sequential and concurrent (multiplexed) modes.
+#
+# Self-contained (boots inline server with trivial Rack app):
+#   ruby benchmarks/throughput.rb
+#
+# External server:
+#   HOST=127.0.0.1 PORT=4433 ruby benchmarks/throughput.rb
+
+require_relative "helpers"
+require "benchmark"
+
+REQUESTS    = ENV.fetch("REQUESTS", "500").to_i
+CONNECTIONS = ENV.fetch("CONNECTIONS", "5").to_i
+CONCURRENCY = ENV.fetch("CONCURRENCY", "8").to_i
+HOST        = ENV["HOST"]
+PORT        = ENV["PORT"]&.to_i
+
+def run_benchmark(host, port)
+  # --- Sequential: 1 request at a time per connection ---
+  puts "\n--- Sequential (1 stream/conn, #{CONNECTIONS} conns) ---"
+  seq_times = []
+  mutex = Mutex.new
+
+  seq_elapsed = Benchmark.realtime do
+    per_conn = REQUESTS / CONNECTIONS
+
+    threads = CONNECTIONS.times.map do
+      Thread.new do
+        client = Quicsilver::Client.new(host, port, connection_timeout: 5000, request_timeout: 10)
+        client.open_connection
+
+        local = []
+        per_conn.times do
+          start = Time.now
+          response = client.get("/")
+          local << (Time.now - start) if response && response[:status] == 200
+        end
+
+        client.disconnect
+        mutex.synchronize { seq_times.concat(local) }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  Benchmarks::Helpers.print_results(
+    total_time: seq_elapsed, total_requests: REQUESTS,
+    times: seq_times, failed: REQUESTS - seq_times.size, latency: true
+  )
+
+  # --- Concurrent: CONCURRENCY streams per connection ---
+  puts "\n--- Concurrent (#{CONCURRENCY} streams/conn, #{CONNECTIONS} conns) ---"
+  con_times = []
+  con_failed = 0
+
+  con_elapsed = Benchmark.realtime do
+    per_conn = REQUESTS / CONNECTIONS
+
+    threads = CONNECTIONS.times.map do
+      Thread.new do
+        client = Quicsilver::Client.new(host, port, connection_timeout: 5000, request_timeout: 10)
+        client.open_connection
+
+        local = []
+        queue = Queue.new
+        per_conn.times { |i| queue << i }
+
+        workers = CONCURRENCY.times.map do
+          Thread.new do
+            while (queue.pop(true) rescue nil)
+              start = Time.now
+              response = client.get("/bench")
+              dur = Time.now - start
+              if response && response[:status] == 200
+                local << dur
+              else
+                mutex.synchronize { con_failed += 1 }
+              end
+            end
+          end
+        end
+        workers.each(&:join)
+        client.disconnect
+        mutex.synchronize { con_times.concat(local) }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  Benchmarks::Helpers.print_results(
+    total_time: con_elapsed, total_requests: REQUESTS,
+    times: con_times, failed: con_failed, latency: true
+  )
+end
+
+Benchmarks::Helpers.print_header(
+  "Quicsilver Throughput (trivial Rack app, no DB)",
+  connections: CONNECTIONS,
+  "reqs/conn": REQUESTS / CONNECTIONS,
+  concurrency: "#{CONCURRENCY} streams/conn",
+  total: REQUESTS
+)
+
+if HOST && PORT
+  run_benchmark(HOST, PORT)
+else
+  puts "Booting inline server..."
+  Benchmarks::Helpers.with_server(Benchmarks::Helpers.benchmark_app) do |port|
+    run_benchmark("localhost", port)
+  end
+end