Binda en databas med Memory-Optimized tabeller till en resurspool

Artikel
01/02/2025

gäller för:SQL Server

En resurspool representerar en delmängd av fysiska resurser som kan styras. Som standard är SQL Server-databaser bundna till och använder resurserna i standardresurspoolen. För att skydda SQL Server från att dess resurser förbrukas av en eller flera minnesoptimerade tabeller och för att förhindra att andra minnesanvändare förbrukar minne som behövs av minnesoptimerade tabeller bör du skapa en separat resurspool för att hantera minnesförbrukning för databasen med minnesoptimerade tabeller.

En databas kan bara bindas till en resurspool. Du kan dock binda flera databaser till samma pool. SQL Server tillåter bindning av en databas utan minnesoptimerade tabeller till en resurspool, men den har ingen effekt. Du kanske vill binda en databas till en namngiven resurspool om du i framtiden kanske vill skapa minnesoptimerade tabeller i databasen.

Innan du kan binda en databas till en resurspool måste både databasen och resurspoolen finnas. Bindningen börjar gälla nästa gång databasen är online. Mer information finns i databastillstånd.

Information om resurspooler finns i Resource Governor-resurspoolen.

Steg för att binda en databas till en resurspool

Annat innehåll i det här ämnet

Skapa databasen och resurspoolen

Du kan skapa databasen och resurspoolen i valfri ordning. Det viktiga är att båda finns innan databasen binds till resurspoolen.

Skapa databasen

Följande Transact-SQL skapar en databas med namnet IMOLTP_DB som innehåller en eller flera minnesoptimerade tabeller. Sökvägen <driveAndPath> måste existera innan detta kommando körs.

CREATE DATABASE IMOLTP_DB  
GO  
ALTER DATABASE IMOLTP_DB ADD FILEGROUP IMOLTP_DB_fg CONTAINS MEMORY_OPTIMIZED_DATA  
ALTER DATABASE IMOLTP_DB ADD FILE( NAME = 'IMOLTP_DB_fg' , FILENAME = 'c:\data\IMOLTP_DB_fg') TO FILEGROUP IMOLTP_DB_fg;  
GO

Fastställa minimivärdet för MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT

När du har fastställt minnesbehoven för dina minnesoptimerade tabeller måste du bestämma vilken procentandel av tillgängligt minne du behöver och ange minnesprocenterna till det värdet eller högre.

Exempel:
I det här exemplet förutsätter vi att du från dina beräkningar har fastställt att dina minnesoptimerade tabeller och index behöver 16 GB minne. Anta att du har 32 GB minne incheckat för din användning.

Vid första anblicken kan det verka som om du måste ange MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT till 50 (16 är 50% av 32). Det skulle dock inte ge dina minnesoptimerade tabeller tillräckligt med minne. Om du tittar på tabellen nedan (procent av det minne som är tillgängligt för minnesoptimerade tabeller och index) ser vi att om det finns 32 GB incheckat minne är endast 80% av det tillgängligt för minnesoptimerade tabeller och index. Därför beräknar vi min- och maxprocenterna baserat på det tillgängliga minnet, inte det incheckade minnet.

memoryNeeded = 16
memoryCommitted = 32
availablePercent = 0.8
memoryAvailable = memoryCommitted * availablePercent
percentNeeded = memoryNeeded / memoryAvailable

Ersätter med riktiga tal:
percentNeeded = 16 / (32 * 0.8) = 16 / 25.6 = 0.625

Därför behöver du minst 62,5% av det tillgängliga minnet för att uppfylla kravet på 16 GB för dina minnesoptimerade tabeller och index. Eftersom värdena för MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT måste vara heltal anger vi dem till minst 63%.

Skapa en resurspool och konfigurera minne

