Gebruik Sample Profile Guided Optimization (SPGO) om C++-prestaties te verbeteren

Profile-Guided Optimization (PGO) gebruikt runtimegegevens om de compiler te helpen betere optimalisatiebeslissingen te nemen. Door gebruik te maken van uitvoeringsprofielgegevens die zijn verzameld van representatieve workloads, kan PGO de compiler slimmere beslissingen nemen over het inlijnen, code-indeling en dynamische/koude codescheiding. Deze beslissingen kunnen niet alleen worden genomen uit statische analyse.

SPGO heeft een andere aanpak. In plaats van uw binaire bestand te instrumenteren en uit te voeren via synthetische trainingsscenario's, gebruikt SPGO hardwareprestatiemeteritems die zijn verzameld uit uw werkelijke binaire releasebestanden. Moderne processors bieden mogelijkheden voor hardwaresampling. U kunt deze voorbeelden verzamelen met verwaarloosbare runtime-overhead, waardoor het praktisch is om runtimeprofielen rechtstreeks vanuit productiecode te verzamelen.

Omdat SPGO-profielen bits vrijgeven in plaats van instrumented builds, biedt het veel meer flexibiliteit in waar en hoe u gegevens verzamelt. U kunt runtimeprofielen verzamelen van productieservers, ontwikkelmachines, prestatielabs of een willekeurige combinatie. Het resultaat is een binair bestand dat dynamische paden efficiënter uitvoert, met een typische snelheid van 5-15%, afhankelijk van de kwaliteit van de profielgegevens.

In deze zelfstudie doorloopt u de volledige SPGO-werkstroom: bouw een voorbeeld-app, profileer deze met behulp xperfvan, bereid de profielgegevens voor en bouw deze opnieuw samen met de profielgegevens. Wanneer u klaar bent, kunt u hetzelfde proces toepassen op uw eigen projecten.

Prerequisites

Voordat u begint, moet u ervoor zorgen dat u over de volgende software en hardware beschikt.

Software

• MSVC-buildhulpprogramma's voor x64/x86/ARM64 v14.51 of hoger: installeer ze via het Visual Studio-installatieprogramma. Zoek onder Afzonderlijke onderdelen naar 'MSVC-buildhulpprogramma's'.
• Windows Performance Toolkit (xperf.exe)— De profiler xperf verzamelt voorbeeldgegevens tijdens de uitvoering van uw programma. Download de Windows Assessment and Deployment Kit (ADK) van ADK install. Wanneer u het ADK-installatieprogramma uitvoert, selecteert u het onderdeel Windows Performance Toolkit om xperf op te halen. U hoeft de volledige ADK niet te installeren.
• War- en Peace-tekstbestand: wordt gebruikt als voorbeeldworkload voor het genereren van profileringsgegevens. Download het van Project Gutenberg: https://www.gutenberg.org/ebooks/2600. Sla het bestand op als een tekstbestand zonder opmaak in uw werkmap.

Hardwarevereisten

De tutorial heeft drie routes voor profilering. Welk pad u gebruikt, is afhankelijk van uw hardware. U voert detectieopdrachten uit in De profileringsmethode kiezen om erachter te komen welk pad uw computer ondersteunt. Gebruik deze tabel voorlopig om te bevestigen dat u voldoet aan ten minste één van de vereisten.

De meeste ontwikkelaars op moderne x64-desktophardware hebben LBR-ondersteuning. VM's en sommige oudere hardware hebben PMC of een timer voor het besturingssysteem.

Hoe SPGO werkt

SPGO verzamelt profielgegevens van uw actieve binaire bestand en voert deze terug naar de compiler wanneer u de volgende build uitvoert. De compiler gebruikt die gegevens om betere beslissingen te nemen over het inlijnen, code-indeling en vertakkingsvoorspelling. Een gemak is dat er geen instrumentatie vereist is.

De werkstroom is:

1. Bouw uw binair bestand met de linkervlag /spgo . In deze stap maakt u een lege voorbeelddatabank voor profielen (bestand .spd).
2. Profileer het binaire bestand met behulp van xperf om een ETL-traceringsbestand te genereren.
3. Converteer de ETL naar een SPT-bestand met behulp van SPTAggregate.exeen converteer de SPT vervolgens naar een SPD-bestand met behulp van SPDConvert.exe.
4. Bouw opnieuw op met de vlag /spdin linker die verwijst naar de ingevulde SPD (Sample Profile Database). De linker past SPGO-optimalisaties toe.

De optimizer gebruikt de SPD om vragen te beantwoorden zoals: welke takken worden het vaakst genomen? Welke functies worden aangeroepen in dynamische lussen? Dit proces produceert een betere code-indeling en het inlijnen van beslissingen dan alleen statische analyses.

SPGO werkt met zowel C als C++. De werkstroom en vlaggen zijn identiek voor beide talen.

