Freigeben über

!heap

  • Artikel

Die Erweiterung !heap zeigt Informationen über die Heap-Nutzung an, steuert Haltepunkte im Heap-Manager, erkennt ausgelaufene Heap-Blöcke, sucht nach Heap-Blöcken oder zeigt Page-Heap-Informationen an.

Diese Erweiterung unterstützt den Segment Heap und den NT Heap. Verwenden Sie !heap ohne Parameter, um alle Heaps und ihren Typ aufzulisten.

!heap [HeapOptions] [ValidationOptions] [Heap] 
!heap -b [{alloc|realloc|free} [Tag]] [Heap | BreakAddress] 
!heap -B {alloc|realloc|free} [Heap | BreakAddress] 
!heap -l 
!heap -s [SummaryOptions] [StatHeapAddress] 
!heap -i HeapAddress
!heap -x [-v] Address 
!heap -p [PageHeapOptions] 
!heap -srch [Size] Pattern
!heap -flt FilterOptions
!heap -stat [-h Handle [-grp GroupBy [MaxDisplay]]]
!heap [-p] -?
!heap -triage [Handle | Address]

Segment- und NT-Heap-Parameter

Diese Parameter funktionieren mit Segment- und NT-Heaps.

-s
Gibt an, dass eine Kurzbeschreibung angefordert wird. Wenn SummaryOptions und StatHeapAddress weggelassen werden, werden Zusammenfassungsinformationen für alle mit dem aktuellen Prozess verbundenen Heaps angezeigt.

SummaryOptions
Kann eine beliebige Kombination der folgenden Optionen sein. Bei den SummaryOptions wird nicht zwischen Groß- und Kleinschreibung unterschieden. Geben Sie !heap -s -? für weitere Informationen ein.

Option Effek

-v

Überprüft alle Datenblöcke.

-b BucketSize

Gibt die Bucketgröße an. Der Standardwert ist 1024 Bit.

-d DumpBlockSize

Gibt die Bucketgröße an.

-a

Alle Heap-Blöcke werden gelöscht.

-c

Gibt an, dass der Inhalt der einzelnen Blöcke angezeigt werden soll.

-triage [Handle | Address]
Veranlasst den Debugger, automatisch nach Fehlern in den Heaps eines Prozesses zu suchen. Wenn ein Heap-Handle als Argument angegeben ist, wird dieser Heap untersucht; andernfalls werden alle Heaps nach einem durchsucht, der die angegebene Adresse enthält, und wenn einer gefunden wird, wird er untersucht. Die Verwendung von -triage ist die einzige Möglichkeit, die Beschädigung des Heaps mit geringer Fragmentierung (LFH) zu überprüfen.

-x [-v]
Veranlasst den Debugger, nach dem Heap-Block zu suchen, der die angegebene Adresse enthält. Wenn -v hinzugefügt wird, durchsucht der Befehl den gesamten virtuellen Speicherbereich des aktuellen Prozesses nach Zeigern auf diesen Heap-Block.

-l
Bewirkt, dass der Debugger ausgelaufene Heap-Blöcke erkennt.

-i Address -h HeapAddress
Zeigt Informationen über den angegebenen Heap an.

Address
Gibt die Adresse an, nach der gesucht werden soll.

-?
Zeigt einen kurzen Hilfetext für diese Erweiterung im Fenster Debugger Command an. Verwenden Sie !heap -? für die allgemeine Hilfe und !heap -p -? für die Seitenheap-Hilfe.

NT Heap Parameters

Diese Parameter funktionieren nur mit dem NT Heap.

HeapOptions
Kann eine beliebige Kombination der folgenden Optionen sein. Bei den Werten von HeapOptions wird zwischen Groß- und Kleinschreibung unterschieden.

Option Effek

-v

Veranlasst den Debugger, den angegebenen Heap zu validieren.

Hinweis Mit dieser Option wird eine Beschädigung des Heaps mit geringer Fragmentierung (LFH) nicht erkannt. Verwenden Sie stattdessen -triage.

-a

