Demonstra Passo a passo: Usando a otimização interativa de analisar
Esta explicação passo a passo demonstra como usar a Otimização Guiada por analisar (PGO) para diversos cenários que variam de implementações simples usando menus de compilação PGO no Visual Studio Integrated IDE (ambiente de desenvolvimento), em cenários mais avançados que exigem configurações personalizadas.Esta explicação passo a passo também discute técnicas avançadas que permitem o uso de ferramentas de linha de comando PGO para personalizar o processo de coleta e mesclando os dados de criação de perfil.Para obter informações gerais, consulte Otimizações de interativa de perfil.
Esse cenário de exemplo ilustra como criar um aplicativo simples usando PGO.
Otimizações guiada de analisar podem ser aplicadas em qualquer projeto Visual C++ nativo.Os procedimentos a seguir ilustram usando PGO com um aplicativo Win32.
Sobre o Arquivo menu, selecionar Novoe, em seguida, selecionar Projeto.A caixa de diálogo New Project será exibida.
No Tipos de projeto painel, selecionar o O Visual C++ nó e no Modelos painel, selecionar Projeto Win32.
No Nome , digite PGODemo.
Clique no botão OK.O Assistente de aplicativo Win32 é exibido.
Manter todas as configurações padrão.clicar no Concluir botão.
Na barra de ferramentas Standard, clicar o Configuração de solução caixa de combinação e selecionar o Versão configuração.
In O gerenciador de soluções, clicar com o botão direito do mouse no nó do projeto PGODemo.No menu de contexto do projeto, selecionar Otimização Guiada por analisare, em seguida, selecionar o instrumentar item de menu.
In O gerenciador de soluções, clicar com o botão direito do mouse no nó do projeto PGODemo.No menu de contexto do projeto, selecionar Otimização Guiada por analisare, em seguida, selecionar Executar aplicativo instrumentado/otimizado para inicialização o aplicativo.
Observação: Também é possível inicialização o aplicativo instrumentado, selecionando Iniciar or Iniciar sem depuração from the Depurar menu.
Repetir a etapa 3, para treinar o aplicativo instrumentado usando diferentes cenários.Quando um aplicativo instrumentado é desligado, um arquivo .PGC é criado no diretório de saída do projeto, que contém os dados de analisar para que são executados.
In O gerenciador de soluções, clicar com o botão direito do mouse no nó do projeto PGODemo.No menu de contexto do projeto, selecionar Otimização Guiada por analisare, em seguida, selecionar Otimizar.
Suponha que você deseja compilação um aplicativo meu_apl.exe dos arquivos de fonte S1, …, Sn, usando a otimização PGO.Primeira etapa é verificar se que você compilar suas fontes S1, …, usando opção do compilador /GL Sn.
Você precisa também especificar as opções de otimização que corresponda às suas necessidades, let’s digamos que você escolher a opção /O2.É a ser mencionado que criar seu aplicativo com a PGO mas sem nenhuma opção de otimização, ou sejausando /Od, acionará um aviso e o compilador irá comutador automaticamente para compilação para LTCG.A partir da linha de comando a primeira etapa seria sistema autônomo segue:
cl.exe /c /GL /O2 S1.cpp … Sn.cpp
link /ltcg:pgi S1.obj … Sn.obj /out:myapp.exe
Etapa 2 cria um meu_apl.exe de imagem PGO instrumentado e cria também myapp.pgd que é o arquivo de banco de dados de analisar que será usado pelo compilador para compilação a final otimizado meu_apl.exe.O nome padrão do arquivo .pgd é o nome do aplicativo e o caminho padrão é o caminho de saída.
Você pode usar o vinculador opção /pgd na etapa anterior para alterar o nome padrão do arquivo .pgd gerado para o seu aplicativo.Você pode usar /pgd da seguinte maneira:
- link /ltcg:pgi /pgd:mypgd.pgd S1.obj … Sn.obj /out:myapp.exe
Agora você está pronto para treinar o meu_apl.exe instrumentado usando seus cenários de criação de perfil.Depois que você está concluído executando os cenários você encontrará um arquivo .pgc criado por execução.
Observação: |
---|
I f você executar mais de uma imagem do Meu_apl.exe do mesmo caminho simultaneamente apenas uma.PGC arquivo será criado para todos eles e esse arquivo será gravado no disco somente após todas as instâncias são encerradas. |
Observação: |
---|
T Ele padrão caminho para o.PGC arquivos é o caminho executável.Você pode alterar isso, definindo a variável de ambiente VCPROFILE_PATH antes de executar seus cenários de criação de perfil.ou seja .conjunto VCPROFILE_PATH = < algum caminho >, em seguida, execute a imagem instrumentada meu_apl.exe |
Você está pronto para compilação o PGO otimizado meu_apl.exe.
- link /ltcg:pgo /pgd:mypgd.pgd S1.obj … Sn.obj /out:myapp.exe
Observação: |
---|
Antes da etapa 1, você precisa ter todos sistema autônomo arquivos .PGC criados durante o cenário de treinamento na mesma pasta que o arquivo de banco de dados de analisar (.PGD) |
Let’s suponha que você tenha dois cenários principal do cliente para seu aplicativo.O primeiro cenário duas vezes é tão importante - ou freqüentemente concluído pelos clientes - sistema autônomo a segunda.
As etapas a seguir, você aprenderá como usar o ambiente de desenvolvimento do Visual Studio e as ferramentas de linha de comando para dar algumas peso mais alto de dados de analisar durante a fusão de no arquivo .PGD.
Sobre o Arquivo menu, selecionar Novoe, em seguida, selecionar Projeto.A caixa de diálogo New Project será exibida.
No Tipos de projeto painel, selecionar o O Visual C++ nó e no Modelos painel, selecionar Projeto Win32.
No Nome , digite PGODemo.
Clique no botão OK.O Assistente de aplicativo Win32 é exibido.
Manter todas as configurações padrão.clicar no Concluir botão.
Na barra de ferramentas padrão, clicar caixa de combinação configuração de solução e escolher o Versão configuração.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar formulário otimização interativa de analisar no menu de atalho e, em seguida, clicar instrumentar.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar otimização interativa de analisar no menu de atalho e, em seguida, clicar Executar aplicativo instrumentado.Isso iniciará o aplicativo.Observe que também é possível inicialização o aplicativo instrumentado usando Start ou Start Without depurar a partir do menu depurar sistema autônomo normal.
Repetir a etapa 3 duas vezes, uma vez para cada um dos cenários de clientes.Esta etapa criará dois arquivos .PGC no diretório de saída: PGODemo! 1.pgc e PGODemo!2.pgc.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Propriedades, a caixa de diálogo PGODemo páginas de propriedade é exibida.
In Propriedades de configuração clicar Criar eventos , em seguida, clicarEvento de pré-vínculo.No Linha de comando, digite o seguinte comando:
"$(VCInstallDir)bin\pgomgr.exe" -merge:2 $(OutDir)\$(ProjectName)!1.pgc $(OutDir)\$(ProjectName).pgd
Observação: Esta etapa irá usar pgomgr.exe mesclagem PGODemo ! 1.pgc em uma etapa separada antes de iniciar o vinculador a compilação a final otimizado de aplicativo.O vinculador chamará pgomgr.exe novamente durante a próxima etapa mesclagem PGODemo ! 2.pgc arquivo, mas com o peso padrão de 1.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Otimização Guiada por analisar no menu de atalho e, em seguida, clicar Otimizar.
Você pode usar sistema autônomo ferramentas de linha de comando para executar a mesclagem de dados de analisar personalizado, da seguinte maneira.
cl.exe /c /GL /O2 S1.cpp … Sn.cpp
link /ltcg:pgi S1.obj … Sn.obj /out:myapp.exe
As duas etapas anteriores serão criar meu_apl.exe instrumentado.
Treinar o meu_apl.exe instrumentado usando dois cenários diferentes serão criar dois diferentes .PGC arquivos myapp!1.pgc e myapp!2.pgc.
Para dar o primeiro cenário peso mais alto use pgomgr.exe sistema autônomo segue:
Pgomgr –merge:2 myapp!1.pgc myapp.pgd
Execute o comando link para criar o aplicativo otimizado final da seguinte maneira
link /ltcg:pgo /pgd:myapp.pgd /out:myapp.exe
Isso irá mesclagem myapp!2.pgc com o peso padrão de 1.
Nos dois cenários anteriores, usamos o /ltcg:pgo opção de vinculador para compilação a final otimizado aplicativo após compilação ing e treinamento de instrumentado. Ao usar /ltcg:pgo opção, o vinculador executará algumas verificações para certificar-se de que nenhuma alteração ocorreu aos arquivos de entrada (arquivos de objeto, bibliotecas, etc.) usados para compilação aplicativo instrumentado. Em outras palavras, para usar /ltcg:pgo, todos sistema autônomo arquivos de entrada passados para o vinculador devem ser o mesmo sistema autônomo arquivos transmitidas pela /ltcg:pgi etapa.
Isso ocorre porque as alterações acidentais fontes após a criação de aplicativo instrumentado e o arquivo .PGD pode drasticamente afetam decisões de geração e otimização de código PGO.
Suponha que depois de criado o aplicativo instrumentado, criou os dados de analisar e criou o aplicativo PGO otimizado, você descobriu que você se esqueceu de atualização o número de versão do seu aplicativo, ou, você descobriu um bug comum que precisa de uma correção muito MAIS que não afeta significativamente o fluxo do aplicativo.Para esse cenário, temos o /ltcg:pgu opção. O uso dessa opção o vinculador não executará verificações quando usando /ltcg:pgo opção. Você pode edição e recompilar arquivos ou até mesmo adicionar novos arquivos ao aplicativo entre PGI e PGU cria.
As etapas a seguir, você aprenderá como usar o ambiente de desenvolvimento do Visual Studio e as ferramentas de linha de comando para usar o /ltcg:pgu opção.
Na barra de ferramentas padrão, clicar caixa de combinação configuração de solução e escolher o Versão configuração.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Otimização Guiada por analisar formulário menu de atalho e, em seguida, clicar instrumentar.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Otimização Guiada por analisar no menu de atalho e, em seguida, clicar Executar aplicativo instrumentado/otimizado.Isso iniciará o aplicativo.Observe que também é possível inicialização o aplicativo instrumentado usando o inicialização a depuração or inicialização sem depuração from the Depurar menu sistema autônomo normal.
Nesta etapa você pode aplicar quaisquer alterações a qualquer arquivo de fonte.sistema autônomo mencionado acima, sistema autônomo alterações que afetam o comportamento do seu aplicativo drasticamente podem causar regressões do desempenho.Em geral você poderia fazer alterações muito pequenas, como pequenas correções de bugs ou alterações de arquivos de recursos.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Otimização Guiada por analisar no menu de atalho e, em seguida, clicar Atualização.Isso irá recompilar apenas os arquivos alterados e, em seguida, inicie o vinculador com /ltcg:pgu opção em vez de /ltcg:pgo, permitindo que arquivos editados
Observação: Você receberá avisos para cada nova função que não tem dados de analisar e cada função editado em uma forma que os dados de analisar coletados durante a etapa do treinamento invalida.Na barra de ferramentas padrão, clicar na caixa de combinação configuração de solução e escolher a configuração de versão.
Observação: Na etapa 5 você clicar com o botão direito do mouse em arquivo de fonte alterações na O gerenciador de soluções e clicar Compilar, essa ação excluirá todos os arquivos na pasta de saída relacionados a PGO porque o sistema de projeto executa uma compilação limpa ao mover para uma compilação normal de compilação PGO.
Você pode usar sistema autônomo ferramentas de linha de comando para executar a atualização PGO da seguinte maneira.
cl.exe /c /GL /O2 S1.cpp … Sn.cpp
link /ltcg:pgi S1.obj … Sn.obj /out:myapp.exe
As duas etapas anteriores serão criar meu_apl.exe instrumentado.
Treinar meu_apl.exe instrumentados
link /ltcg:pgo /pgd:myapp.pgd /out:myapp.exe
Etapa 4 será criar meu_apl.exe otimizado.Suponha que um pequeno bug é encontrado no Sm.cpp, você pode aplicar sistema autônomo correções e compilar apenas Sm.cpp da seguinte maneira
cl /c /GL /O2 Sm.cpp
Em seguida, use /ltcg:pgu para compilação o aplicativo otimizado usando os dados antigos do analisar criados na etapa 3.
link /ltcg:pgu /pgd:myapp.pgd /out:myapp.exe
Nesse cenário, você aprenderá como criar configurações PGO personalizadas para criar soluções com vários projetos.Nesse cenário irá adicionar uma DLL para a solução e vinculá-lo a PGODemo aplicativo.Criaremos duas configurações: PGIRelease e PGORelease e usá-los para criar a solução inteira em vez de usar os itens de menu otimização interativa de analisar para criar cada produto em um time.
Sobre o Arquivo menu, selecionar Novoe, em seguida, selecionar Projeto.A caixa de diálogo New Project será exibida.
No Tipos de projeto painel, selecionar o O Visual C++ nó e no Modelos painel, selecionar Projeto Win32.
No Nome , digite PGODemo.
Clique no botão OK.The Assistente de aplicativos Win32 aparece.
Manter todas as configurações padrão.clicar no Concluir botão.
Agora você tem uma solução e um projeto chamado PGODemo.Em seguida, criar um projeto DLL.
No O gerenciador de soluções, clicar com o botão direito do mouse sobre a solução e selecionar Adicionar.E, em seguida, clicar Novo projeto.A caixa de diálogo New Project será exibida.
No Tipos de projeto painel, selecionar o O Visual C++ nó e no Modelos painel, selecionar Projeto Win32.
No Nome , digite PGODemoDLL.
Clique no botão OK.O Assistente de aplicativo Win32 é exibido.
No Configurações do aplicativo escolherTipo de aplicativo DLL e clicar Concluir.
Agora você terá um projeto DLL chamado PGODemoDLL.
Sobre o O gerenciador de soluções, clicar duas vezes no projeto PGODemoDLL, clicar duas vezes em PGODemoDLL.cpp e adicione o seguinte código:
__declspec(dllexport) void HelloMessage(void) { MessageBox(NULL, L"hello", L"PGODemoDLL", MB_OK); }
Sobre o O gerenciador de soluções, clicar duas vezes no projeto PGODemo, clicar duas vezes em PGODemo.cpp e adicione a declaração a seguir antes da definição de _tWinMain função:
__declspec(dllimport) void HelloMessage(void);
Em _tWinMain antes do loop de mensagem principal, adicione o seguinte código:
HelloMessage();
No O gerenciador de soluções, clicar com o botão direito do mouse sobre a solução PDODemo e clicar Dependências de projeto.The Dependências de projeto caixa de diálogo será exibida.
Na página dependências clicar escolheu PGODemo no Projetos caixa de combinação.Verificar PGODemoDLL no Depende lista.
Em seguida, você criará as configurações de PGIRelease e PGORelease.
No O gerenciador de soluções, botão direito do mouse clicar sobre a solução, clicar Gerenciador de Configurações.clicar sobre o Configuração caixa de combinação para PGODemo projeto e clicar <Novo … >.A caixa de diálogo Novo projeto de configuração será exibida.
Em nome de configuração do projeto edição caixa, digite PGIRelease e escolher Versão in the Copiar configurações de caixa de combinação.Certifique-se de que o Criar nova configuração de solução caixa de seleção está marcada.
Repetir a mesma etapa no projeto PGODemoDLL e para adicionar a configuração PGIRelease para este projeto.Certifique-se de que Criar nova configuração de solução caixa de seleção não é verificada neste momento.
Repetir a etapa 16 para os dois projetos criar PGORelease configuração.Certifique-se de que ele também copia as configurações do Versão configuração.fechar o Gerenciador de Configurações caixa de diálogo.
Agora, criamos duas configurações, PGIRelease e PGORelease.
No O gerenciador de soluções, clicar com o botão direito do mouse no projeto PGODemo e clicar Propriedades.No Configuraçãocaixa de combinação escolher a configuração PGIRelease.In Propriedades de configuração clicar Geral.clicar no Otimização de programa total caixa de combinação e escolher o Otimização Guiada por analisar-instrumentar opção.clicar Aplicar para salvar suas alterações.
No Configuraçãocaixa de combinação escolher a configuração PGORelease.In Propriedades de configuração clicar Geral.clicar no otimizar de programa total combinação caixa e escolher o otimizar Guiada por analisar - otimizar.clicar Aplicar para salvar suas alterações.
Repetir as etapas 18 e 19 nas configurações PGIRelease e PGORelease para projeto PGODemoDLL.
Agora iremos alterar o Diretório intermediário para a configuração PGORelease seja igual a Saída diretório para a configuração PGIRelease para sistema autônomo dois projetos.
No O gerenciador de soluções, clicar com o botão direito do mouse no projeto PGODemo e, em seguida, clique em Propriedades.No Configuraçãocaixa de combinação escolher a configuração PGORelease.In Configuração propriedades clicar geral.No Diretório intermediário, digite PGIRelease $ (SolutionDir).clicar Aplicar e fechar a caixa de diálogo.
Repetir as etapas 21 para projeto PGODemoDLL.
Em seguida, adicionaremos o caminho do PGODemoDLL.dll à variável de ambiente do caminho do aplicativo PGODemo.
No O gerenciador de soluções, clicar com o botão direito do mouse no projeto PGODemo e clicar Propriedades.No Configuraçãocaixa de combinação escolher a configuração PGIRelease.In Propriedades de configuração clicar Depuração.No Ambiente, digite o seguinte e, em seguida, clicar Aplicar:
path=%path%;$(SolutionDir)PGODemoDLL\PGIRelease
No Configuraçãocaixa de combinação escolher a configuração PGORelease.In Configuração Propriedades de clicarDepuração.No Ambiente, digite o seguinte:
path=%path%;$(SolutionDir)PGODemoDLL\PGORelease
Em seguida, clicar Aplicar e, em seguida, clicar OK para fechar a caixa de diálogo.
No O gerenciador de soluções, clicar com o botão direito do mouse no projeto PGODemo e clicar Propriedades.No Configuraçãocaixa de combinação escolher a configuração PGORelease.In Propriedades de configuração clicar Vinculador e, em seguida, clicar Otimização.In o analisar interativa banco de dados edição caixa, substituir $(TargetDir) com $ (IntDir) \.
Repetir essa etapa para projeto PGODemoDLL.
No O gerenciador de soluções, clicar com o botão direito do mouse no projeto PGODemoDLL e clicar Propriedades.No Configuraçãocaixa de combinação escolher a configuração PGORelease.In Propriedades de configuração clicar Vinculador e, em seguida, clicar Avançado.No Importar biblioteca caixa de edição, substitua $(TargetDir) (IntDir) $ \.
Na barra de ferramentas padrão clicar a Configurações de solução combinação e escolher a configuração PGIRelease.No O gerenciador de soluções, clicar com o botão direito do mouse sobre a solução e clicar compilação Solução.
Este será compilação os bits instrumentados para os dois projetos.
clicar no Depurar menu e clicar de Iniciar a depuração or Iniciar sem depuração.Isso irá iniciar PGODemo.Depois de você desligado o aplicativo, dois arquivos .PGC será criado, um em cada uma das pastas de dois saída PGODemo\PGIRelease e PGODemoDLL\PGIRelease.
Na barra de ferramentas padrão clicar a Configurações de solução combinação e escolher a configuração PGORelease.No O gerenciador de soluções, clicar com o botão direito do mouse sobre a solução e clicar compilação Solução.
Agora você tem imagens PGO otimizado nas pastas configuração PGORelease para ambos os projetos
O comportamento padrão para o analisar coleta de dados é salvar todos os dados que descrevem o comportamento do aplicativo instrumentado desde sua inicialização até que ele seja desligado.PGO vem com uma ferramenta chamada PGOSWEEP ajuda você a personalizar o analisar coleta de dados.Você pode usar PGOSWEEP para coletar dados de analisar para alguns específicos time quadro durante o cenário de analisar executado.
As etapas a seguir, você aprenderá como usar o ambiente de desenvolvimento do Visual Studio e as ferramentas de linha de comando para controle a coleta de dados do analisar.
Sobre o Arquivo menu, selecionar Novoe, em seguida, selecionar Projeto.A caixa de diálogo New Project será exibida.
No Tipos de projeto painel, selecionar o Projetos do Visual C++ nó e no Modelos painel, selecionar Projeto Win32.
Na caixa Nome, digite PGODemo.
Clique no botão OK.The Assistente de aplicativos Win32 aparece.
Manter todas as configurações padrão.clicar no Concluir botão.
Na barra de ferramentas padrão, clicar o Configuração de solução combinação caixa e escolher o Versão configuração.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Otimização Guiada por analisar no menu de atalho e, em seguida, clicar instrumentar.
No O gerenciador de soluções, direito clicar projeto PGODemo.clicar Otimização Guiada por analisar no menu de atalho e, em seguida, clicar Executar aplicativo instrumentado/otimizado.Isso iniciará o aplicativo.Observe que também é possível inicialização o aplicativo instrumentado usando o inicialização a depuração or inicialização sem depuração from the Depurar menu sistema autônomo normal.
clicar no Ferramentas menu, clicar Ferramentas externas.The Ferramentas externas caixa de diálogo é exibida.Clique em Adicionar.No Título caixa de edição, digite Pgosweep.clicar no Procurar botão ao lado de Comando caixa de edição e localizar o caminho para a ferramenta PGOSWEEP.PGOSWEEP deve ser instalado na pasta …\VC\bin onde o Visual Studio está instalado.Verifique o Solicitar argumentos caixa de seleção e, em seguida, clicar OK para fechar o Ferramentas externas da caixa de diálogo.
From a Ferramentas menu, clicar Pgosweep.Uma caixa de diálogo aparece.No Argumentos edição caixa, digite:
$(TargetPath) $(TargetDir)$(TargetName)_custom!1.pgc
e clicar OK.
Na janela principal do PGODemo clicar Arquivo e clicar Sair para finalizar os dados de analisar coleção executar.
Agora, se você examinar o $ (OutDir), você encontrará dois arquivos .PGC.PGODemo_custom! 1.pgc é aquele que foi criado por PGOSWEEP e os dados de analisar do início do analisar foi executado até o momento em que chamamos PGOSWEEP.O segundo terá o esquema de nomeação padrão PGODemo!1.pgc e contém dados de analisar do ponto após o sweeping até que os nós encerrar o aplicativo instrumentado.
É muito importante observar que somente os arquivos .PGC que cumprir o padrão de nomeação (ProjectName) $!n.PGC onde n é um número serão mescladas automaticamente quando você constrói a imagem otimizada.Para mesclar PGODemo_custom!1.pgc, nós criado na etapa anterior, você terá que adicionar uma etapa de mesclagem personalizado (por favor consulte o cenário de mesclagem de dados de analisar personalizado descrito anteriormente nesta explicação passo a passo).
Usando essas etapas, você pode controlar a coleta de dados de analisar e--vez--otimizar seu aplicativo baseado em partes mais importantes do aplicativo em time de execução.
Você pode usar sistema autônomo ferramentas de linha de comando para executar o analisar personalizado dados coleção da seguinte maneira.
criar instrumentado executável:
cl.exe /c /GL /O2 S1.cpp Sn.cpp link /ltcg:pgi S1.obj Sn.obj /out:myapp.exe
Execute meu_apl.exe instrumentados e, no ponto desejado enquanto estiver em execução, use a ferramenta pgosweep para coletar os dados de analisar:
Pgosweep myapp.exe mycustomdata.pgc
Observação: PGC arquivos que não cumprir o formato padrão terá que ser mescladas usando a ferramenta Pgomgr manualmente.
Depois meu_apl.exe desligado, outro arquivo .PGC (myapp!1.pgc) será criado automaticamente.Certifique-se de excluir esta ou movê-la fora do diretório de trabalho do vinculador antes de executar o vinculador a compilação meu_apl.exe otimizado, se você não desejar para ser usado sistema autônomo parte de dados de analisar.
Mescle mycustomdata.pgc Pgomgr usando:
Pgomgr –merge mycustomdata.pgc myapp.pgd
Execute o comando link para criar o aplicativo final otimizado:
link /ltcg:pgo /pgd:myapp
Você pode chamar PgoAutoSweep do seu aplicativo para salvar e reiniciar os dados de analisar em qualquer ponto no tempo de execução.O exemplo a seguir mostra como isso funciona
O exemplo a seguir cria dois arquivos .PGC.O primeiro contém dados que descrevem o comportamento em tempo de execução até que a contagem for igual a 3 e o segundo contém os dados coletados após esse ponto até o encerramento de aplicativo.
#include <stdio.h>
#include <windows.h>
#include <pgobootrun.h>
int count = 10;
int g = 0;
void func2(void)
{
printf("hello from func2 %d\n", count);
Sleep(2000);
}
void func1(void)
{
printf("hello from func1 %d\n", count);
Sleep(2000);
}
void main(void)
{
while (count--)
{
if(g)
func2();
else
func1();
if (count == 3)
{
PgoAutoSweep("func1");
g = 1;
}
}
PgoAutoSweep("func2");
}