Beste kandidaten voor SPGO: Grote, vertakkingsgevulde C/C++-toepassingen met strakke binnenlussen. De voordelen nemen toe met de omvang van de codebase en de complexiteit van branches. In het kleine voorbeeld in deze zelfstudie ziet u ongeveer 7% verbetering. Grotere productiecodebasissen zien vaak meer verbetering.

Vergelijking van buildprocessen

In deze sectie leest u hoe SPGO in de buildpipeline past, als u de werking wilt begrijpen.

Normale bouwproces

In een standaard C/C++-release-build:

• Ingangen: Broncodebestanden (.cpp, .h) en compilervlagmen in de releasemodus (/O2, /GLenzovoort).
• Proces: De compiler past standaardoptimalisaties toe, zoals heuristieken, voorspellingsveronderstellingen voor vertakkingen en beslissingen over code-indelingen op basis van alleen statische analyse. Er zijn geen gegevens over hoe het programma zich daadwerkelijk gedraagt wanneer het wordt uitgevoerd.
• Output: Uitvoerbaar (), DLL-bestanden (.exe.dll), foutopsporingsgegevens (.pdb).

Zonder runtimegegevens ontvangen dynamische paden en koude paden vergelijkbare behandeling.

Buildproces met ingeschakelde SPGO

SPGO voegt profileringsgegevens toe als nieuwe invoer aan de build-pijplijn:

• Invoer: Broncode, het .spd-profielbestand (aantallen samples van een profileringsuitvoering), release-mode-compileropties, /link /spgo en /spdin:<path> om een invoer-SPD-bestand op te geven (als dit niet is opgegeven, wordt standaard een .spd-bestand gebruikt met de naam van het binaire bestand in de map obj).
• Proces: De linker leest de SPD naast de tussenliggende code. Het gebruikt vertakkingsfrequentiegegevens om betere beslissingen te nemen over inlining, code-indeling en de volgorde van vertakkingen. Hot functies worden voor snelle toegang geplaatst; cold code wordt naar buiten het kritieke pad verplaatst.
• Output: Geoptimaliseerd uitvoerbaar bestand (.exe), geoptimaliseerde DLL-bestanden (.dll), foutopsporingsgegevens (.pdb) en een nieuw .spd bestand voor toekomstige profileringsiteraties.

Het belangrijkste inzicht: SPGO verplaatst optimalisatiebeslissingen van compiler en linker heuristiek naar gegevensgestuurde keuzes op basis van echte uitvoering.

Belangrijke markeringen

Hoe SPGO verschilt van PGO

PGO (Profile-Guided Optimization) vereist dat u uw binaire bestand compileert met instrumentatievlaggen (/GENPROFILE), het tragere geïnstrumenteerde binaire bestand uitvoert om .pgc-uitvoeringstellingsbestanden te verzamelen, en vervolgens opnieuw linkt met /USEPROFILE. De compiler haalt het aantal uitvoeringen op, maar u moet de code eerst instrumenteren. Zie Profielgestuurde optimalisaties voor meer informatie over dit proces.

SPGO gebruikt hardwarematige CPU-prestatietellers om statistische steekproeven te verzamelen uit uw niet-geïnstrumenteerde releasebinary. Voer uw bestaande binaire bestand uit, profileer het met behulp van xperf, converteer de tracering naar een SPD-bestand en bouw opnieuw. Er is geen geïnstrumenteerde build en geen vertraging tijdens het profileren. De compiler haalt statistische steekproefgegevens op in plaats van exacte aantallen, wat minder nauwkeurig is, maar gemakkelijker te verkrijgen is en geen codewijzigingen vereist. Het maakt ook profilering mogelijk van systeemonderdelen of realtime-onderdelen waarvoor het moeilijk is om gegevens te verzamelen met een geïnstrueerde benadering. U kunt ook binaire bestanden voor definitieve/verzending profilen.

In deze zelfstudie worden drie profileringsmethoden behandeld: LBR, PMC en timer van het besturingssysteem. U kiest uw methode in Kies uw profileringsmethode. Zie BuildProcesvergelijking voor een gedetailleerde vergelijking van het normale buildproces versus het SPGO-buildproces, inclusief een referentietabel voor vlaggen.

perfcore.ini configureren

⚠ϑ Vereist: Zonder deze stap xperf worden de benodigde profileringsgegevens niet verstrekt. Voltooi deze stap voordat u deze uitvoert xperf.

De Windows Performance Toolkit (WPT) gebruikt perfcore.ini, die zich bevindt als u de WPT op de standaardlocatie op C:\Program Files (x86)\Windows Kits\10\Windows Performance Toolkit\perfcore.ini hebt geïnstalleerd, om de DLL-providers te registreren die nodig zijn voor SPGO.

Open Windows Kladblok als beheerder. Open vervolgens perfcore.ini. Zoek de sectie dll-lijst en voeg de volgende vermeldingen toe, één per regel:

perf_spt.dll
perf_lbr.dll

Als xperf.exe niet is geïnstalleerd, zie Algemene problemen om deze te installeren.

