Monitorare e risolvere i problemi relativi all'utilizzo della memoriaMonitor and Troubleshoot Memory Usage

OLTP in memoria di SQL ServerSQL Server In-Memory OLTP utilizza la memoria in modi diversi rispetto alle tabelle basate su disco. consumes memory in different patterns than disk-based tables. È possibile monitorare la quantità di memoria allocata e utilizzata dagli indici e dalle tabelle con ottimizzazione per la memoria nel database tramite DMV o contatori delle prestazioni forniti per il sottosistema di Garbage Collection e memoria.You can monitor the amount of memory allocated and used by memory-optimized tables and indexes in your database using the DMVs or performance counters provided for memory and the garbage collection subsystem. Ciò offre visibilità a livello di sistema e di database e consente di evitare problemi dovuti all'esaurimento della memoria.This gives you visibility at both the system and database level and lets you prevent problems due to memory exhaustion.

In questo argomento viene illustrato il monitoraggio dell'utilizzo della memoria di OLTP in memoriaIn-Memory OLTP .This topic covers monitoring your OLTP in memoriaIn-Memory OLTP memory usage.

Sezioni dell'argomentoSections in this topic

Creare un database di esempio con tabelle con ottimizzazione per la memoria Create a sample database with memory-optimized tables

Se si dispone già di un database con tabelle con ottimizzazione per la memoria è possibile saltare questa sezione.You can skip this section if you already have a database with memory-optimized tables.

Con i passaggi seguenti si crea un database con tre tabelle con ottimizzazione per la memoria che è possibile utilizzare nelle sezioni rimanenti di questo argomento.The following steps create a database with three memory-optimized tables that you can use in the remainder of this topic. Nell'esempio è stato eseguito il mapping del database a un pool di risorse, in modo da poter controllare la quantità di memoria utilizzata dalle tabelle con ottimizzazione per la memoria.In the example, we mapped the database to a resource pool so that we can control how much memory can be taken by memory-optimized tables.

  1. Avviare SQL Server Management StudioSQL Server Management Studio.Launch SQL Server Management StudioSQL Server Management Studio.

  2. Fare clic su Nuova query.Click New Query.

  3. Incollare il codice nella finestra della nuova query ed eseguire ogni sezione.Paste this code into the new query window and execute each section.

    -- create a database to be used  
    CREATE DATABASE IMOLTP_DB  
    GO  
    
    ALTER DATABASE IMOLTP_DB ADD FILEGROUP IMOLTP_DB_xtp_fg CONTAINS MEMORY_OPTIMIZED_DATA  
    ALTER DATABASE IMOLTP_DB ADD FILE( NAME = 'IMOLTP_DB_xtp' , FILENAME = 'C:\Data\IMOLTP_DB_xtp') TO FILEGROUP IMOLTP_DB_xtp_fg;  
    GO  
    
    USE IMOLTP_DB  
    GO  
    
    -- create the resoure pool  
    CREATE RESOURCE POOL PoolIMOLTP WITH (MAX_MEMORY_PERCENT = 60);  
    ALTER RESOURCE GOVERNOR RECONFIGURE;  
    GO  
    
    -- bind the database to a resource pool  
    EXEC sp_xtp_bind_db_resource_pool 'IMOLTP_DB', 'PoolIMOLTP'  
    
    -- you can query the binding using the catalog view as described here  
    SELECT d.database_id  
         , d.name  
         , d.resource_pool_id  
    FROM sys.databases d  
    GO  
    
    -- take database offline/online to finalize the binding to the resource pool  
    USE master  
    GO  
    
    ALTER DATABASE IMOLTP_DB SET OFFLINE  
    GO  
    ALTER DATABASE IMOLTP_DB SET ONLINE  
    GO  
    
    -- create some tables  
    USE IMOLTP_DB  
    GO  
    
    -- create table t1  
    CREATE TABLE dbo.t1 (  
           c1 int NOT NULL CONSTRAINT [pk_t1_c1] PRIMARY KEY NONCLUSTERED  
         , c2 char(40) NOT NULL  
         , c3 char(8000) NOT NULL  
         ) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA)  
    GO  
    
    -- load t1 150K rows  
    DECLARE @i int = 0  
    BEGIN TRAN  
    WHILE (@i <= 150000)  
       BEGIN  
          INSERT t1 VALUES (@i, 'a', replicate ('b', 8000))  
          SET @i += 1;  
       END  
    Commit  
    GO  
    
    -- Create another table, t2  
    CREATE TABLE dbo.t2 (  
           c1 int NOT NULL CONSTRAINT [pk_t2_c1] PRIMARY KEY NONCLUSTERED  
         , c2 char(40) NOT NULL  
         , c3 char(8000) NOT NULL  
         ) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA)  
    GO  
    
    -- Create another table, t3   
    CREATE TABLE dbo.t3 (  
           c1 int NOT NULL CONSTRAINT [pk_t3_c1] PRIMARY KEY NONCLUSTERED HASH (c1) WITH (BUCKET_COUNT = 1000000)  
         , c2 char(40) NOT NULL  
         , c3 char(8000) NOT NULL  
         ) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA)  
    GO  
    

