Rendimiento al generar falta de memoria caché de la CPU

Question

Estoy tratando de conocer el rendimiento de la memoria caché de la CPU en el mundo de .NET. Específicamente estoy trabajando con Igor Ostovsky's article about Processor Cache Effects.

He leído los primeros tres ejemplos en su artículo y he registrado resultados que difieren ampliamente de los suyos. Creo que debo estar haciendo algo mal porque el rendimiento de mi máquina muestra resultados casi opuestos a los que muestra en su artículo. No veo los grandes efectos de errores de caché que esperaría.

¿Qué estoy haciendo mal? (Mal código, configuración del compilador, etc.)

Éstos son los resultados de rendimiento en mi máquina:

Si ayuda, el procesador en mi la máquina es un Intel Core i7-2630QM. Aquí es información en la caché de mi procesador:

he compilado en modo de 64 bits de salida.

A continuación se muestra el código fuente:

class Program 
    { 

     static Stopwatch watch = new Stopwatch(); 

     static int[] arr = new int[64 * 1024 * 1024]; 

     static void Main(string[] args) 
     { 
      Example1(); 
      Example2(); 
      Example3(); 


      Console.ReadLine(); 
     } 

     static void Example1() 
     { 
      Console.WriteLine("Example 1:"); 

      // Loop 1 
      watch.Restart(); 
      for (int i = 0; i < arr.Length; i++) arr[i] *= 3; 
      watch.Stop(); 
      Console.WriteLine("  Loop 1: " + watch.ElapsedMilliseconds.ToString() + " ms"); 

      // Loop 2 
      watch.Restart(); 
      for (int i = 0; i < arr.Length; i += 32) arr[i] *= 3; 
      watch.Stop(); 
      Console.WriteLine("  Loop 2: " + watch.ElapsedMilliseconds.ToString() + " ms"); 

      Console.WriteLine(); 
     } 

     static void Example2() 
     { 

      Console.WriteLine("Example 2:"); 

      for (int k = 1; k <= 1024; k *= 2) 
      { 

       watch.Restart(); 
       for (int i = 0; i < arr.Length; i += k) arr[i] *= 3; 
       watch.Stop(); 
       Console.WriteLine("  K = "+ k + ": " + watch.ElapsedMilliseconds.ToString() + " ms"); 

      } 
      Console.WriteLine(); 
     } 

     static void Example3() 
     { 

      Console.WriteLine("Example 3:"); 

      for (int k = 1; k <= 1024*1024; k *= 2) 
      { 

       //256* 4bytes per 32 bit int * k = k Kilobytes 
       arr = new int[256*k]; 



       int steps = 64 * 1024 * 1024; // Arbitrary number of steps 
       int lengthMod = arr.Length - 1; 

       watch.Restart(); 
       for (int i = 0; i < steps; i++) 
       { 
        arr[(i * 16) & lengthMod]++; // (x & lengthMod) is equal to (x % arr.Length) 
       } 

       watch.Stop(); 
       Console.WriteLine("  Array size = " + arr.Length * 4 + " bytes: " + (int)(watch.Elapsed.TotalMilliseconds * 1000000.0/arr.Length) + " nanoseconds per element"); 

      } 
      Console.WriteLine(); 
     } 

    } 

Answer 1

¿Por qué se utiliza i + = 32 en el segundo bucle. Está pasando por líneas de caché de esta manera. 32 * 4 = 128bytes más grande que 64bytes necesarios.