Regression from v2.2.6 to v2.2.8 and also `devel` in refc `{.align.}` pragma where each 32-byte-aligned heap objects gets its own page

[tersec]

Nim Version

Pre-regression:

Nim Compiler Version 2.2.6 [Linux: amd64]
Compiled at 2026-03-01
Copyright (c) 2006-2025 by Andreas Rumpf

git hash: ab00c56904e3126ad826bb520d243513a139436a
active boot switches: -d:release

Post-regression:

Nim Compiler Version 2.2.8 [Linux: amd64]
Compiled at 2026-03-01
Copyright (c) 2006-2026 by Andreas Rumpf

git hash: 4f500679b196fad944caa50a753f5bbfaefda001
active boot switches: -d:release

Nim Compiler Version 2.3.1 [Linux: amd64]
Compiled at 2026-03-04
Copyright (c) 2006-2026 by Andreas Rumpf

git hash: 8e2547a5e2a616380b71cdcbc922770fa11aafb8
active boot switches: -d:release

Description

type U = object
  d {.align: 32.}: int8
var e: seq[ref U]
for _ in 0 ..< 10000: e.add(new U)
echo getTotalMem()

Also notably, if one uses a variation of this:

type U = object
  d {.align: 32.}: int8
var e: seq[ref U]
for _ in 0 ..< 10000: e.add(new U)
for f in e: echo cast[uint](addr f[]) mod 4096

in v2.2.8, every one byte (but sure, 32-byte-aligned) item is in its own 4096-byte, at a constant offset of 64 into said page, explaining the increased memory usage:

...
64
64
64
64
64
64
64
...

For v2.2.6, it shows:

80
128
176
224
272
320
368
416
464
512
560
608
656
704
752
800

and cycles around more gradually, with 48-byte strides.

Current Output

With v2.2.6: 1052672
With v2.2.8 and devel: 45916160

Expected Output

Known Workarounds

No response

Additional Information

No response

[Araq]

What's the point of this issue? Tracking that optimizing for .align: 16 isn't good enough?

[tersec]

32-byte alignment can be quite helpful on the test Zen 5 system when using AVX2:

import std/os

const
  c = 131072
  g = 6000

{.passC: "-mavx2".}

type
  A = ref object
    d {.align: 32.}: array[c, int32]

  B = ref object
    e {.align: 64.}: array[48, byte]
    d: array[c, int32]

proc f(p: ptr int32) {.noinline.} =
  for i in 0 ..< c:
    cast[ptr UncheckedArray[int32]](p)[i] = 0x12345678'i32

if commandLineParams()[0] == "aligned":
  let j = new A
  doAssert (cast[uint](addr j.d[0]) mod 32) == 0
  for _ in 0 ..< g: f(addr j.d[0])
else:
  let j = new B
  let k = cast[uint](addr j.d[0])
  doAssert k mod 16 == 0 and k mod 32 != 0
  for _ in 0 ..< g: f(addr j.d[0])

Which benchmarks 16-byte vs 32-byte alignment as the latter being 1.7x faster:

$ hyperfine --warmup 5 -N './h aligned' './h misaligned
'
Benchmark 1: ./h aligned
  Time (mean ± σ):      17.2 ms ±   1.2 ms    [User: 16.3 ms, System: 0.7 ms]
  Range (min … max):    15.4 ms …  23.1 ms    184 runs
 
Benchmark 2: ./h misaligned
  Time (mean ± σ):      28.8 ms ±   1.5 ms    [User: 28.2 ms, System: 0.4 ms]
  Range (min … max):    26.9 ms …  38.2 ms    107 runs
 
Summary
  ./h aligned ran
    1.68 ± 0.15 times faster than ./h misaligned

(Edit: I also tried benchmarking the versions without doAsserts, in case. Not much change.)