Dynamische foutopsporing in C++ (Voorvertoning)

Belangrijk

Dynamische foutopsporing in C++ bevindt zich momenteel in preview-versie. Deze informatie heeft betrekking op een voorlopige functie die aanzienlijk kan worden gewijzigd vóór de release. Microsoft geeft geen garanties, uitgedrukt of impliciet, met betrekking tot de informatie die hier wordt verstrekt.

Deze preview-functie, beschikbaar vanaf Visual Studio 2022 versie 17.14 Preview 2, is alleen van toepassing op x64-projecten.

Met dynamische foutopsporing in C++ kunt u fouten opsporen in geoptimaliseerde code alsof deze niet-geoptimaliseerd is. Deze functie is handig voor ontwikkelaars die de prestatievoordelen van geoptimaliseerde code nodig hebben, zoals gameontwikkelaars die hoge framesnelheden nodig hebben. Met dynamische foutopsporing in C++ kunt u genieten van de foutopsporingservaring van niet-geoptimaliseerde code zonder dat u de prestatievoordelen van geoptimaliseerde builds opoffert.

Het opsporen van fouten in geoptimaliseerde code brengt uitdagingen met zich mee. De compiler herschaikt en herordent instructies om de code te optimaliseren. Het resultaat is efficiëntere code, maar dit betekent:

De optimizer kan lokale variabelen verwijderen of verplaatsen naar locaties die onbekend zijn met het foutopsporingsprogramma.
Code in een functie kan niet langer worden uitgelijnd met broncode wanneer de optimizer blokken code samenvoegt.
Functienamen voor functies in de aanroepstack kunnen onjuist zijn als de optimizer twee functies samenvoegt.

In het verleden hebben ontwikkelaars deze problemen en andere problemen opgelost toen ze bezig waren met het opsporen van fouten in geoptimaliseerde code. Deze uitdagingen worden nu geëlimineerd omdat u met dynamische foutopsporing in C++ stap voor stap in geoptimaliseerde code kunt gaan alsof deze niet-geoptimaliseerd is.

Naast het genereren van de geoptimaliseerde binaire bestanden, genereert het compileren met /dynamicdeopt niet-geoptimaliseerde binaire bestanden die worden gebruikt tijdens foutopsporing. Wanneer u een onderbrekingspunt toevoegt of stapt in een functie (inclusief __forceinline functies), laadt het foutopsporingsprogramma het niet-geoptimaliseerde binaire bestand. Vervolgens kunt u fouten opsporen in de niet-geoptimaliseerde code voor de functie in plaats van de geoptimaliseerde code. U kunt fouten opsporen alsof u fouten in niet-geoptimaliseerde code opspoort terwijl u nog steeds de prestatievoordelen van geoptimaliseerde code in de rest van het programma krijgt.

Dynamische foutopsporing voor C++ uitproberen

Laten we eerst eens kijken hoe het is om fouten in geoptimaliseerde code op te sporen. Vervolgens kunt u zien hoe dynamische foutopsporing in C++ het proces vereenvoudigt.

Maak een nieuw C++-consoletoepassingsproject in Visual Studio. Vervang de inhoud van het bestand ConsoleApplication.cpp door de volgende code:

// Code generated by GitHub Copilot
#include <iostream>
#include <chrono>
#include <thread>

using namespace std;

int step = 0;
const int rows = 20;
const int cols = 40;

void printGrid(int grid[rows][cols])
{
    cout << "Step: " << step << endl;
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            cout << (grid[i][j] ? '*' : ' ');
        }
        cout << endl;
    }
}

int countNeighbors(int grid[rows][cols], int x, int y)
{
    int count = 0;
    for (int i = -1; i <= 1; ++i)
    {
        for (int j = -1; j <= 1; ++j)
        {
            if (i == 0 && j == 0)
            {
                continue;
            }

            int ni = x + i;
            int nj = y + j;
            if (ni >= 0 && ni < rows && nj >= 0 && nj < cols)
            {
                count += grid[ni][nj];
            }
        }
    }
    return count;
}

