Performance regression with self-hosted compiler

[voroskoi]

Zig Version

v0.10.0-dev.3672+cd5a9ba1f

Steps to Reproduce

This is on a Raspberry Pi 4 (aarch64). Probably related to #12518
I opened a different report as I am not sure about the cause of the regression, but I think my examples are quite tiny, so it should be easier to tackle down this.

Code for Day 1

Details

const std = @import("std");

const PATH = "input/day01.txt";
const MAX_LINES = 200;

pub fn first(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

    var t = try std.time.Timer.start();
    const input = try parseInput();
    std.debug.print("{d}\n", .{t.read() / std.time.ns_per_us});

    for (input) |item| {
        for (input) |elem| {
            if (item + elem == 2020) {
                return item * elem;
            }
        }
    }

    unreachable;
}

pub fn second(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

    var t = try std.time.Timer.start();
    const input = try parseInput();
    std.debug.print("{d}\n", .{t.read() / std.time.ns_per_us});

    for (input) |item| {
        for (input) |elem| {
            for (input) |third| {
                if (item + elem + third == 2020) {
                    return item * elem * third;
                }
            }
        }
    }

    unreachable;
}

fn parseInput() ![]usize {
    // const file = @embedFile(PATH);
    var lines = std.mem.tokenize(u8, IN, "\n");

    var ret: [MAX_LINES]usize = undefined;

    var counter: usize = 0;
    while (lines.next()) |line| : (counter += 1) {
        ret[counter] = try std.fmt.parseUnsigned(usize, line, 0);
    }

    return &ret;
}

test "day01a" {
    try std.testing.expectEqual(@as(usize, 482811), try first(std.testing.allocator));
}

test "day01b" {
    try std.testing.expectEqual(@as(usize, 193171814), try second(std.testing.allocator));
}

pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try first(null);
    std.debug.print("a: {d} us\n", .{timer.lap() / std.time.ns_per_us});
    _ = try second(null);
    std.debug.print("b: {d} us\n", .{timer.lap() / std.time.ns_per_us});
}

const IN =
    \\1714
    \\1960
    \\1256
    \\1597
    \\1853
    \\1609
    \\1936
    \\2003
    \\1648
    \\1903
    \\1248
    \\1525
    \\1330
    \\1281
    \\1573
    \\1892
    \\1563
    \\1500
    \\1858
    \\176
    \\1802
    \\1370
    \\1708
    \\1453
    \\1342
    \\1830
    \\1580
    \\1607
    \\1848
    \\1626
    \\1602
    \\1919
    \\1640
    \\1574
    \\1414
    \\766
    \\1581
    \\1924
    \\1727
    \\1949
    \\1406
    \\323
    \\957
    \\1862
    \\1354
    \\1427
    \\1583
    \\1067
    \\1863
    \\1553
    \\1923
    \\1990
    \\691
    \\1372
    \\1357
    \\1887
    \\1485
    \\1799
    \\1270
    \\1743
    \\1601
    \\1457
    \\1723
    \\1888
    \\1272
    \\1600
    \\1880
    \\1381
    \\1413
    \\1452
    \\277
    \\1866
    \\1542
    \\1693
    \\1760
    \\1637
    \\1675
    \\1975
    \\1304
    \\1327
    \\1985
    \\1842
    \\1255
    \\1915
    \\1266
    \\1944
    \\1824
    \\1770
    \\1392
    \\1259
    \\1313
    \\1547
    \\1293
    \\1393
    \\1896
    \\1828
    \\1642
    \\1979
    \\1871
    \\1502
    \\1548
    \\1508
    \\710
    \\1786
    \\1845
    \\1334
    \\1362
    \\1940
    \\2009
    \\1271
    \\1448
    \\1964
    \\1676
    \\1654
    \\1804
    \\1835
    \\1910
    \\1939
    \\1298
    \\1572
    \\1704
    \\1841
    \\1399
    \\1576
    \\1164
    \\1868
    \\1035
    \\262
    \\1569
    \\1639
    \\1669
    \\1543
    \\1616
    \\1658
    \\1750
    \\1765
    \\1718
    \\1861
    \\1351
    \\1531
    \\1665
    \\1771
    \\1348
    \\1289
    \\875
    \\1408
    \\1486
    \\1275
    \\1625
    \\1594
    \\1816
    \\704
    \\1800
    \\1564
    \\1291
    \\1234
    \\1981
    \\1843
    \\1387
    \\1938
    \\1827
    \\1883
    \\1911
    \\1755
    \\1353
    \\1808
    \\1498
    \\1416
    \\2006
    \\1916
    \\1411
    \\1539
    \\1963
    \\1874
    \\1898
    \\1951
    \\1292
    \\1366
    \\1912
    \\1369
    \\1478
    \\1359
    \\1859
    \\1421
    \\1384
    \\1534
    \\1283
    \\1913
    \\1794
    \\1494
    \\1860
    \\1312
    \\1869
    \\1730
    \\1510
    \\1319
    \\1428
    \\1706
    \\1432
    \\1532
