Monitorowanie i rozwiązywanie problemów z wykorzystaniem pamięci za pomocą OLTP w pamięci

Dotyczy:SQL Server

In-Memory OLTP zużywa pamięć w innych wzorcach niż tabele oparte na dyskach. Możesz monitorować ilość przydzielonej i wykorzystywanej pamięci przez tabele i indeksy zoptymalizowane pod pamięć w bazie danych, korzystając z DMV lub liczników wydajności udostępnionych dla pamięci oraz podsystemu garbage collector. Daje to widoczność zarówno na poziomie systemu, jak i bazy danych oraz pozwala uniknąć problemów spowodowanych wyczerpaniem pamięci.

Ten artykuł dotyczy monitorowania zużycia pamięci OLTP In-Memory przez SQL Server.

1. Stworzyć przykładową bazę danych z tabelami zoptymalizowanymi pod pamięć

Następne kroki tworzą bazę danych do wykorzystania podczas ćwiczeń.

1. Uruchom program SQL Server Management Studio.

2. Wybierz pozycję Nowe zapytanie.

   Note

   Możesz pominąć ten kolejny krok, jeśli masz już bazę danych z tabelami zoptymalizowanymi pod pamięć.

3. Wklej ten kod do nowego okna zapytania i wykonaj każdą sekcję, aby utworzyć testową bazę danych dla tego ćwiczenia. IMOLTP_DB

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

4. Poniższy przykładowy skrypt używa C:\Data, ale Twoja instancja prawdopodobnie używa różnych lokalizacji folderów dla plików danych bazy danych. Zaktualizuj poniższy skrypt, aby użył odpowiedniej lokalizacji pliku w pamięci i wykonaj.

   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. Poniższy skrypt utworzy trzy tabele zoptymalizowane pod pamięć, które możesz wykorzystać w dalszej części tego tematu. W przykładzie mapowaliśmy bazę danych na pulę zasobów, aby kontrolować, ile pamięci może być zajęte przez tabele zoptymalizowane pod pamięć. Wykonaj następujący skrypt w bazie IMOLTP_DB danych.

   -- 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. Monitorowanie zużycia pamięci

Monitorowanie zużycia pamięci za pomocą SQL Server Management Studio

Od czasu SQL Server 2014 (12.x) SQL Server Management Studio posiada wbudowane standardowe raporty monitorujące zużycie pamięci przez tabele w pamięci. Do tych raportów można uzyskać dostęp za pomocą Eksplorator obiektów. Możesz także użyć eksploratora obiektów do monitorowania pamięci zużywanej przez poszczególne tabele zoptymalizowane pod pamięć.

Konsumpcja na poziomie bazy danych

Możesz monitorować zużycie pamięci na poziomie bazy danych w następujący sposób.

1. Uruchom program SQL Server Management Studio i połącz się z serwerem SQL Server lub wystąpieniem zarządzanym SQL.

2. W Eksplorator obiektów kliknij prawym przyciskiem myszy na bazę danych, na której chcesz raporty.

3. W menu kontekstowym wybierz, Raporty ->Raporty standardowe ->Użycie pamięci przez obiekty zoptymalizowane pod kątem pamięci

Ten raport pokazuje zużycie pamięci przez bazę danych, którą stworzyliśmy powyżej.

Monitorowanie zużycia pamięci za pomocą DMV

Istnieje wiele widoków DMV służących do monitorowania pamięci zużywanej przez tabele zoptymalizowane pod kątem pamięci, indeksy, obiekty systemowe oraz przez struktury środowiska uruchomieniowego.

Zużycie pamięci przez tabele i indeksy zoptymalizowane pod pamięć

Zużycie pamięci dla wszystkich tabel użytkowników, indeksów i obiektów systemowych można znaleźć, wykonując sys.dm_db_xtp_table_memory_stats zapytania jak pokazano tutaj.

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

Przykładowe dane wyjściowe

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  

Więcej informacji można znaleźć w sys.dm_db_xtp_table_memory_stats.