Bewirkt, dass die Anzeige alle Informationen für den angegebenen Heap enthält. Die Größe wird in diesem Fall auf die Granularität des Heaps aufgerundet. (Die Ausführung von !heap mit der Option -a entspricht der Ausführung mit den drei Optionen -h -f -m, was sehr lange dauern kann)

-h

Bewirkt, dass die Anzeige alle Nicht-LFH-Einträge für den angegebenen Heap enthält.

-hl

Bewirkt, dass die Anzeige alle Einträge für den/die angegebenen Heap(s) enthält, einschließlich der LFH-Einträge.

-f

Bewirkt, dass die Anzeige alle freien Listeneinträge für den angegebenen Heap enthält.

-m

Bewirkt, dass die Anzeige alle Segmenteinträge für den angegebenen Heap enthält.

-t

Bewirkt, dass die Anzeige die Tag-Informationen für den angegebenen Heap enthält.

-T

Bewirkt, dass die Anzeige die Pseudo-Tag-Einträge für den angegebenen Heap enthält.

-g

Bewirkt, dass die Anzeige die globalen Tag-Informationen enthält. Globale Tags sind mit jeder nicht markierten Zuweisung verbunden.

-s

Bewirkt, dass die Anzeige Zusammenfassungsinformationen für den angegebenen Heap enthält.

-k

(Nur x86-basierte Targets) Bewirkt, dass die Anzeige den mit jedem Eintrag verbundenen Stack-Backtrace enthält.

ValidationOptions
Kann eine der folgenden Optionen sein. Bei den ValidationOptions wird zwischen Groß- und Kleinschreibung unterschieden.

Option Effek

-D

Deaktiviert Validate-on-Call für den angegebenen Heap.

-E

Aktiviert Validate-on-Call für den angegebenen Heap.

-d

Deaktiviert die Heap-Prüfung für den angegebenen Heap.

-e

Aktiviert die Heap-Prüfung für den angegebenen Heap.

-i Heap Address oder HeapAddress
Zeigt Informationen über den angegebenen Heap an.

BreakAddress
Gibt die Adresse eines Blocks an, in dem ein Haltepunkt gesetzt oder entfernt werden soll.

-b
Veranlasst den Debugger, einen bedingten Haltepunkt im Heap-Manager zu erzeugen. Die Option -b kann gefolgt werden von alloc, realloc oder free; dies gibt an, ob der Haltepunkt durch Allokation, Reallokation oder Freigabe von Speicher aktiviert werden soll. Wenn BreakAddress verwendet wird, um die Adresse des Blocks anzugeben, kann der Haltepunkttyp weggelassen werden. Wenn Heap verwendet wird, um die Heap-Adresse oder den Heap-Index anzugeben, muss der Typ sowie der Parameter Tag enthalten sein.

Tag
Gibt den Tag-Namen innerhalb des Heaps an.

-B
Veranlasst den Debugger, einen bedingten Haltepunkt aus dem Heap-Manager zu entfernen. Der Haltepunkttyp (alloc, realloc oder free) muss angegeben werden und muss derselbe sein, der mit der Option -b verwendet wird.

StatHeapAddress
Gibt die Adresse des Heaps an. Wenn dieser Wert 0 ist oder weggelassen wird, werden alle mit dem aktuellen Prozess verbundenen Heaps angezeigt.

-p
Gibt an, dass Seiten-Heap-Informationen angefordert werden. Wenn dies ohne PageHeapOptions verwendet wird, werden alle Seitenheaps angezeigt.

PageHeapOptions
Kann eine der folgenden Optionen sein. Bei den PageHeapOptions wird zwischen Groß- und Kleinschreibung unterschieden. Wenn keine Optionen angegeben werden, werden alle möglichen Seiten-Heap-Handles angezeigt.

Option Effek

-h Handle

Bewirkt, dass der Debugger detaillierte Informationen über einen Seitenheap mit dem Handle Handle anzeigt.

-a Address