Opslaan en sluiten perfcore.ini. De DLL-bestanden worden al verzonden in dezelfde map als xperf.exe zodat u ze nergens hoeft te kopiëren. Je registreert ze alleen in perfcore.ini. Zorg ervoor dat xperf in uw PATH staat.

De voorbeeld-app maken

De voorbeeld-app voor deze zelfstudie is een C++-programma dat tekst leest uit standaardinvoer en een regelaantal, woordentelling, totaal aantal tekens, een tekenfrequentietabel en verstreken tijd voor het verwerken van het bestand in milliseconden produceert. Het is geschreven in C++, maar SPGO werkt ook met C. De werkstroom is identiek voor C-projecten.

Maak een bestand met de naam textCount.cpp in uw werkmap en voeg de volgende broncode toe:

// textCount.cpp : Text Statistics Counter
// Counts words, lines, and character frequencies from standard input
// Usage: textCount < file.txt

#include <iostream>
#include <string>
#include <map>
#include <cctype>
#include <chrono>

int main()
{
    auto start = std::chrono::steady_clock::now();

    std::map<unsigned char, int> charFrequency;
    int wordCount = 0;
    int lineCount = 0;
    int totalChars = 0;

    std::string line;
    bool inWord = false;

    while (std::getline(std::cin, line))
    {
        lineCount++;

        for (char c : line)
        {
            totalChars++;
            unsigned char uc = static_cast<unsigned char>(c);
            charFrequency[uc]++;

            if (std::isspace(static_cast<unsigned char>(c)))
            {
                inWord = false;
            }
            else
            {
                if (!inWord)
                {
                    wordCount++;
                    inWord = true;
                }
            }
        }

        inWord = false;
    }

    std::cout << "\n=== TEXT STATISTICS ===" << std::endl;
    std::cout << "Lines: " << lineCount << std::endl;
    std::cout << "Words: " << wordCount << std::endl;
    std::cout << "Total Characters: " << totalChars << std::endl;

    std::cout << "\n=== CHARACTER FREQUENCIES ===" << std::endl;

    std::cout << "\nLetters:" << std::endl;
    for (unsigned char ch = 'a'; ch <= 'z'; ch++)
    {
        unsigned char upperCh = static_cast<unsigned char>(std::toupper(ch));
        int count = charFrequency[ch] + charFrequency[upperCh];
        if (count > 0)
        {
            std::cout << static_cast<char>(ch) << ": " << count << std::endl;
        }
    }

    std::cout << "\nDigits:" << std::endl;
    for (unsigned char ch = '0'; ch <= '9'; ch++)
    {
        if (charFrequency[ch] > 0)
        {
            std::cout << static_cast<char>(ch) << ": " << charFrequency[ch] << std::endl;
        }
    }

    std::cout << "\nSpecial Characters:" << std::endl;
    for (const auto& pair : charFrequency)
    {
        unsigned char ch = pair.first;
        if (!std::isalnum(ch))
        {
            std::string displayChar;
            switch (ch)
            {
                case ' ': displayChar = "[space]"; break;
                case '\t': displayChar = "[tab]"; break;
                case '\n': displayChar = "[newline]"; break;
                case '\r': displayChar = "[return]"; break;
                default:
                    if (ch >= 32 && ch < 127)
                    {
                        displayChar = std::string(1, static_cast<char>(ch));
                    }
                    else
                    {
                        displayChar = "[byte:" + std::to_string(static_cast<int>(ch)) + "]";
                    }
                    break;
            }
            std::cout << displayChar << ": " << pair.second << std::endl;
        }
    }

    auto end = std::chrono::steady_clock::now();

    auto elapsed = std::chrono::duration<double, std::milli>(end - start);
    std::cout << "Elapsed time: " << std::fixed;
    std::cout.precision(3);
    std::cout << elapsed.count() << " ms\n";

    return 0;
}

Het voorbeeld bouwen en uitvoeren om een uitgangspunt te krijgen

Voordat u SPGO toepast, bouwt u textCount en voert u het uit op een groot tekstbestand, zoals War and Peace (u kunt het downloaden van Project Gutenberg), om te zien hoe snel het draait. In deze stap ziet u de prestaties voordat u deze optimaliseert met behulp van SPGO:

Build:

cl /EHsc /GL /O2 textCount.cpp

Uitvoeren:

textCount.exe < warAndPeace.txt

De uitvoer ziet er ongeveer als volgt uit:

=== TEXT STATISTICS ===
Lines: 66041
Words: 566333
Total Characters: 3227531

=== CHARACTER FREQUENCIES ===

Letters:
a: 202719
...

Elapsed time: 512.000 ms

Noteer de Elapsed time waarde. U vergelijkt deze met de door SPGO geoptimaliseerde tijd in De resultaten meten.

TextCount bouwen met /spgo

Bouw nu textCount met SPGO ingeschakeld. In deze stap wordt de basis gelegd voor het verzamelen van profileringsgegevens.

cl /EHsc /GL /O2 textCount.cpp /link /debug /spgo

Wanneer de build is voltooid, ziet u een bericht zoals:

SPD textCount.spd not found, compiling without profile guided optimizations

Dit bericht wordt weergegeven in de eerste /spgo build. De linker genereert het SPD-bestand, maar het is nog steeds leeg, dus past het nog geen SPGO-optimalisaties toe. Nadat u het binaire bestand hebt uitgevoerd, profielgegevens hebt verzameld en geconverteerd naar SPD, ziet u dit bericht niet.

Toelichting op de vlaggen:

De /spgo vlag optimaliseert het binaire bestand nog niet. Het bereidt het voor op profilering. De optimalisatie vindt plaats in Rebuild textCount met /spdin nadat de SPD is gevuld met echte runtimegegevens.

Uw profileringsmethode kiezen

SPGO ondersteunt drie profileringsmethoden. Welke methode u gebruikt, is afhankelijk van uw hardware.

De drie profileringsmethoden

Met PMC/IP-modus geeft elke hardware-interrupt u slechts één gegevenspunt: "de CPU was op adres 0x1A2B3C4D toen de interrupt werd geactiveerd". Met LBR geeft elke interrupt je een reeks van de laatste 16–32 branches die de CPU heeft uitgevoerd voordat de interrupt optrad. De optimizer krijgt betere controlestroomgegevens en kan betere inlinings- en indelingsbeslissingen nemen.

Detecteer uw route

Voer de volgende twee opdrachten uit om te bepalen welk profileringspad uw computer ondersteunt. Voor deze commando's is geen prompt met verhoogde rechten vereist.

Stap 1: Controleer op LBR-ondersteuning. Deze test werkt op Intel/AMD/ARM64.

Voer het volgende uit vanaf een administrator Visual Studio opdrachtprompt voor ontwikkelaars:

xperf.exe -on PMC_PROFILE -pmcprofile TotalIssues -LastBranch PmcInterrupt -setProfInt TotalIssues 2560000
xperf -stop -d lbrtest.etl
xperf -tle -i lbrtest.etl -a dumper | findstr "LBR,  TimeStamp"

• Als met deze opdracht een regel wordt gevonden die een regel bevat LBR, TimeStamp, ondersteunt uw computer LBR. Gebruik het LBR-pad.
• Ga anders verder naar stap 2.

Stap 2: Controleren op PMC-ondersteuning (geen LBR)

xperf.exe -pmcsources | findstr TotalIssues

• Als deze opdracht uitvoer produceert, ondersteunt uw computer PMC-tellers, maar niet LBR. Gebruik het PMC-pad.
• Als deze opdracht geen uitvoer produceert, gebruikt u het timerpad van het besturingssysteem.

Zie Hardware PMU-gebeurtenissen opnemen met xperf voor meer informatie over het verzamelen van PMU-gebeurtenissen met xperf.

Beslissingstabel

Kies uw benadering

Bepaal of u het timerpad LBR, PMC of besturingssysteem wilt gebruiken op basis van de detectieresultaten. Elk pad heeft verschillende xperf beginparameters om de juiste profileringsgegevens te verzamelen. Volg het pad dat overeenkomt met uw hardwaremogelijkheden.

Uw pad:

• LBR-gebruikers (LBR gedetecteerd in stap 1): Ga naar LBR-pad.
• PMC-gebruikers (InstructionRetired gedetecteerd in stap 2): Ga naar het PMC-pad (geen LBR).
• Timergebruikers van het besturingssysteem (VM of hardware zonder PMU): Ga naar het timerpad van het besturingssysteem.

Alle paden komen weer samen bij De workload uitvoeren en xperf stoppen.

De opdrachten in deze sectie zijn afhankelijk van het profileringspad dat u hebt geïdentificeerd in De profileringsmethode kiezen. Zoek de subsectie die overeenkomt met uw pad, voer de xperf startopdracht uit en ga door met het uitvoeren van de workload en stop xperf om de workload uit te voeren en xperf te stoppen.

⚠(*) Als administrator uitvoeren:xperf hiervoor is een opdrachtprompt voor ontwikkelaars met verhoogde bevoegdheid (Administrator) vereist. Zonder verhoogde bevoegdheden geeft xperf"failed to configure counters" terug.

LBR-pad

Begin xperf met LBR-collectie:

xperf -on LOADER+PROC_THREAD+PMC_PROFILE -MinBuffers 4096 -MaxBuffers 4096 -BufferSize 4096 -pmcprofile BranchInstructionRetired -LastBranch PmcInterrupt -setProfInt BranchInstructionRetired 16384

Uitleg van parameter:

Nadat u xperf hebt gestart, gaat u door met het uitvoeren van de workload en stopt u xperf.

PMC-pad (zonder LBR)

Begin xperf met de verzameling PMC/IP-modus:

xperf -on LOADER+PROC_THREAD+PMC_PROFILE+PROFILE -MinBuffers 4096 -BufferSize 4096 -pmcprofile InstructionRetired -setProfInt InstructionRetired 16384 -stackwalk profile

Uitleg van parameter:

Vergeleken met LBR: geen -LastBranch vlag; gebruikt InstructionRetired in plaats van BranchInstructionRetired. Het resultaat zijn instructiepointervoorbeelden met aanroepstacks, niet vertakkingsreeksen. Dit pad biedt nog steeds effectieve gegevens voor de optimalisatie, maar het is iets minder rijk.

Nadat u hebt gestart xperf, gaat u verder met het uitvoeren van de workload en stopt u xperf.

Pad van de systeemtimer

Start xperf met sampling op basis van een besturingssysteemtimer:

xperf -on LOADER+PROC_THREAD+PROFILE -MinBuffers 4096 -BufferSize 4096 -setProfInt Timer 1221 -stackwalk profile

Uitleg van parameter:

In vergelijking met LBR en PMC, gebruikt deze methode geen hardware-prestatietellers. De timer van het besturingssysteem wordt met ongeveer vaste tijdsintervallen geactiveerd, ongeacht de CPU-activiteit. Voorbeelden zijn minder dicht gecorreleerd aan hot code, maar bieden nog steeds nuttige controlestroomgegevens voor de optimizer.

Voer de workload uit en stop xperf (alle paden)

Terwijl xperf actief is, voer textCount uit op Oorlog en vrede:

textCount.exe < warAndPeace.txt

Nadat textCount is voltooid, stopt u xperf en schrijft u het traceringsbestand weg. Het laten uitvoeren van andere processen tijdens het profileren verdunt de kwaliteit van de steekproef. Sluit voor de beste resultaten onnodige toepassingen voordat u de workload uitvoert.

xperf -stop -d textCount.etl

Na het stoppen van xperf (het kan even duren voordat het ETL-bestand is weggeschreven), controleert u of textCount.etl is aangemaakt in de huidige map.

Het ETL-bestand converteren naar SPT

Deze stap is hetzelfde voor alle drie de profileringspaden.

Voer SPTAggregate.exe uit om de onbewerkte ETL-tracering te verwerken en een SPT-profielbestand te maken:

SPTAggregate.exe /binary textCount.exe /etl textCount.etl textCount.spt

Uitleg van parameter:

SPTAggregate voert een samenvatting uit die laat zien hoeveel voorbeelden er zijn verzameld. Dit overzicht is uw eerste bevestiging dat profilering heeft gewerkt.

Vergelijk de uitvoer van SPTAggregate met het pad dat u hebt gevolgd:

• LBR-pad: Zoek naar een niet-nul aantal gebruikte LBR-samples.
• PMC-pad: Zoek naar een niet-nul PMC- of stack-voorbeeldaantal.
• OS-timertraject: Zoek naar een niet-nulwaarde voor het aantal gebruikte stacksamples.

Als alle aantallen nul zijn, raadpleegt u Probleemoplossing voordat u doorgaat.

Het SPT-bestand converteren naar SPD

Uw pad:

• LBR-gebruikers (gebruik /mode:LBR): LBR-modus
• PMC-gebruikers (gebruik /mode:IP): IP-modus (PMC- en OS-timer)
• Gebruikers van besturingssysteemtimer (gebruik /mode:IP): IP-modus (PMC- en OS-timer)

Zowel PMC- als OS-timerpaden gebruiken /mode:IP, omdat beide instruction-pointer-samples produceren.

De volgende stap splitst zich op basis van het profileringspad, specifiek op basis van de /mode-vlag die aan SPDConvert.exe is doorgegeven.

LBR-modus

SPDConvert.exe /mode:LBR textCount.spd textCount.spt

/mode:LBR instrueert SPDConvert om de SPT te interpreteren alsof deze LBR-vertakkingssequentiegegevens bevat.

IP-modus (PMC- en OS-timer)

Zowel PMC- als OS-timer produceren instructiepointervoorbeelden, dus beide gebruiken dezelfde conversieopdracht:

SPDConvert.exe /mode:IP textCount.spd textCount.spt

/mode:IP instrueert SPDConvert om de SPT te interpreteren alsof deze instructiepointer-samples bevat.

Controleer na het uitvoeren van SPDConvert of textCount.spd is aangemaakt (of bijgewerkt) in de huidige map.

SPDConvert-uitvoer interpreteren

Met de opdracht SPDConvert textCount.spd textCount.spt wordt een overzicht van de dekking vóór en na de blokdekking afgedrukt, bijvoorbeeld:

Block coverage (before) : 33.90% ( 4507/ 13294)
Block coverage (after)  : 45.64% ( 6067/ 13294)

In deze samenvatting ziet u het percentage van de codeblokken van het binaire bestand waaraan profielgegevens zijn gekoppeld. Een hoger percentage is beter. Dekking boven de 70% is uitstekend, terwijl dekking onder de 40% de effectiviteit van optimalisatie kan beperken. Als de dekking laag is, voert u de profileringsworkload langer uit of combineert u meerdere SPT-bestanden uit afzonderlijke uitvoeringen met verschillende workloads. U kunt bijvoorbeeld uitvoeren textCount op meerdere tekstbestanden om verschillende codepaden uit te oefenen.

