Umdhtools.exe: Como utilizar Umdh.exe para localizar memória fugas

Traduções de Artigos Traduções de Artigos
Artigo: 268343 - Ver produtos para os quais este artigo se aplica.
Expandir tudo | Reduzir tudo

Nesta página

Sumário

O utilitário de área para dados dinâmicos (UMDH) de informações de estado do modo de utilizador funciona com o sistema operativo para analisar as atribuições de pilha do Windows para um processo específico. Este utilitário e as outras ferramentas associadas, são principalmente destinadas para o Windows 2000 e Windows XP. Faça clique sobre o Reproduzir botão para visualizar esta transmissão demonstração de suportes de dados.

Nota O vídeo é codificado com o codec ACELP ®, tem de instalar o codec ACELP ® livre disponível em http://www.ACELP.NET/acelp_eval.php



Nota Uma vez que o malloc função no módulo c run-time (CRT) utiliza a omissão de ponteiro da moldura (Positioning) na versão original comercializada do Windows Server 2003, poderá não conseguir ver as informações de pilha completa da malloc função utilizando a ferramenta UMDH. Este problema foi corrigido no módulo CRT do Windows Server 2003 Service Pack 1 (SP1). Por conseguinte, pode ver as informações de pilha completa da função malloc no Windows Server 2003 SP1.

Mais Informação

Antes de utilizar UMDH

Se pensa que está a ocorrer uma fuga de memória, tenha em atenção que a memória fugas poderão não ser o que são apresentados. Poderá descobrir que um fuga de memória não é uma fuga de memória verdadeiro, mas é um melhoramento de desempenho. Para exemplo, o motor de base de dados Microsoft Jet pode consumir grandes quantidades de memória (até 128 MB num computador 256 MB) uma vez que obtém dados e escreve coloca em cache. A cache permite que o motor Jet para obter rápida leitura antecipada e escrita-para-avanço armazenamento em buffer.

Para determinar se é ou não está com um processo memória fugas, utilizar o Monitor de desempenho do Windows (Perfmon. exe) e monitorizar privado Bytes na categoria de processo para a sua aplicação. Bytes privados é o total de memória que o processo tem atribuídos, mas não está a partilhar com outros processos. Note que isto é diferente de bytes do espaço Virtual, que também é interessantes para monitorizar. Bytes do espaço virtuais é o tamanho actual em bytes do espaço de endereçamento virtual que utiliza o processo. Uma aplicação pode permitir fugas virtual memória, mas não poderá ver uma diferença nos bytes privados que estão atribuídos. Se não vir aumentar quando monitoriza bytes privados, mas de memória suspeita que ainda em execução fora de memória, bytes virtuais do monitor para ver Se estiver a utilizar a cópia de memória virtual. Para obter informações adicionais sobre a detecção de fugas de memória e a descrição geral do Monitor de desempenho do Windows (Perfmon. exe), visite o seguinte Web site da Microsoft:
http://msdn.microsoft.com/en-us/library/ms404355.aspx
Para se certificar de que a aplicação tem pouca memória, colocar a suspeitar de código num ciclo com muitos iterações e, em seguida, monitorizar privados e bytes do espaço virtuais para qualquer aumento de memória. Ver para se certificar de que o número de bytes privados e de bytes virtuais não eventualmente permanecem inalterados e o número tabulações aumentar. Se existir um ponto em que a memória pára aumentar, (por exemplo, não continuar a subida indefinidamente) fizer não ver uma fuga de memória, mas o mais provável, verá uma cache de que está a aumentar a sua tamanho máximo.

Se determinar que vir uma fuga de memória, antes de utilizar UMDH, siga estes passos:
  1. Instale o utilitário UMDH.
  2. Definir a variável de ambiente PATH do sistema para incluir o pasta onde instalou o UMDH.
  3. Definir a variável de ambiente _ NT_SYMBOL_PATH para o Caminho do servidor de símbolos de Microsoft, para que UMDH pode localizar o símbolo de depuração ficheiros.
