low precision of nanoTimestamp on windows

[BeanHeaDza]

Zig Version

0.13.0

Steps to Reproduce and Observed Behavior

nanoTimestamp on windows currently uses GetSystemTimeAsFileTime, however there is a more precise windows api GetSystemTimePreciseAsFileTime. I tried searching for a discussion on why GetSystemTimeAsFileTime is used over GetSystemTimePreciseAsFileTime, but couldn't find anything on the topic. The MSDN documentation states that GetSystemTimePreciseAsFileTime has been available since Windows 8, and based on some issue searching it seems that Windows 7 isn't supported (see this).

So based on that I'd recommend that nanoTimestamp use GetSystemTimePreciseAsFileTime instead. I've written an example program (sorry in 0.13.0 not master) to show that GetSystemTimePreciseAsFileTime does give a better precision for nanoTimestamp on windows.

const std = @import("std");
const builtin = @import("builtin");

pub extern "kernel32" fn GetSystemTimePreciseAsFileTime(*std.os.windows.FILETIME) callconv(std.os.windows.WINAPI) void;

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    var allocator = gpa.allocator();

    const start = std.time.nanoTimestamp();
    const startPrec = nanoTimestamp();

    const heap = try allocator.alloc(usize, 10000);
    defer allocator.free(heap);

    const end = std.time.nanoTimestamp();
    const endPrec = nanoTimestamp();

    std.debug.print("The heap alloc took {d}ns\n", .{end - start});
    std.debug.print("The heap alloc took {d}ns (precise)\n", .{endPrec - startPrec});
}

fn nanoTimestamp() i128 {
    if (builtin.os.tag != .windows) {
        return std.time.nanoTimestamp();
    }

    // FileTime has a granularity of 100 nanoseconds and uses the NTFS/Windows epoch,
    // which is 1601-01-01.
    const epoch_adj = std.time.epoch.windows * (std.time.ns_per_s / 100);
    var ft: std.os.windows.FILETIME = undefined;
    GetSystemTimePreciseAsFileTime(&ft);
    const ft64 = (@as(u64, ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
    return @as(i128, @as(i64, @bitCast(ft64)) + epoch_adj) * 100;
}

output:

The heap alloc took 0ns
The heap alloc took 13600ns (precise)

Expected Behavior

nanoTimestamp on Windows has better precision.