Monitoraggio dell'utilizzo della memoria Monitoring Memory Usage

Uso SQL Server Management StudioSQL Server Management Studio Using SQL Server Management StudioSQL Server Management Studio

SQL Server 2014SQL Server 2014 viene fornito con report standard predefiniti per monitorare la memoria utilizzata dalle tabelle in memoria. ships with built-in standard reports to monitor the memory consumed by in-memory tables. È possibile accedere a questi report utilizzando Esplora oggetti come descritto qui.You can access these reports using Object Explorer as described here. È inoltre possibile utilizzare Esplora oggetti per monitorare la memoria utilizzata dalle singole tabelle con ottimizzazione per la memoria.You can also use the object explorer to monitor memory consumed by individual memory-optimized tables.

Utilizzo a livello di databaseConsumption at the database level

È possibile monitorare l'utilizzo della memoria a livello di database nel modo seguente.You can monitor memory use at the database level as follows.

  1. Avviare SQL Server Management StudioSQL Server Management Studio e connettersi a un server.Launch SQL Server Management StudioSQL Server Management Studio and connect to a server.

  2. In Esplora oggetti fare clic con il pulsante destro del mouse sul database in cui si desidera creare i report.In Object Explorer, right-click the database you want reports on.

  3. Dal menu di scelta rapida scegliere Report -> Standard Report -> Utilizzo memoria da parte di oggetti con ottimizzazione per la memoria.In the context menu select, Reports -> Standard Reports -> Memory Usage By Memory Optimized Objects

    HK_MM_SSMSHK_MM_SSMS

    In questo report viene indicato l'utilizzo della memoria da parte del database creato in precedenza.This report shows memory consumption by the database we created above.

    HK_MM_SSMSHK_MM_SSMS

Utilizzo di DMVs Using DMVs

Sono disponibili alcune DMV per monitorare la memoria utilizzata da tabelle con ottimizzazione per la memoria, indici, oggetti di sistema e strutture di runtime.There are a number of DMVs available to monitor memory consumed by memory-optimized tables, indexes, system objects, and by run-time structures.

Utilizzo della memoria da parte di indici e tabelle con ottimizzazione per la memoriaMemory consumption by memory-optimized tables and indexes

Per conoscere l'utilizzo della memoria da parte di tutte le tabelle utente, gli indici e gli oggetti di sistema, eseguire una query su sys.dm_db_xtp_table_memory_stats come illustrato di seguito.You can find memory consumption for all user tables, indexes, and system objects by querying sys.dm_db_xtp_table_memory_stats as shown here.

SELECT object_name(object_id) AS Name  
     , *  
   FROM sys.dm_db_xtp_table_memory_stats  

Esempio di outputSample Output

Name       object_id   memory_allocated_for_table_kb memory_used_by_table_kb memory_allocated_for_indexes_kb memory_used_by_indexes_kb  
---------- ----------- ----------------------------- ----------------------- ------------------------------- -------------------------  
t3         629577281   0                             0                       128                             0  
t1         565577053   1372928                       1200008                 7872                            1942  
t2         597577167   0                             0                       128                             0  
NULL       -6          0                             0                       2                               2  
NULL       -5          0                             0                       24                              24  
NULL       -4          0                             0                       2                               2  
NULL       -3          0                             0                       2                               2  
NULL       -2          192                           25                      16                              16  

Per altre informazioni, vedere sys.dm_db_xtp_table_memory_stats.For more information see sys.dm_db_xtp_table_memory_stats.

Utilizzo della memoria da parte delle strutture di sistema interneMemory consumption by internal system structures

