Optimering av kod för snabba matematikberäkningar med GCC involverar flera strategier, inriktning på olika aspekter av kompileringsprocessen och din kod själv. Här är en uppdelning av effektiva tekniker:
1. Kompilatorflaggor:
Dessa är de mest påverkande optimeringarna. Du lägger till dem i din kompileringskommandorad (t.ex. `g ++ -O3 -ffast -matemed ...`).
* `-o`,` -o2`, `-o3`,` -ofast`: Dessa flaggor styr optimeringsnivån. `-O` är en grundläggande optimering,` -o2 'är en bra balans mellan hastighet och sammanställningstid, `-o3' är aggressiv optimering och` -ofast` möjliggör ännu mer aggressiva optimeringar, vilket potentiellt kränker IEEE 754-standarder för flytande punkt aritmetik (se nedan). Börja med `-o2` eller` -o3` såvida du inte har specifika skäl att inte göra det.
* `-ffast-Math`: Detta är avgörande för snabb matematik. Det möjliggör flera andra optimeringar som kan påskynda beräkningarna avsevärt men kan äventyra den strikta noggrannheten som krävs av IEEE 754:
* ombeställning av operationer: GCC kan ordna om beräkningar för att förbättra effektiviteten, även om det något ändrar resultatet på grund av flytande punkt precisionsbegränsningar.
* med snabbare men mindre exakta matematiska funktioner: Det kan ersätta standard matematiska funktioner (som `sin ',` cos`, `exp`) med snabbare tillnärmningar.
* Antagande operationer är associerande och distribuerande: Detta möjliggör ytterligare ombeställning och förenkling.
* Avkopplande strikta aliasingregler: Detta kan hjälpa kompilatorn att göra bättre optimeringar mellan olika datatyper.
* `-March =Native`: Denna flagga berättar för kompilatorn att generera kod specifikt optimerad för din CPU -arkitektur. Den utnyttjar specifika instruktioner och funktioner hos din processor, vilket resulterar i betydande hastighetsförbättringar. Var medveten om att kod sammanställd med denna flagga kanske inte är bärbar för andra arkitekturer.
* `-mse`,` -mse2`, `-mse3`,` -mssse3`, `-mse4`,` -Mavx`, `-Mavx2`, etc.: Dessa flaggor möjliggör stöd för specifik SIMD (enstaka instruktioner, flera data) instruktioner. SIMD -instruktioner tillåter parallellbehandling av flera dataelement, vilket dramatiskt påskyndar många matematiska operationer. Använd flaggorna som motsvarar kapaciteten för din CPU.
2. Optimering av kodnivå:
Även med aggressiva kompilatorflaggor är välskriven kod avgörande för optimal prestanda.
* Använd lämpliga datatyper: Välj den minsta datatypen som kan representera dina data utan förlust av precision. Använd till exempel "float" istället för "dubbel" om en enda precisionsnoggrannhet är tillräcklig.
* vektorisering: Strukturera dina slingor och data så att kompilatorn enkelt kan vektorisera dem. Detta innebär att bearbeta flera dataelement samtidigt med SIMD -instruktioner. GCC:s auto-vektorisering är ganska bra, men du kan behöva hjälpa den genom att använda anpassade minnesallokeringar och säkerställa att loop-iterationer är oberoende.
* matematiska identiteter och algoritmer: Använd effektiva matematiska identiteter och algoritmer. Till exempel kan det vara snabbare att använda `Exp2 (x)` istället för `exp (x)` `` `` `
* Loop rullning: Manuellt rulla loopar (upprepa slingkroppen flera gånger) för att minska slingans över huvudet, men tänk på registertrycket. Kompilatorn kan redan utföra denna optimering, så test före och efter.
* Minnesåtkomstmönster: Organisera data i minnet för att minimera cachemissar. Åtkomst till data i följd när det är möjligt.
* Funktion inlining: För små, ofta kallade funktioner, överväg att använda nyckelordet "inline" för att minska funktionssamtalet. Kompilatorn kanske beslutar att inte inline ändå, baserat på sin egen optimeringsanalys.
3. Bibliotek:
* Optimerade matematikbibliotek: Använd bibliotek som Eigen (för linjär algebra), BLAS (grundläggande linjära algebra -underprogram) och lapack (linjär algebra -paket). Dessa är mycket optimerade för olika arkitekturer och överträffar ofta handskrivna kod.
4. Profilering:
När du har använt optimeringar använder du en profiler (som `gProf` eller perf) för att identifiera flaskhalsar för prestanda. Detta hjälper dig att fokusera dina ansträngningar på de delar av din kod som är mest kritiska.
Viktig anmärkning på `-ffast-math`:
Medan `-ffast-mathed` erbjuder betydande prestationsvinster, kan det leda till felaktigheter. Om dina beräkningar kräver strikt anslutning till IEEE 754-standarder (t.ex. i vetenskaplig datoranvändning eller finansiella tillämpningar), undvik att använda denna flagga eller verifiera resultaten noggrant mot en icke-optimerad version.
Exempel Kompilationskommando:
`` `bash
g ++ -o3 -ffast -math -March =native -Mavx2 my_math_program.cpp -o my_math_program
`` `
Kom ihåg att anpassa flaggorna till din specifika CPU och precisionskraven i din applikation. Alltid profil och benchmark för att säkerställa att dina optimeringar faktiskt förbättrar prestandan.