Veranlasst den Debugger, den Page Heap zu finden, dessen Block Address enthält. Es werden alle Einzelheiten darüber angegeben, wie sich diese Adresse zu Ganzseiten-Heap-Blöcken verhält, z. B. ob diese Adresse Teil eines Seiten-Heaps ist, ihr Offset innerhalb des Blocks und ob der Block zugewiesen oder freigegeben wurde. Stack-Traces sind, soweit verfügbar, enthalten. Bei Verwendung dieser Option wird die Größe in Vielfachen der Granularität der Heap-Zuweisung angezeigt.

-t[c|s] [Traces]

Veranlasst den Debugger, die gesammelten Traces der Heavy Heap Users anzuzeigen. Traces gibt die Anzahl der anzuzeigenden Traces an; der Standardwert ist vier. Wenn es mehr als die angegebene Anzahl von Spuren gibt, werden die frühesten Spuren angezeigt. Wenn -t oder -tc verwendet wird, werden die Abhängigkeiten nach der Zählerverwendung sortiert. Wenn -ts verwendet wird, werden die Spuren nach Größe sortiert. (Die Optionen -tc und -ts werden nur von Windows XP unterstützt; die Option -t wird nur von Windows XP und früheren Versionen von Windows unterstützt)

-fi [Traces]

Veranlasst den Debugger, die letzten Fehlerinjektionsspuren anzuzeigen. Traces gibt die Menge an, die angezeigt werden soll; der Standardwert ist 4.

-all

Bewirkt, dass der Debugger detaillierte Informationen über alle Seiten-Heaps anzeigt.

-?

Bewirkt, dass der Debugger die Heap-Hilfe anzeigt, einschließlich eines Diagramms der Heap-Blöcke. (Diese Diagramme sind auch im Abschnitt „Bemerkungen“ zu finden)

Bevor Sie einen beliebigen !heap -p Erweiterungsbefehl verwenden können, muss der Page Heap für Ihren Zielprozess aktiviert sein. Einzelheiten dazu finden Sie im Abschnitt „Bemerkungen“.

-srch
Durchsucht alle Heaps nach dem angegebenen Muster.

Muster
Gibt ein Muster an, nach dem gesucht werden soll.

Größe
Kann eine der folgenden Optionen sein. Hier wird die Größe des Musters angegeben. Das „-“ ist erforderlich.

Option Effek

-b

Das Muster hat eine Größe von einem BYTE.

-w

Das Muster hat eine Größe von einem WORD.

-d

Das Muster hat eine Größe von einem DWORD.

-q

Das Muster hat eine Größe von einem QWORD.

Wenn keine der obigen Angaben gemacht werden, wird davon ausgegangen, dass das Muster die gleiche Größe hat wie der Maschinenzeiger.

-flt
Schränkt die Anzeige so ein, dass nur Heap-Zuordnungen mit der angegebenen Größe oder dem angegebenen Größenbereich angezeigt werden.

FilterOptions
Kann eine der folgenden Optionen sein. Bei den FilterOptions wird zwischen Groß- und Kleinschreibung unterschieden.

Option Effek

s Größe

Schränkt die Anzeige so ein, dass nur Heaps einer Größe angezeigt werden.

r SizeMin SizeMax

Schränkt die Anzeige so ein, dass nur Heaps innerhalb des angegebenen Größenbereichs angezeigt werden.

Hinweis

In späteren Versionen von !heap-Optionen, z. B. -flt, ist dies möglicherweise nicht mehr vorhanden. Verwenden Sie die Befehlszeilenhilfe, um die verfügbaren Optionen zu bestätigen.

-stat
Zeigt Nutzungsstatistiken für den angegebenen Heap an.

-h Handle
Bewirkt, dass die Nutzungsstatistik nur für den Heap unter Handle angezeigt wird. Wenn Handle 0 ist oder ausgelassen wird, werden Nutzungsstatistiken für alle Heaps angezeigt.

-grp GroupBy
Ordnet die Anzeige neu an, wie in GroupBy angegeben. Die Optionen für GroupBy können der folgenden Tabelle entnommen werden.

Option Effek

A

Zeigt die Nutzungsstatistiken nach Zuweisungsgröße an.

B

