Another array access performance issue.

[IntegratedQuantum]

Zig Version

0.11.0-dev.753+331861161

Steps to Reproduce and Observed Behavior

I thought this was covered by #12215, but now that it is fixed I still get terrible performance.
Here is a simple benchmark:

const std = @import("std");

const len = 32*32*32;

fn getIndex(i: u16) u16 {
	return i;
}

pub const Chunk = struct {
	blocks: [len]u16 = undefined,
};

pub noinline fn regenerateMainMesh(chunk: *Chunk) u32 {
	var sum: u32 = 0;
	var i: u16 = 0;
	while(i < len) : (i += 1) {
		sum += chunk.blocks[getIndex(i)]; // ← workaround: (&chunk.blocks)[...]
	}
	return sum;
}

pub fn main() void {
	var chunk: Chunk = Chunk{};
	for(chunk.blocks) |*block, i| {
		block.* = @intCast(u16, i);
	}
	const start = std.time.nanoTimestamp();
	const sum = regenerateMainMesh(&chunk);
	const end = std.time.nanoTimestamp();
	std.log.err("Time: {} Sum: {}", .{end - start, sum});
}

Even in release-fast the performance is terrible:

$ zig run test.zig -OReleaseFast
error: Time: 104980842 Sum: 536854528

godbolt reveals that, like in #12215, there is a memcpy when accessing the array.

Expected Behavior

When applying the workaround

- sum += chunk.blocks[getIndex(i)]; // ← workaround: (&chunk.blocks)[...]
+ sum += (&chunk.blocks)[getIndex(i)]; // ← workaround: (&chunk.blocks)[...]

the performance is significantly better:

$ zig run test.zig -OReleaseFast
error: Time: 4188 Sum: 536854528

[shwqf]

I guess .field_ptr should be generated in fieldAccess in this case.

working on it.

[andrewrk]

Fix reverted in f93a36c

[zeroZshadow]

I've been running into this quite often on platforms where llvm isn't great at optimizing (powerpc).

The following snipped worked great as a test example to show this bug happening and not happening even though all examples index into the array.

const std = @import("std");
const E = enum(u8){
  a,
  b,
  c,
  d,
};

var array: std.enums.EnumArray(E, u32) = std.enums.EnumArray(E, u32).initFill(0);

noinline fn handle(id: u32) u32 {
    // Causes odd stack pushing and popping with 4 or less enum members, but optimized out the memcpy
    // LLVM is unable to optimize out the memcopy when the enum has more than 4 members.
    return array.get(@enumFromInt(id));

    // These both cause correct code generation, and do not generate a call to memcpy in llvm ir
    //return array.values[id];
    //return array.getPtrConst(@enumFromInt(id)).*;
}

export fn square(id: u32) u32 {
    array.set(.a, 5);
    array.set(.c, 8);
    return handle(id);
}

I'm compiling this snipped with -O ReleaseSmall -target powerpc-freestanding-eabi to see the issue easily.
I hope it is of some use.

[cdemirer]

A good explanation can be found here: #17580 (comment)

Summary: When an array is indexed, the expression on the left (the array, which is a value) is evaluated before (by design) the expression on the right (the function that returns the index). If there's any possibility that the function call modifies the array (which is the default assumption), we have no choice but to make a copy of the array before calling that function.

---

    return array.get(@enumFromInt(id));

I guess special cases (as in #13233) can be made for builtin functions like this. (Seems that's not the case as the index expression is the one at here and not the builtin one here)

For the general case, AFAIK possible solutions are:

1. Redefine the evaluation order of the index and the indexed.
2. Somehow optimize-out the copy...