O formato de arquivo de snapshot heap

Investigar o uso de memória em aplicativos Web pode ser difícil. A ferramenta Memória do DevTools permite explorar todos os objetos alocados na memória pelo seu aplicativo Web usando um heap snapshot. Essas informações são úteis para investigações de desempenho porque você pode descobrir quais objetos estão consumindo mais memória.

No entanto, às vezes você pode precisar se concentrar em partes específicas dos dados de memória que a ferramenta Memória não mostra. Nesse caso, use o DevTools para exportar todo o conjunto de dados de memória como um .heapsnapshot arquivo JSON.

Este artigo descreve a estrutura e o conteúdo dos arquivos JSON para que você possa criar suas próprias ferramentas de .heapsnapshot visualização e análise.

Registrar um snapshot de heap

Para exportar um .heapsnapshot arquivo, primeiro você precisa registrar um snapshot de heap na ferramenta Memória, da seguinte forma:

1. No Microsoft Edge, navegue até o site do qual você deseja exportar os dados.

2. Pressione Ctrl+Shift+I (Windows, Linux) ou Command+Option+I (macOS) para abrir o Devtools.

3. Abra a ferramenta Memória .

4. Selecione Heap snapshot e clique em Take snapshot.

Para obter mais informações, consulte Registrar instantâneos de heap usando a ferramenta Memória (tipo de criação de perfil "Heap snapshot")

Exportar e exibir um .heapsnapshot arquivo

Depois de gravar um snapshot de heap, você pode exportá-lo.

1. Na barra lateral esquerda da ferramenta Memória, clique em Salvar ao lado do item do snapshot de heap que você acabou de gravar.

2. Altere a extensão de arquivo de para .json, para facilitar a abertura do arquivo em um editor de .heapsnapshot texto.

3. Abra o arquivo salvo em um editor de texto, como o Visual Studio Code.

4. Para facilitar a leitura do JSON, no Visual Studio Code, clique com o botão direito do mouse em qualquer lugar do código e selecione Formatar documento.

Geralmente, o arquivo resultante .heapsnapshot é diferente toda vez que você grava e exporta um snapshot de heap. Os instantâneos de heap são gerados dinamicamente, com base no conteúdo do aplicativo Web que está sendo inspecionado no momento no DevTools.

Visão geral do .heapsnapshot formato de arquivo

A memória usada por um aplicativo Web é organizada como um gráfico pelo V8, que é o mecanismo JavaScript usado pelo Microsoft Edge. Um gráfico é um tipo de dados composto por nós (pontos no gráfico) e bordas (vínculos entre os pontos).

Os dados no .heapsnapshot arquivo representam a memória do aplicativo Web que representa graficamente com eficiência e facilita a transferência de grupos de dados entre o processo do navegador e o DevTools. O .heapsnapshot arquivo contém uma representação achatada das relações entre nós e bordas, como um objeto JSON que contém matrizes de números e strings. O arquivo tem uma .heapsnapshot extensão de nome de arquivo e contém dados formatados em JSON.

Os dados têm duas partes principais:

• Os metadados, que contêm todas as informações necessárias para analisar as matrizes de dados que representam o gráfico de memória.
• Os dados de matrizes, que contêm os dados reais necessários para recriar o gráfico.

Atualizando esta documentação de formato de dados

O formato do arquivo, conforme documentado abaixo, pode mudar à medida que o V8 e o .heapsnapshot DevTools evoluem. Se você encontrar uma discrepância na documentação, forneça comentários no repositório MicrosoftDocs/edge-developer.

Esquema dos .heapsnapshot dados

Estrutura de nível superior

Os .heapsnapshot dados JSON contêm um objeto raiz que tem as seguintes propriedades:

{
    "snapshot": {},
    "nodes": [],
    "edges": [],
    "trace_function_infos": [],
    "trace_tree": [],
    "samples": [],
    "locations": [],
    "strings": []
}

Instantâneo

{
    "snapshot": {     
        "meta": {},
        "node_count": 123,
        "edge_count": 456,
        "trace_function_count": 0
    }
    ...
}

Metadados de instantâneo

{
    "snapshot": {
        "meta": {
            "node_fields": [],
            "node_types": [],
            "edge_fields": [],
            "edge_types": []
        }
    }
    ...
}

Veja a seguir um exemplo de um objeto de metadados:

{
    "snapshot": {
        "meta": {
            "node_fields": [
                "type",
                "name",
                "id",
                "self_size",
                "edge_count",
                "trace_node_id",
                "detachedness"
            ],
            "node_types": [
                [
                    "hidden",
                    "array",
                    "string",
                    "object",
                    "code",
                    "closure",
                    "regexp",
                    "number",
                    "native",
                    "synthetic",
                    "concatenated string",
                    "sliced string",
                    "symbol",
                    "bigint",
                    "object shape"
                ],
                "string",
                "number",
                "number",
                "number",
                "number",
                "number"
            ],
            "edge_fields": [
                "type",
                "name_or_index",
                "to_node"
            ],
            "edge_types": [
                [
                    "context",
                    "element",
                    "property",
                    "internal",
                    "hidden",
                    "shortcut",
                    "weak"
                ],
                "string_or_number",
                "node"
            ]
        }
    }
}