O utilitário UMDH é incluído com as ferramentas de depuração para Produtos do Windows no seguinte Web site da Microsoft:
http://www.microsoft.com/whdc/devtools/ddk/default.mspx
Transferir e instalar o utilitário e, em seguida, defina o sistema de caminho variável de ambiente para o caminho onde foram instaladas as ferramentas de depuração.

Antes de utilizar UMDH, tem de instalar os símbolos de depuração correcto para o os componentes de aplicação e o sistema operativo. Utilizar o Microsoft Servidor de símbolos para adquirir os símbolos de depuração para os componentes Microsoft. Para mais informações sobre o Microsoft Symbol Server, clique no número de artigo seguinte para visualizar o artigo na Microsoft Knowledge Base:
311503Utilizar o Microsoft Symbol Server para obter ficheiros de símbolos de depuração
UMDH tenta localizar os ficheiros de símbolos, utilizando o Variável de ambiente _ NT_SYMBOL_PATH. O comando para definir o caminho de um linha de comandos pode ter um aspecto semelhante ao seguinte:
Definir _ NT_SYMBOL_PATH = SRV * c:\LocalSymbolCache
Para obter informações adicionais sobre como configurar a depuração simbólica informações, consulte a secção "Símbolos de depuração" mais adiante neste artigo.

Depois de concluir estes passos, está pronto para utilizar o utilitário UMDH.

A captura Heap copia com UMDH

UMDH é um utilitário que copia informações sobre a área para dados dinâmicos atribuições de um processo. Estas informações incluem a pilha de chamadas para cada atribuição, o número de atribuições que são efectuadas através de nessa pilha de chamadas, e o número de bytes que são consumidos através dessa pilha de chamadas. Por exemplo:
00005320 bytes in 0x14 allocations (@ 0x00000428) by: BackTrace00053
           ntdll!RtlDebugAllocateHeap+0x000000FD
           ntdll!RtlAllocateHeapSlowly+0x0000005A
           ntdll!RtlAllocateHeap+0x00000808
           MyApp!_heap_alloc_base+0x00000069
           MyApp!_heap_alloc_dbg+0x000001A2
           MyApp!_nh_malloc_dbg+0x00000023
           MyApp!_nh_malloc+0x00000016
           MyApp!operator new+0x0000000E
           MyApp!LeakyFunc+0x0000001E
           MyApp!main+0x0000002C
           MyApp!mainCRTStartup+0x000000FC
           KERNEL32!BaseProcessStart+0x0000003D
				
Esta saída UMDH mostra que ocorreram 21280 (0x5320) bytes atribuídos total a partir da pilha de chamadas. Os bytes 21280 foram atribuídos a partir de 20 (0x14) Separe as alocações de bytes 1064 (0x428). A pilha de chamadas é dado um identificador do BackTrace00053.

Para produzir um ficheiro de informação de área de dados dinâmicos atribuições, tem de utilizar o utilitário Gflags. exe, que também é incluído com o os produtos Debugging Tools for Windows, para permitir que o sistema operativo saber que pretende que o kernel para controlar as atribuições.

Suponha que pretende que Para copiar o conteúdo de heap(s) para o Notepad. exe. Primeiro tem de activar o rastreio da pilha aquisição da aplicação que pretende testar. Por predefinição, esta funcionalidade não está activada. O comando para activar esta funcionalidade é a seguinte:
Gflags -i Notepad. exe + tem
O comando não activar o rastreio de pilha de processos que são já em execução, mas activa o rastreio de pilha para todas as futuras execuções da Notepad. exe. em alternativa, pode definir o sinalizador através do utilizador GFLAGS Interface (executar Gflags. exe sem quaisquer argumentos, para obter a interface de utilizador). Utilização o -tem opção para gflags desactivar o rastreio de pilha quando estiver concluído a depuração.

