Why Nullable<byte> is aligned to 8 bytes instead of 2 bytes as short does?

[yyjdelete]

Use System.Runtime.CompilerServices.Unsafe.SizeOf<T>() and ValueTuple to do the test, seems it's always the same on different version of .net.(x86 aligned to 4 bytes)
Don't know why it need such a big padding, and use 3 more times(1 more time for x86) memory than it actually needed.

Type	Length
byte?	2
short	2
ValueTuple<byte?>	2
ValueTuple	2
ValueTuple<short, short>	4
ValueTuple<byte?, byte?>	16
ValueTuple<short, short, short>	8
ValueTuple<byte?, byte?, byte?>	24

[MichalStrehovsky]

This is caused by ValueType<T1,T2> being marked as [StructLayout(LayoutKind.Auto)]. If it was Sequential, the size of ValueTuple<byte?, byte?> would probably be 4 bytes.

I don't know off the top of my head whether this is expected.

[stephentoub]

This is caused by ValueType<T1,T2> being marked as [StructLayout(LayoutKind.Auto)]. If it was Sequential

Really? I've always thought of Auto as being "let the runtime optimize the layout by ordering the fields optimally", in which case I'd expect Auto to always end up being as small or smaller than Sequential. Why would Auto cause this?

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

class Program
{
    static void Main()
    {
        Console.WriteLine("Auto:       " + Unsafe.SizeOf<AutoWrapper>());
        Console.WriteLine("Sequential: " + Unsafe.SizeOf<SequentialWrapper>());
    }
}

[StructLayout(LayoutKind.Auto)]
internal struct AutoWrapper { public byte? One, Two; }

[StructLayout(LayoutKind.Sequential)]
internal struct SequentialWrapper { public byte? One, Two; }

outputs on 64-bit:

Auto:       16
Sequential: 4

EDIT: Fixed typos.

[MichalStrehovsky]

The test program is looking at AutoWrapper twice. This is the expected output:

Auto:       16
Sequential: 4

[stephentoub]

Argh, sorry, copy and paste error. You're right. Fixed.

[stephentoub]

Which begs the question... why is that the case?

[benaadams]

Doesn't event need fields to be 16 which is weird?

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

class Program
{
    static void Main()
    {
        Console.WriteLine("Auto:       " + Unsafe.SizeOf<AutoWrapper>());
        Console.WriteLine("Sequential: " + Unsafe.SizeOf<SequentialWrapper>());
    }
}

[StructLayout(LayoutKind.Auto)]
internal struct AutoWrapper { public Nullish<byte> One, Two; }

[StructLayout(LayoutKind.Sequential)]
internal struct SequentialWrapper { public Nullish<byte> One, Two; }

[StructLayout(LayoutKind.Auto)]
internal struct Nullish<T> where T : struct
{
    // No fields
}

Produces

Auto:       16
Sequential: 16

Changing Nullish to

[StructLayout(LayoutKind.Sequential)]
internal struct Nullish<T> where T : struct
{
}

Produces

Auto:       16
Sequential: 2

And changing to

[StructLayout(LayoutKind.Sequential)]
internal struct Nullish<T> where T : struct
{
    T Value;
    bool HashValue;
}

Produces

Auto:       16
Sequential: 4

[MichalStrehovsky]

I suspect it's this:

https://github.com/dotnet/coreclr/blob/ff02091612aa42f79e5d3adbd608b36da9f47fdb/src/vm/methodtablebuilder.cpp#L8077-L8097

It's odd that we don't just pByValueMT->ContainsPointers() instead of speculating about "could have GC pointers". We could just try to do that padding conditionally on ContainsPointers() and see how much it breaks the CI.

The CLR has had this code there since at least 2007 (that's where the TFS history cuts off).