El CPU de tu SQL Server está muy alto y no sabés por dónde empezar. Antes de reiniciar nada, hay un proceso claro para encontrar la causa real y bajarlo — sin tocar lo que no hay que tocar.
En esta guía y video te muestro exactamente lo que hago en mis auditorías cuando me llaman por este problema.
Video explicativo paso a paso:
¿Por qué el CPU está tan alto? Las causas más frecuentes
El consumo de CPU es solo un sintoma, debemos detectar la enfermedad las cuales pueden ser:
- Pocos recursos: Servidores o servicios en azure que tienen muy pocos recursos
- Configuración de la instancia: MAXDOP o umbral de paralelismo mal configurados — esta es una de las causas más comunes y más fácil de corregir.
- Falta de índices: A mayor consumo de I/O por mayor consumo de CPU
- Problemas de diseño: Funciones en los WHERE, Order BY sin TOP, SELECT * sin sentido, conversiones implícitas, etc.
- Mantenimiento: Estadísticas desactualizadas generan malos planes
- Parameter sniffing: Planes compilados en cache de forma ineficiente
Paso 1 – Confirmar que SQL Server es el problema
Antes de tomar alguna medida como optimizar consultas o cambiar parámetros de la instancia, debemos estar muy seguros que el problema de consumo de CPU es de nuestro motor y no de otra aplicación (antivirus, agendes u otras aplicaciones).
Si tenés acceso al servidor, revisá el Resource Monitor o el Performance Monitor. O ejecutá esta consulta directamente en SSMS
DECLARE @ts_now bigint = (SELECT ms_ticks FROM sys.dm_os_sys_info WITH (NOLOCK));
SELECT TOP(60) SQLProcessUtilization AS [SQL Server Process CPU Utilization],
SystemIdle AS [System Idle Process],
100 - SystemIdle - SQLProcessUtilization AS [Other Process CPU Utilization],
DATEADD(ms, -1 * (@ts_now - [timestamp]), GETDATE()) AS [Event Time]
FROM (SELECT record.value('(./Record/@id)[1]', 'int') AS record_id,
record.value('(./Record/SchedulerMonitorEvent/SystemHealth/SystemIdle)[1]', 'int')
AS [SystemIdle],
record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int')
AS [SQLProcessUtilization], [timestamp]
FROM (SELECT [timestamp], CONVERT(xml, record) AS [record]
FROM sys.dm_os_ring_buffers WITH (NOLOCK)
WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR'
AND record LIKE N'%<SystemHealth>%') AS x) AS y
ORDER BY record_id DESC OPTION (RECOMPILE);
Lo que te muestra: el % de CPU que está usando SQL Server o Azure SQL versus el resto del sistema, con historial de los últimos 60 minutos. Si SQL Server está por encima del 80% de forma sostenida, el problema es del motor.
Paso 2 – Revisar los Waits: encontrar la causa raíz
Lo que yo hago primero es revisar los Waits (Tiempos de espera del motor) y buscar si aparece en los primeros lugares Waits como: CXPACKET, CXCONSUMER, THREADPOOL, SOS_SCHEDULER_YIELD .
WITH [Waits]
AS (SELECT wait_type, wait_time_ms/ 1000.0 AS [WaitS],
(wait_time_ms - signal_wait_time_ms) / 1000.0 AS [ResourceS],
signal_wait_time_ms / 1000.0 AS [SignalS],
waiting_tasks_count AS [WaitCount],
100.0 * wait_time_ms / SUM (wait_time_ms) OVER() AS [Percentage],
ROW_NUMBER() OVER(ORDER BY wait_time_ms DESC) AS [RowNum]
FROM sys.dm_os_wait_stats WITH (NOLOCK)
WHERE [wait_type] NOT IN (
N'AZURE_IMDS_VERSIONS',
N'BROKER_EVENTHANDLER', N'BROKER_RECEIVE_WAITFOR', N'BROKER_TASK_STOP',
N'BROKER_TO_FLUSH', N'BROKER_TRANSMITTER', N'CHECKPOINT_QUEUE',
N'CHKPT', N'CLR_AUTO_EVENT', N'CLR_MANUAL_EVENT', N'CLR_SEMAPHORE', N'CXCONSUMER',
N'DBMIRROR_DBM_EVENT', N'DBMIRROR_EVENTS_QUEUE', N'DBMIRROR_WORKER_QUEUE',
N'DBMIRRORING_CMD', N'DIRTY_PAGE_POLL', N'DISPATCHER_QUEUE_SEMAPHORE',
N'EXECSYNC', N'FSAGENT', N'FT_IFTS_SCHEDULER_IDLE_WAIT', N'FT_IFTSHC_MUTEX',
N'HADR_CLUSAPI_CALL', N'HADR_FILESTREAM_IOMGR_IOCOMPLETION', N'HADR_LOGCAPTURE_WAIT',
N'HADR_NOTIFICATION_DEQUEUE', N'HADR_TIMER_TASK', N'HADR_WORK_QUEUE',
N'KSOURCE_WAKEUP', N'LAZYWRITER_SLEEP', N'LOGMGR_QUEUE',
N'MEMORY_ALLOCATION_EXT', N'ONDEMAND_TASK_QUEUE',
N'PARALLEL_REDO_DRAIN_WORKER', N'PARALLEL_REDO_LOG_CACHE', N'PARALLEL_REDO_TRAN_LIST',
N'PARALLEL_REDO_WORKER_SYNC', N'PARALLEL_REDO_WORKER_WAIT_WORK',
N'PREEMPTIVE_HADR_LEASE_MECHANISM', N'PREEMPTIVE_SP_SERVER_DIAGNOSTICS',
N'PREEMPTIVE_OS_LIBRARYOPS', N'PREEMPTIVE_OS_COMOPS', N'PREEMPTIVE_OS_CRYPTOPS',
N'PREEMPTIVE_OS_PIPEOPS', N'PREEMPTIVE_OS_AUTHENTICATIONOPS',
N'PREEMPTIVE_OS_GENERICOPS', N'PREEMPTIVE_OS_VERIFYTRUST',
N'PREEMPTIVE_OS_DELETESECURITYCONTEXT', N'PREEMPTIVE_OS_REPORTEVENT',
N'PREEMPTIVE_OS_FILEOPS', N'PREEMPTIVE_OS_DEVICEOPS', N'PREEMPTIVE_OS_QUERYREGISTRY',
N'PREEMPTIVE_OS_WRITEFILE', N'PREEMPTIVE_OS_WRITEFILEGATHER',
N'PREEMPTIVE_XE_CALLBACKEXECUTE', N'PREEMPTIVE_XE_DISPATCHER',
N'PREEMPTIVE_XE_GETTARGETSTATE', N'PREEMPTIVE_XE_SESSIONCOMMIT',
N'PREEMPTIVE_XE_TARGETINIT', N'PREEMPTIVE_XE_TARGETFINALIZE',
N'POPULATE_LOCK_ORDINALS',
N'PWAIT_ALL_COMPONENTS_INITIALIZED', N'PWAIT_DIRECTLOGCONSUMER_GETNEXT',
N'PWAIT_EXTENSIBILITY_CLEANUP_TASK',
N'QDS_PERSIST_TASK_MAIN_LOOP_SLEEP', N'QDS_ASYNC_QUEUE',
N'QDS_CLEANUP_STALE_QUERIES_TASK_MAIN_LOOP_SLEEP', N'REQUEST_FOR_DEADLOCK_SEARCH',
N'RESOURCE_QUEUE', N'SERVER_IDLE_CHECK', N'SLEEP_BPOOL_FLUSH', N'SLEEP_DBSTARTUP',
N'SLEEP_DCOMSTARTUP', N'SLEEP_MASTERDBREADY', N'SLEEP_MASTERMDREADY',
N'SLEEP_MASTERUPGRADED', N'SLEEP_MSDBSTARTUP', N'SLEEP_SYSTEMTASK', N'SLEEP_TASK',
N'SLEEP_TEMPDBSTARTUP', N'SNI_HTTP_ACCEPT', N'SOS_WORK_DISPATCHER',
N'SP_SERVER_DIAGNOSTICS_SLEEP', N'SOS_WORKER_MIGRATION', N'VDI_CLIENT_OTHER',
N'SQLTRACE_BUFFER_FLUSH', N'SQLTRACE_INCREMENTAL_FLUSH_SLEEP', N'SQLTRACE_WAIT_ENTRIES',
N'STARTUP_DEPENDENCY_MANAGER',
N'WAIT_FOR_RESULTS', N'WAITFOR', N'WAITFOR_TASKSHUTDOWN', N'WAIT_XTP_HOST_WAIT',
N'WAIT_XTP_OFFLINE_CKPT_NEW_LOG', N'WAIT_XTP_CKPT_CLOSE', N'WAIT_XTP_RECOVERY',
N'XE_BUFFERMGR_ALLPROCESSED_EVENT', N'XE_DISPATCHER_JOIN',
N'XE_DISPATCHER_WAIT', N'XE_LIVE_TARGET_TVF', N'XE_TIMER_EVENT')
AND waiting_tasks_count > 0)
SELECT
MAX (W1.wait_type) AS [WaitType],
CAST (MAX (W1.Percentage) AS DECIMAL (5,2)) AS [Wait Percentage]
FROM Waits AS W1
INNER JOIN Waits AS W2
ON W2.RowNum <= W1.RowNum
GROUP BY W1.RowNum, W1.wait_type
HAVING SUM (W2.Percentage) - MAX (W1.Percentage) < 99 -- percentage threshold
OPTION (RECOMPILE);