void updateGrid(int grid[rows][cols])
{
    int newGrid[rows][cols] = { 0 };
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            int neighbors = countNeighbors(grid, i, j);
            if (grid[i][j] == 1)
            {
                newGrid[i][j] = (neighbors < 2 || neighbors > 3) ? 0 : 1;
            }
            else
            {
                newGrid[i][j] = (neighbors == 3) ? 1 : 0;
            }
        }
    }
    // Copy newGrid back to grid
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            grid[i][j] = newGrid[i][j];
        }
    }
}

int main()
{
    int grid[rows][cols] = { 0 };

    // Initial configuration (a simple glider)
    grid[1][2] = 1;
    grid[2][3] = 1;
    grid[3][1] = 1;
    grid[3][2] = 1;
    grid[3][3] = 1;

    while (true)
    {
        printGrid(grid);
        updateGrid(grid);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        cout << "\033[H\033[J"; // Clear the screen
        step++;
    }

    return 0;
}

Wijzig de Oplossingsconfiguraties vervolgkeuzelijst naar Release. Zorg ervoor dat de vervolgkeuzelijst voor het oplossingenplatform is ingesteld op x64-.
Bouw opnieuw door Build>Rebuild Solutionte selecteren.
Stel een onderbrekingspunt in op regel 55 int neighbors = countNeighbors(grid, i, j); in updateGrid(). Voer het programma uit.
Wanneer u het onderbrekingspunt bereikt, bekijkt u het Locals venster. Selecteer in het hoofdmenu Debug>Windows>Locals. U ziet dat u de waarde van i of j niet kunt zien in het venster Locals. De compiler heeft deze weggeoptimeerd.
Probeer een onderbrekingspunt in te stellen op regel 19, cout << (grid[i][j] ? '*' : ' '); in printGrid(). Dat is niet mogelijk. Dit gedrag wordt verwacht omdat de compiler de code heeft geoptimaliseerd.

Stop het programma en schakel dynamische foutopsporing voor C++ in en probeer het opnieuw

Klik in Solution Explorermet de rechtermuisknop op het project en selecteer Eigenschappen om de projecteigenschapspagina's te openen.
Selecteer Geavanceerde>Dynamische foutopsporing voor C++ gebruikenen wijzig de instelling in Ja-.

De eigenschappenpagina wordt geopend voor configuratie-eigenschappen > Advanced > Dynamische foutopsporing in C++ gebruiken. De eigenschap is ingesteld op Ja.

Met deze stap wordt de switch /dynamicdeopt toegevoegd aan de compiler en de linker. Achter de schermen worden ook de C++-optimalisatieswitches /GL en /OPT:ICFuitgeschakeld. Met deze instelling worden schakelaars die u handmatig aan de opdrachtregel hebt toegevoegd of andere ingestelde optimalisatieschakelaars, zoals /O1, niet overschreven.
Bouw opnieuw door Build>Rebuild Solutionte selecteren. Diagnostische code MSB8088 verschijnt, wat aangeeft dat dynamische foutopsporing en volledige programma-optimalisatie niet compatibel zijn. Deze fout betekent dat volledige programmaoptimalisatie (/GL) automatisch is uitgeschakeld tijdens de compilatie.

U kunt de optimalisatie van het hele programma handmatig uitschakelen in de projecteigenschappen. Selecteer configuratie-eigenschappen>geavanceerd>gehele programma-optimalisatieen wijzig de instelling in uit. Nu wordt MSB8088 als waarschuwing behandeld, maar het kan worden behandeld als een fout in een toekomstige versie van Visual Studio.
Voer de app opnieuw uit.

Wanneer u nu het onderbrekingspunt op regel 55 bereikt, ziet u de waarden van i en j in het venster Locals. In het venster Aanroepstack ziet u dat updateGrid() is gedeoptimaliseerd en dat de bestandsnaam life.alt.exeis. Dit alternatieve binaire bestand wordt gebruikt voor het opsporen van fouten in geoptimaliseerde code.