Zeigt die Nutzungsstatistik nach Blockanzahl an.

S

Zeigt die Nutzungsstatistiken nach der Gesamtgröße der einzelnen Zuweisungen an.

MaxDisplay
Begrenzt die Ausgabe auf MaxDisplay Anzahl der Zeilen.

DLL

Windows XP und höher

Ext.dll Exts.dll

Weitere Informationen

Informationen über Heaps finden Sie in den folgenden Ressourcen:

Buch: Microsoft Windows Internals von Mark Russinovich und David Solomon.

Beispiel 11: Aktivieren der Page Heap Verification

Beispiel 12: Page Heap Verification zum Finden eines Fehlers verwenden

Informationen zur Verwendung des Heap-Speicherprozessprotokolls finden Sie unter Beispiel 11: Starten einer privaten Trace-Sitzung

Hinweise

Dieser Erweiterungsbefehl kann für eine Vielzahl von Aufgaben verwendet werden.

Der Standardbefehl !heap wird verwendet, um Heap-Informationen für den aktuellen Prozess anzuzeigen. (Dies sollte nur für Prozesse im Benutzermodus verwendet werden. Für Systemprozesse sollte der Erweiterungsbefehl !pool verwendet werden)

Die Befehle !heap -b und !heap -B werden zum Erstellen und Löschen von bedingten Haltepunkten im Heap-Manager verwendet.

Der Befehl !heap -l erkennt ausgelaufene Heap-Blöcke. Es verwendet einen Garbage-Collector-Algorithmus, um alle belegten Blöcke aus den Heaps zu erkennen, die nirgendwo im Prozessadressraum referenziert sind. Bei umfangreichen Anträgen kann es einige Minuten dauern, bis der Vorgang abgeschlossen ist. Dieser Befehl ist nur in Windows XP und späteren Versionen von Windows verfügbar.

Der Befehl !heap -x sucht nach einem Heap-Block, der eine bestimmte Adresse enthält. Wenn die Option -v verwendet wird, durchsucht dieser Befehl zusätzlich den gesamten virtuellen Speicherbereich des aktuellen Prozesses nach Zeigern auf diesen Heap-Block. Dieser Befehl ist nur in Windows XP und späteren Versionen von Windows verfügbar.

Der Befehl !heap -p zeigt verschiedene Formen von Seiten-Heap-Informationen an. Bevor Sie !heap -p verwenden, müssen Sie den Page Heap für den Zielprozess aktivieren. Dies geschieht über das Dienstprogramm Global Flags (gflags.exe). Starten Sie dazu das Dienstprogramm, geben Sie den Namen der Zielanwendung in das Textfeld Image File Name ein, wählen Sie Image File Options und Enable page heap und wählen Sie Apply. Alternativ können Sie das Dienstprogramm Global Flags von einem Eingabeaufforderungsfenster aus starten, indem Sie gflags /i xxx.exe +hpa eingeben, wobei xxx.exe der Name der Zielanwendung ist.

Die Befehle !heap -p -t[c|s] werden ab Windows XP nicht mehr unterstützt. Verwenden Sie das im Debugger-Paket enthaltene Tool UMDH, um ähnliche Ergebnisse zu erzielen.

Der Befehl !heap -srch zeigt die Heap-Einträge an, die ein bestimmtes angegebenes Muster enthalten.

Der Befehl !heap -flt beschränkt die Anzeige auf Heap-Zuweisungen einer bestimmten Größe.

Der Befehl !heap -stat zeigt Statistiken über die Heap-Nutzung an.

Hier ist ein Beispiel für den Standardbefehl !heap:

0:000> !ntsdexts.heap -a
Index   Address  Name      Debugging options enabled
  1:   00250000 
    Segment at 00250000 to 00350000 (00056000 bytes committed)
    Flags:               50000062
    ForceFlags:          40000060
    Granularity:         8 bytes
    Segment Reserve:     00100000
    Segment Commit:      00004000
    DeCommit Block Thres:00000400
    DeCommit Total Thres:00002000
    Total Free Size:     000003be
    Max. Allocation Size:7ffddfff
    Lock Variable at:    00250b54
    Next TagIndex:       0012
    Maximum TagIndex:    07ff
    Tag Entries:         00350000
    PsuedoTag Entries:   00250548
    Virtual Alloc List:  00250050
    UCR FreeList:        002504d8
    128-bit bitmap of free lists
    FreeList Usage:      00000014 00000000 00000000 00000000
              Free    Free
              List    List
