Használja a mintaprofil-alapú optimalizálást (SPGO) a C++ teljesítményének javítására

A profilvezérelt optimalizálás (PGO) futásidejű adatok felhasználásával segíti a fordítót a jobb optimalizálási döntések meghozatalában. A reprezentatív munkaterhelésekből gyűjtött végrehajtásiprofil-adatok felhasználásával a PGO lehetővé teszi, hogy a fordító jobb döntéseket hozzon a függvények beágyazásáról, a kód elrendezéséről, valamint a forró és hideg kód szétválasztásáról. Ezeket a döntéseket nem lehet egyedül statikus elemzésből meghozni.

Az SPGO más megközelítést alkalmaz. Ahelyett, hogy instrumentálná a binárisát, és szintetikus betanítási forgatókönyveken futtatná, az SPGO a tényleges kiadott binárisokból gyűjtött hardveres teljesítményszámlálók mintavételezését használja. A modern processzorok hardveres mintavételezési képességeket biztosítanak. Ezeket a mintákat elhanyagolható futásidejű terhelés mellett gyűjtheti össze, így közvetlenül az éles környezetben futó kódból is gyakorlatiasan gyűjthetők a futásidejű profilok.

Mivel az SPGO-profilok a rendszerezett buildek helyett biteket bocsátanak ki, sokkal nagyobb rugalmasságot tesz lehetővé az adatok gyűjtésének helye és működése terén. Futtatókörnyezeti profilokat gyűjthet éles kiszolgálókról, fejlesztői gépekről, teljesítménylaborokból vagy bármilyen kombinációból. Az eredmény egy bináris, amely hatékonyabban futtatja a gyakori elérésű útvonalakat, és a profiladatok minőségétől függően általában 5–15% gyorsul a teljesítmény.

További információ a mintaprofil-irányított optimalizálásról (PGO) az MSVC-ben, valamint arról, hogy hogyan javítja a teljesítményt mintavételalapú profilkészítéssel, lásd : Bevezetés a mintaprofil irányított optimalizálása az MSVC-ben

Ebben az oktatóanyagban végigvezeti a teljes SPGO-munkafolyamaton: létrehoz egy mintaalkalmazást, profilt készít a használatával xperf, előkészíti a profiladatokat, és újraépíti a profiladatokkal. Ha végzett, ugyanezt a folyamatot alkalmazhatja saját projektjeire is.

Prerequisites

Mielőtt hozzákezd, győződjön meg arról, hogy rendelkezik a következő szoftver és hardver használatával.

Software

MSVC buildeszközök x64/x86/ARM64 v14.51 vagy újabb verziókhoz – Telepítse őket a Visual Studio Telepítőn keresztül. Az Egyes összetevők területen keressen rá az "MSVC buildeszközök" kifejezésre.
Windows Performance Toolkit (xperf.exe) – A xperf profilkészítő mintaadatokat gyűjt a program végrehajtása során. Töltse le a Windows Assessment and Deployment Kit (ADK) csomagot a ADK telepítéséről. Az ADK-telepítő futtatásakor válassza a Windows Performance Toolkit összetevőt a xperf beszerzéséhez. Nem kell telepítenie a teljes ADK-t.
War and Peace szövegfájl – Minta számítási feladatként használva profilkészítési adatok létrehozásához. Töltse le Project Gutenbergből: https://www.gutenberg.org/ebooks/2600. Mentse egyszerű szöveges fájlként a munkakönyvtárban.

Hardverkövetelmények

Az oktatóanyag három profilkészítési útvonalsal rendelkezik. A használt elérési út a hardvertől függ. Az észlelési parancsokat a Profilkészítési módszer kiválasztása területen futtatva megtudhatja, hogy a gép melyik elérési utat támogatja. Egyelőre ezzel a táblával győződjön meg arról, hogy megfelel legalább egy követelménynek.

Path	CPU-követelmény	Jegyzetek
LBR (legjobb eredmények)	Az utolsó elágazási rekordok (LBR) olyan teljesítményszámlálók, amelyek az Intel Haswell processzorokon (4. generációs Core, 2013) vagy újabbakon, az AMD Zen 4-en (2022) vagy újabbakon, valamint az ARM64 ARMv9.2-A-n (2020) vagy újabbakon érhetők el.	A legjobb fiókadatokat biztosítja. Az LBR-rel kapcsolatos további információkért lásd: Bevezetés a last branch recordokba
PMC/IP mód (jó eredmények)	A teljesítményfigyelő számlálók (PMC) bármilyen x64-processzoron támogatottak teljesítménymonitorozási egységgel (PMU)	A legtöbb modern processzoron működik, ahol az LBR nem érhető el. A PMC-vel kapcsolatos további információkért tekintse meg a hardverteljesítmény (PMU) eseményeinek rögzítését és a hardverteljesítmény -események rögzítését teljes példával
Operációsrendszer-időzítő (mindenhol működik)	Bármilyen x64- vagy ARM64-processzor, beleértve Azure virtuális gépeket és virtuális gépeket	Alacsonyabb hűségű minták, de mindig elérhetők

A modern x64-alapú asztali hardverek legtöbb fejlesztője LBR-támogatással rendelkezik. A virtuális gépek és néhány régebbi hardver rendelkezik PMC-vel vagy operációsrendszer-időzítőkkel.

Az SPGO működése

Az SPGO összegyűjti a profiladatokat a futó bináris fájlból, és a következő buildeléskor visszaküldi azokat a fordítónak. A fordító ezeket az adatokat használva jobb döntéseket hoz a fordításról, a kódelrendezésről és az ág-előrejelzésről. Előnye, hogy nincs szükség műszerezésre.

A munkafolyamat a következő:

Hozza létre a bináris fájlt az /spgo linker jelzővel. Ez a lépés létrehoz egy üres mintaprofil-adatbázist (.spd fájlt).
Készítsen profilt a binárisról a(z) xperf használatával ETL-nyomkövetési fájl létrehozásához.
Konvertálja az ETL-t SPT-fájlba a(z) SPTAggregate.exe segítségével, majd konvertálja az SPT-t SPD-fájlba a(z) SPDConvert.exe segítségével.
Újraépítés a /spdin linker jelzővel, amely a kitöltött mintaprofil-adatbázisra (SPD) mutat. A linker SPGO-optimalizálásokat alkalmaz.

Az optimalizáló az SPD használatával válaszol olyan kérdésekre, mint például: melyik ágakat használják leggyakrabban? Mely függvényeket hívják meg a kritikus ciklusokban? Ez a folyamat jobb kódelrendezést és döntéseket hoz, mint a statikus elemzés önmagában.

Az SPGO a C és a C++ használatával is működik. A munkafolyamat és a jelzők mindkét nyelv esetében azonosak.