Er wordt een onderbrekingspunt weergegeven in de functie updateGrid. De aanroepstack laat zien dat de functie is gedeoptimaliseerd en dat de bestandsnaam life.alt.exeis. Het venster Locals toont de waarden van i en j en de andere lokale variabelen in de functie.

De updateGrid()-functie is op aanvraag gedeoptimaliseerd omdat u er een onderbrekingspunt in instelt. Als u een geoptimaliseerde functie overslaat tijdens het foutopsporen, wordt deze niet gedeoptimaliseerd. Als u stapt in een functie, wordt deze gedeoptimaliseerd. De belangrijkste manier om ervoor te zorgen dat een functie wordt gedeoptimaliseerd, is door een onderbrekingspunt in te stellen of erin te stappen.

U kunt ook een functie deoptimaliseren in het venster Call Stack. Klik met de rechtermuisknop op de functie of een geselecteerde groep functies en selecteer Deoptimize bij volgende vermelding. Deze functie is handig als u lokale variabelen wilt weergeven in een geoptimaliseerde functie waarvoor u geen onderbrekingspunt ergens anders in de aanroepstack hebt ingesteld. Functies die op deze manier zijn gedeoptimaliseerd, worden gegroepeerd in het onderbrekingspunten venster als een onderbrekingspuntgroep met de naam Deoptimized Functions. Als u de onderbrekingspuntgroep verwijdert, worden de bijbehorende functies teruggezet naar de geoptimaliseerde status.

Voorwaardelijke en afhankelijke onderbrekingspunten gebruiken

Probeer een onderbrekingspunt opnieuw in te stellen op regel 19 cout << (grid[i][j] ? '*' : ' '); in printGrid(). Nu werkt het. Als u een onderbrekingspunt instelt in de functie, wordt deze gedeoptimaliseerd om normaal fouten op te sporen.
Klik met de rechtermuisknop op het onderbrekingspunt op regel 19, selecteer Voorwaardenen stel de voorwaarde in op i == 10 && j== 10. Schakel vervolgens het selectievakje Alleen inschakelen wanneer het volgende onderbrekingspunt wordt bereikt: in. Selecteer het onderbrekingspunt op regel 55 in de vervolgkeuzelijst. Nu wordt het onderbrekingspunt op regel 19 pas bereikt als het onderbrekingspunt op regel 50 eerst wordt bereikt en dan wanneer grid[10][10] op het punt staat om naar de console uitgevoerd te worden.

Het punt is dat u voorwaardelijke en afhankelijke onderbrekingspunten kunt instellen in een geoptimaliseerde functie en gebruik kunt maken van lokale variabelen en coderegels die in een geoptimaliseerde build mogelijk niet beschikbaar zijn voor het foutopsporingsprogramma.

Er wordt een voorwaardelijk onderbrekingspunt weergegeven op regel 19, cout < < (raster[i][j] ? '*' : ' ');. De voorwaarde is ingesteld op i == 10 && j== 10. Het selectievakje voor Alleen inschakelen wanneer het volgende onderbrekingspunt wordt bereikt, is geselecteerd. De dropdownlijst voor onderbrekingen is ingesteld op life.cpp regel 55.
Ga door met het uitvoeren van de app. Wanneer het onderbrekingspunt op regel 19 wordt bereikt, kunt u met de rechtermuisknop op regel 15 klikken en Volgende opdracht instellen selecteren om de lus opnieuw uit te voeren.

Een voorwaardelijk en afhankelijk onderbrekingspunt wordt bereikt op regel 19, cout < < (raster[i][j] ? '*' : ' ');. Het venster Locals toont de waarden van i en j en de andere lokale variabelen in de functie. In het venster Aanroepstack ziet u dat de functie is gedeoptimaliseerd en dat de bestandsnaam is life.alt.exe.
Verwijder alle onderbrekingspunten om gedeoptimaliseerde functies te retourneren naar hun geoptimaliseerde status. Selecteer in het hoofdmenu van Visual Studio Fouten opsporen>Alle onderbrekingspunten verwijderen. Alle functies keren vervolgens terug naar hun geoptimaliseerde status.

