zig-http-playground

Playground for different ways of configuring and using Zig std.http.Server (using the new std.http.Server library in zig 0.11.x)

Use this for experimenting and benchmarking different options

Not intended for production use - this is just a playground to see whats fast, what isnt, and what breaks under load

You will need to be running the latest 0.11.x dev version of Zig to play with this

Install / Build

git@github.com:zigster64/zig-http-playground.git
cd zig-http-playground
zig build

Run it

zig-http-playground THREADMODE FILE-IO-MODE PORT

Where THREADMODE in singlethread, threadpool2, threadpoolmax, threadmadness

Where FILE-IO-MODE in code, os

Where PORT = the port to run on (eg 8080)

Running Example :

zig-http-playground singlethread code 8080

Using makefile :

To show all the ways of running it, just run :

make

examples :

make run-single

Thread Modes

singlethread - simple and fast, just do the accept() / handler() in a simple loop.

threadpool2 - accept in a loop, run the handlers in a threadpool of 2 threads

threadpoolmax - accept in a loop, run the handlers in a threadpool of std.Thread.getCpuCount() threads

threadmadness - accept in a loop, spawn a whole new thread for each connection, to see where it melts down. Dont do this in production !

File IO Modes

code - simple Zig code to read the file using stdlib, and write the contents to the response.

os - open the file using Zig stdlib, but then use the std.os.sendfile() to get the kernel to do the IO from the file to the socket

Benchmark Run

Mac M2 pro / 16GB

Hitting the server with

siege -t 10S -c 10 -b http://localhost:8080/

• Concurrency 10 users
• Duration 10 seconds
• Benchmark mode (no delay between requests)

Benchmark Results

WARNING - benchmarks are benchmarks ... dont go reading too much into the results, just use them to get a rough understanding of what goes where.

Figures can vary wildly from run to run.

There doesnt seem to be any significant difference between compiling with debug vs compiling with releaseFast on the Zig side.

Rust is marginally better on release build vs debug build.

Surprised that the Go stdlib doesnt handle keepalive !! Or that nodejs serve / python http.server also dont handle keepalive.

• Transactions = Transactions per second
• Throughput = MB per sec
• Concurrency = Avg number of active simultaneous users

Other non-Zig Things on same machine to benchmark against

Using Zig File IO

Zig Using std.os.sendfile