La memoria viene utilizzata anche dagli oggetti di sistema, ad esempio le strutture transazionali, i buffer per file di dati e differenziali, le strutture di Garbage Collection e altro ancora.Memory is also consumed by system objects, such as, transactional structures, buffers for data and delta files, garbage collection structures, and more. Per conoscere la memoria utilizzata da parte di questi oggetti di sistema, eseguire una query su sys.dm_xtp_system_memory_consumers come illustrato di seguito.You can find the memory used for these system objects by querying sys.dm_xtp_system_memory_consumers as shown here.

SELECT memory_consumer_desc  
     , allocated_bytes/1024 AS allocated_bytes_kb  
     , used_bytes/1024 AS used_bytes_kb  
     , allocation_count  
   FROM sys.dm_xtp_system_memory_consumers  

Esempio di outputSample Output

memory_consumer_ desc allocated_bytes_kb   used_bytes_kb        allocation_count  
------------------------- -------------------- -------------------- ----------------  
VARHEAP                   0                    0                    0  
VARHEAP                   384                  0                    0  
DBG_GC_OUTSTANDING_T      64                   64                   910  
ACTIVE_TX_MAP_LOOKAS      0                    0                    0  
RECOVERY_TABLE_CACHE      0                    0                    0  
RECENTLY_USED_ROWS_L      192                  192                  261  
RANGE_CURSOR_LOOKSID      0                    0                    0  
HASH_CURSOR_LOOKASID      128                  128                  455  
SAVEPOINT_LOOKASIDE       0                    0                    0  
PARTIAL_INSERT_SET_L      192                  192                  351  
CONSTRAINT_SET_LOOKA      192                  192                  646  
SAVEPOINT_SET_LOOKAS      0                    0                    0  
WRITE_SET_LOOKASIDE       192                  192                  183  
SCAN_SET_LOOKASIDE        64                   64                   31  
READ_SET_LOOKASIDE        0                    0                    0  
TRANSACTION_LOOKASID      448                  448                  156  
PGPOOL:256K               768                  768                  3  
PGPOOL: 64K               0                    0                    0  
PGPOOL:  4K               0                    0                    0  

Per altre informazioni, vedere sys.dm_xtp_system_memory_consumers (Transact-SQL).For more information see sys.dm_xtp_system_memory_consumers (Transact-SQL).

Utilizzo della memoria in fase di esecuzione quando si accede alle tabelle con ottimizzazione per la memoriaMemory consumption at run-time when accessing memory-optimized tables

Per determinare la memoria utilizzata dalle strutture di runtime, ad esempio la cache delle procedure, eseguire la query riportata di seguito.You can determine the memory consumed by run time structures, such as the procedure cache with the following query: run this query to get the memory used by run-time structures such as for the procedure cache. Tutte le strutture di runtime sono contrassegnate con XTP.All run-time structures are tagged with XTP.

SELECT memory_object_address  
     , pages_in_bytes  
     , bytes_used  
     , type  
   FROM sys.dm_os_memory_objects WHERE type LIKE '%xtp%'  

Esempio di outputSample Output

memory_object_address pages_ in_bytes bytes_used type  
--------------------- ------------------- ---------- ----  
0x00000001F1EA8040    507904              NULL       MEMOBJ_XTPDB  
0x00000001F1EAA040    68337664            NULL       MEMOBJ_XTPDB  
0x00000001FD67A040    16384               NULL       MEMOBJ_XTPPROCCACHE  
0x00000001FD68C040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD284040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD302040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD382040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD402040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD482040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD502040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001FD67E040    16384               NULL       MEMOBJ_XTPPROCPARTITIONEDHEAP  
0x00000001F813C040    8192                NULL       MEMOBJ_XTPBLOCKALLOC  
0x00000001F813E040    16842752            NULL       MEMOBJ_XTPBLOCKALLOC  

Per altre informazioni, vedere sys.dm_os_memory_objects (Transact-SQL).For more information see sys.dm_os_memory_objects (Transact-SQL).

Memoria utilizzata dal motore OLTP in memoriaIn-Memory OLTP nell'istanzaMemory consumed by OLTP in memoriaIn-Memory OLTP engine across the instance