Quando definir os sinalizadores de imagem através de Gflags. exe, e configurou os símbolos de depuração, está pronto para iniciar o bloco de notas (o aplicação que está a utilizar o UMDH). Depois do programa é iniciado, tem de Determine o ID de processo (PID) do processo de bloco de notas que acaba de ser iniciado. O comando para que esta é a seguinte:
Tlist
Pode encontrar o PID do resultado da aplicação TLIST. As informações de PID podem também ser obtidas a partir do Gestor de tarefas. Assumir o PID para o processo de bloco de notas acaba de ser iniciado é 124. Pode utilizar UMDH para obter um Falha de sistema Heap com o seguinte comando:
umdh - p: 124 - f:notepad124.log
Resultados: Tiver um despejo de memória heap completa do processo de bloco de notas no Ficheiro Notepad124.log. Este ficheiro mostra todas as atribuições que foram efectuadas e o callstacks em que foram efectuadas as atribuições.

Utilizar Umdh.exe para comparar UMDH registos

Enquanto o ficheiro de registo UMDH contém informações importantes sobre o estado actual das pilhas para um processo, se estiver preocupado com a localizar um fuga de memória, poderá ser mais valiosa para comparar as produções de dois registos e Descubra qual o pilha de chamadas tenha visto o maior crescimento entre os ficheiros de dois informação. O utilitário Umdh.exe ajuda-o a comparar dois registos UMDH para fornecer uma análise das diferença entre eles. Assim que tiver dois registos capturados em diferentes intervalos, em seguida, pode utilizar o seguinte comando:
UMDH dh1.log dh2.log > cmp12.txt
- ou -
UMDH -d dh1.log dh2.log > cmp12.txt
O -d opção de linha de comandos informa UMDH para apresentar em decimal em vez de hexadecimal. A saída do comando compara as diferenças da Alocações entre os dois registos e fornece informações de que é semelhantes a o seguinte:
+ 5320 (f110 - 9df0) 3a atribuições BackTrace00053 Total de aumento = = 5320
Para cada BackTrace nos ficheiros de registo UMDH, é uma comparação efectuada entre os ficheiros de dois registos. Neste caso, revela que o último ficheiro de registo é especificado no UMDH da linha de comandos tinha 0xF110 de bytes atribuídos enquanto a primeira registo na linha de comandos UMDH tinha 0x9DF0 de bytes atribuídos para a mesma BackTrace (pilha de chamadas). "5320" É a diferença no número de bytes atribuídos. No Neste caso, existiam mais bytes atribuídos entre os tempos de 0x5320 que o dois registos foram capturados. Os bytes provêem da pilha de chamadas é identificada por "backtrace00053".

O passo seguinte consiste em saber o que há em que backtrace. Se abrir o segundo ficheiro de registo e procure BackTrace00053, poderá encontrar ou algo semelhante ao seguinte:
00005320 bytes in 0x14 allocations (@ 0x00000428) by: BackTrace00053
           ntdll!RtlDebugAllocateHeap+0x000000FD
           ntdll!RtlAllocateHeapSlowly+0x0000005A
           ntdll!RtlAllocateHeap+0x00000808
           MyApp!_heap_alloc_base+0x00000069
           MyApp!_heap_alloc_dbg+0x000001A2
           MyApp!_nh_malloc_dbg+0x00000023
           MyApp!_nh_malloc+0x00000016
           MyApp!operator new+0x0000000E
           MyApp!LeakyFunc+0x0000001E
           MyApp!main+0x0000002C
           MyApp!mainCRTStartup+0x000000FC
           KERNEL32!BaseProcessStart+0x0000003D
				
Quando visualiza a pilha de chamadas, pode ver que o LeakyFunc função atribui memória através da biblioteca de tempo de execução do Visual C++ função de novo operador. Se encontrar a que cresce à medida que o número de atribuições tomar mais ficheiros de informação, pode concluir que a memória não está a ser libertada.

Activar rastreios

As informações mais importantes nos registos de UMDH são os rastreios de atribuições de pilha. Pode analisá-los para verificar se um processo de fugas de pilha memória. Por predefinição, estes rastreios não sejam adquiridos. Pode activar este funcionalidade por processo ou todo o sistema. Utilize o seguinte comando para activar a pilha todo o sistema de rastreio:
Gflags - r + tem
Reinicie o computador após este comando. Para por processo o comando activar, é o seguinte:
Gflags -i NOMEAPLIC + tem
Em que NOMEAPLIC é o nome do ficheiro do executável incluindo a extensão (para exemplo, Services. exe, o Lsass. exe). O comando não activar o rastreio de pilha de um processo que já está em execução. Por conseguinte, para processos que não é possível reiniciar (por exemplo, serviços, lsass, winlogon), tem de reiniciar o ensaio computador.