Als u onderbrekingspunten toevoegt via het venster Stack- aanroepen Deoptimize bij de volgende ingang optie, wat we in dit scenario niet hebben gedaan, kunt u met de rechtermuisknop op de gedeoptimaliseerde functies groep klikken en Verwijderen selecteer om alleen de functies in die groep terug te zetten naar hun geoptimaliseerde staat.

In het venster Onderbrekingspunten ziet u de groep Gedeoptimaliseerde functies. De groep is geselecteerd en het contextmenu is geopend met Onderbrekingspuntgroep verwijderen geselecteerd.

Dynamische foutopsporing voor C++ uitschakelen

Mogelijk moet u fouten opsporen in geoptimaliseerde code zonder dat deze wordt gedeoptimaliseerd of een onderbrekingspunt in geoptimaliseerde code plaatsen en moet de code geoptimaliseerd blijven wanneer het onderbrekingspunt wordt bereikt. Er zijn verschillende manieren om dynamische foutopsporing uit te schakelen of ervoor te zorgen dat de code niet kan worden geoptimaliseerd wanneer u een onderbrekingspunt bereikt:

Selecteer Extra>Opties in het hoofdmenu van Visual Studio. Vouw in het deelvenster Opties de sectie Alle instellingen>voor foutopsporing>algemeen uit. Schakel het selectievakje Uitgeschakeld debugged-functies automatisch deoptimaliseren indien mogelijk (.NET 8+, C++ Dynamische foutopsporing) uit. De volgende keer dat het foutopsporingsprogramma wordt gestart, blijft code geoptimaliseerd.

Selecteer Extra>Opties in het hoofdmenu van Visual Studio. Vouw in het dialoogvenster Opties de sectie Foutopsporing>algemeen uit. Schakel het selectievakje Uitgeschakeld debugged-functies automatisch deoptimaliseren indien mogelijk (.NET 8+, C++ Dynamische foutopsporing) uit. De volgende keer dat het foutopsporingsprogramma wordt gestart, blijft code geoptimaliseerd.

Veel dynamische onderbrekingspunten voor foutopsporing zijn twee onderbrekingspunten: één in het geoptimaliseerde binaire bestand en één in het niet-geoptimaliseerde binaire bestand. Selecteer in het venster Onderbrekingspunten de optie Kolommen weergeven>Functie. Wis het onderbrekingspunt dat is gekoppeld aan het binaire alt. Het andere breakpoint in het paar veroorzaakt een breuk in de geoptimaliseerde code.
Wanneer u foutopsporing uitvoert, selecteert u in het hoofdmenu van Visual Studio Foutopsporing>Windows>Demontage. Zorg ervoor dat deze focus heeft. Wanneer u via het venster Demontage in een functie stapt, wordt de functie niet gedeoptimaliseerd.
Schakel dynamische foutopsporing volledig uit door /dynamicdeopt niet door te geven aan cl.exe, lib.exeen link.exe. Als u bibliotheken van derden gebruikt en deze niet opnieuw kunt opbouwen, geeft u /dynamicdeopt niet door tijdens de laatste link.exe om dynamische foutopsporing voor dat binaire bestand uit te schakelen.
Als u dynamische foutopsporing snel wilt uitschakelen voor één binair bestand (bijvoorbeeld test.dll), wijzigt of verwijdert u de binaire alt (bijvoorbeeld test.alt.dll).
Als u dynamische foutopsporing wilt uitschakelen voor een of meer .cpp bestanden, geeft u /dynamicdeopt niet door wanneer u ze bouwt. De rest van uw project is gebouwd met dynamische foutopsporing.

Dynamische foutopsporing voor C++ inschakelen voor Unreal Engine 5.6 of hoger

Unreal Engine 5.6 biedt ondersteuning voor dynamische C++-foutopsporing voor zowel Unreal Build Tool als Unreal Build Accelerator. Er zijn twee manieren om dit in te schakelen. Wijzig het BuildConfiguration.xml bestand of wijzig het Targets.cs bestand.

Het `BuildConfiguration.xml` bestand wijzigen

