Speichernutzung durch SQL Server

Wie überprüfe ich die Speichernutzung durch meinen SQL Server in der Produktionsbox? Ich verwende SQL Server 2016. Wenn ich den Task-Manager überprüfe, werden über 90% angezeigt. Ich denke nicht, dass dies die tatsächliche Speichernutzung durch SQL Server ist.

Ich habe ein SQL-Leistungstool grafana, das die CPU-Auslastung sehr viel weniger anzeigt als im Task-Manager. Ich habe den Ressourcenmonitor überprüft. Dort wird der durchschnittliche CPU-Wert angezeigt. Ich bin verwirrt, welcher Speicher für den SQL Server verwendet wird. Ich versuche festzustellen, ob der Speicherdruck ein Problem für einige meiner Probleme ist.

Kann jemand auf eine gute / richtige Erklärung verweisen.

Kann jemand auf eine gute / richtige Erklärung verweisen.

Zunächst möchte ich sagen, dass der Task-Manager kein korrekter Ort ist, um den Speicherverbrauch von SQL Server zu messen. Er gibt Ihnen keinen korrekten Wert an, wenn das SQL Server-Dienstkonto über die Berechtigung "Gesperrte Seiten im Speicher" (LPIM) verfügt. Dies liegt daran, dass der Task-Manager normalerweise Process Private bytesnachverfolgt, welcher Speicher ausgelagert und über die VirtualAlloc () -Funktion zugewiesen werden kann. Bei einem Dienstkonto mit LPIM-Speicher wird die Speicherzuweisung jedoch von der AWE-API durchgeführt, die NICHT pageable ist, sodass der Task-Manager ihn nicht nachverfolgt und dies zu Fehlern führen kann Wert.

Es ist ganz normal, dass SQL Server den ihm zugewiesenen Speicher verwendet, was häufig den Anschein hat, als würde viel Speicher verwendet, aber dies ist ganz normal. Keine Panik, wenn ein Tool eine geringe CPU-Auslastung aufweist und der Task-Manager einen hohen Arbeitsspeicher aufweist. Dies ist möglicherweise normal. Um zu wissen, wie viel physischen Speicher SQL Server verwendet, verwenden Sie bitte die folgende Abfrage

select
(physical_memory_in_use_kb/1024)Phy_Memory_usedby_Sqlserver_MB,
(locked_page_allocations_kb/1024 )Locked_pages_used_Sqlserver_MB,
(virtual_address_space_committed_kb/1024 )Total_Memory_UsedBySQLServer_MB,
process_physical_memory_low,
process_virtual_memory_low
from sys. dm_os_process_memory

Phy_Memory_usedby_Sqlserver_MB - Gibt den gesamten von SQL Server in MB verwendeten physischen Speicher an. Total_Memory_usedBy_SQLServer_MB- - Gibt den gesamten von SQL Server in MB verwendeten Arbeitsspeicher (RAM + Auslagerungsdatei ) an

Weitere Informationen darüber, warum der Task-Manager nicht verwendet werden sollte, finden Sie unter Spaß mit gesperrten Seiten, AWE, Task-Manager und Arbeitssatz.

"Ich versuche festzustellen, ob der Speicherdruck ein Problem für einige meiner Probleme ist."

sehr nützliches Skript: https://github.com/ktaranov/sqlserver-kit/blob/master/Scripts/SQLServer_Memory_Information.sql

Sie sehen eine ausführliche Speichernutzung:

https://www.sqlskills.com/blogs/glenn/sql-server-diagnostic-information-queries-for-november-2017/ SQL Server 2017-Diagnoseinformationsabfragen:
siehe Kommentar

-- Page Life Expectancy (PLE) value for each NUMA node in current instance  (Query 46) (PLE by NUMA Node)
SELECT @@SERVERNAME AS [Server Name], RTRIM([object_name]) AS [Object Name], instance_name, cntr_value AS [Page Life Expectancy]
FROM sys.dm_os_performance_counters WITH (NOLOCK)
WHERE [object_name] LIKE N'%Buffer Node%' -- Handles named instances
AND counter_name = N'Page life expectancy' OPTION (RECOMPILE);
------

