The pointer was aligned and the struct was padded

# Self-authored for the EML case corpus (no external origin). Every field in the
# record is correctly aligned and the compiler guarantees it. What the record
# costs is computed below.
#
# Alignment is a correctness property and it holds here exactly. Each field
# begins at an offset divisible by its own size, no load straddles a cache line
# in a way the hardware would trap on, and the compiler inserted whatever gaps
# were needed to make that true without being asked.
#
# The gaps are the cost. Alignment says WHERE each field starts; it says nothing
# about how much of the record is field and how much is the compiler making the
# next offset divide. Reordering the same fields changes nothing about
# correctness and changes the size.
#
# The record is declared in the order a person would read it. Held that way it
# is forty bytes; sorted widest-first it is twenty-four.

# field sizes in declaration order: flag, id, kind, timestamp, count
1 => size_flag
8 => size_id
1 => size_kind
8 => size_timestamp
4 => size_count
8 => widest_field
42000000 => records_resident

size_flag + size_id + size_kind + size_timestamp + size_count => bytes_of_actual_field

# Declaration order: a 1-byte flag, then an 8-byte id needs offset 8, so 7 pad.
# kind at 17, timestamp needs offset 24, so 7 pad. count at 28, then the record
# is padded to a multiple of the widest field.
7 => pad_after_flag
7 => pad_after_kind
bytes_of_actual_field + pad_after_flag + pad_after_kind => size_before_tail_pad
# Tail padding rounds up to a multiple of the alignment, so an array of these
# keeps every element aligned.
int(size_before_tail_pad / widest_field) => whole_units
size_before_tail_pad - whole_units * widest_field => remainder
if remainder > 0:
    widest_field - remainder => tail_pad
else:
    0 => tail_pad
size_before_tail_pad + tail_pad => size_as_declared

# Widest first: id, timestamp, count, flag, kind — nothing needs an interior gap.
size_id + size_timestamp + size_count + size_flag + size_kind => reordered_before_tail
int(reordered_before_tail / widest_field) => r_units
reordered_before_tail - r_units * widest_field => r_remainder
if r_remainder > 0:
    widest_field - r_remainder => reordered_tail_pad
else:
    0 => reordered_tail_pad
reordered_before_tail + reordered_tail_pad => size_reordered

"bytes that are field       : " + str(bytes_of_actual_field) ^0
"size as declared           : " + str(size_as_declared) ^0
"size reordered widest first: " + str(size_reordered) ^0
"" ^0

# ---- what alignment guarantees ----

"the alignment the compiler enforced" ^0
"  flag      at offset 0" ^0
"  id        at offset 8   divisible by 8" ^0
"  kind      at offset 16" ^0
"  timestamp at offset 24  divisible by 8" ^0
"  count     at offset 32  divisible by 4" ^0
"  misaligned loads : 0" ^0
"  verdict          : correctly aligned" ^0
"" ^0
"  true in both layouts, and true for every field; the" ^0
"  compiler will not emit a misaligned one" ^0
"" ^0

# ---- what it cost ----

size_as_declared - bytes_of_actual_field => padding_as_declared
size_reordered - bytes_of_actual_field => padding_reordered
size_as_declared - size_reordered => bytes_per_record_saved

"padding in the declared layout  : " + str(padding_as_declared) ^0
"padding when reordered          : " + str(padding_reordered) ^0
"difference per record           : " + str(bytes_per_record_saved) ^0
"" ^0

int(padding_as_declared * 10000 / size_as_declared) => padding_per_myriad
"share of the declared record that is gap : " + str(padding_per_myriad) + " per ten thousand" ^0
"" ^0

# ---- at scale ----

records_resident * size_as_declared => resident_as_declared
records_resident * size_reordered => resident_reordered
resident_as_declared - resident_reordered => resident_saved

"records held in memory     : " + str(records_resident) ^0
"bytes as declared          : " + str(resident_as_declared) ^0
"bytes reordered            : " + str(resident_reordered) ^0
"bytes the field order cost : " + str(resident_saved) ^0
"" ^0

# ---- null control ----

# Same five fields, same alignment rule, declared widest first from the start.
0 => nc_bytes_saved_by_reordering

"null control - the same fields declared widest first" ^0
"  alignment verdict           : correctly aligned, unchanged" ^0
"  padding                     : " + str(padding_reordered) ^0
"  further saving from reorder : " + str(nc_bytes_saved_by_reordering) ^0
"  the rule did not change; the declaration order stopped" ^0
"  forcing gaps to satisfy it" ^0
"" ^0

# ---- the rule ----

"what correct alignment guarantees" ^0
"  every field starts where the hardware wants it : exactly" ^0
"  the record is no larger than its fields        : not" ^0
"    addressed, and the padding is the mechanism that" ^0
"    makes the first hold" ^0
"" ^0
"alignment is satisfied by inserting gaps; declaration order" ^0
"decides how many gaps satisfying it takes, and no diagnostic" ^0
"fires because nothing is wrong" ^0
"" ^0

"Every field is correctly aligned in both layouts and 0 loads are misaligned." ^0
"The declared order needs " + str(padding_as_declared) + " bytes of gap around " + str(bytes_of_actual_field) + " bytes of field -" ^0
str(padding_per_myriad) + " per ten thousand of the record is padding - so the same five values" ^0
"occupy " + str(size_as_declared) + " bytes instead of " + str(size_reordered) + ", and across " + str(records_resident) + " resident records" ^0
"that is " + str(resident_saved) + " bytes bought by the order somebody wrote the fields in." ^0

