schnelle Vermehrung von Werten in einem Array

Question

Gibt es einen schnellen Weg, um Werte eines Schwimmers Array in C++, zu multiplizieren, um diese Funktion zu optimieren (wo count ein Vielfaches von 4):

void multiply(float* values, float factor, int count) 
{ 
    for(int i=0; i < count; i++) 
    { 
     *value *= factor; 
     value++; 
    } 
} 

Es muss eine Lösung arbeiten unter Mac OS X und Windows, Intel und Nicht-Intel. Denken Sie an SSE, Vektorisierung, Compiler (gcc vs. MSVC).

Answer 1

Wenn Sie möchten, dass Ihr Code plattformübergreifend ist, dann müssen Sie entweder plattformunabhängigen Code schreiben oder Sie müssen eine Last von #ifdef s schreiben.

Haben Sie versucht, eine manuelle Loop-Abrollung auszuprobieren, und zu sehen, ob es einen Unterschied macht?

Answer 2

Da Sie wissen, die count ein Vielfaches von 4, können Sie Ihre Schleife abrollen kann ...

void multiply(float* values, float factor, int count) 
{ 
    count = count >> 2; // count/4 
    for(int i=0; i < count ; i++) 
    { 
     *value *= factor; 
     *(value+1) *= factor; 
     *(value+2) *= factor; 
     *(value+3) *= factor; 
     value += 4; 
    } 
} 

Answer 3

Haftungsausschluss: Offensichtlich wird dies nicht auf dem iPhone funktionieren, iPad, Android, oder ihre Zukunft Äquivalente .

#include <mmintrin.h> 
#include <xmmintrin.h> 

__m128 factor4 = _mm_set1_ps(factor); 
for (int i=0; i+3 < count; i += 4) 
{ 
    __m128 data = _mm_mul_ps(_mm_loadu_ps(values), factor4); 
    _mm_storeu_ps(values, data); 
    values += 4; 
} 
for (int i=(count/4)*4; i < count; i++) 
{ 
    *values *= factor; 
    value++; 
} 

Answer 4

Haben Sie an OpenMP gedacht?

Die meisten modernen Computer haben Multi-Core-CPUs und fast jeder größere Compiler scheint OpenMP eingebaut zu haben. Sie gewinnen Geschwindigkeit um fast jeden Preis.

Siehe Wikipedia's article on OpenMP.

Answer 5

Die beste Lösung ist, es einfach zu halten und den Compiler für Sie optimieren zu lassen. GCC weiß über SSE, SSE2, altivec und was noch. Wenn Ihr Code zu komplex ist, kann Ihr Compiler ihn nicht für jedes mögliche Ziel optimieren.

Answer 6

Wie Sie bereits erwähnt haben, gibt es zahlreiche Architekturen mit SIMD-Erweiterungen und SIMD ist wahrscheinlich die beste Wahl, wenn es um die Optimierung geht. Sie sind alle jedoch plattformspezifisch und die Sprachen C und C++ sind nicht SIMD-freundlich.

Das erste, was Sie jedoch versuchen sollten, ist die SIMD-spezifischen Flags für Ihren Build zu aktivieren. Der Compiler kann Muster erkennen, die mit SIMD optimiert werden können.

Die nächste Sache ist, plattformspezifischen SIMD-Code mit Compiler-Intrinsik oder Assembly zu schreiben, wo es angebracht ist. Sie sollten jedoch eine portable Nicht-SIMD-Implementierung für Plattformen beibehalten, die keine optimierte Version haben. #ifdef s aktivieren SIMD auf Plattformen, die es unterstützen.

Schließlich, zumindest auf ARM, aber nicht sicher auf Intel, beachten Sie, dass kleinere Ganzzahl und Fließkommatypen eine größere Anzahl von parallelen Operationen pro einzelnen SIMD-Befehl erlauben.

Answer 7

Ich denke, es gibt nicht viel, was Sie tun können, macht einen großen Unterschied. Vielleicht können Sie es mit OpenMP oder SSE etwas beschleunigen. Aber moderne CPUs sind schon ziemlich schnell. In einigen Anwendungen ist Speicherbandbreite/Latenz tatsächlich der Flaschenhals und es wird schlechter. Wir haben bereits drei Cache-Ebenen und benötigen intelligente Prefetch-Algorithmen, um große Verzögerungen zu vermeiden. Es macht also Sinn, auch über Speicherzugriffsmuster nachzudenken.Zum Beispiel, wenn Sie bei der Implementierung eines solchen multiply und eine add und es wie folgt verwendet werden:

void multiply(float vec[], float factor, int size) 
{ 
    for (int i=0; i<size; ++i) 
    vec[i] *= factor; 
} 

void add(float vec[], float summand, int size) 
{ 
    for (int i=0; i<size; ++i) 
    vec[i] += summand; 
} 

void foo(float vec[], int size) 
{ 
    multiply(vec,2.f,size); 
    add(vec,9.f,size); 
} 

Sie grundsätzlich zweimal über den Speicherblock vorbei. Abhängig von der Größe des Vektors passt er möglicherweise nicht in den L1-Cache. In diesem Fall wird bei einer zweimaligen Übergabe zusätzliche Zeit benötigt. Dies ist offensichtlich schlecht und Sie sollten versuchen, Speicherzugriffe "lokal" zu halten. In diesem Fall wird eine einzelne Schleife wahrscheinlich schneller sein. Als Faustregel gilt: Versuchen Sie, linear auf den Speicher zuzugreifen, und versuchen Sie, "lokal" auf den Speicher zuzugreifen, indem Sie versuchen, die bereits im L1-Cache vorhandenen Daten wiederzuverwenden. Nur eine Idee.