En producción me encuentro con que el 60% de los casos de CPU alto tienen CXPACKET arriba — y se resuelven en 10 minutos ajustando dos parámetros (cost threshold for parallelism) y Max Degree Of Parallellism .
Paso 3 – Ajustar el paralelismo (MAXDOP y umbral)
Si confirmamos que el problema viene por paralelismo lo que debemos hacer primero es revisar como lo tenemos configurado para luego ajustarlo

El valor por defecto es 5, un número totalmente ridículo y que viene desde hace varios años
Cuidado: ajustar el MAXDOP es simple porque se hace por buenas prácticas y según las guias de Microsoft, pero el umbral no es un valor muchas veces fácil de definir.
Si recomiendo que este por encima de 50 pero muchas veces no alcanza ni con eso, debes ajustar y medir.
Cambiar algunos de estos dos parámetros NO requieren reinício de la instancia
Paso 4 – Identificar las consultas que están comiendo CPU ahora
Aca es un punto clave, detectar que cosas están comiendo el CPU de nuestro motor.
¿Qué está consumiendo CPU en este momento?
Hay várias formas de verlo como (Monitor de actividad, querys internas o reportes desde el SSMS) yo prefiero usar el famoso script sp_whoisactive el cual me da mucha información valiosa, si no lo tenes instalado te lo recomiendo de verdad.
Entonces uso este código de preferencia y miro los que mas CPU me están ahora consumiendo
exec sp_whoisactive @sort_order = '[CPU] DESC'
¿Qué consultas consumen CPU de forma recurrente?
Bueno aca es muy importante tener el Query Store activo en cada una de tus bases de datos, sin el también se puede hacer pero francamente vas a trabajar mucho mas porque necesitas poner un Evento Extendido
Yo lo uso mucho al QS y lo que hago es analizar en las bases diferentes rangos de tiempos para ver que procesos y consultas se están comiendo mi CPU
Para habilitarlo es muy simple y si no lo tenes te recomiendo que primero lo activemos y luego dejes esperar por lo menos medio dia para tener buenos datos


