Övervaka och felsök minnesanvändning med OLTP i minnet

Gäller för:SQL Server

In-Memory OLTP förbrukar minne i andra mönster än diskbaserade tabeller. Du kan övervaka mängden minne som tilldelats och används av minnesoptimerade tabeller och index i din databas med hjälp av DMV:er eller prestandaräknare som tillhandahålls för minne och sopsamlingssystemet. Detta ger dig insyn både på system- och databasnivå och låter dig undvika problem på grund av minnesuttömning.

Den här artikeln handlar om att övervaka din In-Memory OLTP-minnesanvändning för SQL Server.

1. Skapa en exempeldatabas med minnesoptimerade tabeller

Följande steg skapar en databas att använda för vår övning.

1. Starta SQL Server Management Studio.

2. Välj Ny fråga.

   Note

   Du kan hoppa över nästa steg om du redan har en databas med minnesoptimerade tabeller.

3. Klistra in denna kod i det nya frågefönstret och kör varje sektion för att skapa testdatabasen för denna övning, IMOLTP_DB.

   -- create a database to be used  
   CREATE DATABASE IMOLTP_DB  
   GO
   

4. Exempelskriptet nedan använder C:\Data, men din instans använder troligen olika mappplatser för databasdatafiler. Uppdatera följande skript till att använda en lämplig plats för minnesfilen och kör.

   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
   

5. Följande skript skapar tre minnesoptimerade tabeller som du kan använda i resten av detta ämne. I exemplet mappade vi databasen till en resurspool så att vi kan kontrollera hur mycket minne som kan tas av minnesoptimerade tabeller. Exekvera följande skript i databasen IMOLTP_DB .

   -- create some tables  
   USE IMOLTP_DB  
   GO  
   
   -- create the resource 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  
   

2. Övervaka minnesanvändning

Övervaka minnesanvändning med SQL Server Management Studio

Sedan SQL Server 2014 (12.x) har SQL Server Management Studio inbyggda standardrapporter för att övervaka minnet som förbrukas av tabeller i minnet. Du kan komma åt dessa rapporter med Object Explorer. Du kan också använda objektutforskaren för att övervaka minnesförbrukningen för enskilda minnesoptimerade tabeller.

Konsumtion på databasnivå

Du kan övervaka minnesanvändningen på databasnivå enligt följande.

1. Starta SQL Server Management Studio och koppla upp dig mot din SQL Server eller SQL-hanterade instans.

2. I Object Explorer, högerklicka på databasen du vill ha rapporter i.

3. I kontextmenyn väljer du Rapporter ->Standardrapporter ->Minnesanvändning efter minnesoptimerade objekt

Denna rapport visar minnesanvändning i databasen vi skapade ovan.

Övervaka minnesanvändningen med DMV:er

Det finns många DMV:er tillgängliga för att övervaka minne som förbrukas av minnesoptimerade tabeller, index, systemobjekt och av körtidsstrukturer.

Minneskonsumtion med minnesoptimerade tabeller och index

Du kan hitta minnesanvändning för alla användartabeller, index och systemobjekt genom att fråga sys.dm_db_xtp_table_memory_stats som visas här.

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

Exempel på resultat

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  

För mer information, se sys.dm_db_xtp_table_memory_stats.

Minneskonsumtion av interna systemstrukturer

Minne förbrukas också av systemobjekt, såsom transaktionsstrukturer, buffertar för data och delta-filer, skräpsamlingsstrukturer och mer. Du kan hitta minnet som används för dessa systemobjekt genom att fråga sys.dm_xtp_system_memory_consumers som visas här.

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  

Exempel på resultat

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  

För mer information, se sys.dm_xtp_system_memory_consumers).

Minnesanvändning under körning vid åtkomst till minnesoptimerade tabeller

Du kan bestämma vilket minne som används av körtidsstrukturer, såsom procedurcachen, med följande fråga: kör denna fråga för att få minnet som används av körtidsstrukturer, till exempel procedurcachen. Alla körtidsstrukturer är taggade med XTP.

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

Exempel på resultat

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  

För mer information, se sys.dm_os_memory_objects (Transact-SQL).

Minne som används av In-Memory OLTP i hela instansen

Minne som tilldelas In-Memory OLTP-motorn och de minnesoptimerade objekten hanteras på samma sätt som alla andra minneskonsumenter inom en SQL Server instans. Minnesadministratörerna av typen MEMORYCLERK_XTP står för allt minne som har allokerats till In-Memory OLTP-motorn. Använd följande fråga för att hitta allt minne som används av In-Memory OLTP-motorn.

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

Följande exempelutgång visar att det allokerade minnet är 18 MB systemnivåminne och 1358 MB tilldelat database_id = 5. Eftersom denna databas mappas till en dedikerad resurspool redovisas detta minne i den resurspoolen.

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

Mer information finns i sys.dm_os_memory_clerks.

3. Hantera minne som förbrukas av minnesoptimerade objekt

Du kan kontrollera det totala minnesförbrukandet av minnesoptimerade tabeller genom att binda det till en namngiven resurspool. För mer information, se Bind en databas med minnesoptimerade tabeller till en resurspool.

Felsöka minnesproblem

Felsökning av minnesproblem är en trestegsprocess:

1. Identifiera hur mycket minne som förbrukas av objekten i din databas eller instans. Du kan använda ett rikt utbud av övervakningsverktyg tillgängliga för minnesoptimerade tabeller som beskrivits tidigare. Till exempel, se exempelfrågorna på DMV:erna sys.dm_db_xtp_table_memory_stats eller sys.dm_os_memory_clerks.

2. Bestäm hur minneskonsumtionen växer och hur mycket utrymme du har kvar. Genom att regelbundet övervaka minnesförbrukningen kan du veta hur minnesanvändningen växer. Till exempel, om du har mappat databasen till en namngiven resurspool, kan du övervaka prestandaräknaren Used Memory (KB) för att se hur minnesanvändningen växer.

3. Vidta åtgärder för att minska potentiella minnesproblem. För mer information, se Lösa minnesproblem.

Relaterat innehåll

• binda en databas med Memory-Optimized tabeller till en resurspool
• Ändra MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT i en befintlig pool