void read_sync(HANDLE file, char* buffer, u64 beg, u32 len) {
    OVERLAPPED overlapped = {};
    overlapped.Pointer = (void*)beg;

    DWORD bytes_read;
    assert(ReadFile(file, buffer, len, &bytes_read, &overlapped));
    assert(bytes_read == len);
}

1. ReadFile() enters the kernel
2. The kernel dispatches to the Via driver
3. Via sends a request to the server
4. Your thread is put to sleep
5. The request reaches the server after 25 ms
6. The server starts sending packets back at 10 MB/s
7. The first packet is received after 25 ms
8. The last packet is received after another 10 ms
9. Via completes the request and wakes your thread
10. Your thread returns from ReadFile() and continues

void read_async_and_wait(HANDLE file, char* buffer, u64 beg, u32 len) {
    OVERLAPPED overlapped = {};
    overlapped.Pointer = (void*)beg;

    DWORD bytes_read;
    if (ReadFile(file, buffer, len, &bytes_read, &overlapped)) {
        // even though we did everything async, we completed synchronously
        // this can happen in Via if the data is already cached in memory
        assert(bytes_read == len);
    }
    else {
        // either we are running async or we failed, so check the error code
        assert(GetLastError() == ERROR_IO_PENDING);

        // wait for completion, this is what the kernel normally does for you
        assert(GetOverlappedResult(file, &overlapped, &bytes_read, 1));
    }
}

OVERLAPPED overlapped;
u32 read_len;
u32 read_pending;

u32 start_read(HANDLE file, char* buffer, u64 beg, u32 len) {
    // back pressure the requestor if another read is already started
    if (read_pending) {
        return 0;
    }

    overlapped = {};
    overlapped.Pointer = (void*)beg;

    DWORD bytes_read;
    if (ReadFile(file, buffer, len, &bytes_read, &overlapped)) {
        assert(bytes_read == len);

        // even though we did everything async, we completed synchronously
        // this can happen in Via if the data is already cached in memory
        on_read_done(...);
    }
    else {
        // either we are running async or we failed, so check the error code
        assert(GetLastError() == ERROR_IO_PENDING);

        read_len = len;
        read_pending = 1;
    }

    return 1;
}

void handle_completions() {
    // nothing to do, a read isn't pending
    if (!read_pending) {
        return;
    }

    // this macro tests a field in the OVERLAPPED struct, no call
    if (!HasOverlappedIoCompleted(&overlapped)) {
        return;
    }

    DWORD bytes_read;
    assert(GetOverlappedResult(file, &overlapped, &bytes_read, 0));
    assert(bytes_read == read_len);

    read_pending = 0;

    // do whatever you want with the data
    on_read_done(...);
}

void main() {
    ...

    // the game loop
    for (;;) {
        handle_completions();

        // somewhere in your game you may want to start a read
        if (!start_read(...)) {
            // we'll have to try again later, a read is already in progress
        }

        ...
    }
}

OVERLAPPED  reads_overlapped[64];
u32         reads_len[64];
u64         reads_pending;

u32 start_read(HANDLE file, char* buffer, u64 beg, u32 len) {
    u64 free = ~reads_pending;

    // back pressure the requestor if we already have our max reads pending
    if (!free) {
        return 0;
    }

    u32 i = __builtin_ctzll(free);

    OVERLAPPED* overlapped = reads_overlapped + i;
    overlapped->Internal = 0;
    overlapped->InternalHigh = 0;
    overlapped->Pointer = (void*)beg;

    DWORD bytes_read;
    if (ReadFile(file, buffer, len, &bytes_read, overlapped)) {
        assert(bytes_read == len);

        // even though we did everything async, we completed synchronously
        // this can happen in Via if the data is already cached in memory
        on_read_done(...);
    }
    else {
        // either we are running async or we failed, so check the error code
        assert(GetLastError() == ERROR_IO_PENDING);

        reads_len[i] = len;
        reads_pending |= 1ull << i;
    }

    return 1;
}

void handle_completions() {
    for (u32 i = 0; i < 64; i++) {
        if (!(reads_pending & (1ull << i))) continue;
        if (!HasOverlappedIoCompleted(reads_overlapped + i)) continue;

        DWORD bytes_read;
        assert(GetOverlappedResult(file, &overlapped, &bytes_read, 0));
        assert(bytes_read == reads_len[i]);

        reads_pending &= ~(1ull << i);

        // do whatever you want with the data
        on_read_done(...);
    }
}

void main() {
    ...

    // setup a separate event for each read slot
    for (u32 i = 0; i < 64; i++) {
        reads_overlapped[i].hEvent = CreateEvent(0, 0, 0, 0);
    }

    ...

    // the game loop
    for (;;) {
        handle_completions();

        // somewhere in your game you may want to start some reads
        if (!start_read(...)) {
            // we'll try again later, too many reads already in progress
        }

        ...
    }
}

1. The read is queued up with the underlying device (say an NVMe drive)
2. In the background, the hardware is processing that request
3. When done, the hardware signals the CPU
4. An interrupt fires that does as little as possible then schedules a DPC
5. The DPC runs right after the interrupt on the same core
6. The DPC completes the request and signals the event (or the file itself)
7. A user thread sees that the event (or file) is signaled and ready

1. You call MapViewOfFile()
2. Some downstream code accesses part of the mapping for the first time
3. The CPU page faults
4. The kernel's page fault handler runs
5. The kernel dispatches to the Via driver
6. Via sends a request to the server
7. Your thread is put to sleep
8. The request reaches the server after 25 ms
9. The server starts sending packets back at 10 MB/s
10. The first packet is received after 25 ms
11. The last packet is received after another 10 ms
12. Via completes the request and wakes your thread
13. Your thread restarts at the page fault point and continues