Utilize os seguintes comandos para verificar o que tem definições foi definido o nível do sistema ou de um processo específico: todo o sistema:
Gflags - r
Processo específico:
Gflags -i nome da aplicação
Por predefinição, a profundidade de rastreio de pilha máximo é 16. Se pretender Consulte callstacks mais profundas, pode aumentar este executando GFLAGS. Clique para seleccionar Registo do sistemae, em seguida, escreva uma profundidade de nova na Máx. Profundidade de captura de rastreio de pilha controlo de edição. Clique em Aplicare, em seguida, reinicie o computador.
IMPORTANTE: Se estiver a utilizar o Windows NT 4. 0 Service Pack 6, tem de utilizar Umdh_nt4.exe, em vez de Umdh.exe e tem de utilizar o Gflags -r comando para definir o rastreio de pilha de todo o sistema. Certifique-se de que é Reinicie o computador. Rastreio da pilha de Umdh_nt4 não funciona num por processo com base no Windows NT versão 4. Tem de ser definida para todo o sistema.

Símbolos de depuração

Um dos passos mais importantes à utilização de UMDH é certificar-se que tem ficheiros de símbolos boas (ficheiro .dbg ou. pdb) para obter um rastreio de pilha boa. No mínimo, tem dos ficheiros de símbolos de Kernel32.dbg e Ntdll.dbg. É possível adquirir símbolos de depuração adicionais que poderá ter como encontrar mais sobre os componentes geram perda de memória. Para mais informações sobre como obter ficheiros de símbolos de depuração para o Microsoft componentes, clique no número de artigo seguinte para visualizar o artigo na Microsoft Knowledge Base:
311503Utilizar o Microsoft Symbol Server para obter ficheiros de símbolos de depuração
Para obter informações adicionais sobre como utilizar o Microsoft Symbol Server e sobre como obter pacotes de símbolos do Windows, visite o seguinte Web site da Microsoft:
http://www.microsoft.com/whdc/devtools/ddk/default.mspx
Quando criar componentes com o Visual C++, é importante que não ter o programa de base de dados para editar e continuar seleccionada para o C++ Opções do compilador. Em vez disso, seleccione o programa de base de dados. Para definir o caminho do símbolo, iniciar a variável de ambiente _ NT_SYMBOL_PATH o caminho para ser utilizado. Que Pode utilizar o Microsoft Symbol Server para adquirir símbolos para o Microsoft componentes.
311503 Utilizar o Microsoft Symbol Server para obter ficheiros de símbolos de depuração
Siga estes passos para definir o _ NT_SYMBOL_PATH variável de ambiente:
  1. No painel de controlo, faça duplo clique Sistema.
  2. Faça clique sobre o Avançadas separador e, em seguida, clique Variáveis de ambiente.
Ou pode definir a variável de ambiente _ NT_SYMBOL_PATH janela de comandos antes de executar o UMDH.

NOTA: Também incluir o caminho para os PDBs para componentes do seu aplicação. Por exemplo, defina o caminho para o _ NT_SYMBOL_PATH à seguinte:
SRV*c:\Symbols*http://MSDL.microsoft.com/download/symbols;c:\myapplicationssymbols
A primeira parte deste caminho aponta para o Microsoft Symbol Server e os Estados-membros que os símbolos que são utilizados serão transferidos as c:\Symbols. pasta. A parte que se segue o ponto e vírgula é o caminho para os ficheiros PDB (símbolo ficheiros) especificamente para a aplicação de fuga.

Invocar UMDH

O parâmetro da linha de comandos necessário apenas para UMDH é o -p opção, que especifica o PID do processo a partir do qual uma pilha dump será obtido. O PID não pode ser obtido utilizando o Gestor de tarefas ou o Programa de Tlist. exe. Para um comando semelhante à seguinte, o registo será objecto de dumping para a saída padrão:
umdh - p: PID
UMDH também apresenta várias mensagens informativas padrão erro, e, por conseguinte, se a redireccionar, é misturada com o registo real. Para recolher as mensagens informativas UMDH num ficheiro, utilize o seguinte comando:
umdh - p: 2>umdh.msg de PID
Se pretender recolher no registo que é objecto de dumping por UMDH num ficheiro, Utilize um dos seguintes comandos:
umdh - p: PID > umdh.log
- ou -
umdh - p: PID-f:umdh.log
Estes comandos são equivalentes.