Selecteer in Visual Studio de configuratie van de ontwikkelingseditor en wijzig BuildConfiguration.xml deze om op te nemen <bDynamicDebugging>true</bDynamicDebugging>. Zie BuildConfiguration.xml voor meer informatie over en de locatie.

Een manier om uw BuildConfiguration.xml bestand te vinden, is door een build uit te voeren en de uitvoer van het buildlogboek te controleren. Wanneer u bijvoorbeeld de Lyra Starter Game bouwt, ziet u uitvoer als volgt:

- Running UnrealBuildTool: dotnet "..\..\Engine\Binaries\DotNET\UnrealBuildTool\UnrealBuildTool.dll" LyraEditor Win64 Development -Project="C:\LyraStarterGame\LyraStarterGame.uproject" ...
 14% -   Log file: C:\Users\<user>\AppData\Local\UnrealBuildTool\Log.txt

Zoek dat Log.txt naar BuildConfiguration.xml. Deze moet een lijn bevatten zoals Reading configuration file from: C:\LyraStarterGame\Saved\UnrealBuildTool\BuildConfiguration.xml

Wijzig dat BuildConfiguration.xml bestand zodat het bestand het volgende bevat <bDynamicDebugging>true</bDynamicDebugging>:

<?xml version="1.0" encoding="utf-8" ?>
<Configuration xmlns="https://www.unrealengine.com/BuildConfiguration">
    <WindowsPlatform>
        <bDynamicDebugging>true</bDynamicDebugging> <!-- add this line -->
    </WindowsPlatform>
</Configuration>

Het `Targets.cs` bestand wijzigen

De andere manier om dynamische foutopsporing voor C++ in te schakelen voor zowel Unreal Build Tool als Unreal Build Accelerator, is door het Target.cs bestand te wijzigen dat het bestand bevat WindowsPlatform.bDynamicDebugging = true.

Unreal Engine-projecten bevatten Target.cs bestanden die zijn gekoppeld aan verschillende doeltypen, waaronder:

{ProjectName}.Target.cs for the game executable.
{ProjectName}Editor.Target.cs for the editor build.

Voor een editor-build voegt u in het {ProjectName}Editor.Target.cs bestand toe WindowsPlatform.bDynamicDebugging = true; aan de constructor:

public class LyraEditorTarget : TargetRules
{
    public LyraEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        WindowsPlatform.bDynamicDebugging = true; // add this line
        // Other settings...
    }
}

Of voor een game-build, in het {ProjectName}.Target.cs bestand, toevoegen WindowsPlatform.bDynamicDebugging = true; aan ApplyShared{Project name}TargetSettings():

internal static void ApplySharedLyraTargetSettings(TargetRules Target)
{
    ILogger Logger = Target.Logger;
    
    WindowsPlatform.bDynamicDebugging = true; // add this line
    // Other settings...
}

Zie Doelen voor meer informatie over Unreal Engine-doelbestanden.

Dynamische foutopsporing voor C++ inschakelen voor Unreal Engine 5.5 of eerder

Voor Unreal Engine 5.5 of eerder selecteer de veranderingen in het Unreal Build Tool van GitHub naar uw repository.

Opmerking

Voor toegang tot de Epic-opslagplaatsen op GitHub hebt u een Epic-account en een geregistreerd GitHub-account nodig.

Nadat u de wijzigingen hebt geselecteerd die u wilt toepassen op uw opslagplaats, schakelt u deze in bDynamicDebugging zoals eerder beschreven. U moet ook Unreal Build Accelerator van Unreal Engine 5.6 gebruiken. Gebruik de nieuwste bits uit ue5-main of schakel UBA uit door het volgende toe te voegen aan BuildConfiguration.xml:

<BuildConfiguration>
    <bAllowUBAExecutor>false</bAllowUBAExecutor>
    <bAllowUBALocalExecutor>false</bAllowUBALocalExecutor>
</BuildConfiguration>

Zie Build Configurationvoor meer informatie over het configureren van de configuratie van Unreal Engine.

Problemen oplossen

Als onderbrekingspunten niet worden bereikt in gedeoptimaliseerde functies:

Als u uit een [Deoptimized]-frame stapt, bevindt u zich mogelijk in geoptimaliseerde code, tenzij de aanroeper is gedeoptimaliseerd vanwege een onderbrekingspunt erin of u onderweg naar de huidige functie in de aanroeper terechtkwam.
Zorg ervoor dat de alt.exe- en alt.pdb-bestanden zijn gemaakt. Voor test.exe en test.pdbmoeten test.alt.exe en test.alt.pdb bestaan in dezelfde map. Zorg ervoor dat de juiste buildswitches zijn ingesteld volgens dit artikel.
Er bestaat een debug directory vermelding in test.exe die het foutopsporingsprogramma gebruikt om de alt-binary te vinden die moet worden gebruikt voor de gedeoptimaliseerde foutopsporing. Open een x64-systeemeigen Visual Studio-opdrachtprompt en voer link /dump /headers <your executable.exe> uit om te zien of er een deopt vermelding bestaat. Er wordt een deopt vermelding weergegeven in de kolom Type, zoals wordt weergegeven in de laatste regel van dit voorbeeld:
```
  Debug Directories

        Time Type        Size      RVA  Pointer
    -------- ------- -------- -------- --------
    67CF0DA2 cv            30 00076330    75330    Format: RSDS, {7290497A-E223-4DF6-9D61-2D7F2C9F54A0}, 58, D:\work\shadow\test.pdb
    67CF0DA2 feat          14 00076360    75360    Counts: Pre-VC++ 11.00=0, C/C++=205, /GS=205, /sdl=0, guardN=204
    67CF0DA2 coffgrp      36C 00076374    75374
    67CF0DA2 deopt         22 00076708    75708    Timestamp: 0x67cf0da2, size: 532480, name: test.alt.exe
```
Als de deopt debug directoryvermelding niet aanwezig is, controleer dan of u /dynamicdeopt doorgeeft aan cl.exe, lib.exeen link.exe.
Dynamische deoptimalisatie werkt niet consistent als /dynamicdeopt niet wordt doorgegeven aan cl.exe, lib.exeen link.exe voor alle .cpp, .liben binaire bestanden. Controleer of de juiste schakelopties zijn ingesteld wanneer u uw project bouwt.

Zie dynamische foutopsporing in C++ voor meer informatie over bekende problemen: Volledige foutopsporing voor geoptimaliseerde builds.

Als de dingen niet werken zoals verwacht, opent u een ticket op Developer Community. Neem zoveel mogelijk informatie over het probleem op.

Algemene notities

IncrediBuild 10.24 ondersteunt C++ Dynamic Debugging-builds.
FastBuild v1.15 ondersteunt C++ Dynamic Debugging-builds.

Functies die inline zijn, worden op aanvraag gedeoptimaliseerd. Als u een onderbrekingspunt instelt voor een inline-functie, deoptimaliseert het foutopsporingsprogramma de functie en de aanroeper. Het onderbrekingspunt raakt waar u het verwacht, alsof uw programma is gebouwd zonder compileroptimalisaties.

Een functie blijft gedeoptimaliseerd, zelfs als u de onderbrekingspunten erin uitschakelt. U moet het onderbrekingspunt voor de functie verwijderen om terug te keren naar de geoptimaliseerde status.

Veel dynamische onderbrekingspunten voor foutopsporing zijn twee onderbrekingspunten: één in het geoptimaliseerde binaire bestand en één in het niet-geoptimaliseerde binaire bestand. Daarom ziet u meer dan één onderbrekingspunt in het onderbrekingspunten venster.

De compilervlaggen die worden gebruikt voor de gedeoptimaliseerde versie, zijn hetzelfde als de vlaggen die worden gebruikt voor de geoptimaliseerde versie, met uitzondering van optimalisatievlaggen en /dynamicdeopt. Dit gedrag betekent dat alle vlaggen die u instelt voor het definiëren van macro's ook worden ingesteld in de gedeoptimaliseerde versie.