Mogelijk krijgt u een waarschuwing van SPDConvert te zien, zoals de volgende:

Compiler may be conservative on some hot functions due to sparse sample coverage.
SPGO is estimated to optimize better if sample density is increased to 5.4x of current level.
Sample density can be increased by sampling for longer period, or increasing sample rate.

Deze waarschuwing betekent dat tijdens uw profileringssessie niet genoeg samples zijn verzameld om de optimizer alle intensief gebruikte functies met vertrouwen te laten optimaliseren. De SPD is nog steeds bruikbaar, maar u kunt de resultaten verbeteren door:

• De workload langer uitvoeren (bijvoorbeeld 5 of meer minuten in plaats van 1 minuut) of verschillende werkbelastingen gebruiken.
• -setProfInt De waarde in de xperf opdracht verlagen om de steekproefsnelheid te verhogen. De afweging is dat deze wijziging een groter ETL-bestand produceert, wat langer duurt om te verwerken.
• Het combineren van meerdere SPT-bestanden van afzonderlijke profileringsuitvoeringen door ze allemaal door te geven aan SPDConvert.

Het SPT-bestand is een binaire indeling. Als u de inhoud ervan wilt inspecteren, kunt u uitvoeren SPTDump.exe textCount.spt. Op dezelfde manier worden met PTDump.exe textCount.spt de gecompileerde profielgegevens weergegeven na het uitvoeren van SPDConvert. Beide hulpprogramma's zijn handig voor het controleren van niet-nulvoorbeelden voordat u doorgaat.

textCount opnieuw opbouwen met /spdin

Bouw opnieuw textCount met behulp van het gevulde SPD-bestand. De linker leest de profielgegevens en past SPGO-optimalisaties toe.

Deze stap is hetzelfde voor alle drie de profileringspaden.

cl /EHsc /GL /O2 textCount.cpp /link /debug /spgo /spdin:textCount.spd

Nieuwe vlag (vergeleken met Build textCount met /spgo):

De opdracht bevat /spgonog steeds . Er wordt een nieuw SPD-bestand gegenereerd naast het geoptimaliseerde binaire bestand, dat u als uitgangspunt kunt gebruiken voor volgende profileringsiteraties.

Na het opnieuw opbouwen met /spdin, levert de linker statistieken over hoeveel van uw code is geoptimaliseerd met behulp van profielgegevens. Voorbeeld:

221 of 221 (100.00%) profiled functions will be compiled for speed
201 of 1383 inline instances were from dead/cold paths
474 of 474 profiled functions (100.0%) were optimized using profile data
202738780 of 202738780 instructions (100.0%) were optimized using profile data

Een hoog percentage betekent dat de SPD uw binaire bestand goed dekt. Als het percentage laag is (bijvoorbeeld minder dan 90%), heeft de profileringsworkload onvoldoende van het binaire bestand gebruikt of is het binaire bestand aanzienlijk gewijzigd sinds het profiel is verzameld. In beide gevallen moet u het bestand opnieuw instellen op basis van het huidige binaire bestand.

Wat SPGO doet met uw profielgegevens

SPGO gebruikt de verzamelde voorbeeldgegevens om tellingen op elk blok en elke rand in de controlestroomgrafiek van het programma te vullen. Deze aantallen sturen optimalisaties aan, zoals:

• Profielgestuurde inlining: sites voor agressieve inline-aanroepen terwijl code-bloat wordt vermeden van inline koude paden.
• Dynamische/koude codescheiding: verplaats zelden uitgevoerde code om secties van het binaire bestand te scheiden, waardoor het gebruik van de instructiecache en het pagineringsgedrag wordt verbeterd.
• Functie-indeling: plaats functies die elkaar vaak in de buurt van elkaar aanroepen in het binaire bestand, waardoor paginafouten worden verminderd en de lokaliteit wordt verbeterd. Geoptimaliseerde functies zijn ingedeeld in COFF-groepen met hoge affiniteit in het binaire bestand.
• Beslissingen over grootte/snelheid: Compileer dynamische functies voor snelheids- en koude functies voor grootte. Routines zonder waargenomen profielhits kunnen eerder voor codegrootte dan voor snelheid worden gecompileerd, waardoor optimalisaties zoals inlining en het uitrollen van lussen in die zelden uitgevoerde codepaden worden beperkt.
• Speculatieve devirtualisatie: Wanneer bemonstering aantoont dat een indirecte aanroep consequent dezelfde functie aanroept, kan SPGO van dat doel uitgaan en die functie inlinen, met een terugvaloptie voor het uitzonderlijke geval.

De resultaten meten

Voer opnieuw uit textCount en vergelijk verstreken tijden.

textCount.exe < warAndPeace.txt

Verzamel meerdere uitvoeringen voor elke configuratie en gebruik de mediaan. Eén uitvoering is niet betrouwbaar omdat het plannen van het besturingssysteem en systeemruis afzonderlijke metingen kunnen scheeftrekken.

