.net codice più lento su AMD Opteron CPU

Question

Si è verificata una situazione in cui un semplice codice .net fibonniacci è più lento su un particolare set di server e l'unica cosa che è ovviamente diversa è la CPU. processore AMD Opteron 6276 - 11 secs Intel Xeon E7 XPU - 4850 - 7 secondi

Codice sia rispettato per x86 e l'utilizzo di .NET Framework 4.0. -La velocità di clock tra entrambi è simile e in effetti i benchmark PassMark danno punteggi alti per AMD. -Hai provato su altri server AMD nella farm e i tempi sono più lenti. -Anche le mie macchine locali I7 eseguono il codice più velocemente.

codice Fibonnacci:

class Program 
{ 
    static void Main(string[] args) 
    { 
     const int ITERATIONS = 10000; 
     const int FIBONACCI = 100000; 

     var watch = new Stopwatch(); 
     watch.Start(); 


     DoFibonnacci(ITERATIONS, FIBONACCI); 

     watch.Stop(); 

     Console.WriteLine("Total fibonacci time: {0}ms", watch.ElapsedMilliseconds); 
     Console.ReadLine(); 
    } 

    private static void DoFibonnacci(int ITERATIONS, int FIBONACCI) 
    { 
     for (int i = 0; i < ITERATIONS; i++) 
     { 
      Fibonacci(FIBONACCI); 
     } 
    } 

    private static int Fibonacci(int x) 
    { 
     var previousValue = -1; 
     var currentResult = 1; 

     for (var i = 0; i <= x; ++i) 
     { 
      var sum = currentResult + previousValue; 
      previousValue = currentResult; 
      currentResult = sum; 
     } 

     return currentResult; 
    } 

} 

Tutte le idee su quello che forse sta succedendo?

Answer 1

Come abbiamo stabilito nei commenti, è possibile aggirare questo bash delle prestazioni bloccando il processo su un processore specifico sulle macchine AMD Opteron.

Accolto da questa domanda non proprio sull'argomento, ho deciso di dare un'occhiata ai possibili scenari in cui il single-pinning farebbe una tale differenza (da 11 a 7 secondi sembra un po 'estremo).

La risposta più plausibile, non è che rivoluzionaria:

La serie impiego AMD Opteron HyperTransport in una cosiddetta architettura NUMA, al posto di un FSB tradizionale, come si farebbe ricerca di Intel SMP CPU (Xeon 4850 incluso)

La mia ipotesi è che questo sintomo deriva dal fatto che i singoli nodi in un'architettura NUMA hanno una cache individuale, al contrario della CPU Intel, in cui la cache del processore è condivisa.

In altre parole, quando calcoli consecutivi si spostano tra i nodi su Opteron, la cache viene svuotata, mentre il bilanciamento tra processori in un'architettura SMP come Xeon 4850 non ha un tale impatto poiché la cache è condivisa.

Impostazione affinità in .NET è piuttosto facile, basta scegliere un processore (facciamo solo prendere il primo per semplicità):

static void Main(string[] args) 
{ 
    Console.WriteLine(Environment.ProcessorCount); 
    Console.Read(); 

    //An AffinityMask of 0x0001 will make sure the process is always pinned to processer 0 
    Process thisProcess = Process.GetCurrentProcess(); 
    thisProcess.ProcessorAffinity = (IntPtr)0x0001; 

    const int ITERATIONS = 10000; 
    const int FIBONACCI = 100000; 

    var watch = new Stopwatch(); 
    watch.Start(); 


    DoFibonnacci(ITERATIONS, FIBONACCI); 

    watch.Stop(); 

    Console.WriteLine("Total fibonacci time: {0}ms", watch.ElapsedMilliseconds); 
    Console.ReadLine(); 
} 

anche se sono abbastanza sicuro che questo non è molto intelligente in un ambiente NUMA .

Windows 2008 R2 ha some cool native NUMA functionality, e ho trovato un progetto CodePlex promettente con un wrapper NET per questo così: http://multiproc.codeplex.com/

io sono in alcun modo vicino qualificati per insegnare come utilizzare questa tecnologia, ma questo dovrebbe indirizzarti nella giusta direzione.