size_flag = 1
size_id = 8
size_kind = 1
size_timestamp = 8
size_count = 4
widest_field = 8
records_resident = 42000000
bytes_of_actual_field = size_flag + size_id + size_kind + size_timestamp + size_count
pad_after_flag = 7
pad_after_kind = 7
size_before_tail_pad = bytes_of_actual_field + pad_after_flag + pad_after_kind
whole_units = int(size_before_tail_pad / widest_field)
remainder = size_before_tail_pad - whole_units * widest_field
if remainder > 0:
    tail_pad = widest_field - remainder
else:
    tail_pad = 0
size_as_declared = size_before_tail_pad + tail_pad
reordered_before_tail = size_id + size_timestamp + size_count + size_flag + size_kind
r_units = int(reordered_before_tail / widest_field)
r_remainder = reordered_before_tail - r_units * widest_field
if r_remainder > 0:
    reordered_tail_pad = widest_field - r_remainder
else:
    reordered_tail_pad = 0
size_reordered = reordered_before_tail + reordered_tail_pad
print("bytes that are field       : " + str(bytes_of_actual_field))
print("size as declared           : " + str(size_as_declared))
print("size reordered widest first: " + str(size_reordered))
print("")
print("the alignment the compiler enforced")
print("  flag      at offset 0")
print("  id        at offset 8   divisible by 8")
print("  kind      at offset 16")
print("  timestamp at offset 24  divisible by 8")
print("  count     at offset 32  divisible by 4")
print("  misaligned loads : 0")
print("  verdict          : correctly aligned")
print("")
print("  true in both layouts, and true for every field; the")
print("  compiler will not emit a misaligned one")
print("")
padding_as_declared = size_as_declared - bytes_of_actual_field
padding_reordered = size_reordered - bytes_of_actual_field
bytes_per_record_saved = size_as_declared - size_reordered
print("padding in the declared layout  : " + str(padding_as_declared))
print("padding when reordered          : " + str(padding_reordered))
print("difference per record           : " + str(bytes_per_record_saved))
print("")
padding_per_myriad = int(padding_as_declared * 10000 / size_as_declared)
print("share of the declared record that is gap : " + str(padding_per_myriad) + " per ten thousand")
print("")
resident_as_declared = records_resident * size_as_declared
resident_reordered = records_resident * size_reordered
resident_saved = resident_as_declared - resident_reordered
print("records held in memory     : " + str(records_resident))
print("bytes as declared          : " + str(resident_as_declared))
print("bytes reordered            : " + str(resident_reordered))
print("bytes the field order cost : " + str(resident_saved))
print("")
nc_bytes_saved_by_reordering = 0
print("null control - the same fields declared widest first")
print("  alignment verdict           : correctly aligned, unchanged")
print("  padding                     : " + str(padding_reordered))
print("  further saving from reorder : " + str(nc_bytes_saved_by_reordering))
print("  the rule did not change; the declaration order stopped")
print("  forcing gaps to satisfy it")
print("")
print("what correct alignment guarantees")
print("  every field starts where the hardware wants it : exactly")
print("  the record is no larger than its fields        : not")
print("    addressed, and the padding is the mechanism that")
print("    makes the first hold")
print("")
print("alignment is satisfied by inserting gaps; declaration order")
print("decides how many gaps satisfying it takes, and no diagnostic")
print("fires because nothing is wrong")
print("")
print("Every field is correctly aligned in both layouts and 0 loads are misaligned.")
print("The declared order needs " + str(padding_as_declared) + " bytes of gap around " + str(bytes_of_actual_field) + " bytes of field -")
print(str(padding_per_myriad) + " per ten thousand of the record is padding - so the same five values")
print("occupy " + str(size_as_declared) + " bytes instead of " + str(size_reordered) + ", and across " + str(records_resident) + " resident records")
print("that is " + str(resident_saved) + " bytes bought by the order somebody wrote the fields in.")

bytes that are field       : 22
size as declared           : 40
size reordered widest first: 24

the alignment the compiler enforced
  flag      at offset 0
  id        at offset 8   divisible by 8
  kind      at offset 16
  timestamp at offset 24  divisible by 8
  count     at offset 32  divisible by 4
  misaligned loads : 0
  verdict          : correctly aligned

  true in both layouts, and true for every field; the
  compiler will not emit a misaligned one

padding in the declared layout  : 18
padding when reordered          : 2
difference per record           : 16

share of the declared record that is gap : 4500 per ten thousand

records held in memory     : 42000000
bytes as declared          : 1680000000
bytes reordered            : 1008000000
bytes the field order cost : 672000000

null control - the same fields declared widest first
  alignment verdict           : correctly aligned, unchanged
  padding                     : 2
  further saving from reorder : 0
  the rule did not change; the declaration order stopped
  forcing gaps to satisfy it

what correct alignment guarantees
  every field starts where the hardware wants it : exactly
  the record is no larger than its fields        : not
    addressed, and the padding is the mechanism that
    makes the first hold

alignment is satisfied by inserting gaps; declaration order
decides how many gaps satisfying it takes, and no diagnostic
fires because nothing is wrong

Every field is correctly aligned in both layouts and 0 loads are misaligned.
The declared order needs 18 bytes of gap around 22 bytes of field -
4500 per ten thousand of the record is padding - so the same five values
occupy 40 bytes instead of 24, and across 42000000 resident records
that is 672000000 bytes bought by the order somebody wrote the fields in.

Trace event types