Geoptimaliseerde code is niet hetzelfde als foutopsporingscode. De gedeoptimaliseerde code wordt gecompileerd met dezelfde optimalisatievlaggen als de geoptimaliseerde versie, dus bevestigingen en andere code dat afhankelijk zijn van foutopsporingsspecifieke instellingen, worden niet opgenomen.

Systeemintegratie bouwen

Dynamische foutopsporing in C++ vereist dat compiler- en linkervlaggen op een bepaalde manier worden ingesteld. In de volgende secties wordt beschreven hoe u een toegewezen configuratie instelt voor dynamische foutopsporing die geen conflicterende switches heeft.

Als uw project is gebouwd met het Visual Studio-buildsysteem, is het een goede manier om een dynamische foutopsporingsconfiguratie te maken door Configuration Manager te gebruiken om de configuratie voor release of foutopsporing te klonen en wijzigingen aan te brengen om dynamische foutopsporing mogelijk te maken. In de volgende twee secties worden de procedures beschreven.

Een nieuwe releaseconfiguratie maken

Selecteer in het hoofdmenu van Visual Studio Build>Configuration Manager- om Configuration Manager te openen.
Selecteer de vervolgkeuzelijst Configuratie en selecteer vervolgens <Nieuw...>.

In Configuration Manager, onder Projectcontexten, is de vervolgkeuzelijst Configuratie geopend en is gemarkeerd.
Het dialoogvenster Nieuwe oplossingsconfiguratie wordt geopend. Voer in het veld Naam een naam in voor de nieuwe configuratie, zoals ReleaseDD. Zorg ervoor dat instellingen kopiëren van: is ingesteld op Release-. Selecteer vervolgens OK- om de nieuwe configuratie te maken.

Het veld Naam is ingesteld op ReleaseDD. De vervolgkeuzelijst Instellingen kopiëren uit is ingesteld op Release.
De nieuwe configuratie wordt weergegeven in de vervolgkeuzelijst Actieve oplossingsconfiguratie. Selecteer Sluitaf.
Als de vervolgkeuzelijst Configuration is ingesteld op ReleaseDD, klikt u met de rechtermuisknop op uw project in Solution Explorer en kiest u Eigenschappen.
Stel in configuratie-eigenschappen>GeavanceerdeDynamische foutopsporing voor C++ gebruiken in op Ja-.
Zorg ervoor dat Hele Programmaoptimalisatie is ingesteld op Geen.

De eigenschappenpagina wordt geopend voor configuratie-eigenschappen > Geavanceerd. Dynamische foutopsporing in C++ gebruiken. De eigenschap is ingesteld op Ja. Hele programmaoptimalisatie is ingesteld op Nee.
Zorg ervoor dat in configuratie-eigenschappen>Linker>OptimalisatieCOMDAT folding is ingesteld op Nee (/OPT:NOICF).

De eigenschappenpagina wordt geopend voor Configuratie-eigenschappen > Linker > Optimalisatie > CMDAT Folding inschakelen. De eigenschap is ingesteld op Nee (/OPT:NOICF).

Met deze instelling wordt de /dynamicdeopt switch toegevoegd aan de compiler en de linker. Met C++ optimalisatieswitches /GL en /OPT:ICF ook uitgeschakeld, kunt u uw project nu bouwen en uitvoeren in de nieuwe configuratie wanneer u een geoptimaliseerde release-build wilt die u kunt gebruiken met C++ Dynamische foutopsporing.

U kunt andere switches die u met uw retail-builds gebruikt, toevoegen aan deze configuratie, zodat u altijd precies de switches hebt ingeschakeld of uitgeschakeld die u verwacht wanneer u dynamische foutopsporing gebruikt. Zie Incompatibele optiesvoor meer informatie over schakelopties die u niet moet gebruiken met dynamische foutopsporing.

Zie Configuraties maken en bewerkenvoor meer informatie over configuraties in Visual Studio.

Een nieuwe configuratie voor foutopsporing maken

Als u binaire bestanden voor foutopsporing wilt gebruiken, maar u wilt dat ze sneller worden uitgevoerd, kunt u de configuratie voor foutopsporing wijzigen.