SPGO-hoz legalkalmasabbak: Nagy, sok elágazást tartalmazó C/C++-alkalmazások szűk belső ciklusokkal. Az előnyök a kódbázis méretével és az ágak összetettségével arányosan nőnek. Az oktatóanyagban szereplő kis minta körülbelül 7% javulást mutat be. A nagyobb, élesben használt kódbázisok gyakran nagyobb mértékben javulnak.

Összeállítási folyamat összehasonlítása

Ez a szakasz áttekinti, hogyan illeszkedik az SPGO a buildfolyamatba, ha szeretné megérteni a működését.

Normál összeállítási folyamat

Egy szokásos C/C++ kiadási összeállítás esetén:

Bemenetek: Forráskódfájlok (.cpp, .h) és kiadási módú fordítójelzők (/O2stb /GL.).
Folyamat: A fordító kizárólag statikus elemzés alapján szabványos optimalizálásokat alkalmaz, például beágyazási heurisztikákat, elágazás-előrejelzési feltételezéseket és a kódelrendezésre vonatkozó döntéseket. Nincs adata arról, hogy a program hogyan viselkedik a futtatáskor.
Kimeneti: Végrehajtható (.exe), DLL-fájlok (.dll), hibakeresési információk (.pdb).

Futásidejű adatok nélkül a gyakori elérésű útvonalak és a hideg útvonalak hasonló kezelést kapnak.

SPGO-kompatibilis buildelési folyamat

Az SPGO új bemenetként hozzáadja a profilkészítési adatokat a buildelési folyamathoz:

Bemenetek: Forráskód, a .spd profilfájl (egy profilkészítési futtatásból származó mintaszámok), kiadási módú fordítási jelzők, /link /spgo, valamint /spdin:<path> egy bemeneti SPD-fájl megadásához (ha nincs megadva, alapértelmezés szerint a bináris nevét használó és az obj mappában található .spd fájl lesz használva).
Folyamat: A szerkesztőprogram az SPD-t a köztes kóddal együtt olvassa be. Az elágazásgyakorisági adatokat a jobb függvénybeágyazási, kódelrendezési és elágazássorrendezési döntések meghozatalához használja fel. A gyors hozzáférés érdekében a gyakran futó függvények úgy rendeződnek el, hogy gyorsan elérhetők legyenek; a ritkán futó kód kikerül a kritikus végrehajtási útvonalból.
Kimeneti: Optimalizált végrehajtható (.exe), optimalizált DLL-fájlok (.dll), hibakeresési információk (.pdb) és új .spd fájl a jövőbeli profilkészítési iterációkhoz.

A legfontosabb megállapítás: Az SPGO az optimalizálási döntéseket a fordítótól és a linker heurisztikustól a valós végrehajtáson alapuló adatvezérelt döntésekre helyezi át.

Fő jelzők

Zászló	Típus	Alkalmazás célja
`/spgo`	Linker	Engedélyezi az SPGO-t. Beágyazza az SPGO-metaadatokat a bináris fájlba, és üres kimeneti fájlt hoz létre `.spd` , hacsak nincs `/spdin` megadva, ebben az esetben a megadott `.spd` fájlt használja bemenetként.
`/spdin:<path>`	Linker	Bemeneti SPD – profiladatokat biztosít a linkernek optimalizáláshoz
`/spd:<path>`	Linker	Kimeneti SPD-elérési út – megadja, hogy az új SPD hol van megírva (nem kötelező; alapértelmezés szerint ugyanarra a könyvtárra vonatkozik, mint a bináris). Bemeneti SPD-elérési útként szolgál, ha `/spdin` nincs megadva.
`/GL`	Fordítóprogram	Teljes programoptimalizálás szükséges ahhoz, hogy az SPGO a fordítási egységek között működjön
`/O1`, `/O2` (Méret minimalizálása, Maximális sebesség)	Fordítóprogram	Optimalizálás sebességre; lehetővé teszi az olyan agresszív optimalizálásokat, amelyeket az SPGO fejleszthet

Miben különbözik az SPGO a PGO-tól?

A PGO (profilvezérelt optimalizálás) megköveteli, hogy a binárisát instrumentálási kapcsolókkal (/GENPROFILE) fordítsa le, majd a lassabb, instrumentált binárist futtassa a .pgc végrehajtásszámláló fájlok összegyűjtéséhez, végül pedig újralinkelje a /USEPROFILE használatával. A fordító pontos végrehajtási számokat kap, de ehhez előbb instrumentálni kell a kódot. A folyamatról további információt a profilalapú optimalizálásokkal kapcsolatban talál.

Az SPGO a CPU hardveres teljesítményszámlálóit használja arra, hogy statisztikai mintákat gyűjtsön a nem instrumentált kiadási binárisából. Futtassa a meglévő bináris fájlt, profilozza azt a használatával xperf, konvertálja a nyomkövetést SPD-fájllá, és építse újra. Nincs sem instrumentált build, sem lassulás a profilozás során. A fordító a pontos számok helyett statisztikai mintavételezési adatokat kap, ami kevésbé pontos, de könnyebben lekérhető, és nem igényel kódmódosítást. Emellett lehetővé teszi olyan rendszerösszetevők vagy valós idejű összetevők profilkészítését is, amelyekhez nehéz adatokat gyűjteni egy rendszerszintű megközelítéssel. A végleges/kiadási binárisokat is profilozhatja.

Ez az oktatóanyag három profilkészítési módszert tartalmaz: LBR, PMC és operációsrendszer-időzítő. A módszert a Profilkészítési módszer kiválasztása területen választhatja ki. A normál buildelési folyamat és az SPGO összeállítási folyamatának részletes összehasonlításáért, beleértve a jelző referenciatáblát is, tekintse meg a Build Process Comparison című témakört.

`perfcore.ini` konfigurálása

⚠️ Kötelező: E lépés xperf nélkül nem adja meg a szükséges profilkészítési adatokat. A(z) xperf futtatása előtt hajtsa végre ezt a lépést.

A Windows Performance Toolkit (WPT) a perfcore.ini elemet használja az SPGO-hoz szükséges DLL-szolgáltatók regisztrálásához; ez az elem a C:\Program Files (x86)\Windows Kits\10\Windows Performance Toolkit\perfcore.ini helyen található, ha a WPT az alapértelmezett helyre lett telepítve.

Nyissa meg Windows Jegyzettömbet rendszergazdaként. Ezután nyissa meg a(z) perfcore.ini elemet. Keresse meg a DLL-lista szakaszt, és adja hozzá a következő bejegyzéseket, soronként egyet:

perf_lbr.dll
perf_spt.dll
perf_hv.dll

Ha xperf.exe nincs telepítve, tekintse meg a telepítés általános problémáit .

