bounds-check-elimination

I was recently reading this article by Dave Detlefs in which he presents a few cases where the CLR performs array bounds check elimination. I decided to test this myself, so I did the following: Opened Visual Studio 2010 Ultimate SP1 Created a new C# project of type Console Application (targeting .NET 4 Client Profile by default) Added the following code (all sub-methods are taken directly from the article): class Program { static void Main(string[] args) { int[] array = new int[30]; Test_SimpleAscend(array); Test_SimpleRedundant(array, 3); foreach (int i in array) { Console.WriteLine(i); } }

I'm interested in how efficient low-level algorithms can be in .net. I would like to enable us to choose to write more of our code in C# rather than C++ in the future, but one stumbling block is the bounds checking in .net that occurs with looping and random access to arrays. A motivating example is a function that calculates the sum of products of corresponding elements in two arrays (this is the dot product of two vectors). static void SumProduct(double[] X, double[] Y) { double sum = 0; int length = X.Length; if (length != Y.Length) throw new ArgumentException("X and Y must be same size");

I wrote a simple benchmark in order to find out if bounds check can be eliminated when the array gets computed via bitwise and. This is basically what nearly all hash tables do: They compute h & (table.length - 1) as an index into the table , where h is the hashCode or a derived value. The results shows that the bounds check don't get eliminated. The idea of my benchmark is pretty simple: Compute two values i and j , where both are guaranteed to be valid array indexes. i is the loop counter. When it gets used as array index, the bounds check gets eliminated. j gets computed as x & (table