Selecteer in het hoofdmenu van Visual Studio Build>Configuration Manager- om Configuration Manager te openen.
Selecteer de vervolgkeuzelijst Configuratie en selecteer vervolgens <Nieuw...>.

In Configuration Manager wordt in het projectcontextgedeelte van het venster de Configuratie-vervolgkeuzelijst geopend en is gemarkeerd.
Het dialoogvenster Nieuwe projectconfiguratie wordt geopend. Voer in het veld Naam een naam in voor de nieuwe configuratie, zoals DebugDD. Zorg ervoor dat Instellingen kopiëren van: is ingesteld op Debug. Selecteer vervolgens OK- om de nieuwe configuratie te maken.

Het naamveld is ingesteld op DebugDD. De vervolgkeuzelijst "instellingen kopiëren van:" is ingesteld op Debug.
De nieuwe configuratie wordt weergegeven in de vervolgkeuzelijst Actieve oplossingsconfiguratie. Selecteer Sluitaf.
Stel de vervolgkeuzelijst Configuration in op DebugDD, klik met de rechtermuisknop op uw project in Solution Explorer en selecteer Eigenschappen.
Schakel in configuratie-eigenschappen>C/C++>Optimalisatiede gewenste optimalisaties in. U kunt bijvoorbeeld Optimalisatie- instellen op Maximaliseren van snelheid (/O2).
Stel in C/C++>Code Generationde Basic Runtime Checks in op Default.
Schakel in C/C++>GeneralSupport Just My Code Debugginguit.
Stel debug-informatieformaat in op Program Database (/Zi).

U kunt andere switches toevoegen die u met uw foutopsporingsversies gebruikt voor deze configuratie, zodat u altijd precies de switches hebt ingeschakeld of uitgeschakeld die u verwacht wanneer u dynamische foutopsporing gebruikt. Zie Incompatibele optiesvoor meer informatie over schakelopties die u niet moet gebruiken met dynamische foutopsporing.

Zie Configuraties maken en bewerkenvoor meer informatie over configuraties in Visual Studio.

Overwegingen voor het aangepaste buildsysteem

Als u een aangepast buildsysteem hebt, moet u het volgende doen:

Geef /dynamicdeopt door aan cl.exe, lib.exeen link.exe.
Gebruik geen /ZI, een van de /RTC vlaggen of /JMC.

Voor bouwdistributeurs:

Voor een project met de naam testproduceert de compiler test.alt.obj, test.alt.exp, test.objen test.exp. De linker produceert test.alt.exe, test.alt.pdb, test.exeen test.pdb.
U moet de nieuwe binaire toolset c2dd.dll naast c2.dllimplementeren.

Incompatibele opties

Sommige opties voor compileren en linker zijn niet compatibel met dynamische foutopsporing in C++ Als u dynamische foutopsporing voor C++ inschakelt met behulp van de projectinstellingen van Visual Studio, worden incompatibele opties automatisch uitgeschakeld, tenzij u deze specifiek instelt in de instelling voor extra opdrachtregelopties.

De volgende compileropties zijn niet compatibel met dynamische foutopsporing in C++ :

/GH
/GL
/Gh
/RTC1 
/RTCc 
/RTCs 
/RTCu 
/ZI (/Zi is OK)
/ZW 
/clr 
/clr:initialAppDomain
/clr:netcore
/clr:newSyntax
/clr:noAssembly
/clr:pure
/clr:safe
/fastcap
/fsanitize=address
/fsanitize=kernel-address

De volgende linkeropties zijn niet compatibel met dynamische foutopsporing in C++ :

/DEBUG:FASTLINK
/INCREMENTAL
/OPT:ICF  You can specify /OPT:ICF but the debugging experience may be poor

Zie ook

/dynamicdeopt compiler-vlag (voorvertoning)
/DYNAMICDEOPT linkervlag (voorbeeld)
dynamische foutopsporing in C++ : Volledige foutopsporing voor geoptimaliseerde builds
Geoptimaliseerde code voor foutopsporing

Feedback

Is deze pagina nuttig?

Last updated on 2025-10-27