Mentés és bezárás perfcore.ini. A DLL-fájlok már a(z) xperf.exe könyvtárával megegyező könyvtárban találhatók, ezért nem kell őket sehova másolnia. Csak a(z) perfcore.ini helyen regisztrálja őket. Győződjön meg arról, hogy az xperf elérési úton van.

A mintaalkalmazás létrehozása

Az oktatóanyag mintaalkalmazása egy C++ program, amely beolvassa a szöveget a standard bemenetből, és sorszámot, szószámot, teljes karakterszámot, karakterfrekvencia-táblázatot és a fájl ezredmásodpercben történő feldolgozásához eltelt időt hoz létre. C++-ban van megírva, de az SPGO a C-vel is működik. A munkafolyamat azonos a C-projektek esetében.

Hozzon létre egy fájlt a munkakönyvtárban, textCount.cpp és adja hozzá a következő forráskódot:

// 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;
}

A minta létrehozása és futtatása alapterv lekéréséhez

Az SPGO alkalmazása előtt készítsen textCount, és futtassa egy nagy szöveges fájlon, például War és Béke (letöltheti Project Gutenbergből), hogy lássa, milyen gyorsan fut. Ez a lépés bemutatja a teljesítményt, mielőtt optimalizálja az SPGO használatával:

Épít:

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

Futtatás:

textCount.exe < warAndPeace.txt

A következőhöz hasonló kimenet jelenik meg:

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

=== CHARACTER FREQUENCIES ===

Letters:
a: 202719
...

Elapsed time: 512.000 ms

Jegyezze fel az Elapsed time értéket. Összehasonlíthatja az SPGO-val optimalizált idővel a(z) Eredmények mérése részben.

TextCount létrehozása az /spgo használatával

Most hozzon létre textCount-t, ha engedélyezve van az SPGO. Ez a lépés lefekteti a profilkészítési adatok gyűjtésének alapjait.

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

Amikor a build befejeződik, megjelenik egy üzenet, például:

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

Ez az üzenet az első /spgo buildben jelenik meg. A linker létrehozza az SPD-fájlt, de még üres, ezért még nem alkalmaz SPGO-optimalizálásokat. Miután futtatta a bináris fájlt, begyűjtötte a profiladatokat, és SPD-vé konvertálta, ez az üzenet nem jelenik meg.

Jelölőmagyarázatok:

Zászló	Alkalmazás célja
`/Zi`	Teljes hibakeresési információk létrehozása. Erre azért van szükség, hogy az SPGO a profilkészítési mintákat a forráskódhoz rendelje.
`/EHsc`	C++ kivételkezelés engedélyezése
`/GL`	Teljes programoptimalizálás – az SPGO-hoz szükséges. A végső optimalizálást a linkelési időre halasztja, így lehetővé téve a modulok közötti beágyazásra, a kódelrendezésre és a holt kód eltávolítására vonatkozó döntéseket.
`/O2`	Sebességre optimalizálás – lehetővé teszi az agresszív beágyazást, a hurokoptimalizálást, a halott kód eltávolítását és a kapcsolódó átalakításokat.
`/link /debug`	Adja át `/debug` a linkernek a hibakeresési információk létrehozásához (`.pdb`amelyet az xperf a profilkészítési minták forráskódhoz való leképezéséhez használ).
`/spgo`	SPGO linker jelző – beágyazza az SPGO-metaadatokat a bináris fájlba, és létrehoz egy üres `textCount.spd` fájlt a végrehajtható fájl mellett.

Note

/spgo egy linker jelző. Adja át a linkernek a /link /spgo segítségével a cl parancsban.

A /spgo jelölő még nem optimalizálja a bináris fájlt. Előkészíti azt a profilozáshoz. Az optimalizálás a textCount és a /spdin újraépítésében történik, miután az SPD valós futtatókörnyezeti adatokkal van feltöltve.

Note

Ha az SPD-t egy adott helyre szeretné írni, adja hozzá az opcionális /spd:<path> hivatkozásjelzőt. Például: /link /debug /spgo /spd:.\profiles\textCount.spd. Ha kihagyja ezt a jelzőt, az SPD a .exe mellett jön létre.

A profilkészítési módszer kiválasztása

Az SPGO három profilkészítési módszert támogat. A használt módszer a hardvertől függ.

A három profilkészítési módszer

Módszer	A minta minősége	Hardverkövetelmény	Legjobb a számára
LBR (utolsó ágrekord)	Legmagasabb – a nemrég bejárt ágak sorozatait rögzíti, így mintánként részletes vezérlésifolyamat-adatokat biztosít az optimalizáló számára	Intel Haswell (2013) vagy újabb; AMD Zen 4 (2022) vagy újabb; ARM64 ARMv9.2-A (2020) vagy újabb	A legtöbb modern asztali hardver
PMC/IP mód (Teljesítményfigyelési számláló/Utasításmutató mód)	Jó. A CPU teljesítményfigyelő egységének (PMU) használatával rögzíti a hívásveremmel együtt gyűjtött utasításszámláló-mintákat, a Windows eseménykövetésén (ETW) keresztül.	Bármilyen x64- vagy ARM64-processzor PMU-val	Hardver LBR-támogatás nélkül
Operációsrendszer-időzítő	Alapszintű – időzítőalapú minták	Bármilyen x64- vagy ARM64-processzor, PMU-átengedés nélküli virtuális gép	Virtuális gépek és régebbi hardverek

PMC/IP módban minden egyes hardveres megszakítás csak egyetlen adatpontot szolgáltat: „a CPU a 0x1A2B3C4D címen volt, amikor a megszakítás bekövetkezett”. Az LBR esetén minden megszakítás egy vermet biztosít a CPU által a megszakítás bekövetkezése előtt végrehajtott utolsó 16–32 elágazásról. Az optimalizáló jobb vezérlésifolyam-adatokat kap, és jobb beágyazási és elrendezési döntéseket hozhat.

Az elérési út észlelése

Futtassa az alábbi két parancsot annak megállapításához, hogy a gép melyik profilkészítési útvonalat támogatja. Ezek a parancsok nem igényelnek emelt szintű kérést.

1. lépés: LBR-támogatás ellenőrzése. Ez a teszt az Intel/AMD/ARM64 rendszeren működik.

Futtassa a következőket egy administrator Visual Studio fejlesztői parancssorból:

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"

Ha ez a parancs talál egy sort tartalmazó LBR, TimeStampsort, akkor a gép támogatja az LBR-t. Használja az LBR elérési utat.
Ellenkező esetben folytassa a 2. lépésben.

2. lépés: A PMC támogatásának ellenőrzése (LBR nélkül)

xperf.exe -pmcsources | findstr TotalIssues