La memoria allocata al motore OLTP in memoriaIn-Memory OLTP e agli oggetti con ottimizzazione per la memoria viene gestita in modo analogo a qualsiasi altro consumer di memoria all'interno dell'istanza di SQL ServerSQL Server .Memory allocated to the OLTP in memoriaIn-Memory OLTP engine and the memory-optimized objects is managed the same way as any other memory consumer within a SQL ServerSQL Server instance. I clerk di tipo MEMORYCLERK_XTP tengono conto di tutta la memoria allocata al motore OLTP in memoriaIn-Memory OLTP .The clerks of type MEMORYCLERK_XTP accounts for all the memory allocated to OLTP in memoriaIn-Memory OLTP engine. Utilizzare la query seguente per trovare tutta la memoria utilizzata dal motore OLTP in memoriaIn-Memory OLTP .Use the following query to find all the memory used by the OLTP in memoriaIn-Memory OLTP engine.

-- this DMV accounts for all memory used by the hek_2 engine  
SELECT type  
     , name  
     , memory_node_id  
     , pages_kb/1024 AS pages_MB   
   FROM sys.dm_os_memory_clerks WHERE type LIKE '%xtp%'  

Nell'output campione viene mostrato che la memoria totale allocata corrisponde all'utilizzo di memoria a livello di sistema pari a 18 MB e 1358 MB allocati a un ID 5 del database.The sample output shows that the total memory allocated is 18 MB system-level memory consumption and 1358MB allocated to database id of 5. Poiché viene eseguito il mapping di questo database a un pool di risorse dedicato, questa memoria incide sul pool di risorse in questione.Since this database is mapped to a dedicated resource pool, this memory is accounted for in that resource pool.

Esempio di outputSample Output

type                 name       memory_node_id pages_MB  
-------------------- ---------- -------------- --------------------  
MEMORYCLERK_XTP      Default    0              18  
MEMORYCLERK_XTP      DB_ID_5    0              1358  
MEMORYCLERK_XTP      Default    64             0  

Per altre informazioni, vedere sys.dm_os_memory_clerks (Transact-SQL).For more information see sys.dm_os_memory_clerks (Transact-SQL).

Gestione della memoria utilizzata dagli oggetti con ottimizzazione per la memoria Managing memory consumed by memory-optimized objects

È possibile controllare la memoria totale utilizzata dalle tabelle con ottimizzazione per la memoria mediante l'associazione a un pool di risorse denominato, come descritto nell'argomento Associare un database con tabelle con ottimizzazione per la memoria a un pool di risorse.You can control the total memory consumed by memory-optimized tables by binding it to a named resource pool as described in the topic Bind a Database with Memory-Optimized Tables to a Resource Pool.

Risoluzione dei problemi relativi alla memoria Troubleshooting Memory Issues

La risoluzione dei problemi relativi alla memoria è un processo in tre passaggi:Troubleshooting memory issues is a three step process:

  1. Identificare la quantità di memoria utilizzata dagli oggetti nel database o nell'istanza.Identify how much memory is being consumed by the objects in your database or instance. È possibile utilizzare un'ampia gamma di strumenti di monitoraggio disponibili per le tabelle con ottimizzazione per la memoria, come indicato in precedenza.You can use a rich set of monitoring tools available for memory-optimized tables as described earlier. Ad esempio, le DMV sys.dm_db_xtp_table_memory_stats o sys.dm_os_memory_clerks.For example the DMVs sys.dm_db_xtp_table_memory_stats or sys.dm_os_memory_clerks.

  2. Determinare la crescita dell'utilizzo della memoria e quanto spazio disponibile rimane.Determine how memory consumption is growing and how much head room you have left. Attraverso il monitoraggio periodico dell'utilizzo della memoria è possibile capire la relativa modalità di crescita.By monitoring the memory consumption periodically, you can know how the memory use is growing. Ad esempio, se è stato eseguito il mapping del database a un pool di risorse denominato, è possibile monitorare il contatore delle prestazioni Memoria utilizzata (KB) per capire come cresce la memoria.For example, if you have mapped the database to a named resource pool, you can monitor the performance counter Used Memory (KB) to see how memory usage is growing.

  3. Adottare misure adeguate per contenere i potenziali problemi di memoria.Take action to mitigate the potential memory issues. Per altre informazioni, vedere Risolvere i problemi di memoria insufficiente.For more information see Resolve Out Of Memory Issues.

Vedere ancheSee Also

Associare un database con tabelle con ottimizzazione per la memoria a un pool di risorse Bind a Database with Memory-Optimized Tables to a Resource Pool
Modificare il valore di MIN_MEMORY_PERCENT e MAX_MEMORY_PERCENT in un pool esistente Change MIN_MEMORY_PERCENT and MAX_MEMORY_PERCENT on an existing pool