Zużycie pamięci przez wewnętrzne struktury systemu

Pamięć jest również wykorzystywana przez obiekty systemowe, takie jak struktury transakcyjne, bufory plików danych i plików delta, struktury odśmiecania pamięci i nie tylko. Pamięć używaną dla tych obiektów systemowych można znaleźć, zapytując sys.dm_xtp_system_memory_consumers tak, jak pokazano tutaj.

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  

Przykładowe dane wyjściowe

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  

Więcej informacji można znaleźć w sys.dm_xtp_system_memory_consumers).

Zużycie pamięci w czasie wykonywania podczas uzyskiwania dostępu do tabel zoptymalizowanych pod kątem pamięci

Możesz określić pamięć zużywaną przez struktury wykonawcze, takie jak pamięć podręczną procedur, za pomocą następującego zapytania: uruchom to zapytanie, aby uzyskać pamięć używaną przez struktury wykonawcze, takie jak pamięć podręczna procedur. Wszystkie struktury wykonawcze są oznaczane tagiem XTP.

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

Przykładowe dane wyjściowe

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  

Więcej informacji można znaleźć w sys.dm_os_memory_objects (Transact-SQL).

Pamięć zużywana przez silnik In-Memory OLTP w całej instancji

Pamięć przydzielona mechanizmowi In-Memory OLTP oraz obiektom zoptymalizowanym pod kątem pamięci jest zarządzana tak samo, jak w przypadku każdego innego składnika korzystającego z pamięci w ramach wystąpienia programu SQL Server. Klerki pamięci typu MEMORYCLERK_XTP odpowiadają za całą pamięć przydzieloną silnikowi OLTP In-Memory. Użyj następującego zapytania, aby znaleźć całą pamięć używaną przez silnik OLTP In-Memory.

-- 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%'  

Poniższy przykładowy wynik pokazuje, że przydzielono 18 MB pamięci systemowej oraz 1358 MB dla database_id = 5. Ponieważ ta baza danych jest przypisana do dedykowanej puli zasobów, ta pamięć jest uwzględniona w tej puli.

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

Aby uzyskać więcej informacji, zobacz sys.dm_os_memory_clerks.

3. Zarządzanie pamięcią zużywaną przez obiekty zoptymalizowane pod pamięć

Możesz kontrolować całkowitą ilość pamięci zużywanej przez tabele zoptymalizowane pod pamięć, wiążąc ją z nazwaną pulą zasobów. Więcej informacji można znaleźć w temacie Przypisywanie bazy danych z tabelami zoptymalizowanymi pod kątem pamięci do puli zasobów.

Rozwiązywanie problemów z pamięcią

Rozwiązywanie problemów z pamięcią to trzyetapowy proces:

1. Zidentyfikuj, ile pamięci jest zużywane przez obiekty w bazie danych lub instancji. Możesz korzystać z bogatego zestawu narzędzi monitorujących dostępnych dla tabel zoptymalizowanych pod pamięć, jak opisano wcześniej. Na przykład zobacz przykładowe zapytania dotyczące DMV sys.dm_db_xtp_table_memory_stats lub sys.dm_os_memory_clerks.

2. Określ, jak rośnie zużycie pamięci i ile masz jeszcze miejsca na rozsądek. Monitorując okresowe zużycie pamięci, możesz wiedzieć, jak rośnie jej zużycie. Na przykład, jeśli przypisałeś bazę danych do nazwanej puli zasobów, możesz monitorować licznik wydajności Used Memory (KB), aby zobaczyć, jak rośnie zużycie pamięci.

3. Podejmij działania, aby zminimalizować potencjalne problemy z pamięcią. Więcej informacji można znaleźć w artykule Rozwiązywanie problemów z pamięcią.

Treści powiązane

• powiązanie bazy danych z tabelami Memory-Optimized z pulą zasobów
• Zmień MIN_MEMORY_PERCENT i MAX_MEMORY_PERCENT w istniejącej puli