Ha ez a parancs kimenetet hoz létre, akkor a gép támogatja a PMC-számlálókat, de az LBR-t nem. Használja a PMC elérési útját.
Ha ez a parancs nem hoz létre kimenetet, használja az operációsrendszer-időzítő elérési útját.

További információ az xperf-alapú PMU-eseménygyűjtésről: Hardveres PMU-események rögzítése xperf használatával.

Döntési táblázat

`LBR, TimeStamp` kimenet	`TotalIssues` kimenet	Az Ön útja
Nem üres	(nincs bejelölve)	LBR
Üres	Nem üres	PMC
Üres	Üres	Operációsrendszer-időzítő
ARM64 processzor	N/A	PMC (ha elérhető PMU) vagy operációsrendszer-időzítő

A megközelítés kiválasztása

Döntse el, hogy az észlelési eredmények alapján használja-e az LBR, a PMC vagy az operációs rendszer időzítőútvonalát. Minden elérési út különböző xperf indítási paraméterekkel rendelkezik a megfelelő profilkészítési adatok gyűjtéséhez. Kövesse a hardver képességeinek megfelelő útvonalat.

Az elérési út:

LBR-felhasználók (az 1. lépésben észlelt LBR): Ugrás az LBR elérési útjára.

PMC felhasználók (a 2. lépésben észlelt InstructionRetired): Lépjen a PMC elérési útra (LBR nélkül).

Operációsrendszer-időzítő felhasználói (virtuális gép vagy hardver PMU nélkül): Nyissa meg az operációsrendszer-időzítő elérési útját.

Minden útvonal itt fut össze: A munkaterhelés futtatása és az xperf leállítása.

Az ebben a szakaszban található parancsok a Profilkészítési módszer kiválasztása szakaszban azonosított profilkészítési útvonaltól függnek. Keresse meg az elérési útnak megfelelő alszakaszt, futtassa a xperf start parancsot, majd futtassa a számítási feladatot, és állítsa le az xperf parancsot a számítási feladat futtatásához és az xperf leállításához.

⚠️ Futtatás rendszergazdaként:xperf emelt szintű (rendszergazdai) fejlesztői parancssort igényel. Szintemelés nélkül ad xperf"failed to configure counters"vissza.

LBR elérési út

Kezdés xperf az LBR-gyűjteménnyel:

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

Paraméter magyarázata:

Paraméter	Alkalmazás célja
`LOADER+PROC_THREAD+PMC_PROFILE`	Kernelszolgáltatók: betöltőesemények (modulleképezés), folyamat-/szálesemények (végrehajtási környezet) és PMC-profilkészítési események
`-MinBuffers 4096 -MaxBuffers 4096 -BufferSize 4096`	Nagy körkörös pufferek a mintavesztés elkerülésére egy teljes War and Peace-lefuttatás során
`-pmcprofile BranchInstructionRetired`	PMC eseményindító: mintavétel minden N-edik végrehajtott elágazási utasításnál
`-LastBranch PmcInterrupt`	LBR hardverrögzítés engedélyezése: minden PMC-megszakításon rögzítse a hardver utolsó ág rekordveremét
`-setProfInt BranchInstructionRetired 16384`	Mintavételi intervallum: megszakítás generálása minden 16 384 végrehajtott elágazási utasítás után

Az xperf indítása után folytassa a számítási feladat futtatását és az xperf leállítását.

PMC-elérési út (LBR nélkül)

Kezdje el a(z) xperf PMC / IP-módú gyűjtést:

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

Paraméter magyarázata:

Paraméter	Alkalmazás célja
`LOADER+PROC_THREAD+PMC_PROFILE+PROFILE`	Hozzáadja a `PROFILE` (CPU-mintavételezés) és a `PMC_PROFILE` támogatását a PMC-eseményekhez; nincs `-LastBranch`
`-pmcprofile InstructionRetired`	PMC eseményindító: minta a kivezetett utasításokhoz (utasításmutató mód)
`-setProfInt InstructionRetired 16384`	Váltson ki megszakítást minden 16 384 végrehajtott utasítás után
`-stackwalk profile`	Rögzítse a hívásvermet minden profilozási megszakításkor, így elágazási sorozatok helyett hívásilánc-adatokat biztosít.

LBR-hez képest: nincs -LastBranch jelölő; ahelyett InstructionRetiredhasználBranchInstructionRetired. Az eredmény hívásveremekkel együtt rögzített utasításmutató-minták, nem elágazási sorozatok. Ez az elérési út továbbra is hatékony adatokat biztosít az optimalizáló számára, de kevésbé gazdag.

A kezdés xperfután folytassa a számítási feladat futtatását és az xperf leállítását.

Az operációs rendszer időzítőjének útvonala

Indítsa el az xperf-et az operációs rendszer időzítőalapú mintavételezésével:

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

Paraméter magyarázata:

Paraméter	Alkalmazás célja
`LOADER+PROC_THREAD+PROFILE`	Nincs PMC-esemény; CPU-mintavételezés csak az operációs rendszer időzítőjének megszakítása révén
`-setProfInt Timer 1221`	Az operációs rendszer időzítőmegszakításakor minden 1,221 időzítőimpulzus után aktiválódik (körülbelül 1 kHz-en)
`-stackwalk profile`	Hívásverem rögzítése minden időzítő-megszakításkor

Az LBR-hez és a PMC-hez képest ez a módszer nem használ hardverteljesítmény-számlálókat. Az operációs rendszer időzítője a processzortevékenységtől függetlenül nagyjából rögzített időközönként aktiválódik. A minták kevésbé mutatnak szoros korrelációt a gyakran futtatott kóddal, de továbbra is hasznos, a vezérlési folyamatra vonatkozó adatokat szolgáltatnak az optimalizáló számára.

Futtassa a számítási feladatot, és állítsa le az xperf-et (minden elérési út)

xperf futtatása közben futtasd a(z) textCount programot a Háború és béke ellen:

textCount.exe < warAndPeace.txt

Miután textCount befejeződik, állítsa le a(z) xperf elemet, és írja ki a nyomkövetési fájlt. A profilkészítés során más folyamatok futtatása hígítja a mintaminőséget. A legjobb eredmény érdekében zárja be a szükségtelen alkalmazásokat a számítási feladat futtatása előtt.

xperf -stop -d textCount.etl

A(z) xperf leállítása után (az ETL-fájl kiírása eltarthat egy ideig) ellenőrizze, hogy a(z) textCount.etl létrejött-e az aktuális könyvtárban.

Az ETL-fájl konvertálása SPT-fájllá

Ez a lépés mindhárom profilkészítési útvonal esetében ugyanaz.

Futtassa SPTAggregate.exe a nyers ETL-nyomkövetés feldolgozásához és egy SPT-profilfájl létrehozásához:

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

Paraméter magyarázata:

Paraméter	Alkalmazás célja
`/binary textCount.exe`	Az a bináris fájl, amelyből a mintákat ki kell nyerni. Az ETL a profilkészítés során futtatott összes folyamat mintáit tartalmazhatja
`/etl textCount.etl`	Bemeneti ETL-nyomkövetési fájl
`textCount.spt`	SPT-profil kimeneti fájl

SPTAggregate egy összegzést ad ki, amely bemutatja, hogy hány mintát gyűjtött össze. Ez az összegzés az első megerősítés, hogy a profilkészítés működött.

Vesse össze a(z) SPTAggregate kimenetét azzal az útvonallal, amelyet megtett:

LBR-elérési út: Keresse meg a nem használt LBR-minták számát.
PMC-útvonal: Keressen nem nulla PMC-t vagy nem nulla veremmintaszámot.
OS-időzítő útvonala: Keresse a nem nulla használtverem-minták számát.

Ha minden szám nulla, a folytatás előtt tekintse meg a hibaelhárítást .

Az SPT-fájl átalakítása SPD-vé

Az elérési út:

Az LBR felhasználói (/mode:LBR használatával): LBR mód

PMC használói (/mode:IP használatával): IP üzemmód (PMC és az operációs rendszer időzítője)

OS-időzítő használói (/mode:IP használatával): IP-mód (PMC és OS-időzítő)

Mind a PMC, mind az OS-időzítő útvonala a /mode:IP elemet használja, mert mindkettő utasításmutató-mintákat eredményez.

A következő lépés a profilozási útvonal szerint ágazik el, konkrétan a /mode számára átadott SPDConvert.exe jelölő alapján.

LBR üzemmód

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

/mode:LBR arra utasítja a SPDConvert elemet, hogy az SPT-t LBR-elágazásszekvencia-adatokat tartalmazóként értelmezze.

IP-mód (PMC- és operációsrendszer-időzítő)

A PMC és az operációs rendszer időzítője is utasításmutató-mintákat hoz létre, ezért mindkettő ugyanazt a konverziós parancsot használja:

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

/mode:IP arra utasítja SPDConvert-t, hogy az SPT-t utasításmutató-mintákat tartalmazónak értelmezze.

Warning

Ha nem megfelelő módot használ az adattípushoz, üres vagy hibásan formázott SPD-t hozhat létre. Ha LBR-rel profilozott, használja a /mode:LBR. Ha PMC-vel vagy az operációs rendszer időzítőjével készített profilt, használja a /mode:IP elemet. Az SPTAggregateETL-fájl SPT-vé alakítása összefoglaló kimenete azt mutatja, hogy mely mintatípusok lettek összegyűjtve, és megerősíti a megfelelő módot.

A(z) SPDConvert futtatása után ellenőrizze, hogy a(z) textCount.spd létrejött (vagy frissült) az aktuális könyvtárban.

SPDConvert kimenet értelmezése

A parancs SPDConvert textCount.spd textCount.spt kinyomtat egy előzetes és utáni blokklefedettségi összegzést, például:

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

Ez az összefoglalás a társított profiladatokkal rendelkező bináris kódblokkok százalékos arányát mutatja. A nagyobb százalék jobb. A 70% feletti lefedettség kiváló, míg a 40% alatti lefedettség korlátozhatja az optimalizálási hatékonyságot. Ha a lefedettség alacsony, futtassa hosszabb ideig a profilkészítési számítási feladatot, vagy egyesítse a különálló futtatásokból származó több SPT-fájlt különböző számítási feladatokkal. Futtathatja például a(z) textCount elemet több szövegfájlon is, hogy különböző kódvonalakat futtasson be.

A következőhöz hasonló, SPDConvert-tól származó figyelmeztetést láthat:

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.

Ez a figyelmeztetés azt jelenti, hogy a profilkészítési futtatás nem gyűjtött elegendő mintát az optimalizáló számára az összes gyakori funkció magabiztos optimalizálásához. Az SPD továbbra is használható, de az eredményeket a következővel javíthatja:

A számítási feladat hosszabb futtatása (például 1 perc helyett 5 vagy több perc) vagy különböző számítási feladatok használata.
A -setProfInt parancsban a xperf érték csökkentése a mintavételezési sebesség növelése érdekében. A kompromisszum az, hogy ez a módosítás egy nagyobb ETL-fájlt hoz létre, amely hosszabb ideig tart a feldolgozáshoz.
Több SPT-fájl egyesítése külön profilozási futásokból úgy, hogy mindegyiket átadja a SPDConvert számára.

Az SPT-fájl bináris formátum. A tartalom vizsgálatához futtathatja a következőt SPTDump.exe textCount.spt: . Hasonlóképpen PTDump.exe textCount.spt megjeleníti a lefordított profiladatokat a(z) SPDConvert futtatása után. Mindkét eszköz hasznos a nemzero minták ellenőrzéséhez a folytatás előtt.

TextCount újraépítése a /spdin használatával

Építse újra a textCount elemet a kitöltött SPD-fájl használatával. A linker beolvassa a profiladatokat, és SPGO-optimalizálásokat alkalmaz.

Ez a lépés mindhárom profilkészítési útvonal esetében ugyanaz.

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

Új jelölő (a Build textCount with /spgo használatával összehasonlítva):

Zászló	Alkalmazás célja
`/spdin:textCount.spd`	Adja meg az SPD-profil adatait a linkernek optimalizáláshoz

A parancs továbbra is tartalmazza a(z) /spgo címkét. Létrehoz egy új SPD-fájlt az optimalizált bináris mellett, amelyet kiindulási pontként használhat a későbbi profilkészítési iterációkhoz.

Warning

Az SPD-fájl ahhoz a konkrét binárishoz van társítva, amelyet profiloz. Ha a textCount elemet /spdin nélkül építi újra, vagy módosított forrásból építi újra, új SPD-fájlt kell létrehoznia. A meglévő nem egyezik meg az új bináris GUID-jával, és a linker nem fogja használni.

A /spdin kapcsolóval végzett újraépítés után a linker statisztikákat jelenít meg arról, hogy a kód mekkora részét optimalizálta a profiladatok felhasználásával. Például:

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

A magas százalék azt jelenti, hogy az SPD jól lefedi a bináris elemeket. Ha a százalékos arány alacsony (például 90% alatt), akkor vagy a profilozási munkaterhelés nem fedte le eléggé a bináris állományt, vagy a bináris jelentősen megváltozott, amióta a profilt begyűjtötték. Mindkét esetben profilozza újra az aktuális binárissal.

Az SPGO feladata a profiladatokkal

Az SPGO az összegyűjtött mintaadatokat használja a program vezérlőfolyamat-gráfjában lévő egyes blokkok és élek számának feltöltésére. Ezek a számlálók például a következő optimalizálásokat teszik lehetővé:

Profilvezérelt függvénybeillesztés: Agresszívan beilleszti a forró hívási helyeket, miközben elkerüli a ritkán végrehajtott kódútvonalak beillesztéséből eredő kódméret-növekedést.
A gyakran és ritkán futó kód szétválasztása: A ritkán végrehajtott kód áthelyezése a bináris külön szakaszaiba, ami javítja az utasításcache kihasználtságát és a lapozási viselkedést.
Függvényelrendezés: Helyezze el az egymást gyakran egymáshoz közel hívó függvényeket a bináris fájlban, csökkentve az oldalhibákat, és javítsa a helységet. Az optimalizált függvények nagy affinitású COFF-csoportokba vannak rendezve a binárisban.
Döntések a méret és a sebesség között: A gyakran használt függvényeket a sebesség, a ritkán használt függvényeket pedig a méret szempontjából fordítsa le. Azokat a rutinokat, amelyekhez nem tartoznak észlelt profiltalálatok, a sebesség helyett inkább méretre optimalizálva fordíthatják le, ami korlátozhatja az olyan optimalizálásokat, mint a beágyazás és a ciklusok kigörgetése ezeken a ritkán futó útvonalakon.
Spekulatív devirtualizáció: Ha a mintavételezés azt mutatja, hogy egy közvetett hívás rendszeresen ugyanazt a függvényt célozza, az SPGO feltételezheti ezt a célpontot, és beillesztheti a kódját, miközben visszaesési lehetőséget biztosít a ritka esetekre.

Az eredmények mérése

Futtassa újra a(z) textCount elemet, majd hasonlítsa össze az eltelt időket.

textCount.exe < warAndPeace.txt

Minden konfigurációhoz gyűjtsön össze több futtatást, és használja a mediánt. Egyetlen futtatás nem ad megbízható eredményt, mert az operációs rendszer ütemezése és a rendszerzaj torzíthatja az egyes méréseket.

Felépítés	Reprezentatív eltelt idő
Alapállapot (`cl /Zi /EHsc /O2 /link /debug`)	(az Ön mérése)
`/spgo` build (még nincsenek profilozási adatok)	(az alapkonfigurációhoz közel kell lennie)
SPGO-ra optimalizált (`/spdin`)	(javulást kell mutatnia)

Az egyik vizsgálatban az LBR metódust használó SPGO körülbelül 7% az eltelt idő csökkenését jelentette. Az eredmények eltérhetnek a saját projektjeitől, mert az SPGO-nyereség attól függ, hogy a profilkészítési számítási feladat mennyire felel meg a tipikus végrehajtásnak. A nagyobb, ágokkal kitöltött kódbázisok általában nagyobb javulást látnak az 5–10% tartományon belül. A profilkészítési módszer befolyásolja az optimalizálási minőséget. Az LBR általában jobb eredményeket hoz, mint a PMC, ami jobb eredményeket eredményez, mint az operációs rendszer időzítője. Ha az operációsrendszer-időzítő útvonalán van, kisebb nyereségre számíthat.

Az ebben az oktatóanyagban követett LBR-útvonalat a SQLite projekten alkalmazták, amely egy éles környezetben használt adatbázis-kódtár. Az SPGO-optimalizált SQLite bináris körülbelül 7% javulást mutatott.

SPGO alkalmazása saját projektre

Ezzel az ellenőrzőlistával alkalmazhatja az SPGO-t a saját C vagy C++ alkalmazására.

Adja hozzá /Zi /link /debug /spgo a meglévő kiadás buildelési parancsához. Módosítsa a buildszkriptet vagy a projektfájlt:
```
cl /Zi /EHsc /GL /O2 myapp.cpp /link /debug /spgo
```
Válasszon egy reprezentatív számítási feladatot. Válasszon ki egy valós használati forgatókönyvet, amely az alkalmazás gyakori elérési útjait gyakorolja. Éles környezethez hasonló adatok használata. Kerülje a következőket elsődleges profilkészítési számítási feladatként: kódlefedettségi tesztek (nem stresszelik a teljesítmény szűk keresztmetszeteit), nem gyakori hibaelérési útvonalak, indítási és leállítási fázisok, valamint elavult kódelérési utak. Ez a számítási feladat hajtja az optimalizálót tápláló profilt.
Futtassa az xperf parancsot a felismert elérési út használatával. Használja a(z) Profilkészítési módszer kiválasztása részben azonosított útvonalat (LBR, PMC vagy az operációs rendszer időzítője). Indítsa el xperf, futtassa egyszer a számítási feladatot, állítsa le xperfés rögzítse az ETL-fájlt.
A PMC vagy az operációs rendszer időzítőútvonalához futtassa az SPTAggregate és az SPDConvert parancsot a megfelelő /mode jelölővel. Konvertálja az ETL-t SPT-vé, majd SPD-vé. LBR-adatokhoz használható /mode:LBR ; /mode:IP PMC- vagy operációsrendszer-időzítőadatokhoz használható.
Építse újra ezzel: /spdin:<your-spd-path>. Fordítsa le az alkalmazását a kitöltött SPD-vel:
```
cl /Zi /EHsc /GL /O2 yourApp.cpp /link /debug /spgo /spdin:yourApp.spd
```
Mérjen előtte és utána. Futtassa a számítási feladatot a nem optimalizált és az SPGO-ra optimalizált bináris fájlokkal is. Gyűjtse össze az egyes konfigurációkhoz tartozó több futtatás mediánját . Egyetlen futtatás nem megbízható a teljesítményértékeléshez.
Tárolja a .spd fájlt forráskezelőben. Vegye fel a .spd fájlt a verziókövető rendszerébe a forráskódjával együtt.
Engedélyezze az SPGO-t a fejlesztői kiadás buildjeiben. A csapat Release buildjei ugyanazokat az SPGO-optimalizált binárisokat használják, mint a produkcióban. Ez segít a teljesítményregressziók korai észlelésében.
Az SPGO letiltása hibakeresési buildekben.
Tekintse meg a linker profiljának teljességi statisztikáit. Minden /spgo build után jegyezze fel a profiladatok felhasználásával optimalizált profilozott függvények százalékát. Ha ez jelentősen csökken (90% alatt), profilozza újra a jelenlegi binárist. A kódmódosítások halmozódnak, és az SPD elavulttá válhat.

Alternatíva a(z) `xperf` használata helyett

Profiladatok gyűjtésének másik módja egy mintavételezési profilkészítő használata, például Windows Teljesítményrögzítő (WPR). A WPR alapértelmezés szerint telepítve van Windows 10 és újabb verziókra. A xperf-hoz hasonló adatokat gyűjt. A WPR úgy konfigurálható, hogy hívási veremekkel gyűjtsön CPU-mintákat, majd az adatokat egy ETL-fájlba exportálhatja, amelyet a SPTAggregate ETL-hez hasonlóan a SPDConvert és a xperf segítségével dolgozhat fel. Íme egy példa a WPR profiladatok gyűjtésére:

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