;

Code for Day 11

Details

const std = @import("std");

const PATH = "input/day11.txt";

const Str = []const u8;

pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try first(null);
    std.debug.print("a: {d} us\n", .{timer.lap() / std.time.ns_per_us});
    _ = try second(null);
    std.debug.print("b: {d} us\n", .{timer.lap() / std.time.ns_per_us});
}

const Seat = enum {
    floor,
    empty,
    occupied,
};

const GRID_ROWS = 93;
const GRID_COLS = 97;
const Grid = struct {
    grd: [GRID_ROWS][GRID_COLS]Seat,

    const directions = [_][2]i2{
        .{ -1, -1 },
        .{ -1, 0 },
        .{ -1, 1 },
        .{ 1, -1 },
        .{ 1, 0 },
        .{ 1, 1 },
        .{ 0, -1 },
        .{ 0, 1 },
    };

    fn countOccupied(self: @This()) usize {
        var sum: usize = 0;
        for (self.grd) |gr| {
            for (gr) |item| {
                if (item == .occupied) sum += 1;
            }
        }
        return sum;
    }

    fn adjacentOccupied(self: @This(), row: usize, col: usize) u4 {
        var ret: u4 = 0;
        for (directions) |d| {
            const diffrow = @intCast(isize, row) + d[0];
            if (diffrow < 0 or diffrow >= GRID_ROWS) continue;

            const diffcol = @intCast(isize, col) + d[1];
            if (diffcol < 0 or diffcol >= GRID_COLS) continue;

            if (self.grd[@intCast(usize, diffrow)][@intCast(usize, diffcol)] == .occupied) ret += 1;
        }
        return ret;
    }

    fn seenOccupied(self: @This(), row: usize, col: usize) u4 {
        var ret: u4 = 0;
        for (directions) |d| {
            var diffrow = @intCast(isize, row);
            var diffcol = @intCast(isize, col);
            while (true) {
                diffrow += d[0];
                if (diffrow < 0 or diffrow >= GRID_ROWS) break;

                diffcol += d[1];
                if (diffcol < 0 or diffcol >= GRID_COLS) break;

                switch (self.grd[@intCast(usize, diffrow)][@intCast(usize, diffcol)]) {
                    .occupied => {
                        ret += 1;
                        break;
                    },
                    .empty => break,
                    .floor => continue,
                }
            }
        }
        return ret;
    }
};

pub fn first(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

    var grid = parseInput(IN);

    while (true) {
        var next_grid = grid.grd;
        var changed = false;
        for (grid.grd) |grid_row, row| {
            for (grid_row) |item, col| {
                switch (item) {
                    .empty => {
                        if (grid.adjacentOccupied(row, col) == 0) {
                            next_grid[row][col] = .occupied;
                            changed = true;
                        }
                    },
                    .occupied => {
                        if (grid.adjacentOccupied(row, col) >= 4) {
                            next_grid[row][col] = .empty;
                            changed = true;
                        }
                    },
                    .floor => {},
                }
            }
        }

        grid.grd = next_grid;

        if (!changed) break;
    }

    return grid.countOccupied();
}