Nós

A nodes matriz, que está no nível superior dos .heapsnapshot dados, contém todas as informações necessárias para recriar os nós do gráfico de memória.

Para analisar essa matriz, as seguintes informações são necessárias:

• snapshot.node_count, para saber quantos nós existem.
• snapshot.meta.node_fields, para saber quantos campos cada nó tem.

Cada nó da matriz é representado por uma série de snapshot.meta.node_fields.length números. Portanto, o número total de elementos na nodes matriz é snapshot.node_count multiplicado por snapshot.meta.node_fields.length.

Para recriar um nó, leia os números da nodes matriz por grupos de tamanho snapshot.meta.node_fields.length.

O trecho de código a seguir mostra os node_fields metadados e os dados dos dois primeiros nós no gráfico:

{
    "snapshot": {
        "meta": {
            "node_fields": [
                "type",
                "name",
                "id",
                "self_size",
                "edge_count",
                "trace_node_id",
                "detachedness"
            ]
            ...
        }
        ...
    },
    "nodes": [
        9,1,1,0,10,0,0,
        2,1,79,12,1,0,0,
        ...
    ]
    ...
}

Tipos de nó

O primeiro número no grupo de números de um nó na nodes matriz corresponde ao seu tipo. Esse número é um índice que pode ser usado para pesquisar o nome do tipo na snapshot.meta.node_types[0] matriz.

Arestas

Semelhante à nodes matriz, a edges matriz de nível superior contém todos os elementos necessários para recriar as bordas do gráfico de memória.

Também semelhante aos nós, o número total de arestas pode ser calculado multiplicando snapshot.edge_count por snapshot.meta.edge_fields.length. As arestas também são armazenadas como uma sequência de números, que você precisará iterar por grupos de tamanho snapshot.meta.edge_fields.length.

No entanto, para ler a edges matriz corretamente, primeiro você precisa ler a nodes matriz, porque cada nó sabe quantas arestas ele tem.

Para recriar uma borda, você precisa de três informações:

• O tipo de borda.
• O nome ou índice da borda.
• O nó ao qual a borda está conectada.

Por exemplo, se você ler o primeiro nó da nodes matriz e sua edge_count propriedade estiver definida como 4, os primeiros quatro grupos de snapshot.meta.edge_fields.length números na matriz corresponderão edges às quatro arestas desse nó.

Tipos de borda

O primeiro número no grupo de números de uma aresta na edges matriz corresponde ao seu tipo. Esse número é um índice que pode ser usado para pesquisar o nome do tipo na snapshot.meta.edge_types[0] matriz.

locations

A locations matriz, que está no nível superior dos .heapsnapshot dados, contém informações sobre onde alguns dos nós no snapshot foram criados. Essa matriz consiste em uma série de números destinados a serem lidos por grupos de tamanho snapshot.meta.location_fields.length. Portanto, iríamos para snapshot.meta.location_fields saber quantos campos cada local da locations matriz tem e quais são esses campos. Por exemplo, se location_fields contiver 4 itens, a locations matriz deverá ser lida por grupos de 4.

snapshot.meta.location_fields Contém as informações para cada local:

O exemplo de código a seguir mostra como vincular a snapshot.locations matriz à snapshot.nodes matriz:

{
    "snapshot": {
        "meta": {
            "location_fields": [
                "object_index",
                "script_id",
                "line",
                "column"
            ]
            ...
        }
        ...
    },
    "nodes": [
        9,1,1,0,10,0,0,
        2,1,79,12,1,0,0,
        ...
    ],
    "locations":[
        7,9,0,0,
        113792,3,25,21,
        ...
    ],
    ...
}

O primeiro local na locations matriz é 7,9,0,0,. Esse local está associado ao grupo de informações do nó que começa no índice 7 na nodes matriz. Portanto, o nó contém os seguintes pares de chave/valor:

"type": 2,
"name": 1,
"id": 79,
"self_size": 12,
"edge_count": 1,
"trace_node_id": 0,
"detachedness": 0,
"script_id": 9,
"line" 0,
"column": 0,

Confira também

Para saber mais sobre o formato de .heapsnapshot arquivo, consulte o código que gera o arquivo, que é a HeapSnapshotGenerator classe em heap-snapshot-generator.h.

• Classe HeapSnapshot (linha 142)
• Classe HeapSnapshotGenerator (linha 522)