A WPR használatával kapcsolatos további információkért lásd: A teljesítményrögzítő használata Windows.

SPD-eloszlás

Ön megteheti:

Ellenőrizze a fájlt közvetlenül a .spd forráskód mellett a forrásvezérlőben.
Ossza meg a .spd fájlt a csapattagokkal, hogy újraprofilozás nélkül építhessenek SPGO-optimalizálásokkal.
Csomagolja be a fájlt a .spd bináris fájlokkal verziószámozott összetevőként (például NuGet-csomagként), és jegyezze fel, hogy melyik verzió melyik binárisnak felel meg.
A profilkészítési munkafolyamat megismétlésével bármikor újragenerálhatja .spd a fájlt.

Az SPD pontosan ahhoz a bináris fájlhoz van állítva, amelyből készült. Jelentős kódmódosítások után profilozza újra a kódot egy új SPD létrehozásához. A buildelés során a /spdin fordító egy új .spd fájlt is létrehoz. Mentse ezt az új SPD-t buildösszetevőként – ez a következő profilkészítési iteráció kiindulópontja.

SPD-információk újrafelhasználása a buildekben

Az SPGO „carry forward” koncepciója lehetővé teszi, hogy profilozási adatokat adjon hozzá egy meglévő SPD-fájlhoz anélkül, hogy az összes forgatókönyvet ismét a nulláról kellene profiloznia, és anélkül, hogy elveszítené a meglévő profilinformációkat. Azt is beállíthatja, hogy mennyi súlyt adjon a régebbi profiladatoknak. Ez a rugalmasság akkor hasznos, ha idővel viselkedésbeli változások következhetnek be, és nem szeretné teljesen elveszíteni a korábbi forgatókönyvek profilkészítési adatait. Például előfordulhat, hogy egy DLL különböző API-hívásokkal találkozik, ahogy az azt meghívó alkalmazás fejlődik. Továbbra is szeretné megtartani a korábbi működésből adódó optimalizálásokat, de emellett ötvözné azokat az optimalizálási lehetőségekkel is, amelyek abból fakadnak, hogy most időnként másképp viselkedik. A profilt idővel továbbfejlesztheti a régi és az új adatok keverésével.

Új SPT-fájllal történő SPDConvert futtatásakor adja meg a meglévő SPD-fájl nevét. Ezután a /retire:N beállítással szabályozhatja, hogy új SPT-fájlok hozzáadásakor a SPDConvert milyen mértékben csökkentse a régebbi profiladatok jelentőségét:

Az alapértelmezett (/retire:8) nagyobb súlyt ad az újabb adatoknak.
A /retire:0 használatával egyenlő súlyt adhat az összes futtatásnak.
A(z) /retire:16 használatával csak a legújabb adatok számítsanak.

Hibaelhárítás

Keresse meg a problémát:

LBR-útvonalproblémák:LBR-útvonalproblémák

A PMC útvonalával kapcsolatos problémák:A PMC útvonalával kapcsolatos problémák

Operációsrendszer-időzítő problémái:Az operációs rendszer időzítőjének elérési útjának problémái

Az összes elérési utat érintő problémák:Általános problémák

LBR-útvonalproblémák

Probléma	Valószínű ok	Javítás
Nincs LBR-minta a(z) `SPTAggregate` kimenetben	A CPU nem támogatja az LBR-t, vagy a virtuális gép nem teszi elérhetővé az LBR-t	Futtassa az észlelési parancsot a Az elérési út észlelése lehetőségből. Ha Hyper-V virtuális gépben fut, futtassa a `Set-VMProcessor MyVMName -Perfmon @("pmu", "lbr")` parancsot a gazdagépen. Ha az LBR nem érhető el, váltson a PMC vagy az operációs rendszer időzítőjének elérési útjára.
A processzor támogatja az LBR-t, de `SPTAggregate` 0 LBR-mintát mutat be	`perfcore.ini` A DLL-regisztráció hiányos	Végezze el a telepítést a `perfcore.ini`perfcore.inikonfigurálása című témakörben. Győződjön meg arról, hogy `perf_lbr.dll` regisztrálva van.
`SPDConvert` meghiúsul, vagy üres SPD-t eredményez	Hibás `/mode` jelző, vagy az SPT csak IP-módú mintákat tartalmaz	Ellenőrizze, hogy a kimenet LBR-mintákat mutatott-e `SPTAggregate` . Ha a kimenet csak IP-módú mintákat jelenít meg, váltson át a(z) `/mode:IP` értékre.

A PMC elérési útjaival kapcsolatos problémák

Probléma	Valószínű ok	Javítás
Nulla PMC-minta a kimenetben `SPTAggregate`	`perfcore.ini` A DLL-regisztráció helytelen	Végezze el a telepítést a `perfcore.ini`perfcore.inikonfigurálása című témakörben. Győződjön meg arról, hogy `perf_spt.dll` regisztrálva van. A DLL `xperf` nélkül nulla PMC-mintát hoz létre hibaüzenet nélkül. Futtassa a `xperf.exe -pmcsources` parancsot a CPU-ján elérhető teljesítményszámláló-források listájának megtekintéséhez. Ha nem látja az olyan bejegyzéseket, mint `SPT_OP_RETIRE_INSTR` vagy `SPT_OP_RETIRE_BR_INSTRSPT_OP_ETW_INSTR`, akkor előfordulhat, hogy a DLL-regisztráció `perfcore.ini` hiányos, vagy a processzor nem támogatja a PMC-t. Ha nem tudja feloldani a DLL-regisztrációt, próbálja meg inkább az operációs rendszer időzítőjének elérési útját.
`findstr InstructionRetired` kimenetet ad vissza, de `xperf` nem hoz létre mintákat	Virtuális gép maszkolása PMC-számlálók	Ellenőrizze, hogy fut-e virtuális gépen. Engedélyezze a PMU-t a Hyper-V-ben a(z) `Set-VMProcessor` használatával, vagy váltson az operációs rendszer időzítőútvonalára.
`SPDConvert` meghiúsul a PMC elérési útvonalon	`/mode:LBR` használata csak IP-címeket használó SPT-n	Váltson erre: `/mode:IP`

Operációsrendszer-időzítő elérési útjának problémái

