Intel-C++-Compiler: Optimaler Code für den Prozessor

Die Optimierung beim Intel-Compiler setzt sich neben Standard-Optimierungsverfahren aus drei Hauptkomponenten zusammen. Als erstes ist die Auto-Vectorization zu nennen. Hierbei werden arithmetische Operationen darauf optimiert, mittels SIMD-Instruktionen gleichzeitig ausgeführt werden zu können.

Im Gegensatz zum Konkurrenten Microsoft und GCC kann der Intel-Compiler Schleifen-Strukturen deutlich tiefer aufbrechen und mittels SIMD-Instruktionen vektorisieren. Daraus resultiert eine deutlich höhere Ausführungsgeschwindigkeit, aber auch ein wesentlich größerer Code.

Der Compiler unterstützt dabei SSE bis hin zu SSE4. Der Intel-Compiler erlaubt dabei, jeweils zusätzlich generischen IA-32 oder EM64T-Code zu generieren, so dass das Executable auf jedem Prozessor lauffähig ist.

Allerdings wird entweder der komplett optimierte oder der generische Code gewählt. Das heißt: Kompiliert man für SSSE3, dann wird immer der Code ganz ohne SSE ausgeführt, wenn man ihn auf einem Prozessor mit SSE3 oder geringer ausführt.

Weiterhin gilt zu unterscheiden, dass Intel-spezifische Instruktionen kompiliert werden
können, was dazu führt, dass der Code auf AMD-Prozessoren gar nicht oder nur ganz ohne SIMD-Instruktionen läuft, siehe Bild 4.

Nahtlos in die Auto-Vectorization integriert sich die Interprocedural Optimization (IPO). Mittels IPO lässt sich Code aus verschiedenen Sourcefiles optimieren. Dies entspricht im wesentlichen der Link-Time-Code-Generation bei Microsoft (LTCG).

Der Intel-Compiler kann parallelisierbare Schleifen erkennen und generiert mehrere Threads, entsprechend der Anzahl der logischen Prozessoren auf dem Rechner. In der Version 10 des Intel-Compilers ist die Auto-Parallelization neu. Außerdem unterstützt er OpenMP, bei der der Entwickler Schleifen selber kennzeichnen muss, ob sie zur parallelen Ausführung auf Multi-Core-Systemen oder Clustern geeignet sind.

Es lässt sich ein Schwellenwert (/Qpar-threshold) von 0 bis 100 einstellen, um zu entscheiden, wann der Overhead des zusätzlichen Threads geringer ist, als die parallele Ausführung.

Nimmt man folgende Schleife:

for (i
= 0;
i<_num_iterations;
i++)

{
c[i]=a[i]+b[i];

}

So ergibt sich daraus, dass die Array-Elemente c als Summe von a und b unabhängig voneinander erechnet werden können. Der Intel-Compiler generiert nun Code, der die Schleife auf Threads aufteilt. Für die Dauer der Schleife, werden alle Prozessoren in einem Rechner verwendet.