#       Head      Blink      Flink
    FreeList[ 00 ] at 002500b8: 002a4378 . 002a4378
                                0x02 - HEAP_ENTRY_EXTRA_PRESENT
                                0x04 - HEAP_ENTRY_FILL_PATTERN
        Entry     Prev    Cur   0x10 - HEAP_ENTRY_LAST_ENTRY

Address   Size    Size  flags
002a4370: 00098 . 01c90 [14] - free
    FreeList[ 02 ] at 002500c8: 0025cb30 . 002527b8
002527b0: 00058 . 00010 [04] - free
0025cb28: 00088 . 00010 [04] - free
    FreeList[ 04 ] at 002500d8: 00269a08 . 0026e530
0026e528: 00038 . 00020 [04] - free
0026a4d0: 00038 . 00020 [06] - free
0026f9b8: 00038 . 00020 [04] - free
0025cda0: 00030 . 00020 [06] - free
00272660: 00038 . 00020 [04] - free
0026ab60: 00038 . 00020 [06] - free
00269f20: 00038 . 00020 [06] - free
00299818: 00038 . 00020 [04] - free
0026c028: 00038 . 00020 [06] - free
00269a00: 00038 . 00020 [46] - free
 
    Segment00 at 00250b90:
Flags:           00000000
Base:            00250000
First Entry:     00250bc8
Last Entry:      00350000
Total Pages:     00000080
Total UnCommit:  00000055
Largest UnCommit:000aa000
UnCommitted Ranges: (1)
    002a6000: 000aa000

    Heap entries for Segment00 in Heap 250000
                        0x01 - HEAP_ENTRY_BUSY            
                        0x02 - HEAP_ENTRY_EXTRA_PRESENT   
                        0x04 - HEAP_ENTRY_FILL_PATTERN    
                        0x08 - HEAP_ENTRY_VIRTUAL_ALLOC   
                        0x10 - HEAP_ENTRY_LAST_ENTRY      
                        0x20 - HEAP_ENTRY_SETTABLE_FLAG1  
                        0x40 - HEAP_ENTRY_SETTABLE_FLAG2  
Entry     Prev    Cur   0x80 - HEAP_ENTRY_SETTABLE_FLAG3  

