Wydajność podczas generowania braków pamięci podręcznej procesora

Question

Próbuję dowiedzieć się o wydajności pamięci podręcznej procesora w świecie .NET. W szczególności pracuję przy Igor Ostovsky's article about Processor Cache Effects.

Przeszedłem przez pierwsze trzy przykłady w jego artykule i zapisałem wyniki, które znacznie różnią się od jego. Myślę, że muszę zrobić coś złego, ponieważ wydajność na mojej maszynie pokazuje prawie dokładnie odwrotne wyniki tego, co pokazuje w swoim artykule. Nie widzę dużych efektów w wyniku chybień w pamięci podręcznej, których oczekiwałbym.

Co robię źle? (Zły kod, ustawienie kompilator, itp)

Oto WYNIKI na moim komputerze:

Jeśli to pomoże, procesor na mój maszyna to Intel Core i7-2630QM. Oto informacje na pamięć podręczna procesora:

Mam skompilowany w trybie x64 wydania.

Poniżej jest mój kod źródłowy:

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

Dlaczego używasz I + = 32 w drugiej pętli. W ten sposób przechodzisz przez linie pamięci podręcznej. 32 * 4 = 128 bajtów większy niż 64 bajty.