O registo predefinido que é obtido por UMDH contém uma enumeração dos consumidores de área dinâmica para dados que são ordenados por contagem de alocação. Se, para fins de depuração, também necessitar de um ficheiro de informação de todos os dos blocos atribuídos com seus rastreios correspondente, o -d opção pode ser utilizada:
umdh - p: PID -d
Se utilizar este comando, poderá ver o seguinte no UMDH ficheiro de registo:
Atribuições de rastreio BackTrace00046: 005F69A0 005F6150
Estes são os endereços de memória de atribuições para que pilha de chamadas. Se o depurador for anexado ao processo, poderá copiar o conteúdo da memória a estes endereços para ver o que lhe tenha sido atribuído.

Se o registo contiver demasiada informação, pode ser limitada apenas a contam grandes utilizadores que têm a alocação acima de um determinado limiar. Utilizar o seguinte comando:
umdh - p: PID - t: limiar
Todas as opções da linha de comandos (por exemplo, -p, -f, -t, -d) podem ser especificados simultaneamente em qualquer ordem. Segue-se uma exemplo da linha de comandos mais difícil:
umdh - p: 123 - t: 1000 - f:umdh.log -d
Este comando copia pilhas para o processo com o PID 123 em o ficheiro Umdh.log. Copia apenas rastreios essa conta para mais de 1000 alocações e também copia os endereços dos blocos heap que são atribuídos através de cada rastreamento da pilha.

Outra opção UMDH útil é o -l opção. Isto faz com que os números de ficheiro e de linha sejam impressos na pilha de chamadas sempre que possível.

Saída UMDH, explicada

Se o registo tiver redireccionado para um ficheiro (umdh - p: PID-f:umdh.log), o conteúdo é semelhante à seguinte, que foi obtida a partir de um processo em execução do bloco de notas:
UMDH: Logtime 2000-06-28 10:54 - Machine=MYMachine - PID=704
   *********** Heap 00270000 Information ********************
       Flags: 58000062
       Number Of Entries: 87
       Number Of Tags: <unknown>
       Bytes Allocated: 00008DF0
       Bytes Committed: 0000A000
       Total FreeSpace: 00001210
       Number of Virtual Address chunks used: 1
       Address Space Used: <unknown>
       Entry Overhead: 8
       Creator:  (Backtrace00007)
           ntdll!RtlDebugCreateHeap+0x00000196
           ntdll!RtlCreateHeap+0x0000023F
           ntdll!LdrpInitializeProcess+0x00000369
           ntdll!LdrpInitialize+0x0000028D
           ntdll!KiUserApcDispatcher+0x00000007
   *********** Heap 00270000 Hogs ********************
   000001A0 bytes in 0x4 allocations (@ 0x00000068) by: BackTrace00031
           ntdll!RtlDebugAllocateHeap+0x000000FB
           ntdll!RtlAllocateHeapSlowly+0x0000005B
           ntdll!RtlAllocateHeap+0x00000D81
           ntdll!LdrpAllocateDataTableEntry+0x00000039
           ntdll!LdrpMapDll+0x000002A4
           ntdll!LdrpLoadImportModule+0x0000010D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpLoadImportModule+0x0000011D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpLoadImportModule+0x0000011D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpInitializeProcess+0x000009DC
           ntdll!LdrpInitialize+0x0000028D
           ntdll!KiUserApcDispatcher+0x00000007

   000001A0 bytes in 0x4 allocations (@ 0x00000068) by: BackTrace00034
           ntdll!RtlDebugAllocateHeap+0x000000FB
           ntdll!RtlAllocateHeapSlowly+0x0000005B
           ntdll!RtlAllocateHeap+0x00000D81
           ntdll!LdrpAllocateDataTableEntry+0x00000039
           ntdll!LdrpMapDll+0x000002A4
           ntdll!LdrpLoadImportModule+0x0000010D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpLoadImportModule+0x0000011D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpLoadImportModule+0x0000011D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpLoadImportModule+0x0000011D
           ntdll!LdrpWalkImportDescriptor+0x0000008B
           ntdll!LdrpInitializeProcess+0x000009DC
           ntdll!LdrpInitialize+0x0000028D
           ntdll!KiUserApcDispatcher+0x00000007
				
