Windows: Faster getenvW and a standalone environment variable test

[squeek502]

Inspired by #23265, I thought I'd try applying the same strategy to the Windows implementation. Also adds a standalone test to make sure the functionality remains the same.

---

Instead of parsing the full key and value for each environment variable before checking the key for (case-insensitive) equality, we skip to the next environment variable once it's no longer possible for the key to match.

This makes getting environment variables about 2x faster across the board on Windows.

Note: We still have to scan to find the end of each environment variable (even the ones that are skipped, since we only know where it ends by a NUL terminator), so this strategy doesn't provide the same speedup on Windows as it does on POSIX (#23265)

---

Benchmark code

const std = @import("std");

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();

    const Bench = enum {
        all,
        found,
        short,
        long,
        random,
        empty,
    };

    var args = try std.process.argsWithAllocator(allocator);
    defer args.deinit();

    _ = args.next();
    const bench: Bench = bench: {
        const str = args.next() orelse break :bench .all;
        break :bench std.meta.stringToEnum(Bench, str) orelse {
            std.debug.print("bench not recognized: {s}\n", .{str});
            std.process.exit(1);
        };
    };

    const num_iterations = 1000000;

    var env_map = try std.process.getEnvMap(allocator);
    defer env_map.deinit();

    var names: std.ArrayListUnmanaged([]const u8) = try .initCapacity(allocator, env_map.count());
    defer names.deinit(allocator);
    var longest_name: usize = 0;
    var it = env_map.iterator();
    while (it.next()) |entry| {
        if (entry.key_ptr.*.len > longest_name) longest_name = entry.key_ptr.*.len;
        names.appendAssumeCapacity(entry.key_ptr.*);
    }

    var name_mod_buf: std.ArrayListUnmanaged(u8) = try .initCapacity(allocator, longest_name + 1);
    defer name_mod_buf.deinit(allocator);

    var timer = try std.time.Timer.start();
    var prng = std.Random.DefaultPrng.init(0);
    const rand = prng.random();

    if (bench == .found or bench == .all) {
        const elapsed = elapsed: {
            timer.reset();
            for (0..num_iterations) |_| {
                const name = names.items[rand.uintLessThan(usize, names.items.len)];
                const value = try std.process.getEnvVarOwned(allocator, name);
                std.mem.doNotOptimizeAway(&value);
            }
            break :elapsed timer.read();
        };
        std.debug.print("found: {}/lookup\n", .{std.fmt.fmtDuration(elapsed / num_iterations)});
    }

    if (bench == .long or bench == .all) {
        const elapsed = elapsed: {
            timer.reset();
            for (0..num_iterations) |_| {
                const name = names.items[rand.uintLessThan(usize, names.items.len)];
                name_mod_buf.clearRetainingCapacity();
                name_mod_buf.appendSliceAssumeCapacity(name);
                // Append a random ascii character
                name_mod_buf.appendAssumeCapacity(rand.int(u7));
                const value = std.process.getEnvVarOwned(allocator, name_mod_buf.items) catch |err| switch (err) {
                    error.EnvironmentVariableNotFound => continue,
                    error.InvalidWtf8 => unreachable,
                    error.OutOfMemory => |e| return e,
                };
                std.mem.doNotOptimizeAway(&value);
            }
            break :elapsed timer.read();
        };
        std.debug.print("one char too long: {}/lookup\n", .{std.fmt.fmtDuration(elapsed / num_iterations)});
    }

    if (bench == .short or bench == .all) {
        const elapsed = elapsed: {
            timer.reset();
            for (0..num_iterations) |_| {
                const name = names.items[rand.uintLessThan(usize, names.items.len)];
                const name_trunc = name[0 .. name.len - 1];
                const value = std.process.getEnvVarOwned(allocator, name_trunc) catch |err| switch (err) {
                    error.EnvironmentVariableNotFound => continue,
                    error.InvalidWtf8 => unreachable,
                    error.OutOfMemory => |e| return e,
                };
                std.mem.doNotOptimizeAway(&value);
            }
            break :elapsed timer.read();
        };
        std.debug.print("one char too short: {}/lookup\n", .{std.fmt.fmtDuration(elapsed / num_iterations)});
    }

    if (bench == .random or bench == .all) {
        const elapsed = elapsed: {
            timer.reset();
            for (0..num_iterations) |_| {
                const len = rand.uintAtMost(usize, longest_name);
                name_mod_buf.items.len = len;
                for (name_mod_buf.items) |*c| {
                    c.* = rand.int(u7);
                }
                const value = std.process.getEnvVarOwned(allocator, name_mod_buf.items) catch |err| switch (err) {
                    error.EnvironmentVariableNotFound => continue,
                    error.InvalidWtf8 => unreachable,
                    error.OutOfMemory => |e| return e,
                };
                std.mem.doNotOptimizeAway(&value);
            }
            break :elapsed timer.read();
        };
        std.debug.print("random ascii: {}/lookup\n", .{std.fmt.fmtDuration(elapsed / num_iterations)});
    }

    if (bench == .empty or bench == .all) {
        const elapsed = elapsed: {
            timer.reset();
            for (0..num_iterations) |_| {
                const value = std.process.getEnvVarOwned(allocator, "") catch |err| switch (err) {
                    error.EnvironmentVariableNotFound => continue,
                    error.InvalidWtf8 => unreachable,
                    error.OutOfMemory => |e| return e,
                };
                std.mem.doNotOptimizeAway(&value);
            }
            break :elapsed timer.read();
        };
        std.debug.print("empty name: {}/lookup\n", .{std.fmt.fmtDuration(elapsed / num_iterations)});
    }
}