Address   Size    Size  flags       (Bytes used)    (Tag name)
00250000: 00000 . 00b90 [01] - busy (b90)
00250b90: 00b90 . 00038 [01] - busy (38) 
00250bc8: 00038 . 00040 [07] - busy (24), tail fill (NTDLL!LDR Database)
00250c08: 00040 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
00250c68: 00060 . 00028 [07] - busy (10), tail fill (NTDLL!LDR Database)
00250c90: 00028 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
00250cf0: 00060 . 00050 [07] - busy (38), tail fill (Objects=  80)
00250d40: 00050 . 00048 [07] - busy (2e), tail fill (NTDLL!LDR Database)
00250d88: 00048 . 00c10 [07] - busy (bf4), tail fill (Objects>1024)
00251998: 00c10 . 00030 [07] - busy (12), tail fill (NTDLL!LDR Database)
...
002525c0: 00030 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
00252620: 00060 . 00050 [07] - busy (38), tail fill (NTDLL!LDR Database)
00252670: 00050 . 00040 [07] - busy (22), tail fill (NTDLL!CSRSS Client)
002526b0: 00040 . 00040 [07] - busy (24), tail fill (Objects=  64)
002526f0: 00040 . 00040 [07] - busy (24), tail fill (Objects=  64)
00252730: 00040 . 00028 [07] - busy (10), tail fill (Objects=  40)
00252758: 00028 . 00058 [07] - busy (3c), tail fill (Objects=  88)
002527b0: 00058 . 00010 [04] free fill
002527c0: 00010 . 00058 [07] - busy (3c), tail fill (NTDLL!LDR Database)
00252818: 00058 . 002d0 [07] - busy (2b8), tail fill (Objects= 720)
00252ae8: 002d0 . 00330 [07] - busy (314), tail fill (Objects= 816)
00252e18: 00330 . 00330 [07] - busy (314), tail fill (Objects= 816)
00253148: 00330 . 002a8 [07] - busy (28c), tail fill (NTDLL!LocalAtom)
002533f0: 002a8 . 00030 [07] - busy (18), tail fill (NTDLL!LocalAtom)
00253420: 00030 . 00030 [07] - busy (18), tail fill (NTDLL!LocalAtom)
00253450: 00030 . 00098 [07] - busy (7c), tail fill (BASEDLL!LMEM)
002534e8: 00098 . 00060 [07] - busy (44), tail fill (BASEDLL!TMP)
00253548: 00060 . 00020 [07] - busy (1), tail fill (Objects=  32)
00253568: 00020 . 00028 [07] - busy (10), tail fill (Objects=  40)
00253590: 00028 . 00030 [07] - busy (16), tail fill (Objects=  48)
...
0025ccb8: 00038 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
0025cd18: 00060 . 00058 [07] - busy (3c), tail fill (NTDLL!LDR Database)
0025cd70: 00058 . 00030 [07] - busy (18), tail fill (NTDLL!LDR Database)
0025cda0: 00030 . 00020 [06] free fill (NTDLL!Temporary)
0025cdc0: 00020 . 00258 [07] - busy (23c), tail fill (Objects= 600)
0025d018: 00258 . 01018 [07] - busy (1000), tail fill (Objects>1024)
0025e030: 01018 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
...
002a4190: 00028 . 00118 [07] - busy (100), tail fill (BASEDLL!GMEM)
002a42a8: 00118 . 00030 [07] - busy (18), tail fill (Objects=  48)
002a42d8: 00030 . 00098 [07] - busy (7c), tail fill (Objects= 152)
002a4370: 00098 . 01c90 [14] free fill
002a6000:      000aa000      - uncommitted bytes.

Hier ist ein Beispiel für den Befehl !heap -l:

1:0:011> !heap -l
1:Heap 00170000
Heap 00280000
Heap 00520000
Heap 00b50000
Heap 00c60000
Heap 01420000
Heap 01550000
Heap 016d0000
Heap 019b0000
Heap 01b40000
Scanning VM ...
## Entry     User      Heap      Segment       Size  PrevSize  Flags

001b2958  001b2960  00170000  00000000        40        18  busy extra
001b9cb0  001b9cb8  00170000  00000000        80       300  busy extra
001ba208  001ba210  00170000  00000000        80        78  busy extra
001cbc90  001cbc98  00170000  00000000        e0        48  busy extra
001cbd70  001cbd78  00170000  00000000        d8        e0  busy extra
001cbe90  001cbe98  00170000  00000000        68        48  busy extra
001cbef8  001cbf00  00170000  00000000        58        68  busy extra
001cc078  001cc080  00170000  00000000        f8       128  busy extra
001cc360  001cc368  00170000  00000000        80        50  busy extra
001cc3e0  001cc3e8  00170000  00000000        58        80  busy extra
001fe550  001fe558  00170000  00000000       150       278  busy extra
001fe6e8  001fe6f0  00170000  00000000        48        48  busy extra
002057a8  002057b0  00170000  00000000        58        58  busy extra
00205800  00205808  00170000  00000000        48        58  busy extra
002058b8  002058c0  00170000  00000000        58        70  busy extra
00205910  00205918  00170000  00000000        48        58  busy extra
00205958  00205960  00170000  00000000        90        48  busy extra
00246970  00246978  00170000  00000000        60        88  busy extra
00251168  00251170  00170000  00000000        78        d0  busy extra user_flag
00527730  00527738  00520000  00000000        40        40  busy extra
00527920  00527928  00520000  00000000        40        80  busy extra
21 leaks detected.