O registo contém uma informação de cada pilha no processo. Neste exemplo, o registo começa com um heap no endereço 270000. Após alguns contadores globais para a pilha, o registo contém uma informação por ordem decrescente ordenada de rastreios da pilha que são responsáveis as maior parte das atribuições. Quando comparar a dinâmica do memória que são utilizadas em momentos diferentes, pode deduzir o que ocorreu no processo e se a qualquer utilização da pilha é semelhante a uma fuga.

Problemas que poderão ocorrer quando utilizar UMDH

Os erros mais comuns quando utiliza o UMDH ocorrerem porque pilha rastreio não está activado. Além disso, símbolos incorrectos para Ntdll. dll impedir UMDH partir de em execução. Para os outros ficheiros de símbolos, UMDH é executado, mas o ficheiro de registo contém pilha rastreios que têm nomes de funções mas em vez disso terem endereços relativos dentro de módulos. Um erro de terceiro distante está a especificar um PID errado. O seguinte resultados da mensagem de erro quando tenta executar o UMDH de um processo que não tem rastreio de pilha activado:
C:\>umdh - p: 1140 UMDH: Logtime 2000-06-28 12: 43 - Máquina = MyMachine - PID = 1140 ligar...Módulo Enumeração concluída. SymGetSymFromName (processo, ntdll!RtlpStackTraceDataBase, xxx) falhou, o último erro = 126 UmdhGetAddrFromName não foi possível encontrar DB de rastreio de pilha ponteiro (ntdll!RtlpStackTraceDataBase). símbolos de Ntdll. dll estão incorrectos; Vamos deve conseguir ver não importar símbolos.
Utilize o seguinte comando para Verifique novamente as definições para o processo que está a investigar:
Gflags -i NOMEAP
Utilize o seguinte comando quando se basear a pilha de todo o sistema rastreio:
Gflags - r
Estes comandos mostram a lista de sinalizadores definidos para a aplicação. Note que no caso de rastreio de pilha de todo o sistema, a funcionalidade poderá aparecer como Active mas se não de reiniciar o computador depois de executar o Gflags - r + tem o comando, na realidade não está activado. Se pretender saber cada aplicação que tenha activado o rastreio de pilha, pode ver a chave USTEnabled na seguinte chave de registo:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image ficheiro Opções de execução
Se executar UMDH a um processo que tem o rastreio de pilha activado, mas Não foi reiniciado a aplicação uma vez que definir os sinalizadores, poderá receber a seguinte mensagem no seus registos:
Foi um rastreio de pilha não são guardadas para esta atribuição (índice = = 0)
Se executar não definir a correcto no caminho de símbolos ou os símbolos estão incorrectos e executar o UMDH, poderá recebe uma mensagem de erro no registo. No entanto, apenas poderá receber incorrecto ou callstacks enganosas. Para verificar se tem os símbolos correctos, inicie o Depurador de sistema NTSD para um processo, por exemplo:
NTSD bloco de notas
Em seguida, a partir da consola do depurador, execute o LD comando para carregar as informações de símbolo para o módulo e o LM comando para listar quais os módulos tem seus símbolos carregados. Se o saída da LM comando mostra símbolos de exportação carregados, os símbolos não são boas. IF tiver símbolos PDB carregados, os símbolos estão em boas condições. Poderá receber a seguinte mensagem de erro se tiver especificado o PID errado:
C:\>umdh - p: 1000 UMDH: Logtime 2000-06-28 09: 45 - máquina = MyMachine - PID = 1000 a ligar... Falha em OpenProcess, último erro = 0x57

Chamar UMDH a partir do Visual Basic