pub fn second(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

    var grid = parseInput(@embedFile(PATH));

    while (true) {
        var next_grid = grid.grd;
        var changed = false;
        for (grid.grd) |grid_row, row| {
            for (grid_row) |item, col| {
                switch (item) {
                    .empty => {
                        if (grid.seenOccupied(row, col) == 0) {
                            next_grid[row][col] = .occupied;
                            changed = true;
                        }
                    },
                    .occupied => {
                        if (grid.seenOccupied(row, col) >= 5) {
                            next_grid[row][col] = .empty;
                            changed = true;
                        }
                    },
                    .floor => {},
                }
            }
        }

        grid.grd = next_grid;

        if (!changed) break;
    }

    return grid.countOccupied();
}

fn parseInput(input: Str) Grid {
    var lines = std.mem.tokenize(u8, input, "\n");

    var grid: Grid = undefined;

    var row: usize = 0;
    while (lines.next()) |line| : (row += 1) {
        for (line) |ch, col| {
            grid.grd[row][col] = switch (ch) {
                '.' => .floor,
                'L' => .empty,
                '#' => .occupied,
                else => unreachable,
            };
        }
    }

    return grid;
}

test "day11a" {
    try std.testing.expectEqual(@as(usize, 2316), try first(std.testing.allocator));
}

test "day11b" {
    try std.testing.expectEqual(@as(usize, 2128), try second(std.testing.allocator));
}

const IN =
    \\LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLL.LL.LLLLLLLL.LLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLL.L.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\..L...L.L..L.LL.....L.L..L...L.L.....L.L...LLL..L....L.L.LL.LL...L.....LLL.....L...L..L..L.......
    \\LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLL.LLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLL.LLLL.LLLLLLLLLLLLL
    \\.....LLL....L..L.L..L.L..L...L.L.LL.....L...L..LL.LL..L.L.LL...LL....LL.....L.....L.L.LL.L..L.L..
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.L.LLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLL..LLLLLLLLLLLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LL.LLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLL.LLL.LLLLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\..L.L.LL.L..LL..L..LL.L..L................L....L............L.L..L...L...L..LLLL....L.L..LL....L.
    \\LLLLLL.LLL.LLLL.LLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.L.LLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLL.LLL.LLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLL.L.LLL.LLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LL.L.L.L.....L..L...L.L...L.......L...LLL...L.LL.L.....L.LLL.LL....LLLLL.L....LLL.L..LL..L....L.L
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLLLLLLLL.LLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL
    \\LLLLLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLL.L.LLLLLLLLLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLL.LLL
    \\.L.LL..LL...L....LL...L.LL.L....LL.LL......L..L........LL..LLL..L...LLL.....LL....L.L...L.....L..
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLLLLLL.LLL.LLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLL.L.LLLLLLLLLLLLL
    \\.LLLLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLL.L.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLL.LLLLLLL.LLL.LLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLL
    \\..L....LL..LL.LLLL......L..L...LLL.L......L.L.....L....L....LLLL.....L..LL...L....L....LLL....LL.
    \\LLLLLLLLLLLLLLL.LLLL.LLLLL.LLLLLLLL..LLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLL.LLLLLLLL.LLLL..LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLL.LLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLL..LLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLL.LL
    \\LLLLLLLLLLLLLLL.LLL..LLLLLLLL.LL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLL.LLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\...LL.LL.....LL..LLL.....LL....LL....L.LL.L.LL....L........LLLL..LLLLLL.L..L..LLL......L....L....
    \\LLL.LLLLLLLLLLLLLLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LL.LLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\.....L.L..LL..LL..L.L.L.....LLLLL.....L..L...L.....L.L..L..L....LL....L...........L.L.......L.LLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLL.LLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL..LLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLL.LLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLL.LLLLLLL.L.LLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLL.L.LLL.LLLL.LLLL.LLLLLLLLLLLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLL.LLLLLLLL.LL.L.LLLLLLLL
    \\L.LLL.................LLL....L...LL..........L.L.L.......L.....L.....LLLLLL......L.......L...L.LL
    \\LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLL.LL.LLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLL.LL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL.LLL.LLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLL.LLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLLLLLLL.LLL..LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\..L...LL.LLL.LLL.......LL..LL.L...LLL.....L....LLLL.L..........L.....L.L....L..............LL.L..
    \\LLLLLLLLLL.LLLL.LLL..LLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
    \\LLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLL.LLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLLLL.LL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLLL.LLLLL.LLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLL.LL.LL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LL.L.L..LL..L.......L.L..LL....L.L.L...L.L..LL....LL.LL....L....LL..L....L............L.......L..
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLL.L.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
    \\..L.L.....L......L..L.....L.......L..L....LL...L.L.L...LLL.L.L..L..L..L......LLL.....L..L..L.....
    \\LLLLLLLLLLLLLLL.LLLLLL.LLLLLL.LLLLL.LLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLL.LLLLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLLLLLL.LLLLLL.L.LLLLLL.LLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLLLLLL..LLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLL.LLLLLLLL.LLLLLL.LLLLLLLLLLLLL.LLLLLLLL
    \\LLLLLLLLLL.LLLLLLLLL.LL.LLLLL.LLLLLLLLLLLLL.LLLLLLL.LLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLL
;

Expected Behavior

The self-hosted performance should be on-par with the stage1 compiler.

I have tried to pick minimal examples, but here you can find all the related code: https://nest.pijul.com/voroskoi/aoc2020-zig

As You can see, self-hosted is approximately 4 times slower overall, with Day 11 being the biggest regression.

Actual Behavior

The output is much slower with the self-hosted compiler.

Here are my results for day 1. The difference is not horrible, but still should not be there.

voroskoi ~/code/aoc2020-zig via ↯ v0.10.0-dev.3672+cd5a9ba1f ❯ zig run src/day01.zig -fstage1 -O ReleaseFast
17
a: 75 us
35
b: 3642 us
voroskoi ~/code/aoc2020-zig via ↯ v0.10.0-dev.3672+cd5a9ba1f ❯ zig run src/day01.zig -O ReleaseFast
14
a: 80 us
11
b: 4172 us

This is the output for Day 11. Huge difference.

voroskoi ~/code/aoc2020-zig via ↯ v0.10.0-dev.3672+cd5a9ba1f ❯ zig run src/day11.zig -O ReleaseFast -fstage1
a: 17343 us
b: 49528 us
voroskoi ~/code/aoc2020-zig via ↯ v0.10.0-dev.3672+cd5a9ba1f ❯ zig run src/day11.zig -O ReleaseFast
a: 5754004 us
b: 7529408 us

[Vexu]

Possibly related to #12215

[topolarity]

This seems to be due to stage2 introducing local temporaries when loading fields from the large Grid parameter.

It is surprising that LLVM fails to optimize these away, given that their last usage immediately follows their definition and no derived references escape the block. Still, it's best for Zig to elide these temporaries wherever we can, especially for Debug-mode performance.

Example as provided:

$ zig run test2.zig -O ReleaseFast -fstage1
a: 4469 us
b: 14792 us
$ zig run test2.zig -O ReleaseFast
a: 339310 us
b: 521673 us 

If self: @This() is changed to self: *const @This() in countOccupied, adjacentOccupied, seenOccupied:

$ zig run test2.zig -O ReleaseFast -fstage1
a: 4492 us
b: 13780 us
$ zig run test2.zig -O ReleaseFast
a: 4287 us
b: 14628 us

Edit: Found the missing copy elision in AIR (.struct_field_val) for by-ref types. Fix incoming