Die Tabelle in diesem Beispiel enthält alle 21 gefundenen Lecks.

Hier ist ein Beispiel für den Befehl !heap -x:

0:011> !heap 002057b8 -x
## Entry     User      Heap      Segment       Size  PrevSize  Flags

002057a8  002057b0  00170000  00170640        58        58  busy extra

Hier ist ein Beispiel für den Befehl !heap -x -v:

1:0:011> !heap 002057b8 -x -v
## 1:Entry     User      Heap      Segment       Size  PrevSize  Flags

002057a8  002057b0  00170000  00170640        58        58  busy extra

Search VM for address range 002057a8 - 002057ff : 00205990 (002057d0),

In diesem Beispiel gibt es einen Zeiger auf diesen Heap-Block an der Adresse 0x00205990.

Hier ist ein Beispiel für den Befehl !heap -flt s:

0:001>!heap -flt s 0x50

Dadurch werden alle Zuweisungen der Größe 0x50 angezeigt.

Hier ist ein Beispiel für den Befehl !heap -flt r:

0:001>!heap -flt r 0x50 0x80

Dadurch wird jede Zuweisung angezeigt, deren Größe zwischen 0x50 und 0x7F liegt.

Hier ist ein Beispiel für den Befehl !heap -srch.

0:001> !heap -srch 77176934
    _HEAP @ 00090000
   in HEAP_ENTRY: Size : Prev Flags - UserPtr UserSize - state
        00099A48: 0018 : 0005 [01] - 00099A50 (000000B8) - (busy)
          ole32!CALLFRAME_CACHE<INTERFACE_HELPER_CLSID>::`vftable'
    _HEAP @ 00090000
   in HEAP_ENTRY: Size : Prev Flags - UserPtr UserSize - state
        00099B58: 0018 : 0005 [01] - 00099B60 (000000B8) - (busy)
          ole32!CALLFRAME_CACHE<INTERFACE_HELPER_CLSID>::`vftable'

Die folgenden Diagramme zeigen die Anordnung der Heap-Blöcke.

Light-Page-Heap-Block -- zugewiesen:

 +-----+---------------+---+                                  
 |     |               |   |                                  
 +-----+---------------+---+                                  
    ^         ^          ^                                    
    |         |          8 suffix bytes (filled with 0xA0)    
    |         User allocation (filled with E0 if zeroing not requested) 
    Block header (starts with 0xABCDAAAA and ends with 0xDCBAAAAA)

Light-Page-Heap-Block -- freigegeben:

 +-----+---------------+---+                                  
 |     |               |   |                                  
 +-----+---------------+---+                                  
    ^         ^          ^                                    
    |         |          8 suffix bytes (filled with 0xA0)    
    |         User allocation (filled with F0 bytes)          
    Block header (starts with 0xABCDAAA9 and ends with 0xDCBAAA9)

Full-Page-Heap-Block - zugewiesen:

 +-----+---------+---+-------                                 
 |     |         |   |  ... N/A page                          
 +-----+---------+---+-------                                 
    ^       ^      ^                                          
    |       |      0-7 suffix bytes (filled with 0xD0)        
    |       User allocation (if zeroing not requested, filled   
            with C0)       
    Block header (starts with 0xABCDBBBB and ends with 0xDCBABBBB)

Full-Page- -- freigegeben:

 +-----+---------+---+-------                                 
 |     |         |   |  ... N/A page                          
 +-----+---------+---+-------                                 
    ^       ^      ^                                          
    |       |      0-7 suffix bytes (filled with 0xD0)        
    |       User allocation (filled with F0 bytes)            
    Block header (starts with 0xABCDBBA and ends with 0xDCBABBBA)

Um den Stack-Trace der Zuweisung oder Freigabe eines Heap-Blocks oder Full-Page-Heap-Blocks zu sehen, verwenden Sie dt DPH_BLOCK_INFORMATION mit der Header-Adresse, gefolgt von dds mit dem Feld StackTrace des Blocks.