Poderá ser útil, por vezes, para um número de registos de falha de sistema ao longo do tempo uma vez que a fuga poderá não ser muito perceptível à primeira. Por exemplo, se suspeitar que a aplicação Web Active Server Pages (ASP) tem uma fuga de memória, poderá ser útil escrever um componente do COM no Visual Basic que shells fora para UMDH. Em seguida, pode chamar esse componente a partir de sua página ASP.

O Segue-se algum código de Visual Basic que invoca o UMDH e cria um ficheiro de registo que se baseia a hora actual:
Private Declare Function GetCurrentProcessId Lib "kernel32" () As Long
      Public Function GetProcessID()
      GetProcessID = GetCurrentProcessId()
      End Function  
   .
   .
   .
      Dim strTime As String

      Dim sProcID As String
      sProcID = GetProcessID()
      strTime = "MYLOG_" & Format(Now(), "hhmm")
     
      Shell ("C:\UMDH\umdh -p:" & sProcID & " -f:d:\logs\" & strTime & ".txt")
				

Utilize UMDH com Windows NT 4. 0 Service Pack 6a (SP6a)

O utilitário UMDH que está incluído com as ferramentas de depuração para Produtos do Windows não funciona no Windows NT 4. 0. Um executável de extracção automática (Umdhnt4tools.exe) está incluído no presente artigo e contém o seguinte ferramentas para ser utilizado com o NT 4. 0:
  • Umdh_nt4.exe e dbghelp. dll
    Esta é a configuração do Windows NT 4. 0 Versão SP6 do utilitário UMDH.
  • Dhcmp.exe
    Este utilitário é utilizado para comparar dois UMDH informações de estado para determinar o local onde uma possível memória permitir fugas ocorrer.
O ficheiro seguinte está disponível para transferência a partir da transferência da Microsoft Centro:
Reduzir esta imagemExpandir esta imagem
Transferir
Transferir Umdhnt4tools.exe. exe agora
Data de edição: 28 de Agosto de 2002

Para mais informações sobre como transferir ficheiros de suporte da Microsoft, clique no número de artigo seguinte para visualizar o artigo na Microsoft Knowledge Base:
119591 Como obter o Microsoft support files from online services
A Microsoft procedeu vírus neste ficheiro. A Microsoft utilizou o software de detecção de vírus mais actual, que estava disponível na data em que o ficheiro tiver sido registado. O ficheiro é armazenado em servidores com segurança melhorada, que ajudam a impedir quaisquer alterações não autorizadas ao ficheiro. Colocar numa pasta, Umdh_nt4.exe e dbghelp. dll e, em seguida colocá-los primeiro numa variável de ambiente PATH. Utilizar Umdh_nt4.exe em vez de UMDH.

Num computador que esteja a executar o Windows NT 4. 0, tem de utilizar Gflags. exe para definir o rastreio de pilha de todo o sistema. Por exemplo:
Gflags - r
Certifique-se de que reinicie o computador. Rastreio da pilha de Umdh_nt4 não funciona numa base por processo no Windows NT versão 4. 0. É definida para todo o sistema.

UMDH_NT4 é ao contrário de UMDH em que isso não aconteça Compare ficheiros de registo. Por exemplo, não pode fazer o seguinte:
UMDH_NT4 dh1.log dh2.log > cmp12.txt
Em vez disso, tem de utilizar o utilitário de Dhcmp.exe que está incluído no Este artigo. O comando é semelhante à seguinte:
DHCMP dh1.log dh2.log > cmp12.txt

Propriedades

Artigo: 268343 - Última revisão: 18 de maio de 2011 - Revisão: 1.0
A informação contida neste artigo aplica-se a:
  • Microsoft Windows 2000 Server
  • Microsoft Windows 2000 Advanced Server
  • Microsoft Windows 2000 Professional Edition
  • Microsoft Windows NT Server 4.0 Standard Edition
  • Microsoft Windows NT Workstation 4.0 Developer Edition
Palavras-chave: 
kbdownload kbarttypeshowme kbfile kbgraphxlinkcritical kbhowto kbsample kbmt KB268343 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 268343

Submeter comentários

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com