Homework: Multikernels

Hand-In Procedure

Shared memory versus message-passing

Figure 3 in the paper shows that under some circumstances, updating shared state can be faster using a message-passing style than a shared memory style.

We'll explore message-passing in the context of a simple counter (shared memory is certainly the faster approach for something as simple as a counter, but the trade-off is more interesting for larger structures). The shared-memory version of our program simply increments one shared variable from multiple threads:

int counter;   // shared counter that is cache-line aligned

thread()
{
    while (1) {
        atomic_increment(&counter);
    }
}

Sketch out what the message-version for the microbenchmark is. That is, how do you use shared-memory to communicate a cache-line to a single server thread? Here is a start:

server()
{
    int server_counter;  // not shared, just the server accesses it.
    while (1) {
        int client_id;
        r = wait_for_request(&client_id);
        server_counter++;
        send_response(client_id, server_counter);
    }
}

client()
{
    send_request(client_id);
    int count = receive_response();
}