När du konfigurerar minne för minnesoptimerade tabeller bör kapacitetsplaneringen göras baserat på MIN_MEMORY_PERCENT, inte på MAX_MEMORY_PERCENT. Mer information om MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT finns i ALTER RESOURCE POOL (Transact-SQL) . Detta ger mer förutsägbar minnestillgänglighet för minnesoptimerade tabeller eftersom MIN_MEMORY_PERCENT orsakar minnesbelastning för andra resurspooler för att se till att det respekteras. För att säkerställa att minnet är tillgängligt och hjälper till att undvika minnesbrist bör värdena för MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT vara desamma. Se procent av det minne som är tillgängligt för minnesoptimerade tabeller och index nedan för procentandelen minne som är tillgängligt för minnesoptimerade tabeller baserat på mängden incheckat minne.

Mer information om hur du arbetar i en VM-miljö finns i metodtips: Använda In-Memory OLTP i en VM-miljö.

Följande Transact-SQL kod skapar en resurspool med namnet Pool_IMOLTP med hälften av det tillgängliga minnet för dess användning. När poolen har skapats konfigureras Resource Governor om för att inkludera Pool_IMOLTP.

-- set MIN_MEMORY_PERCENT and MAX_MEMORY_PERCENT to the same value  
CREATE RESOURCE POOL Pool_IMOLTP   
  WITH   
    ( MIN_MEMORY_PERCENT = 63,   
    MAX_MEMORY_PERCENT = 63 );  
GO  
  
ALTER RESOURCE GOVERNOR RECONFIGURE;  
GO

Binda databasen till poolen

Använd systemfunktionen sp_xtp_bind_db_resource_pool för att binda databasen till resurspoolen. Funktionen tar två parametrar: databasnamnet och resurspoolens namn.

Följande Transact-SQL definierar en bindning av databasen IMOLTP_DB till resurspoolen Pool_IMOLTP. Bindningen träder inte i kraft förrän du har fört databasen online.

EXEC sp_xtp_bind_db_resource_pool 'IMOLTP_DB', 'Pool_IMOLTP'  
GO

Systemfunktionen sp_xtp_bind_db_resource_pool tar två strängparametrar: database_name och pool_name.

Bekräfta bindningen

Bekräfta bindningen och notera resurspoolens ID för IMOLTP_DB. Den bör inte vara NULL.

SELECT d.database_id, d.name, d.resource_pool_id  
FROM sys.databases d  
GO

Gör bindningen effektiv

Du måste ta databasen offline och online igen när du har bindt den till resurspoolen för att bindningen ska börja gälla. Om databasen var bunden till en annan pool tidigare tas det allokerade minnet bort från den tidigare resurspoolen och minnesallokeringarna för din minnesoptimerade tabell och index kommer nu från resurspoolen som nyligen är bunden till databasen.

USE master  
GO  
  
ALTER DATABASE IMOLTP_DB SET OFFLINE  
GO  
ALTER DATABASE IMOLTP_DB SET ONLINE  
GO  
  
USE IMOLTP_DB  
GO

Och nu är databasen bunden till resurspoolen.

Ändra MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT i en befintlig pool

Om du lägger till ytterligare minne på servern eller mängden minne som behövs för dina minnesoptimerade tabeller kan du behöva ändra värdet för MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT. Följande steg visar hur du ändrar värdet för MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT i en resurspool. Se avsnittet nedan för vägledning om vilka värden som ska användas för MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT. Mer information finns i avsnittet Best Practices: Using In-Memory OLTP in a VM environment (Använda In-Memory OLTP i en VM-miljö).

Använd ALTER RESOURCE POOL för att ändra värdet för både MIN_MEMORY_PERCENT och MAX_MEMORY_PERCENT.
Använd ALTER RESOURCE GOVERNOR för att konfigurera om resursguvernören med de nya värdena.

exempelkod

ALTER RESOURCE POOL Pool_IMOLTP  
WITH  
     ( MIN_MEMORY_PERCENT = 70,  
       MAX_MEMORY_PERCENT = 70 )   
GO  
  
-- reconfigure the Resource Governor  
ALTER RESOURCE GOVERNOR RECONFIGURE  
GO

Procentandel tillgängligt minne för minnesoptimerade tabeller och index

