Post History

Measuring arithmetic overflow checking overflow in C#

[Overflow checking for integral-type arithmetic operations](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/checked) is [disabled by default](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/language) and it can be explicitly enabled by using using `checked` function or the `-checked` compiler switch.

Since I mainly develop business applications where the main focus is correctness, **I am wondering if globally switching to `checked` makes sense and what would be the performance impact**.

My benchmarking code is the following:

```c#
[MemoryDiagnoser]
public class Program
{
    private const int Loops = 100 * 1000;
    private static readonly int[][] Data = new int[Loops][];
    private static readonly int[] Results = new int[Loops];
    private const int MaxValue = 1000;

    [GlobalSetup]
    // populate data to avoid wasting benchmarking time with this
    public static void CreateData()
    {
        Random r = new();
        int n1 = r.Next(MaxValue);
        int n2 = r.Next(MaxValue);
        int n3 = r.Next(MaxValue);

        for (int i = 0; i < Loops; i++)
        {
            Data[i] = new[] { n1, n2, n3 };
        }
    }

    // checked is applied based on flag
    // since checked(function_call) does not seem to work
    private static int GetSum(bool isChecked, int[] numbers)
    {
        if (isChecked)
            return checked (numbers[0] + numbers[1] + numbers[2]);

        return numbers[0] + numbers[1] + numbers[2];
    }

    // execute the sum in a loop to get a significant computation time
    private static void Compute(bool isChecked)
    {
        for (int i = 0; i < Loops; i++)
        {
            int[] row = Data[i];
            int result = GetSum(isChecked , new [] {row[0], row[1], row[2]});
            Results[i] = result;
        }
    }

    [Benchmark(Baseline = true)]
    public void ComputeBaseline()
    {
        Compute(false);
    }

    [Benchmark(Baseline = false)]
    public void ComputeChecked_()
    {
        Compute(true);
    }

    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<Program>();
    }
}
```

My results are as follows (release without attached to process):

```
|          Method |     Mean |     Error |    StdDev | Ratio | RatioSD |    Gen 0 | Allocated |
|---------------- |---------:|----------:|----------:|------:|--------:|---------:|----------:|
| ComputeBaseline | 1.257 ms | 0.0127 ms | 0.0106 ms |  1.00 |    0.00 | 849.6094 |      4 MB |
| ComputeChecked_ | 1.153 ms | 0.0213 ms | 0.0209 ms |  0.92 |    0.02 | 849.6094 |      4 MB |
```

I am not sure I am reading this correct, because it seems that the `checked` version is a little bit faster than the unchecked one or my code is incorrectly written for the benchmark.

I would appreciate a code review to understand if I doing something wrong in my assessment.