A parallel loop that updates per-thread counters gets slower as you add cores. What is false sharing, how do you detect it, and how do you fix it in .NET?

1. The ping-pong, drawn

      core 0                       core 1
  L1: [ c0 c1 c2 ... ]  <-line->  [ c0 c1 c2 ... ]   one 64-byte line holds c0..c7

  core 0 writes c0  -> invalidate core 1's copy
  core 1 writes c1  -> must fetch line from core 0, invalidate core 0's copy
  core 0 writes c0  -> must fetch line back ...

Each transfer costs roughly 40–100+ cycles on one socket and more across sockets, versus about 1 cycle for an increment in L1.

2. MESI in one table

Writing requires the line in Modified or Exclusive state, so any other copies are invalidated first.

3. Cache line sizes and padding choices

Padding to 128 bytes is a safe portable choice for a small number of hot slots.

4. Padding in C#

[StructLayout(LayoutKind.Explicit, Size = 128)]
public struct PaddedLong
{
    [FieldOffset(64)] public long Value;   // value sits in the middle of its own 128-byte block
}

An array PaddedLong[] then places each value on its own line (arrays of structs are contiguous, and the element size is 128). Note the array's start isn't guaranteed to be 128-byte aligned; putting the value at offset 64 keeps neighbours at least 64 bytes away either side.

5. Where false sharing hides in .NET code

• Per-thread or per-partition counters in arrays.
• Hand-written ring buffers with head and tail fields next to each other.
• Small objects allocated together and each owned by a different thread (the GC packs them closely).
• static fields of one class updated by different threads (statics of a class are stored together).

6. Choosing the right fix

Can each thread keep its own running value until the end?
   yes -> local accumulation (localInit/localFinally, Aggregate) -- best
   no  -> does the value need to be read while running?
            occasionally -> sharded, padded counters; sum on read
            constantly   -> rethink: one contended value can't scale

7. Try it yourself

1. Benchmark the shared long[] version, a padded version and a local-accumulation version with MaxDegreeOfParallelism set to 1, 2, 4 and 8.
2. On Linux, run the shared version under perf c2c record -- dotnet run -c Release and look at the top shared cache line in perf c2c report.
3. Replace the counters with a single Interlocked.Increment and observe true sharing.

namespace FalseSharing;

using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Explicit, Size = 128)]
public struct PaddedLong
{
    [FieldOffset(64)] public long Value;
}

public static class Counting
{
    // BAD: slots share cache lines, and threads can collide on a slot (lost updates).
    public static long SharedArray(int[] items, int workers)
    {
        var counts = new long[workers];
        Parallel.For(0, workers, new ParallelOptions { MaxDegreeOfParallelism = workers }, w =>
        {
            for (var i = w; i < items.Length; i += workers)
            {
                if (items[i] % 3 == 0) counts[w]++;      // neighbours on the same line
            }
        });
        return counts.Sum();
    }

    // Better: each worker's slot is on its own cache line.
    public static long Padded(int[] items, int workers)
    {
        var counts = new PaddedLong[workers];
        Parallel.For(0, workers, new ParallelOptions { MaxDegreeOfParallelism = workers }, w =>
        {
            for (var i = w; i < items.Length; i += workers)
            {
                if (items[i] % 3 == 0) counts[w].Value++;
            }
        });
        long total = 0;
        foreach (var c in counts) total += c.Value;
        return total;
    }

    // Best: accumulate in a local, publish once per partition.
    public static long LocalAccumulation(int[] items)
    {
        long total = 0;
        Parallel.ForEach(
            System.Collections.Concurrent.Partitioner.Create(0, items.Length),
            localInit: () => 0L,
            body: (range, _, local) =>
            {
                for (var i = range.Item1; i < range.Item2; i++)
                {
                    if (items[i] % 3 == 0) local++;
                }
                return local;
            },
            localFinally: local => Interlocked.Add(ref total, local));
        return total;
    }
}