-- PLE is a good measurement of internal memory pressure
-- Higher PLE is better. Watch the trend over time, not the absolute value

(Abfrage 14)

-- Good basic information about OS memory amounts and state  (Query 14) (System Memory)
SELECT total_physical_memory_kb/1024 AS [Physical Memory (MB)], 
       available_physical_memory_kb/1024 AS [Available Memory (MB)], 
       total_page_file_kb/1024 AS [Total Page File (MB)], 
       available_page_file_kb/1024 AS [Available Page File (MB)], 
       system_cache_kb/1024 AS [System Cache (MB)],
       system_memory_state_desc AS [System Memory State]
FROM sys.dm_os_sys_memory WITH (NOLOCK) OPTION (RECOMPILE);
------

-- You want to see "Available physical memory is high" for System Memory State
-- This indicates that you are not under external memory pressure

-- Possible System Memory State values:
-- Available physical memory is high
-- Physical memory usage is steady
-- Available physical memory is low
-- Available physical memory is running low
-- Physical memory state is transitioning

(47)

-- Memory Grants Pending value for current instance  (Query 47) (Memory Grants Pending)
SELECT @@SERVERNAME AS [Server Name], RTRIM([object_name]) AS [Object Name], cntr_value AS [Memory Grants Pending]
FROM sys.dm_os_performance_counters WITH (NOLOCK)
WHERE [object_name] LIKE N'%Memory Manager%' -- Handles named instances
AND counter_name = N'Memory Grants Pending' OPTION (RECOMPILE);
------

-- Run multiple times, and run periodically if you suspect you are under memory pressure
-- Memory Grants Pending above zero for a sustained period is a very strong indicator of internal memory pressure

(62)

-- Top Cached SPs By Total Logical Reads. Logical reads relate to memory pressure  (Query 62) (SP Logical Reads)
SELECT TOP(25) p.name AS [SP Name], qs.total_logical_reads AS [TotalLogicalReads], 
qs.total_logical_reads/qs.execution_count AS [AvgLogicalReads],qs.execution_count, 
ISNULL(qs.execution_count/DATEDIFF(Minute, qs.cached_time, GETDATE()), 0) AS [Calls/Minute], 
qs.total_elapsed_time, qs.total_elapsed_time/qs.execution_count AS [avg_elapsed_time],
CASE WHEN CONVERT(nvarchar(max), qp.query_plan) LIKE N'%<MissingIndexes>%' THEN 1 ELSE 0 END AS [Has Missing Index], 
FORMAT(qs.last_execution_time, 'yyyy-MM-dd HH:mm:ss', 'en-US') AS [Last Execution Time], 
FORMAT(qs.cached_time, 'yyyy-MM-dd HH:mm:ss', 'en-US') AS [Plan Cached Time]
-- ,qp.query_plan AS [Query Plan] -- Uncomment if you want the Query Plan
FROM sys.procedures AS p WITH (NOLOCK)
INNER JOIN sys.dm_exec_procedure_stats AS qs WITH (NOLOCK)
ON p.[object_id] = qs.[object_id]
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) AS qp
WHERE qs.database_id = DB_ID()
AND DATEDIFF(Minute, qs.cached_time, GETDATE()) > 0
ORDER BY qs.total_logical_reads DESC OPTION (RECOMPILE);
------

-- This helps you find the most expensive cached stored procedures from a memory perspective
-- You should look at this if you see signs of memory pressure

(63)

-- Top Cached SPs By Total Physical Reads. Physical reads relate to disk read I/O pressure  (Query 63) (SP Physical Reads)
SELECT TOP(25) p.name AS [SP Name],qs.total_physical_reads AS [TotalPhysicalReads], 
qs.total_physical_reads/qs.execution_count AS [AvgPhysicalReads], qs.execution_count, 
qs.total_logical_reads,qs.total_elapsed_time, qs.total_elapsed_time/qs.execution_count AS [avg_elapsed_time],
CASE WHEN CONVERT(nvarchar(max), qp.query_plan) LIKE N'%<MissingIndexes>%' THEN 1 ELSE 0 END AS [Has Missing Index],
FORMAT(qs.last_execution_time, 'yyyy-MM-dd HH:mm:ss', 'en-US') AS [Last Execution Time], 
FORMAT(qs.cached_time, 'yyyy-MM-dd HH:mm:ss', 'en-US') AS [Plan Cached Time]
-- ,qp.query_plan AS [Query Plan] -- Uncomment if you want the Query Plan 
FROM sys.procedures AS p WITH (NOLOCK)
INNER JOIN sys.dm_exec_procedure_stats AS qs WITH (NOLOCK)
ON p.[object_id] = qs.[object_id]
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) AS qp
WHERE qs.database_id = DB_ID()
AND qs.total_physical_reads > 0
ORDER BY qs.total_physical_reads DESC, qs.total_logical_reads DESC OPTION (RECOMPILE);
------