In één test leverde SPGO met behulp van de LBR-methode ongeveer 7% vermindering van de verstreken tijd. Uw resultaten kunnen variëren met uw eigen projecten, omdat SPGO-winsten afhankelijk zijn van hoe goed de profileringsworkload een typische uitvoering vertegenwoordigt. Grotere codebases met veel branches laten doorgaans meer verbetering zien in de orde van 5–10%. De profileringsmethode is van invloed op de optimalisatiekwaliteit. LBR produceert doorgaans betere resultaten dan PMC, wat betere resultaten oplevert dan de timer van het besturingssysteem. Als u zich op het timerpad van het besturingssysteem bevindt, verwacht u kleinere winsten.

Het LBR-pad dat in deze zelfstudie werd gevolgd, is toegepast op het SQLite-project , een productiedatabasebibliotheek. Het binaire bestand SQLITE dat is geoptimaliseerd voor SPGO vertoonde ongeveer 7% verbetering.

SPGO toepassen op uw eigen project

Gebruik deze controlelijst om SPGO toe te passen op uw eigen C- of C++-toepassing.

1. Voeg /link /spgo toe aan je bestaande release-buildopdracht. Wijzig uw buildscript of projectbestand:

   cl /EHsc /GL /O2 myapp.cpp /link /spgo
   

2. Kies een representatieve workload. Selecteer een echt gebruiksscenario waarmee de dynamische paden van uw toepassing worden uitgevoerd. Gebruik productieachtige gegevens. Vermijd het volgende als primaire workload voor profilering: tests voor codedekking (die prestatieknelpunten niet zwaar belasten), ongebruikelijke foutpaden, opstart- en afsluitfasen en verouderde codepaden. Deze workload bepaalt het profiel dat de optimizer invoert.

3. Voer xperf uit met behulp van uw gedetecteerde pad. Gebruik het pad dat u hebt geïdentificeerd in De profileringsmethode kiezen (LBR, PMC of timer van het besturingssysteem). Start xperf, voer de workload eenmaal uit, stop xperfen leg het ETL-bestand vast.

4. Voer SPTAggregate en SPDConvert uit met de juiste /mode vlag voor het PMC- of os-timerpad. Converteer ETL naar SPT en vervolgens naar SPD. Gebruiken /mode:LBR voor LBR-gegevens; gebruiken /mode:IP voor PMC- of os-timergegevens.

5. Herbouwen met /spdin:<your-spd-path>. Compileer uw toepassing met de gevulde SPD:

   cl /EHsc /GL /O2 yourApp.cpp /link /spgo /spdin:yourApp.spd
   

6. Meet vóór en na. Voer uw workload uit met zowel de niet-geoptimaliseerde als voor SPGO geoptimaliseerde binaire bestanden. Neem voor elke configuratie de mediaan van meerdere runs. Eén testrun is niet betrouwbaar om mee te benchmarken.

7. Sla het .spd bestand op in broncodebeheer. Controleer het .spd bestand in uw broncodebeheersysteem naast uw broncode.

8. Schakel SPGO in releaseversies voor ontwikkelaars in. Zorg ervoor dat de Release-builds van uw team dezelfde SPGO-geoptimaliseerde binaries gebruiken als in productie. Dit helpt om prestatieregressies vroeg te ondervangen.

9. Schakel SPGO uit in builds voor foutopsporing.

10. Bekijk de statistieken over de volledigheid van het linkerprofiel. Noteer na elke build met /spgohet percentage geprofileerde functies dat is geoptimaliseerd met behulp van profielgegevens. Als dit aanzienlijk afneemt (minder dan 90%), herprofilet u het huidige binaire bestand. Codewijzigingen stapelen zich op en de SPD kan verouderen.

Alternatief voor het gebruik van xperf

Een andere manier om profielgegevens te verzamelen, is door een sampling profiler zoals Windows Performance Recorder (WPR) te gebruiken. WPR is standaard geïnstalleerd op Windows 10 en hoger. Het verzamelt vergelijkbare gegevens als xperf. U kunt WPR zo configureren dat CPU-samples met aanroepstacks worden verzameld en de gegevens vervolgens exporteren naar een ETL-bestand dat u met SPTAggregate en SPDConvert kunt verwerken, net als de xperf-ETL. Hier volgt een voorbeeld van het gebruik van WPR om profielgegevens te verzamelen:

wpr -start CPU.light -filemode
textCount.exe < warAndPeace.txt
wpr -stop spgo_data.etl

Zie Using Windows Performance Recorder voor meer informatie over het gebruik van WPR.

distributie van SPD

U kunt:

• Controleer het .spd bestand rechtstreeks in broncodebeheer naast uw broncode.
• Deel het .spd bestand met teamleden, zodat ze kunnen bouwen met SPGO-optimalisaties zonder dat ze opnieuw hoeven te worden geprofileerd.
• Pak het .spd bestand in met uw binaire bestanden als een versie-artefact (bijvoorbeeld een NuGet-pakket) en noteer welke versie overeenkomt met welk binair bestand.
• Genereer het .spd bestand op elk gewenst moment opnieuw door de profileringswerkstroom te herhalen.