Probléma	Valószínű ok	Javítás
A vártnál kisebb javulás	Várt – Az operációs rendszer időzítője alacsonyabb megbízhatóságú	Ez nem jelent problémát. Az optimalizáló számára az időzítőből származó minták kevesebb információt nyújtanak az elágazások lefutásáról, mint az LBR vagy a PMC. A teljesítménynövekedés kisebb. Fontolja meg a PMC-re vagy az LBR-re való frissítést, ha a hardver támogatja.
Nulla időzítő minták	`xperf` nem emelt jogosultságú parancssorban lett futtatva, vagy hiányzik a(z) `PROFILE` szolgáltató	Ellenőrizze, hogy rendszergazdaként fut-e. Erősítse meg, hogy a(z) `-stackwalk profile` meg lett adva a(z) `xperf` parancsnak.

Általános problémák (minden elérési út)

Probléma	Valószínű ok	Javítás
`"failed to configure counters"` hiba	`xperf` nem rendszergazdaként fut	Indítsa újra a parancssort rendszergazdaként (kattintson a jobb gombbal a > Futtatás rendszergazdaként elemre). Az xperf emelt szintű jogosultságokat igényel a hardverteljesítmény-számlálók konfigurálásához.
`xperf` nem található	`xperf.exe` nem található a PATH-ban	Ellenőrizze, hogy telepítve van-e a Windows ADK. Ellenőrizze `C:\Program Files (x86)\Windows Kits\10\Windows Performance Toolkit\`. Adja hozzá a könyvtárat a PATH-hoz, vagy futtassa közvetlenül az xperf fájlt.
`textCount.etl` nincs létrehozva	xperf hibaüzenet nélkül meghiúsult	Ellenőrizze, hogy rendszergazdaként fut-e. Futtassa újra az xperf start parancsot, és ellenőrizze a hiba kimenetét.
`SPTAggregate` a "bináris nem található" hibával meghiúsul	`textCount.exe` nincs az aktuális könyvtárban vagy rossz elérési út	Győződjön meg arról, hogy ugyanabban a könyvtárban van, mint `textCount.exe`a paraméter, vagy adja meg a `/binary` paraméter teljes elérési útját.
Az SPD-fájl nem jött létre	`SPDConvert` Nem sikerült	Ellenőrizze, hogy `textCount.spt` a méret nem-e nulla. Futtassa a `SPTDump.exe textCount.spt` parancsot a tartalmának megvizsgálásához.
`/spdin` a build nem hoz létre javulást	GUID-/age-eltérés az SPD és a bináris fájl között	Az SPD egy másik `textCount.exe` alapján készült. Profilozza újra a jelenlegi buildet egy friss SPD létrehozásához.
MSVC-verzióhiba a következőn: `/spgo`	MSVC-eszközkészlet a 14.51-nél korábbi verziónál	Nyissa meg a Visual Studio Installer >Individual Components> telepítse MSVC v14.51 vagy újabb verzióját. Nyissa meg újra a fejlesztői parancssort.

Következő lépések

Az oktatóanyag elvégzése után az alábbi képességeket ismerheti meg, hogy többet szerezzen az SPGO-tól:

Profilok egyesítése: Futtasson több munkaterhelést, gyűjtse össze az egyes futtatásokból származó SPT-fájlokat, és adja át őket a(z) SPDConvert számára. A kevert SPD-k a valós használati minták teljes körét tükrözik, és jobb optimalizálást eredményeznek, mint egy egyforgatókönyves profil. A /retire:N beállítással szabályozhatja, hogy a SPDConvert milyen mértékben csökkentse a régebbi profiladatok hangsúlyát új SPT-fájlok hozzáadásakor. Az alapértelmezett (/retire:8) nagyobb súlyt ad az újabb adatoknak. A /retire:0 használatával egyenlő súlyt adhat az összes futásnak; a /retire:16 használatával csak a legújabb adatok számítanak.
A legjobb eredmények a profilok több forrásból való keveréséből származnak, például olyan teljesítménymutatókból, amelyek a kulcsfontosságú forgatókönyveket, valamint a valós adatokat (ahol elérhetőek) stresszelik. Továbbítsa az összes forrásból származó SPT-fájlt ide: SPDConvert. Ismételje meg az SPT-fájlt az argumentumlistában, hogy nagyobb súlyt adjon neki (például a SPDConvert myapp.spd critical.spt critical.spt common.spt a critical.spt fájlnak kétszer akkora súlyt ad, mint a common.spt-nek).
Iteratív optimalizálás: Minden /spdin használatával végzett újraépítés új SPD-t hoz létre. Megismételheti a futtatás, profilozás és újraépítés ciklusát. A későbbi iterációk egyre kisebb hozadékot hozhatnak, de egy második kör olykor felismerhet olyan mintázatokat, amelyeket az első nem vett észre.
Kódmódosítások: A forráskód jelentős módosításai után gyűjtse újra a profiladatokat. A meglévő SPD ahhoz a binárishoz van kötve, amely alapján profilozták. Nem fog megegyezni egy jelentősen újraépített binárissal.
Profil aktualitása: A csatolószerkesztő minden egyes /spdin build után megadja a profiladatok felhasználásával optimalizált profilozott függvények százalékos arányát. Ha ez a százalék jelentősen csökken, az azt jelzi, hogy a kód eltér a profiltól. Az aktuális bináris újraprofilosítása.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-05-20

Használja a mintaprofil-alapú optimalizálást (SPGO) a C++ teljesítményének javítására

Prerequisites

Software

Hardverkövetelmények

Az SPGO működése

Összeállítási folyamat összehasonlítása

Normál összeállítási folyamat

SPGO-kompatibilis buildelési folyamat

Fő jelzők

Miben különbözik az SPGO a PGO-tól?

perfcore.ini konfigurálása

A mintaalkalmazás létrehozása

A minta létrehozása és futtatása alapterv lekéréséhez

TextCount létrehozása az /spgo használatával

A profilkészítési módszer kiválasztása

A három profilkészítési módszer

Az elérési út észlelése

Döntési táblázat

A megközelítés kiválasztása

LBR elérési út

PMC-elérési út (LBR nélkül)

Az operációs rendszer időzítőjének útvonala

Futtassa a számítási feladatot, és állítsa le az xperf-et (minden elérési út)

Az ETL-fájl konvertálása SPT-fájllá

Az SPT-fájl átalakítása SPD-vé

LBR üzemmód

IP-mód (PMC- és operációsrendszer-időzítő)

SPDConvert kimenet értelmezése

TextCount újraépítése a /spdin használatával

Az SPGO feladata a profiladatokkal

Az eredmények mérése

SPGO alkalmazása saját projektre

Alternatíva a(z) xperf használata helyett

SPD-eloszlás

SPD-információk újrafelhasználása a buildekben

Hibaelhárítás

LBR-útvonalproblémák

A PMC elérési útjaival kapcsolatos problémák

Operációsrendszer-időzítő elérési útjának problémái

Általános problémák (minden elérési út)

Következő lépések

Visszajelzés

További források

`perfcore.ini` konfigurálása

Alternatíva a(z) `xperf` használata helyett