// all environment variable lookups are found
  benchenv.exe found ran
    1.98 ± 0.57 times faster than benchenv-master.exe found

// all environment variable lookups have their name truncated by one byte
  benchenv.exe short ran
    1.95 ± 0.43 times faster than benchenv-master.exe short

// all environment variable lookups have an extra ASCII character added to the name
  benchenv.exe long ran
    2.03 ± 0.37 times faster than benchenv-master.exe long

// all environment variable lookups are random strings of ASCII characters
  benchenv.exe random ran
    2.05 ± 0.53 times faster than benchenv-master.exe random

// looking up a zero-length string as the name
  benchenv.exe empty ran
    3.24 ± 0.61 times faster than benchenv-master.exe empty

(presumably, the magnitude of any speedup would also (on average) increase as the number of environment variables in the environment increases)

[rootbeer]

Very nice tests! I've got a bunch of comments, but they're mostly suggestions for more work, so feel free to ignore them as this seems like an improvement to me as-is.

Oh, one more suggestion: maybe expand the comment on getenvW to say that it does linear searches and if the caller is going to frequently fetch environment variables, it may be worthwhile to use std.process.getEnvMap to be able to query for them more efficiently?

[rootbeer]

Nice. Maybe test with non-ASCII in the "value" part too?

And can you test with a key with a leading =? That seems like a special case from the code.

[rootbeer]

Does looking up "FOO=" fail gracefully too?

[rootbeer]

This is concise, but seems like it might create unnecessary state (but I guess the optimizer can remove all that?). I think it'd be easier to read (and cleaner to implement) as something like: i = skipPastNextNull(ptr, i) that just does a while loop over ptr? Feel free to leave this if you've got faith in the optimizer, though.

[rootbeer]

Please add a comment here that this expects to be run by the build.zig which defines the expected environment.

[rootbeer]

This code ends up upcasing the key for each entry in the environment. Can you stash a pre-upcased key on the stack that you can reuse? I don't see a well-defined limit on the key length ... ah, 32k is the limit on the overall environment length, so I guess that's a maximum key length? That seems a bit large, so maybe there isn't a good way to do this ...