Modern C++

Why 1% matters: Real server counts, language performance comparison

GC overhead, compaction, metadata, write barriers, cache misses

Smart pointers, coroutines, ranges, zero-cost abstractions

• ✓ Memory safe - automatic cleanup
• ✓ Bounds checking - catches errors
• ✓ STL compatible - works with algorithms
• ✓ Zero-cost abstractions - same performance

• ✓ Works with C APIs (.data())
• ✓ Range-based for loops
• ✓ Standard algorithms (sort, find, etc.)
• ✓ Move semantics - efficient transfers

C#: async/await

// Accept connections
while (true) {
  var socket = await listener.AcceptSocketAsync();
  
  // Handle each connection
  _ = HandleRequest(socket);
}

// Handle request
async Task HandleRequest(Socket socket) {
  using var stream = new NetworkStream(socket);
  
  while (true) {
    // Read request (async)
    var request = await ReadHttpRequest(stream);
    
    if (request == null) break;
    
    // Process request
    var response = MakeResponse(request);
    
    // Write response (async)
    await WriteHttpResponse(stream, response);
  }
}
								

C++20: co_await

// Accept connections
  for (;;) {
  auto [ec, socket] = co_await acceptor.async_accept(
        asio::use_awaitable);
  
  if (!ec) {
    // Spawn handler for each connection
    asio::co_spawn(executor, 
        handle_request(std::move(socket)), 
        asio::detached);
  }
}

// Handle request
asio::awaitable<void> handle_request(tcp::socket socket) {
  beast::tcp_stream stream(std::move(socket));
  
  for (;;) {
    // Read request (async, non-blocking!)
    auto [ec, bytes] = co_await beast::http::async_read(
        stream, buffer, req, asio::use_awaitable);
    
    if (ec) break;
    
    // Process request
    auto response = make_response(req);
    
    // Write response (async!)
    co_await beast::http::async_write(
        stream, response, asio::use_awaitable);
  }
}
							

C# State Machine

// Your code:
async Task<int> Fetch(string url) {
    var resp = await client.GetAsync(url);
    var data = await resp.Content.ReadAsStringAsync();
    return data.Length;
}

// Generated state machine:
class FetchStateMachine : IAsyncStateMachine {
    int state;
    string url;
    HttpResponseMessage resp;
    string data;
    TaskAwaiter awaiter1, awaiter2;
    
    void MoveNext() {
        switch (state) {
            case 0:
                awaiter1 = client.GetAsync(url).GetAwaiter();
                state = 1;
                awaiter1.OnCompleted(MoveNext);
                break;
            case 1:
                resp = awaiter1.GetResult();
                awaiter2 = resp.Content.ReadAsStringAsync()
                    .GetAwaiter();
                state = 2;
                awaiter2.OnCompleted(MoveNext);
                break;
            case 2:
                data = awaiter2.GetResult();
                result.SetResult(data.Length);
                break;
        }
    }
}
								

C++ State Machine

// Your code:
task<int> fetch(string url) {
    auto resp = co_await client.get(url);
    auto data = co_await resp.read_body();
    co_return data.size();
}

// Generated coroutine frame:
struct FetchFrame {
    int state = 0;
    string url;
    Response resp;
    string data;
    awaiter_t awaiter1, awaiter2;
    
    void resume() {
        switch (state) {
            case 0:
                awaiter1 = client.get(url).operator co_await();
                state = 1;
                awaiter1.await_suspend(handle);
                break;
            case 1:
                resp = awaiter1.await_resume();
                awaiter2 = resp.read_body().operator co_await();
                state = 2;
                awaiter2.await_suspend(handle);
                break;
            case 2:
                data = awaiter2.await_resume();
                promise.return_value(data.size());
                break;
        }
    }
};
								

Go: Preemptive Scheduling

// Go runtime can interrupt goroutines anywhere
func worker() {
    for i := 0; i < 1000000; i++ {
        // No explicit yield needed!
        // Runtime can preempt here
        doWork(i)
    }
}

// ⚠️ Anti-pattern example (but won't deadlock!)
// Even infinite loop won't hang runtime
func badWorker() {
    for {
        x := computeSomething()  // Runtime preempts
    }
}  // Other goroutines still run!

// GOMAXPROCS: M:N scheduling
// 1 million goroutines → 4-8 OS threads
runtime.GOMAXPROCS(8)  // Max 8 parallel threads
go worker()  // Scheduled by runtime
go worker()  // Runtime handles fairness
go worker()  // Can't monopolize CPU
								

C++: Cooperative Scheduling

// C++ coroutines: MUST explicitly yield
asio::awaitable<void> worker() {
    for (int i = 0; i < 1000000; i++) {
        // Must co_await to yield!
        co_await asio::post(asio::use_awaitable);
        doWork(i);
    }
}

// ⚠️ DANGER: Anti-pattern example!
// Infinite loop WILL hang everything!
asio::awaitable<void> badWorker() {
    for (;;) {
        int x = computeSomething();
        // Never yields → blocks entire thread!
    }
}  // All other coroutines blocked!

// Thread control: Explicit
asio::io_context io;  // Single event loop
asio::co_spawn(io, worker(), asio::detached);
asio::co_spawn(io, worker(), asio::detached);
io.run();  // Run event loop (single thread)
								

Go: Goroutines & Channels

// Buffered channel
ch := make(chan int, 10)

// Producer goroutine
go func() {
    for i := 0; i < 100; i++ {
        ch <- i  // Send to channel
    }
    close(ch)
}()

// Consumer goroutine
go func() {
    for val := range ch {
        fmt.Println(val)
    }
}()

// Wait for completion
time.Sleep(1 * time.Second)

// Lightweight: millions of goroutines possible
								

C++: Boost.Fiber (User-Space)

// Buffered channel
boost::fibers::buffered_channel<int> ch(10);

// Producer fiber
boost::fibers::fiber producer([&ch]() {
    for (int i = 0; i < 100; i++) {
        ch.push(i);  // Send to channel
    }
    ch.close();
});

// Consumer fiber
boost::fibers::fiber consumer([&ch]() {
    int val;
    while (ch.pop(val) == 
           boost::fibers::channel_op_status::success) {
        std::cout << val << '\n';
    }
});

// Wait for completion
producer.join();
consumer.join();

// Lightweight: cooperative scheduling, no GC!