Du bist kein Sklave!
Geschlossener Bildungsgang für Elitekinder: „Die wahre Ordnung der Welt“.
http://noslave.org
Aus Wikipedia, der freien Enzyklopädie
| Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). | ||||||||||||||||||||||||||||||||||||
| Typ | ||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Autor |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Entwickler | ||||||||||||||||||||||||||||||||||||
| Entwickler |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Geschrieben in |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Schnittstelle |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Operationssystem | ||||||||||||||||||||||||||||||||||||
| Schnittstellensprachen |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Erste Ausgabe |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Hardware-Plattform | ||||||||||||||||||||||||||||||||||||
| letzte Version | ||||||||||||||||||||||||||||||||||||
| Release-Kandidat |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Betaversion |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Alpha-Version |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Testversion |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Lesbare Dateiformate |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Generierte Dateiformate |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Zustand |
Lua-Fehler in Module:Wikidata in Zeile 170: Versuch, das Feld "Wikibase" zu indizieren (ein Nullwert). |
|||||||||||||||||||||||||||||||||||
| Lizenz |
Hauptmerkmale:
Der Compiler unterstützt den OpenMP 3.0-Standard zum Schreiben paralleler Programme. Es enthält auch eine Modifikation von OpenMP namens Cluster OpenMP, mit der Sie Anwendungen, die gemäß OpenMP geschrieben wurden, auf Clustern mit MPI ausführen können. Der Intel C++ Compiler verwendet ein Frontend (der Teil des Compilers, der das zu kompilierende Programm parst) von der Edison Design Group. Dasselbe Frontend wird von den Compilern SGI MIPSpro, Comeau C++ und Portland Group verwendet. Dieser Compiler wird häufig zum Kompilieren von SPEC-CPU-Benchmarks verwendet. Es gibt 4 Produktserien von Intel, die den Compiler enthalten:
Zu den Nachteilen der Linux-Version des Compilers gehört die teilweise Inkompatibilität mit den GNU-Erweiterungen der C-Sprache (unterstützt vom GCC-Compiler), die beim Kompilieren einiger Programme zu Problemen führen kann.
Experimentelle VariantenDie folgenden experimentellen Versionen des Compilers wurden veröffentlicht:
Hauptflaggen
Schreiben Sie eine Rezension zum Artikel "Intel C++ Compiler"Anmerkungensiehe auchVerknüpfungen
Ein Auszug, der den Intel C++ Compiler charakterisiertUnd doch kehrte sie zurück, um den Weißen Magier ein letztes Mal zu sehen ... Ihren Ehemann und treuesten Freund, den sie nie vergessen konnte. In ihrem Herzen verzieh sie ihm. Aber zu seinem großen Bedauern konnte sie ihm die Vergebung von Magdalena nicht bringen ... Also, wie Sie sehen, Isidora, ist die große christliche Fabel über "Vergebung" nur eine kindische Lüge für naive Gläubige, die ihnen erlaubt, etwas zu tun Böse, wissend, dass ihnen, was auch immer sie tun, am Ende vergeben wird. Aber du kannst nur dem vergeben, was wirklich der Vergebung würdig ist. Ein Mensch muss verstehen, dass er sich für alles Böse verantworten muss ... Und nicht vor einem mysteriösen Gott, sondern vor sich selbst, der sich selbst dazu zwingt, grausam zu leiden. Magdalena vergab Vladyka nicht, obwohl sie ihn zutiefst respektierte und aufrichtig liebte. So wie sie uns allen den schrecklichen Tod von Radomir nicht vergeben hat. Schließlich war SIE es, die am besten verstand – wir konnten ihm helfen, wir konnten ihn vor einem grausamen Tod bewahren … Aber wir wollten nicht. Da sie die Schuld des Weißen Magiers für zu grausam hielt, ließ sie ihn mit dieser Schuld leben und vergaß sie nicht einen Moment lang ... Sie wollte ihm keine einfache Vergebung gewähren. Wir haben sie nie wieder gesehen. Wie nie ihre Babys gesehen. Durch einen der Ritter ihres Tempels – unseren Zauberer – übermittelte Magdalena dem Herrn die Antwort auf seine Bitte, zu uns zurückzukehren: „Die Sonne geht nicht zweimal an einem Tag auf ... Die Freude deiner Welt (Radomir) wird niemals zu dir zurückkehren, genauso wie ich nicht zu dir zurückkehren werde und ich... Ich habe meinen GLAUBEN und meine WAHRHEIT gefunden, sie sind LEBENDIG, deine ist TOT... Trauere um deine Söhne - sie haben dich geliebt. Ich werde dir ihren Tod nie vergeben, solange ich lebe. Und möge deine Schuld bei dir bleiben. Vielleicht bringt sie dir eines Tages Licht und Vergebung ... Aber nicht von mir. Der Kopf von Magus John wurde aus dem gleichen Grund nicht nach Meteora gebracht - keiner der Ritter des Tempels wollte zu uns zurückkehren ... Wir verloren sie, wie wir viele andere mehr als einmal verloren, die nicht verstehen wollten und akzeptiere unsere Opfer ... Wem geht es genauso wie dir - sie sind gegangen und haben uns verurteilt.Mir wurde schwindelig! … Als Durstige, die meinen ewigen Wissenshunger stillte, nahm ich gierig den Strom erstaunlicher Informationen auf, die mir der Norden großzügig gab … Und ich wollte noch viel mehr! … Ich wollte alles bis zum Ende wissen . Es war ein Hauch frischen Wassers in der von Schmerz und Unglück versengten Wüste! Und ich konnte nicht genug trinken... Ich habe tausend Fragen! Aber es bleibt keine Zeit ... Was soll ich tun, Sever? .. - Frag, Isidora!... Frag, ich werde versuchen, dir zu antworten... - Sag mir, Sever, warum scheint es mir, dass in dieser Geschichte zwei Lebensgeschichten, die mit ähnlichen Ereignissen verflochten sind, miteinander verbunden sind und als das Leben einer Person dargestellt werden? Oder bin ich nicht richtig? – Sie haben vollkommen recht, Isidora. Wie ich Ihnen bereits sagte, haben die „Mächtigen dieser Welt“, die eine falsche Geschichte der Menschheit geschaffen haben, dem wahren Leben Christi das fremde Leben des jüdischen Propheten Josua „aufgesetzt“, der vor anderthalbtausend Jahren lebte (seit der Geschichte des Nordens). Und nicht nur er selbst, sondern auch seine Familie, seine Verwandten und Freunde, seine Freunde und Anhänger. Immerhin war es die Frau des Propheten Josua, die Jüdin Mary, die eine Schwester Martha und einen Bruder Lazarus hatte, die Schwester seiner Mutter Maria Yakobe und andere, die nie in der Nähe von Radomir und Magdalena waren. So wie es neben ihnen keine anderen "Apostel" gab - Paulus, Matthäus, Petrus, Lukas und die anderen ... Es war die Familie des Propheten Joshua, die vor anderthalbtausend Jahren in die Provence (damals Gallien (Transalpine Gaul) genannt) in die griechische Stadt Massalia (heute Marseille) zog, da Massalia damals die „Tor“ zwischen Europa und Asien, und es war für alle „Verfolgten“ der einfachste Weg, Verfolgung und Unglück zu vermeiden.
| |||||||||||||||||||||||||||||||||||
Einführung Ende 2003 stellte Intel Version 8.0 seiner Compiler-Sammlung vor. Neue Compiler wurden entwickelt, um die Leistung von Anwendungen zu verbessern, die auf Servern, Desktops und Computern ausgeführt werden mobile Systeme(Laptops, Mobiltelefone und PDAs) basierend auf Intel-Prozessoren. Wir freuen uns, dass dieses Produkt unter aktiver Beteiligung von Mitarbeitern des Nischni Nowgorod Intel Software Development Center und Intel-Spezialisten aus Sarov entwickelt wurde.
Die neue Serie umfasst Intel-Compiler für C++ und Fortran für Windows und Linux sowie Intel-Compiler für C++ für Windows CE .NET. Die Compiler zielen auf Systeme ab, die auf den folgenden Intel-Prozessoren basieren: Intel Itanium 2, Intel Xeon, Intel Pentium 4, Intel Personal Internet Client Architecture-Prozessoren für Mobiltelefone und PDAs und der Intel Pentium M-Prozessor für mobile PCs (eine Komponente der Intel Centrino-Technologie für Mobiltelefone).PC).
Der Intel Visual Fortran Compiler für Windows bietet Kompilierungstechnologien der nächsten Generation für Hochleistungs-Computing. Es kombiniert die Funktionalität der Programmiersprache Compaq Visual Fortran (CVF) mit den Leistungsverbesserungen, die durch Intels Kompilierungs- und Optimierungstechnologien für die Codegenerierung ermöglicht werden, und vereinfacht die Aufgabe der Portierung Quellcode, entwickelt mit CVF, in die Intel Visual Fortran-Umgebung. Dieser Compiler ist der erste, der CVF-Funktionen sowohl für 32-Bit-Intel-Systeme als auch für Systeme implementiert, die auf der Intel Itanium-Prozessorfamilie basieren Windows-Umgebung. Darüber hinaus können Sie mit diesem Compiler CVF-Sprachfunktionen auf Linux-Systemen implementieren, die auf 32-Bit-Intel-Prozessoren und der Intel Itanium-Prozessorfamilie basieren. Für 2004 ist die Veröffentlichung einer erweiterten Version dieses Compilers geplant - der Compiler Intel Visual Fortran Compiler Professional Edition für Windows, der die von Visual Numerics, Inc. entwickelte IMSL Fortran 5.0-Bibliothek enthalten wird.
„Die neuen Compiler unterstützen auch Intels kommende Prozessoren mit dem Codenamen Prescott, die neue Befehle zur Verbesserung der Grafik- und Videoleistung sowie andere Leistungsverbesserungen bieten. Sie unterstützen auch neue Technologie Mobile MMX(tm), das in ähnlicher Weise die Leistung von Grafik-, Ton- und Videoanwendungen für Mobiltelefone und PDAs verbessert, - sagte Alexei Odinokov, Co-Direktor des Intel Software Development Center in Nischni Nowgorod. - Diese Compiler bieten Anwendungsentwicklern einen einzigen Satz von Tools zum Erstellen neuer Anwendungen für drahtlose Netzwerke basierend auf Intel-Architektur. Die neuen Intel-Compiler unterstützen auch Intels Hyper-Threading-Technologie und die Industriespezifikation OpenMP 2.0, die die Verwendung von Direktiven definiert hohes Level um den Befehlsfluss in Anwendungen zu steuern".
Zu den neuen Tools, die in den Compilern enthalten sind, gehören die Tools Intel Code Coverage und Intel Test Prioritization. Zusammen tragen diese Tools dazu bei, die Anwendungsentwicklung zu beschleunigen und die Anwendungsqualität zu verbessern, indem sie den Testprozess verbessern. Software.
Das Codeabdeckungstool stellt beim Testen einer Anwendung vollständige Details über die Verwendung der Logik der Anwendung und die Position der Bereiche bereit, die im Quellcode der Anwendung verwendet werden. Wenn Änderungen an der Anwendung vorgenommen werden oder dieser Test es nicht erlaubt, den Teil der Anwendung zu überprüfen, der für den Entwickler von Interesse ist, können Sie mit dem Testpriorisierungstool den Betrieb des ausgewählten Bereichs überprüfen Programmcode.
Die neuen Intel-Compiler sind in einer Vielzahl von Konfigurationen erhältlich, die von 399 bis 1.499 US-Dollar reichen. Sie können heute bei der Intel Corporation oder bei Wiederverkäufern auf der ganzen Welt erworben werden, deren Liste sich auf der Website befindet. http://www.intel.com/software/products/reseller.htm#Russia.
Unterstützung für Prescott-Prozessoren
Die Unterstützung für den Intel Pentium 4 (Prescott)-Prozessor in der achten Version des Compilers ist wie folgt:1. Unterstützung für SSE3-Befehle (oder PNI, Prescott New Instructions). Es gibt drei Möglichkeiten, hier hervorzuheben:
A. Assembler-Einsätze (Inline-Montage). Beispielsweise erkennt der Compiler die folgende Verwendung des SSE3-Befehls _asm(addsubpd xmm0, xmm1). Somit können Benutzer, die an Low-Level-Optimierung interessiert sind, direkt auf die Assembler-Befehle zugreifen.
B. Im C/C++-Compiler sind neue Anweisungen auf einer höheren Ebene als bei der Verwendung von Assembler-Einfügungen verfügbar. Nämlich durch eingebaute Funktionen (intrinsische Funktionen):
Eingebaute Funktionen
| eingebaute Funktion | Generierter Befehl |
|---|---|
| _mm_addsub_ps | Addsubps |
| _mm_hadd_ps | Haddps |
| _mm_hsub_ps | Msubps |
| _mm_moveldup_ps | Movsldup |
| _mm_movehdup_ps | Movshdup |
| _mm_addsub_pd | Subpd hinzufügen |
| _mm_hadd_pd | Haddpd |
| _mm_hsub_pd | hsubpd |
| _mm_loaddup_pd | movddup xmm, m64 |
| _mm_movedup_pd | movddup reg, reg |
| _mm_lddqu_si128 | Lddqu |
Die Tabelle zeigt die integrierten Funktionen und die entsprechenden Assembler-Anweisungen aus dem SSE3-Set. Dieselbe Unterstützung besteht für Befehle aus den MMX\SSE\SSE2-Sets. Dadurch kann der Programmierer Low-Level-Code-Optimierung durchführen, ohne auf Assembler-Programmierung zurückgreifen zu müssen: Der Compiler kümmert sich selbst um die Abbildung (Mapping "e") der eingebauten Funktionen auf die entsprechenden Prozessoranweisungen und die optimale Verwendung von Registern. Der Programmierer kann Konzentrieren Sie sich darauf, einen Algorithmus zu erstellen, der neue Befehlssätze effektiv verwendet.
v. Automatische Generierung neuer Befehle durch den Compiler. Die vorherigen zwei Verfahren beinhalten die Verwendung neuer Befehle durch den Programmierer. Aber der Compiler ist auch in der Lage (unter Verwendung geeigneter Optionen – siehe Abschnitt 3 unten), automatisch neue Anweisungen aus dem SSE3-Satz für C/C++- und Fortran-Code zu generieren. Beispielsweise der optimierte Befehl zum unausgerichteten Laden (lddqu), mit dem Sie eine Leistungssteigerung von bis zu 40 % erzielen können (z. B. bei Video- und Audiocodierungsaufgaben). Andere Befehle aus dem SSE3-Set ermöglichen Ihnen eine deutliche Beschleunigung bei 3D-Grafikaufgaben oder Rechenaufgaben mit komplexen Zahlen. Das Diagramm in Abschnitt 3.1 unten zeigt beispielsweise, dass für die Anwendung 168.wupwise aus der SPEC CPU2000 FP-Suite die durch die automatische Generierung von SSE3-Anweisungen erzielte Beschleunigung ~25 % betrug. Die Leistung dieser Anwendung hängt stark von der Geschwindigkeit der komplexen Zahlenarithmetik ab.
2. Nutzung der mikroarchitektonischen Vorteile des Prescott-Prozessors. Bei der Codegenerierung berücksichtigt der Compiler Änderungen der Mikroarchitektur im neuen Prozessor. Beispielsweise sind einige Operationen (wie ganzzahlige Verschiebungen, ganzzahlige Multiplikationen oder Zahlenkonvertierungen zwischen verschiedenen Gleitkommaformaten in SSE2) auf dem neuen Prozessor schneller als in früheren Versionen (sagen wir, eine ganzzahlige Verschiebung dauert jetzt einen Prozessorzyklus gegenüber vier für die vorherige Version) Intel Pentium 4 Prozessor). Durch eine intensivere Verwendung solcher Befehle können Sie Anwendungen erheblich beschleunigen.
Ein weiteres Beispiel für Mikroarchitekturänderungen ist der verbesserte S(schnelles Laden von zuvor im Speicher gespeicherten Daten); Das eigentliche Speichern findet nicht einmal im Cache-Speicher statt, sondern in einem Zwischenspeicher, der dann einen sehr schnellen Zugriff auf die Daten ermöglicht. Ein solches Merkmal der Architektur ermöglicht es beispielsweise, eine aggressivere automatische Vektorisierung des Programmcodes durchzuführen.
Der Compiler berücksichtigt auch die erhöhte Menge an Cache-Speicher in der ersten und zweiten Ebene.
3. Verbesserte Unterstützung für die Hyper-Threading-Technologie. Dieser Punkt kann durchaus mit dem vorherigen verwandt sein - Änderungen der Mikroarchitektur und ihre Verwendung im Compiler. Beispielsweise wurde eine Laufzeitbibliothek, die die OpenMP-Industriespezifikation unterstützt, für die Ausführung auf dem neuen Prozessor optimiert.
Leistung
Die Verwendung von Compilern ist eine einfache und effiziente Möglichkeit, Intel-Prozessorarchitekturen zu nutzen. Im Folgenden werden zwei Möglichkeiten der Verwendung von Compilern bedingt (sehr) hervorgehoben: a) Neukompilierung von Programmen mit mögliche Änderung Compiler-Einstellungen, b) Neukompilierung mit Änderung sowohl der Compiler-Einstellungen als auch des Quelltextes, sowie Nutzung der Compiler-Diagnose für laufende Optimierungen und die mögliche Nutzung anderer Software-Tools(z. B. Profiler).1.1 Optimieren von Programmen durch Neukompilieren und Ändern von Compilereinstellungen
Häufig besteht der erste Schritt bei der Migration zu einem neuen Optimierungscompiler darin, ihn mit den Standardeinstellungen zu verwenden. Der nächste logische Schritt besteht darin, Optionen für eine aggressivere Optimierung zu verwenden. Die Abbildungen 1, 2, 3 und 4 zeigen die Auswirkung des Wechsels auf die Intel-Compiler-Version 8.0 im Vergleich zur Verwendung anderer branchenführender Produkte (-O2 - Standard-Compiler-Einstellungen, Basis - Einstellungen an maximale Performance). Der Vergleich erfolgt auf 32-Bit- und 64-Bit-Intel-Architekturen. Als Testset werden Applikationen von SPEC CPU2000 verwendet.
Bild 1
Figur 2
Figur 3
Figur 4
Einige der Optionen sind unten aufgeführt (im Folgenden gelten die Optionen für die Windows-Betriebssystemfamilie; für die Linux-Betriebssystemfamilie gibt es Optionen mit derselben Wirkung, aber der Name kann unterschiedlich sein; zum Beispiel haben -Od oder QxK für Windows eine ähnlicher Effekt mit -O0 bzw. -xK für Linux, mehr genaue Information finden Sie im Compiler-Handbuch), die vom Intel-Compiler unterstützt werden.
Steuerung der Optimierungsstufen: Optionen -Od (keine Optimierungen; wird zum Debuggen von Programmen verwendet), -O1 (maximale Geschwindigkeit bei Minimierung der Codegröße), -O2 (Optimierung für die Codeausführungsgeschwindigkeit; standardmäßig verwendet), -O3 (aktiviert die aggressivsten Optimierungen für die Codeausführung Geschwindigkeit ; in manchen Fällen kann es zum gegenteiligen Effekt führen, d.h. zu einer Verlangsamung; zu beachten ist, dass bei IA-64 die Verwendung von -O3 in den meisten Fällen zu einer Beschleunigung führt, während der positive Effekt bei IA-32 weniger ausgeprägt ist ). Beispiele für Optimierungen, die durch -O3 ermöglicht werden, sind Loop-Austausch, Loop-Fusion, Loop-Verteilung (Reverse-Loop-Fusion-Optimierung), Software-Prefetch von Daten. Der Grund, warum Langsamkeit bei der Verwendung von -O3 möglich ist, kann sein, dass der Compiler einen heuristischen Ansatz verwendet hat, um eine aggressive Optimierung zu wählen konkreten Fall, ohne ausreichende Informationen über das Programm zu haben (z. B. generierte Prefetch-Anweisungen für die in der Schleife verwendeten Daten, in der Annahme, dass die Schleife viele Male ausgeführt wird, obwohl sie tatsächlich nur wenige Iterationen hat). In dieser Situation können die prozedurale Profiloptimierung sowie eine Vielzahl von Programmier-„Hinweisen“ (siehe Abschnitt 3.2) hilfreich sein.
Interprozedurale Optimierung: -Qip (innerhalb einer einzelnen Datei) und -Qipo (innerhalb mehrerer oder aller Projektdateien). Umfasst solche Optimierungen wie zum Beispiel die Inline-Ersetzung von häufig verwendetem Code (Reduzierung der Kosten für den Aufruf einer Funktion/Prozedur). Stellt Informationen für andere Optimierungsstufen dar – zum Beispiel Informationen über die Obergrenze der Schleife (z. B. wenn es sich um eine Kompilierzeitkonstante handelt, die in einer Datei definiert ist, aber in vielen verwendet wird) oder Informationen über die Datenausrichtung im Speicher (viele MMX \SSE\SSE2\SSE3-Befehle arbeiten schneller, wenn die Operanden im Speicher an einer 8- oder 16-Byte-Grenze ausgerichtet sind). Die Analyse von Speicherzuweisungsverfahren (in einer der Projektdateien implementiert/aufgerufen) wird an die Funktionen/Prozeduren weitergegeben, bei denen dieser Speicher verwendet wird (dies kann dem Compiler helfen, die konservative Annahme aufzugeben, dass die Daten im Speicher nicht richtig ausgerichtet sind; und die Annahme sollte konservativ sein, wenn keine zusätzlichen Informationen vorhanden sind). Als weiteres Beispiel kann die Disambiguierung, die Datenaliasing-Analyse dienen: In Ermangelung zusätzlicher Informationen und der Unmöglichkeit, die Abwesenheit von Schnittmengen zu beweisen, geht der Ersteller von der konservativen Annahme aus, dass es Schnittmengen gibt. Eine solche Entscheidung kann die Qualität solcher Optimierungen wie zum Beispiel automatische Vektorisierung auf IA-32 oder Software-Pipelining (Software-Pipelining oder SWP) auf IA-64 negativ beeinflussen. Die interprozedurale Optimierung kann bei der Analyse des Vorhandenseins von Speicherüberschneidungen helfen.
Profiloptimierung: Enthält drei Stufen. 1) Generieren von instrumentiertem Code mit der Option -Qprof_gen. 2) Der resultierende Code wird mit repräsentativen Daten ausgeführt, während der Ausführung Informationen über verschiedene Eigenschaften der Codeausführung gesammelt werden (z. B. Übergangswahrscheinlichkeiten oder ein typischer Wert für die Anzahl der Schleifeniterationen). 3) Neukompilierung mit der Option -Qprof_use, die sicherstellt, dass der Compiler die im vorherigen Schritt gesammelten Informationen verwendet. Somit hat der Compiler die Möglichkeit, nicht nur statische Schätzungen wichtiger Programmeigenschaften zu verwenden, sondern auch Daten, die während eines realen Programmlaufs erhalten werden. Dies kann bei der anschließenden Auswahl bestimmter Optimierungen helfen (z. B. eine effizientere Anordnung verschiedener Programmzweige im Speicher, basierend auf Informationen darüber, welche Zweige mit welcher Häufigkeit ausgeführt wurden; oder Anwenden einer Optimierung auf eine Schleife basierend auf Informationen über die typische Anzahl von Iterationen darin) . Die Profiloptimierung ist besonders nützlich, wenn es möglich ist, einen kleinen, aber repräsentativen Datensatz (für Schritt 2) auszuwählen, der die typischsten zukünftigen Anwendungsfälle des Programms gut veranschaulicht. In manchen Fachgebieten ist die Wahl eines solchen repräsentativen Sets durchaus möglich. Beispielsweise wird die Profiling-Optimierung von DBMS-Entwicklern verwendet.
Die oben aufgeführten Optimierungen sind vom generischen Typ, d.h. Der generierte Code funktioniert auf allen verschiedenen Prozessoren der Familie (z. B. im Fall einer 32-Bit-Architektur auf allen folgenden Prozessoren: Intel Pentium-III, Pentium 4, einschließlich des Prescott-Kerns, Intel Pentium M). Es gibt auch Optimierungen für einen bestimmten Prozessor.
Prozessorspezifische Optimierungen: -QxK (Pentium-III; Verwendung von SSE-Befehlen, Besonderheiten der Mikroarchitektur), -QxW und -QxN (Pentium 4; Verwendung von SSE- und SSE2-Befehlen, Besonderheiten der Mikroarchitektur), -QxB (Pentium M; Verwendung von SSE- und SSE2-Befehlen, Besonderheiten der Mikroarchitektur) ), QxP (Prescott; Verwendung von SSE-, SSE2- und SSE3-Befehlen, Mikroarchitekturfunktionen). In diesem Fall funktioniert der mit diesen Optionen generierte Code möglicherweise nicht auf anderen Vertretern der Prozessorfamilie (z. B. kann -QxW-Code zur Ausführung eines ungültigen Befehls führen, wenn er auf einem System ausgeführt wird, das auf einem Intel Pentium-III basiert Prozessor). Oder arbeiten Sie nicht mit maximaler Effizienz (z. B. -QxB-Code auf einem Pentium 4-Prozessor aufgrund von Unterschieden in der Mikroarchitektur). Mit diesen Optionen ist es auch möglich, Laufzeitbibliotheken zu verwenden, die für einen bestimmten Prozessor mit seinem Befehlssatz optimiert sind. Um zu kontrollieren, dass der Code tatsächlich auf dem Zielprozessor ausgeführt wird, wird ein Dispatch-Mechanismus (cpu-dispatch) implementiert: Überprüfung des Prozessors während der Programmausführung. In verschiedenen Situationen kann dieser Mechanismus entweder aktiviert werden oder nicht. Dispatch wird immer verwendet, wenn die Optionsvariante -Qax(KWNP) verwendet wird. In diesem Fall werden zwei Versionen des Codes generiert: optimiert für einen bestimmten Prozessor und "allgemein" (generisch), die Auswahl erfolgt während der Ausführung des Programms. Somit ist es durch Erhöhen der Größe des Codes möglich, eine Programmausführung auf allen Prozessoren der Linie und eine optimale Ausführung auf dem Zielprozessor zu erreichen. Eine andere Möglichkeit besteht darin, die Codeoptimierung für den vorherigen Vertreter der Linie zu verwenden und diesen Code auf diesem und nachfolgenden Prozessoren zu verwenden. Beispielsweise kann -QxN-Code auf einem Pentium 4 mit Northwood- und Prescott-Kernen ausgeführt werden. Es gibt keine Erhöhung der Codegröße. Mit diesem Ansatz können Sie eine gute, aber immer noch nicht optimale Leistung auf einem System mit einem Prescott-Prozessor (da SSE3 nicht verwendet wird und Mikroarchitekturunterschiede nicht berücksichtigt werden) mit optimaler Leistung auf Northwood erzielen. Ähnliche Optionen existieren auch für Prozessoren mit IA-64-Architektur. An dieser Moment Es gibt zwei davon: -G1 (Itanium) und -G2 (Itanium 2; Standardoption).
Das folgende Diagramm (Abbildung 5) zeigt die Beschleunigung (basierend auf einer – keine Beschleunigung) durch die Verwendung einiger der oben aufgeführten Optimierungen (nämlich -O3 -Qipo -Qprof_use -Qx(N,P)) auf einem Prescott-Prozessor im Vergleich zu den Standardeinstellungen (-O2). Die Verwendung von -QxP hilft in einigen Fällen, eine Beschleunigung im Vergleich zu -QxN zu erzielen. Den größten Speedup erzielt die bereits im vorigen Abschnitt erwähnte Anwendung 168.wupwise (aufgrund intensiver Optimierung komplexer Arithmetik mittels SSE3-Anweisungen).
Abbildung 5
Abbildung 6 unten zeigt das Verhältnis (in Zeiten) der Geschwindigkeit des Codes mit optimale Einstellungen im Vergleich zu völlig unoptimiertem Code (-Od) auf Pentium 4- und Itanium 2-Prozessoren Es ist ersichtlich, dass Itanium 2 viel mehr von der Qualität der Optimierung abhängt. Dies ist besonders ausgeprägt bei Gleitkomma(FP)-Berechnungen, wo das Verhältnis etwa 36-mal beträgt. Gleitkommaberechnungen sind starker Punkt IA-64-Architekturen, aber es muss darauf geachtet werden, die effizientesten Compiler-Einstellungen zu verwenden. Der daraus resultierende Produktivitätsgewinn zahlt sich für die Arbeit aus, die für die Suche aufgewendet wurde.
Abbildung 6. Beschleunigung bei Verwendung der besten Optimierungsoptionen SPEC CPU200
Intel-Compiler unterstützen die OpenMP-Industriespezifikation zum Erstellen von Multithread-Anwendungen. Explizite (Option -Qopenmp) und automatische (-Qparallel) Parallelisierung werden unterstützt. Beim expliziten Modus ist der Programmierer für die korrekte und effiziente Nutzung des OpenMP-Standards verantwortlich. Bei automatischer Parallelisierung entsteht für den Compiler eine zusätzliche Belastung durch die Analyse des Programmcodes. Aus diesem Grund funktioniert die automatische Parallelisierung derzeit nur bei relativ einfachen Codes effektiv.
Das Diagramm in Abbildung 7 zeigt die Beschleunigung durch die Verwendung expliziter Parallelisierung auf einem Engineering-Beispielsystem (Vorproduktion) basierend auf einem Intel Pentium 4-Prozessor (Prescott) mit Unterstützung der Hyper-Threading-Technologie: 2,8 GHz, 2 GB RAM, 8 K L1-Cache, 512K L2-Cache . Als Testsuite wird SPEC OMPM2001 verwendet. Dieses Set konzentriert sich auf kleine und mittlere SMP-Systeme, der Speicherverbrauch beträgt bis zu zwei Gigabyte. Die Anwendungen wurden mit Intel 8.0 C/C++ und Fortran mit zwei Optionssätzen kompiliert: -Qopenmp -Qipo -O3 -QxN und -Qopenmp -Qipo -O3 -QxP, wobei die Anwendungen jeweils mit aktiviertem und deaktiviertem Hyper-Threading gestartet wurden . Die Beschleunigungswerte in der Grafik sind auf die Leistung der Single-Threaded-Version mit deaktiviertem Hyper-Threading normalisiert.
Abbildung 7: Anwendungen aus der SPEC OMPM2001-Suite auf einem Prescott-Prozessor
Es ist ersichtlich, dass in 9 von 11 Fällen die Verwendung der expliziten Parallelisierung mit OpenMP zu einem Leistungsschub führt, wenn die Hyper-Threading-Technologie aktiviert ist. Bei einer Anwendung (312.swim) kommt es zu Verlangsamungen. Es ist eine bekannte Tatsache, dass diese Anwendung durch ein hohes Maß an Abhängigkeit gekennzeichnet ist Bandbreite Speicher. Wie bei der SPEC CPU2000 profitiert wupwise stark von Prescott-Optimierungen (-QxP).
1.2 Optimierung von Programmen mit Änderungen am Quellcode und Nutzung der Compiler-Diagnose
In den vorherigen Abschnitten haben wir den Einfluss des Compilers (und seiner Einstellungen) auf die Geschwindigkeit der Codeausführung betrachtet. Gleichzeitig bieten Intel-Compiler mehr Möglichkeiten zur Codeoptimierung als nur das Ändern von Einstellungen. Insbesondere ermöglichen Compiler dem Programmierer, „Hinweise“ im Programmcode zu machen, die die Generierung von effizienterem Code in Bezug auf die Leistung ermöglichen. Unten sind einige Beispiele für die Sprache C/C++ (es gibt ähnliche Tools für die Sprache Fortran, die sich nur in der Syntax unterscheiden).
#pragma ivdep (wobei ivdep Vektorabhängigkeiten ignorieren bedeutet) wird vor Programmschleifen verwendet, um dem Compiler mitzuteilen, dass darin keine Datenabhängigkeiten vorhanden sind. Dieser Hinweis funktioniert, wenn der Compiler (basierend auf der Analyse) konservativ annimmt, dass solche Abhängigkeiten existieren können (wenn der Compiler als Ergebnis der Analyse beweisen kann, dass die Abhängigkeit existiert, dann hat der „Hinweis“ keine Wirkung), während der Codeautor weiß, dass solche Abhängigkeiten nicht entstehen können. Mit diesem Hinweis kann der Compiler effizienteren Code generieren: automatische Vektorisierung für IA-32 (unter Verwendung von Vektoranweisungen aus den MMX\SSE\SSE2\SSE3-Sets für C/C++- und Fortran-Programmschleifen; mehr über diese Technik erfahren Sie z Beispiel, weiter Artikel im Intel Technology Journal), Software-Pipelining (SWP) für IA-64.
#pragma vector wird immer verwendet, um den Compiler zu zwingen, die Entscheidung über die Ineffizienz der Schleifenvektorisierung (sowohl automatisch für IA-32 als auch SWP für IA-64) zu ändern, basierend auf einer Analyse der quantitativen und qualitativen Merkmale der jeweiligen Arbeit Wiederholung.
#pragma novector macht immer das Gegenteil von #pragma vector.
#pragma vector aligned wird verwendet, um dem Compiler mitzuteilen, dass die in der Schleife verwendeten Daten an einer 16-Byte-Grenze ausgerichtet sind. Dadurch können Sie effizienteren und/oder kompakteren (aufgrund fehlender Laufzeitprüfungen) Code generieren.
#pragma vector nicht ausgerichtet macht das Gegenteil von #pragma ausgerichtet. In diesem Fall ist es schwierig, von Leistungsgewinnen zu sprechen, aber Sie können sich auf einen kompakteren Code verlassen.
Der #pragma-Verteilungspunkt wird innerhalb der Programmschleife verwendet, damit der Compiler die Verteilungsschleife an dieser Stelle in mehrere kleinere aufteilen kann. Beispielsweise kann ein solcher "Hinweis" verwendet werden, wenn der Compiler die Quellschleife nicht automatisch vektorisiert (beispielsweise aufgrund einer Datenabhängigkeit, die auch mit #pragma ivdep nicht ignoriert werden kann), während jede (oder ein Teil) der neu gebildete Zyklen können effizient vektorisiert werden.
#pragma loop count (N) wird verwendet, um dem Compiler mitzuteilen, dass der wahrscheinlichste Wert für die Anzahl der Iterationen der Schleife N ist. Diese Information hilft bei der Entscheidung über die effektivste Optimierung für diese Schleife (z. B. ob sie entrollt werden soll). , ob SWP oder automatische Vektorisierung durchgeführt werden soll, ob Softwaredaten-Prefetch-Befehle verwendet werden sollen, ...)
Der "Hinweis" _assume_aligned(p, base) wird verwendet, um dem Compiler mitzuteilen, dass der dem Zeiger p zugeordnete Speicherbereich an einer base = 2^n-Byte-Grenze ausgerichtet ist.
Das ist weit davon entfernt volle Liste verschiedene "Hinweise" an den Compiler, die die Effizienz des generierten Codes erheblich beeinträchtigen können. Es kann sich die Frage stellen, wie festgestellt werden kann, dass der Compiler einen Hinweis benötigt.
Erstens können Sie die Compiler-Diagnose in Form von Berichten verwenden, die er dem Programmierer zur Verfügung stellt. Wenn Sie beispielsweise die Option -Qvec_reportN verwenden (wobei N zwischen 0 und 3 variiert und die Detailebene darstellt), können Sie einen automatischen Vektorisierungsbericht erhalten. Der Programmierer hat Zugriff auf Informationen darüber, welche Schleifen vektorisiert wurden und welche nicht. Andernfalls meldet der Compiler die Gründe, warum die Vektorisierung fehlgeschlagen ist. Nehmen wir an, die Ursache sei eine konservativ angenommene Abhängigkeit von den Daten gewesen. Wenn der Programmierer in diesem Fall sicher ist, dass die Abhängigkeit nicht auftreten kann, kann #pragma ivdep verwendet werden. Der Compiler bietet ähnliche (im Vergleich zu Qvec_reportN für IA-32) Fähigkeiten auf IA-64, um das Vorhandensein und die Effektivität von SWP zu kontrollieren. Im Allgemeinen bieten Intel-Compiler zahlreiche Möglichkeiten zur Diagnose von Optimierungen.
Zweitens können andere Softwareprodukte (z. B. der Profiler Intel VTune) verwendet werden, um Leistungsengpässe im Code zu finden. Die Ergebnisse der Analyse können dem Programmierer helfen, die notwendigen Änderungen vorzunehmen.
Sie können auch das vom Compiler generierte Assembler-Code-Listing zur Analyse verwenden.
Abbildung 8
Abbildung 8 oben zeigt den schrittweisen Prozess der Optimierung einer Anwendung mit einem Compiler (und anderen Softwareprodukte) Intel in Fortran-Sprache für IA-64-Architektur. Als Beispiel wird ein nicht-adiabatisches regionales Vorhersageschema für 48 Stunden des Roshydrometcenters betrachtet (Sie können darüber beispielsweise in diesem Artikel lesen. Der Artikel spricht von einer Berechnungszeit von etwa 25 Minuten, aber es sind erhebliche Änderungen aufgetreten seit der Erstellung Die Codeleistung wird als Ausgangspunkt auf einem Cray-YMP-System genommen Unmodifizierter Code mit Standard-Compileroptionen (-O2) zeigte eine Leistungssteigerung von 20 % auf einem 4-Wege-System basierend auf einem Intel Itanium 2 900 MHz Prozessor Die Anwendung einer aggressiveren Optimierung (-O3) führte zu einer ca. 2,5-fachen Beschleunigung, ohne den Code zu ändern, hauptsächlich aufgrund von SWP und Datenvorabruf. Die Analyse mithilfe der Compiler-Diagnose und des Intel VTune-Profilers ergab einige Engpässe. Beispielsweise hat der Compiler mehrere Leistungs- kritische Schleifen, die im Bericht berichten, dass es auf eine Datenabhängigkeit hindeutet. Kleine Änderungen am Code (Direktive ivdep) halfen, den Effekt zu erzielen aktive Förderung. Mit dem VTune-Profiler wurde festgestellt (und der Compilerbericht bestätigte dies), dass der Compiler die Reihenfolge der verschachtelten Schleifen (Loop Interchange) nicht geändert hat, um den Cache-Speicher effizienter zu nutzen. Der Grund waren wiederum konservative Annahmen über die Abhängigkeit von den Daten. Es wurden Änderungen im Quellcode des Programms vorgenommen. Dadurch ist es uns gelungen, eine 4-fache Beschleunigung im Vergleich zur ursprünglichen Version zu erreichen. Verwenden Sie die explizite Parallelisierung mit OpenMP-Anweisungen und wechseln Sie dann zu einem System mit mehr als Hochfrequenz ermöglichte es, die Berechnungszeit auf weniger als 8 Minuten zu reduzieren, was eine mehr als 16-fache Beschleunigung im Vergleich zur ursprünglichen Version bedeutete.
Intel Visual Fortran
Intel Visual Fortran 8.0 verwendet das Front-End (Teil des Compilers, der für die Konvertierung des Programms von Text in der Programmiersprache in die interne Darstellung des Compilers verantwortlich ist, die weitgehend unabhängig von der Programmiersprache oder dem Zielcomputer ist), den CVF-Compiler Technologien und Komponenten des Intel-Compilers, die für eine Reihe von Optimierungen und die Codegenerierung verantwortlich sind.
Abbildung 9
Abbildung 10
Die Abbildungen 9 und 10 zeigen Vergleichsdiagramme Intel-Leistung Visual Fortran 8.0 mit der vorherigen Version von Intel Fortran 7.1 und mit anderen branchenbekannten Compilern dieser Sprache, die unter dem Betriebssystem ausgeführt werden Windows-Familien und Linux. Zum Vergleich wurden Tests herangezogen, deren Quelltexte nach den Standards F77 und F90 unter http://www.polyhedron.com/ verfügbar sind. Auf derselben Seite sind detailliertere Informationen zum Vergleich der Compilerleistung verfügbar (Win32 Compiler Comparisons -> Fortran (77, 90) Execution Time Benchmarks and Linux Compiler Comparisons -> Fortran (77, 90) Execution Time Benchmarks): Es gibt mehr verschiedene Compiler gezeigt, und das geometrische Mittel wird in Verbindung mit den einzelnen Ergebnissen für jeden Test angegeben.
In der vorherigen Ausgabe des Magazins haben wir über Produkte der Intel VTune Performance Analyzer-Familie gesprochen – Tools zur Leistungsanalyse, die zu Recht bei Anwendungsentwicklern beliebt sind und die es Ihnen ermöglichen, sie im Code zu erkennen Team-Anwendungen, das zu viele Prozessorressourcen verbraucht, was Entwicklern die Möglichkeit gibt, potenzielle Engpässe im Zusammenhang mit solchen Codeabschnitten zu identifizieren und zu beseitigen, wodurch der Anwendungsentwicklungsprozess beschleunigt wird. Beachten Sie jedoch, dass die Leistung von Anwendungen weitgehend davon abhängt, wie effizient die bei ihrer Entwicklung verwendeten Compiler sind und welche Hardwarefunktionen sie beim Generieren von Maschinencode verwenden.
Die neuesten Intel C++- und Intel Fortran-Compiler für Windows und Linux bieten bis zu 40 % Leistungssteigerung bei der Anwendungsleistung für Systeme, die auf Intel Itanium 2-, Intel Xeon- und Intel Pentium 4-Prozessoren basieren, gegenüber bestehenden Compilern anderer Anbieter, indem sie diese Funktionen nutzen Prozessoren, wie Hyper-Threading-Technologie.
Zu den Unterschieden, die mit der Codeoptimierung dieser Compilerfamilie verbunden sind, gehören die Verwendung eines Stacks zur Durchführung von Gleitkommaoperationen, die interprozedurale Optimierung (Interprocedural Optimization, IPO), die Optimierung gemäß dem Anwendungsprofil (Profile Guided Optimization, PGO), das Vorladen von Daten in der Cache (Data Prefetching), der die mit dem Speicherzugriff verbundene Verzögerung vermeidet, Unterstützung für charakteristische Merkmale von Intel-Prozessoren (z. B. Erweiterungen für die Streaming-Datenverarbeitung Intel Streaming SIMD Extensions 2, spezifisch für Intel Pentium 4), automatische Parallelisierung der Codeausführung , Erstellung von Anwendungen, läuft auf mehreren verschiedene Typen Prozessoren bei der Optimierung für einen von ihnen, Mittel zur "Vorhersage" des nachfolgenden Codes (Branch Prediction), erweiterte Unterstützung für die Arbeit mit Ausführungsthreads.
Beachten Sie, dass Intel-Compiler in so bekannten Unternehmen wie Alias/Wavefront, Oracle, Fujitsu Siemens, ABAQUS, Silicon Graphics, IBM verwendet werden. Basierend auf unabhängigen Tests einer Reihe von Unternehmen übertrifft die Leistung von Intel-Compilern die Leistung von Compilern anderer Hersteller erheblich (siehe beispielsweise http://intel.com/software/products/compilers/techtopics/compiler_gnu_perf.pdf).
Im Folgenden werden wir uns einige der Funktionen ansehen letzte Version Intel-Compiler für Desktop und Server Betriebssysteme.
Compiler für die Microsoft Windows-Plattform
Intel C++-Compiler 7.1 für Windows
Intel C++ Compiler 7.1 ist ein Anfang dieses Jahres veröffentlichter Compiler, mit dem Sie das erreichen können hochgradig Code-Optimierungen für die Intel Itanium-, Intel Itanium 2-, Intel Pentium 4- und Intel Xeon-Prozessoren sowie für den Intel Pentium M-Prozessor verwenden Intel-Technologie Centrino und für den Einsatz in mobilen Geräten konzipiert.
Der angegebene Compiler ist vollständig kompatibel mit Microsoft Visual C++ 6.0-Entwicklungstools und Microsoft Visual Studio .NET: Es kann in entsprechende Entwicklungsumgebungen eingebaut werden.
Dieser Compiler unterstützt ANSI- und ISO-C/C++-Standards.
Intel Fortran-Compiler 7.1 für Windows
Mit dem Intel Fortran Compiler 7.1 für Windows, der ebenfalls Anfang dieses Jahres veröffentlicht wurde, können Sie optimierten Code für Intel Itanium-, Intel Itanium 2-, Intel Pentium 4- und Intel Xeon- und Intel Pentium M-Prozessoren erstellen.
Dieser Compiler ist voll kompatibel zu den Entwicklungswerkzeugen Microsoft Visual C++ 6.0 und Microsoft Visual Studio .NET, dh er kann in die entsprechenden Entwicklungsumgebungen integriert werden. Darüber hinaus können Sie mit diesem Compiler 64-Bit-Anwendungen für Betriebssysteme entwickeln, die auf Itanium / Itanium 2-Prozessoren laufen Hilfe von Microsoft Visual Studio auf einem 32-Bit-Pentium-Prozessor mit dem 64-Bit-Intel Fortran-Compiler. Beim Debuggen von Code können Sie mit diesem Compiler den Debugger für die Microsoft .NET-Plattform verwenden.
Wenn Sie Compaq Visual Fortran 6.6 installiert haben, können Sie den Intel Fortran Compiler 7.1 anstelle des ursprünglichen Compilers verwenden, da diese Compiler auf Quellcodeebene kompatibel sind.
Der Intel Fortran Compiler 7.1 für Windows ist vollständig kompatibel mit dem ISO Fortran 95-Standard und unterstützt das Erstellen und Debuggen von zweisprachigen Anwendungen C und Fortran.
Compiler für die Linux-Plattform
Intel C++-Compiler 7.1 für Linux
Ein weiterer Compiler, der Anfang des Jahres veröffentlicht wurde, Intel C++ Compiler 7.1 für Linux, ermöglicht ein hohes Maß an Codeoptimierung für Intel Itanium-, Intel Itanium 2-, Intel Pentium 4- und Intel Pentium M-Prozessoren kompatibel mit dem GNU C-Compiler auf der Ebene des Quellcodes und der Objektmodule, sodass mit GNU C erstellte Anwendungen ohne zusätzliche Kosten darauf migriert werden können (Betriebssysteme SCO, frühe Versionen von Sun Solaris usw.), was volle Kompatibilität bedeutet der gcc 3.2-Compiler auf der Binärebene. Schließlich können Sie mit dem Intel C++ Compiler 7.1 für Linux sogar den Linux-Kernel mit ein paar geringfügigen Änderungen am Quellcode neu kompilieren.
Intel Fortran-Compiler 7.1 für Linux
Der Compiler Intel Fortran Compiler 7.1 für Linux ermöglicht die Erstellung von optimiertem Code für Intel Itanium-, Intel Itanium 2-, Intel Pentium 4- und Intel Pentium M-Prozessoren.Dieser Compiler ist vollständig kompatibel mit dem Compaq Visual Fortran 6.6-Compiler auf Quellcodeebene Damit können Sie mit Compaq Visual Fortran erstellte Anwendungen neu kompilieren und so deren Leistung verbessern.
Darüber hinaus ist der angegebene Compiler kompatibel mit Dienstprogrammen, die von Entwicklern verwendet werden, wie dem emacs-Editor, dem gdb-Debugger und dem Dienstprogramm make application build.
Wie die Windows-Version dieses Compilers ist Intel Fortran Compiler 7.1 für Linux vollständig kompatibel mit dem ISO Fortran 95-Standard und unterstützt die Erstellung und das Debugging von Anwendungen, die Code in den zwei Sprachen C und Fortran enthalten.
Hervorzuheben ist, dass ein wesentlicher Beitrag zur Erstellung der aufgeführten Intel-Compiler von Spezialisten geleistet wurde Russisches Zentrum Intel für die Softwareentwicklung in Nischni Nowgorod. Weitere Informationen zu Intel-Compilern finden Sie auf der Intel-Website unter: www.intel.com/software/products/ .
Der zweite Teil dieses Artikels widmet sich Intel-Compilern, die Anwendungen für mobile Geräte erstellen.
Beispiele für echte Hacks: Intel C++ 7.0 Compiler – WASM.RU Archive
…der Intel C++ 7.0-Compiler, der spät in der Nacht heruntergeladen wurde, gegen 5:00 Uhr morgens. Ich wollte unglaublich schlafen, aber die Neugier: ob der Schutz verstärkt wurde oder nicht, riss auch auseinander. Ich entscheide, dass ich immer noch nicht einschlafen werde, bis ich mich mit dem Schutz befasst habe, nachdem ich mich geöffnet habe neue Konsole, und Neuinstallation der TEMP- und TMP-Systemvariablen in das Verzeichnis C:\TEMP, tippte hastig den unanständig langen Installer-Namen W_CC_P_7.0.073.exe ein Befehlszeile(Die Notwendigkeit, die TEMP- und TMP-Variablen zu setzen, liegt daran, dass sie in Windows 2000 standardmäßig auf ein sehr tief verschachteltes Verzeichnis zeigen und der Intel C ++ - Installer - und nicht nur er - solche riesigen Pfade nicht unterstützt.) .
Es wurde sofort klar, dass die Schutzpolitik grundlegend überarbeitet wurde und nun bereits bei der Installation des Programms auf das Vorhandensein einer Lizenz geprüft wurde (in der Version 5.x verlief die Installation problemlos). OK, wir geben den dir-Befehl und schauen uns den Inhalt dessen an, was wir jetzt bekämpfen müssen:
Inhalt des Ordners C:\TMP\IntelC++Compiler70
17.03.2003 05:10
html 17.03.2003 05:11
x86 17.03.2003 05:11
Itanium 17.03.2003 05:11
Anmerkungen 05.06.2002 10:35 45 056 AutoRun.exe
10.07.2001 12:56 27 autorun.inf
29.10.2002 11:25 2.831 ccompindex.htm
24.10.2002 08:12 126 976 ChkLic.dll
18.10.2002 10:37 552 960 chklic.exe
17.10.2002 16:29 28.663 CLizenz.rtf
17.10.2002 16:35 386 credist.txt
16.10.2002 17:02 34 136 Crelnotes.htm
19.03.2002 14:28 4.635 PLSuite.htm
21.02.2002 12:39 2 478 registrieren.htm
02.10.2002 14:51 40 960 Setup.exe
02.10.2002 10:40 151 Setup.ini
10.07.2001 12:56 184 setup.mwg
19 Dateien 2.519.238 Byte
6 Ordner 886 571 008 Bytes frei
Aha! Das Installationsprogramm setup.exe benötigt nur etwa vierzig Kilobyte. Sehr gut! In einem solchen Volumen kann man kaum ernsthaften Schutz verbergen, und selbst wenn, kostet es nichts, diese winzige Datei vollständig zu analysieren - bis zum letzten Byte des Disassembler-Listings. Es ist jedoch keine Tatsache, dass sich der Sicherheitscode genau in setup.exe befindet, er kann sich an einer anderen Stelle befinden, zum Beispiel ... ChkLic.dll / ChkLic.exe, die zusammen etwas weniger als siebenhundert Kilobyte belegen . Warten Sie, was ist ChkLic? Ist das die Abkürzung für Check License? Ähm, die Jungs von Intel haben offensichtlich ernsthafte Probleme mit Humor. Es wäre besser, wenn sie diese Datei ehrlich "Hack Me" nennen würden! Nun, der Lautstärke nach zu urteilen, ist ChkLic derselbe FLEX-lm, und wir sind ihm bereits begegnet (siehe „Intel C++ 5.0 Compiler“) und stellen uns ungefähr vor, wie man ihn bricht.
Wir geben den Befehl "dumpbin / EXPORTS ChkLic.dll", um die exportierten Funktionen zu untersuchen und ... halten Klava fest, um nicht vom Stuhl zu fallen:
Dump der Datei ChkLic.dll
Abschnitt enthält die folgenden Exporte für ChkLic.dll
0 Eigenschaften
3DB438B4 Zeit-Datum-Stempel Mo 21. Okt 21:26:12 2002
1 Anzahl Funktionen
1 Anzahl Namen
ordinaler Hinweis RVA-Name
1 0 000010A0_CheckValidLicense
Verdammt! Protection exportiert nur eine einzige Funktion mit dem wunderbaren Namen CheckValidLicense. "Bemerkenswert" - weil der Zweck der Funktion aus ihrem Namen deutlich wird und es möglich wird, eine mühsame Analyse des Disassembler-Codes zu vermeiden. Nun, sie haben das ganze Interesse wiedererlangt ... es wäre besser, wenn sie es in einer Ordinalzahl oder so exportieren oder es zumindest auf einen beängstigenden Namen wie DES Decrypt taufen würden.
...träumend! Okay, zurück zu unseren Schafen. Lassen Sie uns logisch denken: Wenn sich der gesamte Sicherheitscode direkt in ChkLic.dll befindet (und nach der "gelenkigen" Natur der Sicherheit zu urteilen, ist dies wahr), dann läuft der gesamte "Schutz" darauf hinaus, CheckValidLicense von Setup.exe und aufzurufen Überprüfung des von ihm zurückgegebenen Ergebnisses. Daher reicht es zum "Hacken" aus, ChkLic.dll zu patchen, wodurch die ChekValidLicense-Funktion gezwungen wird, immer zurückzugeben ... übrigens, was sollte sie zurückgeben? Genauer gesagt: Was genau ist der Rückgabewert, der einer erfolgreichen Lizenzprüfung entspricht? Nein, beeilen Sie sich nicht, setup.exe zu disassemblieren, um das herauszufinden, denn es gibt nicht so viele mögliche Optionen: entweder FALSE oder TRUE. Setzen Sie auf TRUE? Nun, in gewisser Weise ist das logisch, aber andererseits: Warum haben wir uns eigentlich entschieden, dass die CheckValidLicense-Funktion genau das Erfolgs-Flag der Operation zurückgibt und nicht den Fehlercode? Schließlich müssen die Gründe für die Weigerung, den Compiler zu installieren, irgendwie motiviert sein: Die Datei mit der Lizenz wurde nicht gefunden, die Datei ist beschädigt, die Lizenz ist abgelaufen und so weiter? Okay, versuchen wir, eine Null zurückzugeben, und wenn das nicht funktioniert, geben wir eine Eins zurück.
OK, anschnallen, los geht's! Wir starten HIEW, öffnen die Datei ChkLic.dll (wenn sie sich nicht öffnet, erinnern Sie sich dreimal an die Gophers, kopieren Sie sie vorübergehend in das Stammverzeichnis oder in ein anderes Verzeichnis, das keine Sonderzeichen im Namen enthält, die hiew "y" nicht mag so viel) Dann wenden wir uns wieder der mit dumpbin erhaltenen Exporttabelle zu, ermitteln die Adresse der CheckValidLicense-Funktion (in diesem Fall 010A0h) und gehen über "10A0" zu ihrem Anfang. Jetzt schneiden wir sie live und überschreiben über den alten Code "XOR EAX, EAX / RETN 4. Warum genau "REN 4", und nicht nur "RET"? Ja, weil die Funktion die stdcall-Konvention unterstützt, was man anhand ihres Epilogs in HIEW herausfinden kann " e (scrollen Sie einfach den Disassembler-Bildschirm nach unten, bis Sie RET treffen).
Überprüfung... Es funktioniert!!! Trotz fehlender Lizenz startet der Installer die Installation ohne zu viele Fragen zu stellen! Die Abwehr ist also gefallen. Oh, wir können nicht glauben, dass alles so einfach ist, und um nicht zu sitzen und verständnislos auf den Monitor zu starren, während wir auf den Abschluss des Programminstallationsprozesses warten, setzen wir unseren bevorzugten IDA-Disassembler auf setup.exe. Das erste, was auffällt, ist das Fehlen von CheckValidLicense in der Liste der importierten Funktionen. Vielleicht startet sie irgendwie die Datei ChkLic.exe? Versuchen wir, unter den automatisch erkannten Strings den passenden Link zu finden: "~View aNames", "ChkLic"... ja, der String "Chklic.exe" ist gar nicht da, aber "Chklic.dll" wird gefunden. Ja, ich verstehe, das bedeutet, dass die ChkLic-Bibliothek durch explizites Verknüpfen über LoadLibrary geladen wird. Und nach dem Querverweis bestätigt sich dies:
Text: 0040175D Push-Offset aChklic_dll ; lpLibFileName
Text:00401762 Anruf ds:LoadLibraryA
Text:00401762 ; ChkLic.dll laden ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Text:00401762 ;
Text:00401768 Umzug esi,eax
Text:0040176A push offset a_checkvalidlic ; lpProcName
Text:0040176F push esi ; hModul
Text:00401770 Aufruf ds:GetProcAddress
Text:00401770 ; Rufen Sie die Adresse der CheckValidLicense-Funktion ab
Text:00401770 ;
Text:00401776 cmpe esi, ebx
Text:00401778 jz loc_40192E
Text:00401778 ; Wenn es keine solche Bibliothek gibt, beenden Sie das Installationsprogramm
Text:00401778 ;
Text:0040177E cmp eax, ebx
Text:00401780 jz loc_40192E
Text:00401780 ; Wenn es keine solche Funktion in der Bibliothek gibt, beenden Sie die Installation
Text:00401780 ;
Text:00401786 push ebx
Text:00401787 Eax anrufen
Text:00401787 ; Rufen Sie die Funktion CheckValidLicense auf
Text:00401787 ;
Text:00401789 test eax, eax
Text:0040178B jnz loc_4019A3
Text:0040178 ; Wenn die Funktion einen Wert ungleich Null zurückgibt, beenden Sie das Installationsprogramm
Unglaublich, diese schrecklich primitive Verteidigung ist einfach so aufgebaut! Außerdem wird die Halbmeter-ChkLic.exe-Datei überhaupt nicht benötigt! Und warum hat es sich gelohnt, es aus dem Internet zu ziehen? Übrigens, wenn Sie sich entscheiden, die Compiler-Distribution zu speichern (Achtung: ich habe nicht „distribute“ gesagt!), dann können Sie, um Speicherplatz zu sparen, ChkLic.ChkLic.dll löschen, die die stdcall-Funktion CheckValidLicence der Form exportiert: int CheckValidLicence(int some_flag) (return 0;)
Während wir all dies besprachen, beendete das Installationsprogramm die Installation des Compilers und beendete seine Arbeit erfolgreich. Ob es interessant ist, ob der Compiler gestartet wird oder das Interessanteste erst beginnt? Wir gehen fieberhaft die verzweigte Hierarchie verschachtelter Ordner hinunter, finden icl.exe, die erwartungsgemäß im bin-Verzeichnis liegt, klicken und ... Der Compiler startet natürlich nicht, verweist darauf, dass "icl: error: konnte die FLEX lm-Lizenz nicht auschecken, ohne die er seine Arbeit nicht fortsetzen kann.
Es stellt sich heraus, dass Intel einen mehrstufigen Schutz angewendet hat und sich die erste Stufe als grobe Verteidigung gegen Dummköpfe herausstellte. Also! Wir nehmen diese Herausforderung an und suchen aufgrund unserer bisherigen Erfahrungen automatisch nach der LMGR*.DLL-Datei im Compiler-Verzeichnis. Nutzlos! Diesmal gibt es hier keine solche Datei, aber es stellt sich heraus, dass icl.exe stark an Gewicht zugenommen hat und die Marke von sechshundert Kilobyte überschritten hat ... Stopp! Aber haben die Entwickler des Compilers genau diesen FLEX-lm mit einem statischen Link verknüpft? Wir schauen: In Intel C++ 5.0 betrug die Summe der Größen von lmgr327.dll und icl.exe 598 KB, und jetzt nimmt icl.exe allein 684 KB ein. Nach Anpassung an die natürliche senile „Fettleibigkeit“ konvergieren die Zahlen sehr gut. Also doch FLEX lm! Oh oh! Aber jetzt, ohne die symbolischen Namen von Funktionen, wird es viel schwieriger, den Schutz zu brechen ... Aber keine Panik! Denken wir einfach in Ruhe nach! Es ist unwahrscheinlich, dass das Entwicklungsteam den gesamten Code, der mit diesem „Umschlag“-Schutz interagiert, komplett neu geschrieben hat. Höchstwahrscheinlich endete seine "Verbesserung" durch bloße Änderung des Layouttyps. Und wenn ja, dann sind die Chancen, das Programm zu hacken, immer noch groß!
Denken Sie daran, dass der Sicherheitscode das letzte Mal eingegeben wurde Hauptfunktionen, setzen wir, nachdem wir seine Adresse ermittelt haben, einfach einen Haltepunkt und, nachdem wir auf das Popup des Debuggers gewartet haben, verfolgen wir dummerweise den Code, indem wir abwechselnd entweder auf den Debugger oder auf das Programmausgabefenster blicken: Ist dort eine missbräuchliche Meldung erschienen? Gleichzeitig markieren wir alle bedingten Sprünge, auf die wir stoßen, auf einem separaten Blatt Papier (oder legen es in unserem eigenen Gedächtnis beiseite, wenn Sie dies wünschen), und vergessen nicht, anzugeben, ob jeder bedingte Sprung ausgeführt wurde oder nicht . .. Stoppen! Wir haben etwas gechattet, aber die beleidigende Nachricht ist bereits aufgetaucht! OK gut! Mal sehen, welcher bedingte Übergang ihm entsprach. Unsere Aufzeichnungen zeigen, dass die letzte gefundene Verzweigung die bedingte JNZ-Verzweigung war, die sich an der Adresse 0401075h befindet und auf das von sub_404C0E zurückgegebene Ergebnis "reagiert":
Text:0040107F loc_40107F: ; CODE XREF: _main+75^j
Text:0040107F mov eax, offset aFfrps ; "FFrps"
Text:00401084 mov edx, 21h
Text: 00401089 Anruf sub_404C0E
Text:0040108E test eax, eax
Text:00401090 jnz kurz loc_40109A
Offensichtlich ist sub_404C0E dieselbe Schutzprozedur, die die Lizenz auf ihr Vorhandensein prüft. Wie kann man sie austricksen? Nun, es gibt viele Möglichkeiten... Zuerst können Sie den Inhalt von sub_404C0E nachdenklich und gewissenhaft analysieren, um herauszufinden: was genau und wie genau es prüft. Zweitens können Sie JNZ kurz loc_40107F einfach durch JZ kurz loc_40107F oder sogar NOP, NOP ersetzen. Drittens kann der Befehl zum Prüfen des Rückgabeergebnisses TEST EAX, EAX in einen Nullsetzbefehl umgewandelt werden: XOR EAX, EAX. Viertens kann sub_404C0E selbst so gepatcht werden, dass es immer Null zurückgibt. Ich weiß nicht, wie es euch geht, aber Methode Nummer drei hat mir am besten gefallen. Wir ändern zwei Bytes und starten den Compiler. Wenn der Schutz keine anderen Überprüfungen seiner "Lizenzierung" durchführt, funktioniert das Programm und dementsprechend umgekehrt. (Wie wir uns erinnern, gab es in der fünften Version zwei solcher Überprüfungen). Es ist erstaunlich, aber der Compiler schwört nicht mehr und funktioniert!!! Tatsächlich haben seine Entwickler den Schutz erwartungsgemäß überhaupt nicht verstärkt, sondern im Gegenteil sogar geschwächt! Chris Kaspersky
Wird geladen...