De SPD is gekoppeld aan het exacte binaire bestand waaruit deze is opgebouwd. Nadat belangrijke code is gewijzigd, moet u het bestand opnieuw maken om een nieuwe SPD te genereren. Tijdens de /spdin build produceert de compiler ook een nieuw .spd bestand. Sla deze nieuwe SPD op als een build-artefact. Dit is het startpunt voor de volgende profileringsiteratie.

SPD-gegevens hergebruiken in builds

Met het concept 'carry forward' in SPGO kunt u profileringsgegevens toevoegen aan een bestaand SPD-bestand zonder dat u al uw scenario's helemaal opnieuw profileert en zonder bestaande profielgegevens te verliezen. U kunt ook aanpassen hoeveel gewicht u wilt geven aan oudere profielgegevens. Deze flexibiliteit is handig wanneer er na verloop van tijd gedragswijzigingen kunnen zijn en u de profileringsgegevens van eerdere scenario's niet volledig wilt verliezen. Een DLL kan bijvoorbeeld verschillende API-aanroepen ontvangen naarmate de applicatie die de DLL aanroept zich verder ontwikkelt. U wilt nog steeds de optimalisaties voor hoe het zich vroeger gedroeg, maar u wilt die combineren met optimalisatiemogelijkheden voor hoe het zich nu soms anders gedraagt. U kunt het profiel in de loop van de tijd ontwikkelen door oude en nieuwe gegevens te combineren.

Wanneer u SPDConvert uitvoert met een nieuw SPT-bestand, geeft u de naam van het bestaande SPD-bestand op. Gebruik vervolgens de optie /retire:N om te bepalen hoe agressief SPDConvert minder nadruk legt op oudere profielgegevens wanneer u nieuwe SPT-bestanden toevoegt:

• De standaardwaarde (/retire:8) kent nieuwere gegevens een groter gewicht toe.
• Gebruik /retire:0 om aan alle uitvoeringen gelijk gewicht te geven.
• Gebruik /retire:16 om alleen de nieuwste gegevens mee te laten tellen.

Troubleshooting

Zoek uw probleem op:

• LBR-padproblemen:LBR-padproblemen
• PMC-padproblemen:PMC-padproblemen
• Problemen met besturingssysteemtimer:problemen met timerpad van het besturingssysteem
• Problemen die van invloed zijn op alle paden:Algemene problemen

Problemen met LBR-pad

Problemen met het PMC-pad

Problemen met het timerpad van het besturingssysteem

Algemene problemen (alle paden)

Volgende stappen 

Nadat u deze zelfstudie hebt voltooid, verkent u deze mogelijkheden om meer te krijgen van SPGO:

• Profielmenging: Voer meerdere workloads uit, verzamel SPT-bestanden van elke uitvoering en geef ze allemaal door aan SPDConvert. Een gemengde SPD weerspiegelt het volledige scala aan reële gebruikspatronen en produceert betere optimalisaties dan een profiel met één scenario. Gebruik de optie /retire:N om te regelen hoe agressief SPDConvert minder gewicht toekent aan oudere profielgegevens wanneer u nieuwe SPT-bestanden toevoegt. De standaardwaarde (/retire:8) kent nieuwere gegevens een groter gewicht toe. Gebruik /retire:0 om alle runs even zwaar te laten meewegen; gebruik /retire:16 om alleen de meest recente gegevens mee te laten tellen.
• De beste resultaten zijn afkomstig van het combineren van profielen uit meerdere bronnen, zoals benchmarks die belangrijke scenario's plus echte gegevens (indien beschikbaar) benadrukken. SPT-bestanden van alle bronnen doorgeven aan SPDConvert. Herhaal een SPT-bestand in de argumentenlijst om het meer gewicht te geven (bijvoorbeeld SPDConvert myapp.spd critical.spt critical.spt common.spt gewichten critical.spt twee keer zo zwaar als common.spt).
• Iteratieve optimalisatie: Elke build met /spdin levert een nieuwe SPD op. U kunt de cyclus van uitvoeren, profileren en opnieuw bouwen herhalen. Latere iteraties kunnen steeds minder opleveren, maar een tweede ronde kan soms patronen oppikken die de eerste keer over het hoofd zijn gezien.
• Codewijzigingen: Na ingrijpende wijzigingen in de broncode moet u profielgegevens opnieuw verzamelen. De bestaande SPD is gekoppeld aan het binaire bestand waartegen het is geprofileerd. Het zal niet overeenkomen met een aanzienlijk opnieuw opgebouwd binair bestand.
• Actualiteit van het profiel: De linker rapporteert na elk /spdin buildproces het percentage geprofileerde functies dat met behulp van profielgegevens is geoptimaliseerd. Als dit percentage aanzienlijk afneemt, is het een signaal dat de code is afgeleid van het profiel. Profileer het huidige binaire bestand opnieuw.