Om du mappar en databas med minnesoptimerade tabeller och en SQL Server-arbetsbelastning till samma resurspool anger Resource Governor ett internt tröskelvärde för In-Memory OLTP-användning så att användarna av poolen inte har konflikter om poolanvändningen. Generellt sett är tröskelvärdet för In-Memory OLTP-användning cirka 80% av poolen. I följande tabell visas faktiska tröskelvärden för olika minnesstorlekar.

När du skapar en dedikerad resurspool för In-Memory OLTP-databas måste du uppskatta hur mycket fysiskt minne du behöver för tabellerna i minnet när du har redovisat radversioner och datatillväxt. När du uppskattar det minne som behövs skapar du en resurspool med en procent av det allokerade målminnet för SQL Instance enligt kolumnen "committed_target_kb" i DMV sys.dm_os_sys_info. Du kan till exempel skapa en resurspool P1 med 40% av det totala minnet som är tillgängligt för instansen. Av dessa 40%får In-Memory OLTP-motorn en mindre andel för att lagra In-Memory OLTP-data. Detta görs för att se till att In-Memory OLTP inte förbrukar allt minne från den här poolen. Detta värde för den mindre procenten beror på avsatt målsattsminne. I följande tabell beskrivs minne som är tillgängligt för In-Memory OLTP-databas i en resurspool (namngiven eller standard) innan ett OOM-fel utlöses.

Målat tilldelat minne	Procent tillgängligt för minnesinterna tabeller
<= 8 GB	70%
<= 16 GB	75%
<= 32 GB	80%
<= 96 GB	85%
>96 GB	90%

Om ditt "målbekrälade minne" till exempel är 100 GB och du uppskattar att dina minnesoptimerade tabeller och index behöver 60 GB minne, sedan kan du skapa en resurspool med MAX_MEMORY_PERCENT = 67 (60 GB behövs / 0,90 = 66,667 GB – avrunda upp till 67 GB; 67 GB / 100 GB installerat = 67%) för att säkerställa att dina In-Memory OLTP-objekt har de 60 GB de behöver.

När en databas har bundits till en namngiven resurspool använder du följande fråga för att se minnesallokeringar i olika resurspooler.

SELECT pool_id  
     , Name  
     , min_memory_percent  
     , max_memory_percent  
     , max_memory_kb/1024 AS max_memory_mb  
     , used_memory_kb/1024 AS used_memory_mb   
     , target_memory_kb/1024 AS target_memory_mb  
   FROM sys.dm_resource_governor_resource_pools

Det här exemplet visar att minnet som tas av minnesoptimerade objekt är 1356 MB i resurspoolen, PoolIMOLTP, med en övre gräns på 2 307 MB. Den här övre gränsen styr det totala minne som kan tas av användar- och systemminnesoptimerade objekt som mappas till den här poolen.

Exempel på resultat
Dessa utdata kommer från databasen och tabellerna som vi skapade ovan.

pool_id     Name        min_memory_percent max_memory_percent max_memory_mb used_memory_mb target_memory_mb  
----------- ----------- ------------------ ------------------ ------------- -------------- ----------------   
1           internal    0                  100                3845          125            3845  
2           default     0                  100                3845          32             3845  
259         Pool_IMOLTP 0                  100                3845          1356           2307

Mer information finns i sys.dm_resource_governor_resource_pools (Transact-SQL).

Om du inte binder databasen till en namngiven resurspool är den bunden till "standardpoolen". Eftersom standardresurspoolen används av SQL Server för de flesta andra allokeringar kan man inte övervaka det minne som förbrukas av minnesoptimerade tabeller med DMV sys.dm_resource_governor_resource_pools korrekt för den specifika databasen.

Se även

sys.sp_xtp_bind_db_resource_pool (Transact-SQL)
sys.sp_xtp_unbind_db_resource_pool (Transact-SQL)
Resurskontrollant
resurspoolen Resource Governor
Skapa en resurspool
Ändra inställningar för resurspooler
Ta bort en resurspool

Dela via