Memantau dan memecahkan masalah penggunaan memori dengan OLTP dalam memori
Berlaku untuk: 
SQL Server
OLTP Dalam Memori menggunakan memori dalam pola yang berbeda dari tabel berbasis disk. Anda dapat memantau jumlah memori yang dialokasikan dan digunakan oleh tabel dan indeks yang dioptimalkan memori dalam database Anda menggunakan DMV atau penghitung kinerja yang disediakan untuk memori dan subsistem pengumpulan sampah. Ini memberi Anda visibilitas pada tingkat sistem dan database dan memungkinkan Anda mencegah masalah karena kelelahan memori.
Artikel ini membahas pemantauan penggunaan memori OLTP Dalam Memori Anda untuk SQL Server.
Catatan
Tutorial ini tidak berlaku di Azure SQL Managed Instance atau Azure SQL Database. Sebagai gantinya, untuk demonstrasi OLTP dalam memori di Azure SQL, lihat:
Untuk informasi selengkapnya tentang pemantauan penggunaan OLTP dalam memori, lihat:
1. Buat database sampel dengan tabel yang dioptimalkan memori
Langkah-langkah berikut membuat database yang akan digunakan untuk latihan kami.
Luncurkan SQL Server Management Studio.
Pilih Kueri Baru.
Catatan
Anda dapat melewati langkah berikutnya ini jika Anda sudah memiliki database dengan tabel yang dioptimalkan memori.
Tempelkan kode ini ke jendela kueri baru dan jalankan setiap bagian untuk membuat database pengujian untuk latihan ini,
IMOLTP_DB.-- create a database to be used CREATE DATABASE IMOLTP_DB GOContoh skrip di bawah ini menggunakan
C:\Data, tetapi instans Anda kemungkinan menggunakan lokasi folder yang berbeda untuk file data database. Perbarui skrip berikut untuk menggunakan lokasi yang tepat untuk lokasi file dalam memori, dan jalankan.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; GOSkrip berikut akan membuat tiga tabel yang dioptimalkan memori yang dapat Anda gunakan di sisa topik ini. Dalam contoh, kami memetakan database ke kumpulan sumber daya sehingga kami dapat mengontrol berapa banyak memori yang dapat diambil oleh tabel yang dioptimalkan memori. Jalankan skrip berikut dalam
IMOLTP_DBdatabase.-- create some tables 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
2. Memantau penggunaan memori
Memantau penggunaan memori dengan SQL Server Management Studio
Sejak SQL Server 2014 (12.x), SQL Server Management Studio memiliki laporan standar bawaan untuk memantau memori yang digunakan oleh tabel dalam memori. Anda dapat mengakses laporan ini menggunakan Object Explorer. Anda juga dapat menggunakan penjelajah objek untuk memantau memori yang dikonsumsi oleh tabel yang dioptimalkan memori individual.
Konsumsi di tingkat database
Anda dapat memantau penggunaan memori di tingkat database sebagai berikut.
Luncurkan SQL Server Management Studio dan sambungkan ke SQL Server atau instans terkelola SQL Anda.
Di Object Explorer, klik kanan database yang ingin Anda laporkan.
Di menu konteks pilih, Laporan ->Laporan Standar ->Penggunaan Memori Berdasarkan Objek yang Dioptimalkan Memori
Laporan ini menunjukkan konsumsi memori oleh database yang kami buat di atas.
Memantau penggunaan memori dengan DMV
Ada banyak DMV yang tersedia untuk memantau memori yang digunakan oleh tabel yang dioptimalkan memori, indeks, objek sistem, dan oleh struktur run-time.
Konsumsi memori berdasarkan tabel dan indeks yang dioptimalkan memori
Anda dapat menemukan konsumsi memori untuk semua tabel pengguna, indeks, dan objek sistem dengan mengkueri seperti yang sys.dm_db_xtp_table_memory_stats diperlihatkan di sini.
SELECT object_name(object_id) AS [Name]
, *
FROM sys.dm_db_xtp_table_memory_stats;
Output sampel
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
Untuk informasi selengkapnya, lihat sys.dm_db_xtp_table_memory_stats.
Konsumsi memori oleh struktur sistem internal
Memori juga dikonsumsi oleh objek sistem, seperti struktur transaksional, buffer untuk file data dan delta, struktur pengumpulan sampah, dan banyak lagi. Anda dapat menemukan memori yang digunakan untuk objek sistem ini dengan mengkueri sys.dm_xtp_system_memory_consumers seperti yang diperlihatkan di sini.
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
Output sampel
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
Untuk informasi selengkapnya, lihat sys.dm_xtp_system_memory_consumers).
Konsumsi memori pada run-time saat mengakses tabel yang dioptimalkan memori
Anda dapat menentukan memori yang digunakan oleh struktur run time, seperti cache prosedur dengan kueri berikut: jalankan kueri ini untuk mendapatkan memori yang digunakan oleh struktur run-time seperti untuk cache prosedur. Semua struktur run-time ditandai dengan XTP.
SELECT memory_object_address
, pages_in_bytes
, bytes_used
, type
FROM sys.dm_os_memory_objects WHERE type LIKE '%xtp%'
Output sampel
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
Untuk informasi selengkapnya, lihat sys.dm_os_memory_objects (Transact-SQL).
Memori yang digunakan oleh mesin OLTP Dalam Memori di seluruh instans
Memori yang dialokasikan untuk mesin OLTP Dalam Memori dan objek yang dioptimalkan memori dikelola dengan cara yang sama seperti konsumen memori lain dalam instans SQL Server. Petugas jenis MEMORYCLERK_XTP akun untuk semua memori yang dialokasikan untuk mesin OLTP Dalam Memori. Gunakan kueri berikut untuk menemukan semua memori yang digunakan oleh mesin OLTP Dalam Memori.
-- 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%'
Contoh output berikut menunjukkan bahwa memori yang dialokasikan adalah memori tingkat sistem 18 MB dan 1358 MB yang dialokasikan ke database_id = 5. Karena database ini dipetakan ke kumpulan sumber daya khusus, memori ini diperhitungkan dalam kumpulan sumber daya tersebut.
type name memory_node_id pages_MB
-------------------- ---------- -------------- --------------------
MEMORYCLERK_XTP Default 0 18
MEMORYCLERK_XTP DB_ID_5 0 1358
MEMORYCLERK_XTP Default 64 0
Untuk informasi selengkapnya, lihat sys.dm_os_memory_clerks.
3. Kelola memori yang dikonsumsi oleh objek yang dioptimalkan memori
Anda dapat mengontrol total memori yang digunakan oleh tabel yang dioptimalkan memori dengan mengikatnya ke kumpulan sumber daya bernama. Untuk informasi selengkapnya, lihat Mengikat database dengan tabel yang dioptimalkan memori ke kumpulan sumber daya.
Pecahkan masalah memori
Pemecahan masalah memori adalah proses tiga langkah:
Identifikasi berapa banyak memori yang digunakan oleh objek dalam database atau instans Anda. Anda dapat menggunakan serangkaian alat pemantauan yang kaya yang tersedia untuk tabel yang dioptimalkan memori seperti yang dijelaskan sebelumnya. Misalnya, lihat kueri sampel pada DMV
sys.dm_db_xtp_table_memory_statsatausys.dm_os_memory_clerks.Tentukan bagaimana konsumsi memori tumbuh dan berapa banyak ruang kepala yang tersisa. Dengan memantau konsumsi memori secara berkala, Anda dapat mengetahui bagaimana penggunaan memori tumbuh. Misalnya, jika Anda telah memetakan database ke kumpulan sumber daya bernama, Anda dapat memantau penghitung kinerja Memori Yang Digunakan (KB) untuk melihat bagaimana penggunaan memori tumbuh.
Ambil tindakan untuk mengurangi potensi masalah memori. Untuk informasi selengkapnya, lihat Mengatasi Masalah Kehabisan Memori.