Hier ist ein Teil des C ++ - Codes, der ein sehr eigenartiges Verhalten zeigt. Aus irgendeinem seltsamen Grund macht das Sortieren der Daten auf wundersame Weise den Code fast sechsmal schneller:
#include <algorithm>
#include <ctime>
#include <iostream>
int main()
{
// Generate data
const unsigned arraySize = 32768;
int data[arraySize];
for (unsigned c = 0; c < arraySize; ++c)
data[c] = std::rand() % 256;
// !!! With this, the next loop runs faster.
std::sort(data, data + arraySize);
// Test
clock_t start = clock();
long long sum = 0;
for (unsigned i = 0; i < 100000; ++i)
{
// Primary loop
for (unsigned c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;
std::cout << elapsedTime << std::endl;
std::cout << "sum = " << sum << std::endl;
}- Ohne
std::sort(data, data + arraySize);läuft der Code in 11,54 Sekunden. - Mit den sortierten Daten läuft der Code in 1,93 Sekunden.
Anfangs dachte ich, dies könnte nur eine Sprach- oder Compiler-Anomalie sein, also habe ich Java ausprobiert:
import java.util.Arrays;
import java.util.Random;
public class Main
{
public static void main(String[] args)
{
// Generate data
int arraySize = 32768;
int data[] = new int[arraySize];
Random rnd = new Random(0);
for (int c = 0; c < arraySize; ++c)
data[c] = rnd.nextInt() % 256;
// !!! With this, the next loop runs faster
Arrays.sort(data);
// Test
long start = System.nanoTime();
long sum = 0;
for (int i = 0; i < 100000; ++i)
{
// Primary loop
for (int c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
System.out.println((System.nanoTime() - start) / 1000000000.0);
System.out.println("sum = " + sum);
}
}Mit einem ähnlichen, aber weniger extremen Ergebnis.
Mein erster Gedanke war, dass das Sortieren die Daten in den Cache bringt, aber dann dachte ich, wie dumm das war, weil das Array gerade generiert wurde.
- Was ist los?
- Warum ist die Verarbeitung eines sortierten Arrays schneller als die Verarbeitung eines unsortierten Arrays?
Der Code fasst einige unabhängige Begriffe zusammen, daher sollte die Reihenfolge keine Rolle spielen.
170
Woops ... re: Meltdown und Spectre
—
KyleMit
@SachinVerma Auf den ersten Blick: 1) Die JVM ist möglicherweise endlich klug genug, um bedingte Bewegungen auszuführen. 2) Der Code ist speichergebunden. 200M sind viel zu groß, um in den CPU-Cache zu passen. Die Leistung wird also durch Speicherbandbreite und nicht durch Verzweigung beeinträchtigt.
—
Mysticial
@ Mysticial, ungefähr 2). Ich dachte, die Vorhersage-Tabelle verfolgt Muster (unabhängig von den tatsächlichen Variablen, die für dieses Muster überprüft wurden) und ändert die Vorhersage-Ausgabe basierend auf dem Verlauf. Könnten Sie mir bitte einen Grund nennen, warum ein super großes Array nicht von der Verzweigungsvorhersage profitieren würde?
—
Sachin Verma
@SachinVerma Das tut es, aber wenn das Array so groß ist, kommt wahrscheinlich ein noch größerer Faktor ins Spiel - die Speicherbandbreite. Der Speicher ist nicht flach . Der Zugriff auf den Speicher ist sehr langsam und die Bandbreite ist begrenzt. Um die Dinge zu vereinfachen, gibt es nur so viele Bytes, die in einer festgelegten Zeit zwischen CPU und Speicher übertragen werden können. Einfacher Code wie der in dieser Frage wird wahrscheinlich diese Grenze erreichen, selbst wenn er durch falsche Vorhersagen verlangsamt wird. Dies ist bei einem Array von 32768 (128 KB) nicht der Fall, da es in den L2-Cache der CPU passt.
—
Mysticial
Es gibt eine neue Sicherheitslücke namens BranchScope: cs.ucr.edu/~nael/pubs/asplos18.pdf
—
Veve