-- This helps you find the most expensive cached stored procedures from a read I/O perspective
-- You should look at this if you see signs of I/O pressure or of memory pressure

(64)

-- Top Cached SPs By Total Logical Writes (Query 64) (SP Logical Writes)
-- Logical writes relate to both memory and disk I/O pressure 
SELECT TOP(25) p.name AS [SP Name], qs.total_logical_writes AS [TotalLogicalWrites], 
qs.total_logical_writes/qs.execution_count AS [AvgLogicalWrites], qs.execution_count,
ISNULL(qs.execution_count/DATEDIFF(Minute, qs.cached_time, GETDATE()), 0) AS [Calls/Minute],
qs.total_elapsed_time, qs.total_elapsed_time/qs.execution_count AS [avg_elapsed_time],
CASE WHEN CONVERT(nvarchar(max), qp.query_plan) LIKE N'%<MissingIndexes>%' THEN 1 ELSE 0 END AS [Has Missing Index], 
FORMAT(qs.last_execution_time, 'yyyy-MM-dd HH:mm:ss', 'en-US') AS [Last Execution Time], 
FORMAT(qs.cached_time, 'yyyy-MM-dd HH:mm:ss', 'en-US') AS [Plan Cached Time]
-- ,qp.query_plan AS [Query Plan] -- Uncomment if you want the Query Plan 
FROM sys.procedures AS p WITH (NOLOCK)
INNER JOIN sys.dm_exec_procedure_stats AS qs WITH (NOLOCK)
ON p.[object_id] = qs.[object_id]
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) AS qp
WHERE qs.database_id = DB_ID()
AND qs.total_logical_writes > 0
AND DATEDIFF(Minute, qs.cached_time, GETDATE()) > 0
ORDER BY qs.total_logical_writes DESC OPTION (RECOMPILE);
------

-- This helps you find the most expensive cached stored procedures from a write I/O perspective
-- You should look at this if you see signs of I/O pressure or of memory pressure

PS Dies ist keine erschöpfende Antwort

Ich bin mir über das Tool grafana nicht sicher, aber wenn Sie die folgende Abfrage ausführen, wird der aktuell zugewiesene Speicher angezeigt

SELECT  
(physical_memory_in_use_kb/1024) AS Memory_usedby_Sqlserver_MB,  
(locked_page_allocations_kb/1024) AS Locked_pages_used_Sqlserver_MB,  
(total_virtual_address_space_kb/1024) AS Total_VAS_in_MB,  
process_physical_memory_low,  
process_virtual_memory_low  
FROM sys.dm_os_process_memory; 

Sie sollten den Task-Manager weglassen, da er in einigen Fällen die Speicherzuweisungsinformationen nicht ordnungsgemäß meldet, abhängig von den von der Anwendung verwendeten Speicherzuweisungsroutinen. Unter Betriebssystem sollten Sie mit perfmon gut umgehen können, da es die Speichernutzung ordnungsgemäß melden sollte. Sie können auch SQL-DMVs verwenden, die Speicherinformationen melden, z. B. sys.dm_os_sys_memory (je nach Ihren Anforderungen und der SQL Server-Version gibt es mehr speicherbezogene dmvs).

In diesem Artikel wird der Task-Manager erläutert, in dem die Verwendung von SQL Server-Memroy ungenau gemeldet wird:

LINK: Verwenden Sie nicht mehr den Task-Manager, um die SQL-Speichernutzung zu überprüfen