Docs Build status updates of commit 6211bfb:

✅ Validation status: passed

For more details, please refer to the build report.

Note: Broken links written as relative paths are included in the above build report. For broken links written as absolute paths or external URLs, see the broken link report.

For any questions, please:

• Try searching in the Docs contributor and Admin Guide
• See the frequently asked questions
• Post your question in the Docs support channel

while uncommon in .NET are not impossible.

E.g. with such a struct?

[StructLayout(LayoutKind.Explicit)]
public struct Bar
{
    [FieldOffset(0)]
    public byte A;

    [FieldOffset(1)]
    public long B;

    [FieldOffset(9)]
    public byte C;

    [FieldOffset(10)]
    public long D;
}

B and D aren't aligned to a 8 byte boundary anymore, the size of the struct is 24 bytes so it may cross cache lines.

while uncommon in .NET are not impossible.

E.g. with such a struct?

[StructLayout(LayoutKind.Explicit)]
public struct Bar
{
    [FieldOffset(0)]
    public byte A;

    [FieldOffset(1)]
    public long B;

    [FieldOffset(9)]
    public byte C;

    [FieldOffset(10)]
    public long D;
}

B and D aren't aligned to a 8 byte boundary anymore, the size of the struct is 24 bytes so it may cross cache lines.

Yeap. This used to be the more common way of getting to this sort of situation, but with the advent of .NET Span you have new ways of getting to this sort of situation.

Docs Build status updates of commit 979e162:

✅ Validation status: passed

For more details, please refer to the build report.

Note: Broken links written as relative paths are included in the above build report. For broken links written as absolute paths or external URLs, see the broken link report.

For any questions, please:

• Try searching in the Docs contributor and Admin Guide
• See the frequently asked questions
• Post your question in the Docs support channel

I believe interlocked operations on 64-bit memory locations have a requirement for the memory location to be aligned to 8 bytes, so they cannot cross a cache line boundary. I don't think there is a way to do atomic operations on unaligned 64-bit memory locations.

I believe interlocked operations on 64-bit memory locations have a requirement for the memory location to be aligned to 8 bytes, so they cannot cross a cache line boundary. I don't think there is a way to do atomic operations on unaligned 64-bit memory locations.

None of the above is true for Intel / x86 architectures:

1. 8 byte and cache-line alignment are unrelated (although I do understand you intention that some non-aligned 8-byte addresses will also be un-aligned to a 64 bytes cache line)
2. Cross-cache-line atomic are allowed, albeit at a significant performance drop
3. Intra cache-line misaligned atomics are allowed and carry no performance degradation.

Reference Intel docs / text explaining (1)-(3) was linked in the original comment at the top of this issue.

True, but that doesn't seem to be the case for ARM architectures, where load/store-exclusive instructions seem to require alignment in many if not all cases, with perhaps a stricter requirement on the size of the locked region (within which unaligned accesses may be allowed) than the size of a cache line. The interlocked read prevents tearing on 32-bit systems (similarly to Volatile.Read(ref Int64), which would also have the same alignment constraints on 32-bit processors that don't allow interlocked unaligned accesses). The operation offers stronger memory ordering than both a basic aligned read and an aligned Volatile.Read(ref Int64) even on 64-bit systems. Instead of suggesting when usage of the API is not necessary I think it would be more useful to say something like:

• Some systems may require the memory location to be aligned to 8 bytes, so for compatibility the method should not be used on references that may not be aligned as such.

Maybe some more guidance would be useful, suggestions?

That's something different then... 👍

All I'm saying is that this PR, specifically, corrects a false statement:

...method is unnecessary on 64-bit systems, because 64-bit

Into a correct one:

...method is only necessary on 64-bit systems when the location refers...

I think that the issue of alignment is more of a conceptual issue that is probably best addressed in general in some conceptual-level documentation of the Interlocked class...

Maybe something such as a "See Also" link from this page pointing to a dedicated page that discusses alignment, can even (gasp!) link to the actual relevant documentation per supported architecture in .NET (e.g. x86 + arm) and give the proper context...

Makes sense?

Yea maybe the general guidance should be in the Interlocked class docs with links to it from method docs and maybe in Volatile class docs as well. For the purpose of correcting the incorrect info, that sounds fine to me, but I suggest changing method is only necessary ... when to method is necessary ... when, as the only seems to imply that that's the only case where it may be necessary.

Hi @damageboy; I think there's a piece of feedback left to address here. Would you like to update the PR for approval?

Thanks!