Question

We need to represent huge numbers in our application. We’re doing this using integer arrays. The final production should be maxed for performance. We were thinking about encapsulating our array in a class so we could add properties to be related to the array such as isNegative, numberBase and alike.

We’re afraid that using classes, however, will kill us performance wise. We did a test where we created a fixed amount of arrays and set it’s value through pure arrays usage and where a class was created and the array accessed through the class:

for (int i = 0; i < 10000; i++)
{
    if (createClass)
    {
        BigNumber b = new BigNumber(new int[5000], 10);
        for (int j = 0; j < b.Number.Length; j++)
        {
            b[j] = 5;
        }
    }
    else
    {
        int[] test = new int[5000];
        for (int j = 0; j < test.Length; j++)
        {
            test[j] = 5;
        }
    }
}

And it appears that using classes slows down the runnign time of the above code by a factor 6 almost. We tried the above just by encapsulating the array in a struct instead which caused the running time to be almost equal to pure array usage.

What is causing this huge overhead when using classes compared to structs? Is it really just the performance gain you get when you use the stack instead of the heap?

BigNumber just stores the array in a private variable exposed by a property. Simplified:

public class BigNumber{
  private int[] number;

  public BigNumber(int[] number) { this.number = number;}

  public int[] Number{get{return number;}}
}

Answer 1

It’s not surprising that the second loop is much faster than the first one. What’s happening is not that the class is extraordinarily slow, it’s that the loop is really easy for the compiler to optimize.

As the loop ranges from 0 to test.Length-1, the compiler can tell that the index variable can never be outside of the array, so it can remove the range check when accessing the array by index.

In the first loop the compiler can’t do the connection between the loop and the array, so it has to check the index against the boundaries for each item that is accessed.

There will always be a bit of overhead when you encapsulate an array inside a class, but it’s not as much as the difference that you get in your test. You have chosen a situation where the compiler is able to optimize the plain array access very well, so what you are testing is more the compilers capability to optimize the code rather than what you set out to test.