Yo aca juego con los tiempos (el QS te muestra la última hora pero lo podes cambiar desde configuraciones )


Lo que nadie te dice sobre el CPU al 100%
Cuando el CPU al 100% aparece en sistemas críticos, un DBA especializado en SQL Server puede diagnosticar la causa sin reiniciar a ciegas.
El error más común que veo en empresas es este: el DBA detecta el problema, mata la consulta culpable, y listo — hasta la próxima vez. El CPU baja por unas horas y vuelve a subir.
El problema no es la consulta. El problema es que el entorno está configurado para que esa consulta se comporte así.
Sin ajustar el MAXDOP, sin habilitar Query Store, sin revisar los índices — el incendio se apaga hoy y se vuelve a prender mañana.
Lo que yo hago con mis clientes es atacar la emergencia y dejar el entorno configurado para que no vuelva a pasar.
Son cosas distintas y hay que hacer las dos.
Preguntas frecuentes
¿Cómo sé si el problema de CPU es de SQL Server o de otra aplicación?
Ejecutá la query contra sys.dm_os_ring_buffers que está en el Paso 1. Te muestra el % de CPU del proceso de SQL Server separado del resto del sistema. Si SQL Server está por debajo del 50% y el total del servidor está al 100%, el problema es de otra aplicación.
¿Qué valor de MAXDOP debo usar?
Depende de la cantidad de cores y del tipo de carga. Como regla general: en servidores con hasta 8 cores, MAXDOP = número de cores. En servidores con más de 8 cores, MAXDOP entre 4 y 8. Pero siempre hay que medirlo con Wait Stats antes y después del cambio.
¿Qué umbral de paralelismo debo usar?
Hoy en día, como mínimo 50, pero cada instancia es diferente: tengo clientes con valores de 200, 400 y más.
¿El Query Store impacta en el rendimiento?
Mínimamente — entre 1% y 3% de overhead según Microsoft. En todos los clientes que administro está habilitado.
¿Puedo bajar el CPU sin reiniciar SQL Server?
Sí. Todos los cambios de esta guía (ajuste de MAXDOP y del umbral de paralelismo) se aplican sin reiniciar el servicio.
¿Tu SQL Server tiene el CPU al 100% y no encontrás la causa?
En Triggerdb Consulting hacemos auditorías e implementación de las mejoras sobre rendimiento en SQL Server y Azure SQL — analizamos Waits, configuración, consultas críticas e índices, te entregamos un informe , un plan de mejora priorizado y te acompañamos a implementarlo en tu entorno productivo.
Si el problema es urgente, también podemos ayudarte o armar un abono mensual de soporte y monitoreo.
Agendemos una llamada de 15 minutos si te interesa Formulario .

