Distriggersndo il hyperthreading migliorare le performance dell'installazione di SQL Server

Riguardo a: Saggezza attuale su SQL Server e Hyperthreading

Recentemente abbiamo aggiornato il nostro server di database di Windows 2008 R2 da un X5470 a un X5560 . La teoria è che entrambe le CPU hanno performance molto simili, se nulla è il X5560 leggermente più veloce.

Tuttavia, le performance di SQL Server 2008 R2 sono state piuttosto male nell'ultimo giorno o così e l'utilizzo della CPU è stato abbastanza alto.

L'aspettativa di vita della pagina è enorme, stiamo ottenendo quasi 100% di cache per le pagine, quindi la memory non è un problema.

Quando ho corso:

SELECT * FROM sys.dm_os_wait_stats order by signal_wait_time_ms desc 

Ho ottenuto:

 wait_type waiting_tasks_count wait_time_ms max_wait_time_ms signal_wait_time_ms
 -------------------------------------------------- ---------- -------------------- -------------------- -------------------- --------------------
 XE_TIMER_EVENT 115166 2799125790 30165 2799125065
 REQUEST_FOR_DEADLOCK_SEARCH 559393 2799053973 5180 2799053973
 SOS_SCHEDULER_YIELD 152289883 189948844 960 189756877
 CXPACKET 234638389 2383701040 141334 118796827
 SLEEP_TASK 170743505 1525669557 1406 76485386
 LATCH_EX 97301008 810738519 1107 55093884
 LOGMGR_QUEUE 16525384 2798527632 20751319 4083713
 WRITELOG 16850119 18328365 1193 2367880
 PAGELATCH_EX 13254618 8524515 11263 1670113
 ASYNC_NETWORK_IO 23954146 6981220 7110 1475699

 (10 righe interessate)

Ho anche corso

 -- Isolate top waits for server instance since last restart or statistics clear WITH Waits AS ( SELECT wait_type, wait_time_ms / 1000. AS [wait_time_s], 100. * wait_time_ms / SUM(wait_time_ms) OVER() AS [pct], ROW_NUMBER() OVER(ORDER BY wait_time_ms DESC) AS [rn] FROM sys.dm_os_wait_stats WHERE wait_type NOT IN ('CLR_SEMAPHORE','LAZYWRITER_SLEEP','RESOURCE_QUEUE', 'SLEEP_TASK','SLEEP_SYSTEMTASK','SQLTRACE_BUFFER_FLUSH','WAITFOR','LOGMGR_QUEUE', 'CHECKPOINT_QUEUE','REQUEST_FOR_DEADLOCK_SEARCH','XE_TIMER_EVENT','BROKER_TO_FLUSH', 'BROKER_TASK_STOP','CLR_MANUAL_EVENT','CLR_AUTO_EVENT','DISPATCHER_QUEUE_SEMAPHORE', 'FT_IFTS_SCHEDULER_IDLE_WAIT','XE_DISPATCHER_WAIT', 'XE_DISPATCHER_JOIN')) SELECT W1.wait_type, CAST(W1.wait_time_s AS DECIMAL(12, 2)) AS wait_time_s, CAST(W1.pct AS DECIMAL(12, 2)) AS pct, CAST(SUM(W2.pct) AS DECIMAL(12, 2)) AS running_pct FROM Waits AS W1 INNER JOIN Waits AS W2 ON W2.rn <= W1.rn GROUP BY W1.rn, W1.wait_type, W1.wait_time_s, W1.pct HAVING SUM(W2.pct) - W1.pct < 95; -- percentage threshold 

E ho avuto

 wait_type wait_time_s pct running_pct
 CXPACKET 554821.66 65,82 65,82
 LATCH_EX 184123.16 21.84 87.66
 SOS_SCHEDULER_YIELD 37541.17 4.45 92.11
 PAGEIOLATCH_SH 19018.53 2.26 94.37
 FT_IFTSHC_MUTEX 14306.05 1.70 96.07

Ciò mostra enormi quantità di tempo di sincronizzazione delle query che coinvolgono il parallelismo (alto CXPACKET). Inoltre, aneddotalmente molte di queste query problema vengono eseguite su più core (non abbiamo nessun suggerimento MAXDOP ovunque nel nostro codice)

Il server non è stato sotto carico per più di un giorno o così. Stiamo provando una grande quantità di varianza con le esecuzioni di query, in genere molte query sembrano essere più lente che erano sul nostro precedente server DB e la CPU è veramente alta.

Distriggersndo l'aiuto di Hyperthreading per ridurre l'utilizzo della CPU e aumentare il throughput?

8 Solutions collect form web for “Distriggersndo il hyperthreading migliorare le performance dell'installazione di SQL Server”

Sento ancora che l' esame del carico di lavoro specifico , come per la risposta originale, è l'unico modo per essere sicuri. Non è una risposta ideale quando si sta tentando di sintonizzare un sistema di produzione (quindi mi chiederei se fosse ansible get un testbed identico in sisthemes in cui sia la performance sia la disponibilità), ma è l'unico a cui sono davvero confortevole con.

Possiamo parlare della teoria della questione se Hyperthreading wheresse o no far ferire o migliorare le cose in generale (mi sembra che sia più probabile che danneggiare che aiutare i server in modo tale da distriggersre una distribuzione "generica") ma c'è solo un modo per vedere sicuramente se sta andando a fare la differenza nel tuo caso specifico, e questo è provarlo e vedere.

Sono d'accordo

  • al meglio la raccomandazione è "provare HyperThreading sul carico di lavoro e vedere cosa succede". Facciamo questo adesso mentre scrivo, e … non è buono!
  • probabilmente dovresti sempre iniziare con HyperThreading disabilitato, in quanto è più sicuro

Sembra che dovremmo sintonizzare due cose:

  1. MAXDOP (massimo gradi di parallelo). Tutto ciò che leggo indica che avere questo senza limiti è probabilmente una ctriggers idea e la documentazione di Microsoft dice:

    Impostando questa opzione [MAXDOP] su un valore maggiore [di 8] spesso provoca il consumo di risorse e il degrado delle performance indesiderati.

    nulla di più di 8 non è generalmente raccomandato .. quindi ho impostato a 4 per ora. Inizialmente era zero (non limitato).

  2. Soglia di costo per il parallelismo. A quanto pare il default di 5 qui è considerato un default piuttosto basso in base a alcuni post MVP di SQL che ho trovato – possiamo ottimizzarlo per ridurre il parallelismo che è persino tentato dallo scheduler.

Ma sinceramente questi si sentono come soluzioni alternative; Penso che la vera soluzione per il nostro carico di lavoro (full-text indice pesante) è quello di distriggersre HT.

Anandtech ha scoperto che con il carico puro di lettura, ha ferito un po ', e con un carico pesante di scrittura, è stato un po' una vittoria. Non ho visto nulla per farmi pensare che ti farà un colpo molto peggiore del -5%, o una vittoria molto meglio del 15%. Nota che cosa con un Atom, è una grande vittoria, ma è una CPU molto strana.

Tutto quello che hai cambiato è stata la CPU? È passato da cache di 12 MB e 4 thread, quindi 3 MB di cache per thread, 8 MB di cache e 8 thread, quindi 1 MB per thread. Ora, che è troppo semplice, ma scommetto che è ciò che ti uccide, hai eseguito query in cache e ora li esegui dalla RAM perché hanno bisogno di più di 1 MB, ma less di 3 MB. Spegnere HT probabilmente aiuterà, ma ritornerei alla vecchia CPU. Spegni HT, e ottieni 2MB per thread, ma se il tuo carico di lavoro scompare con tanto, non aiuterà. Può darsi che la vecchia CPU di cache di 12 MB sia molto più veloce per il tuo carico di lavoro.

Vorrei provare a spegnere HT e vedere se è un miglioramento, ma sospetto che la cache sia re per il tuo carico di lavoro e potrebbe essere necessario tornare al chip da 12 MB.

Iperthreading è al massimo solo un modo di astrazione che consente di passare dal sistema operativo e di metterlo in procinto, con accesso diretto alla cache L1 e L2, rendendo più veloce il task di commutare un crapload.

I test con VMWare hanno indicato che la distriggerszione di HT non ha fatto differenza discerne sotto il carico standard e un aumento del 5% in termini di carico pesante, a causa del fatto che ESXi è abbastanza intelligente per conoscere la differenza tra il thread "vero" e il thread "falso" (c'è molto di più, ma in termini di laici). SQL Server 2005 non è abbastanza intelligente, ma combinato con un sistema operativo aggiornato non dovrebbe avere un piccolo vantaggio per disabilitare HT.

Tutto quello che ho detto, sono d'accordo con Ronald che probabilmente sarà la tua cache L2. Un calo del 33% della dimensione della cache è sostanziale, e quando specifichiamo i nostri server SQL, continuiamo sempre a cache su velocità di clock raw each volta.

Sulla base della mia esperienza, HT stava intraprendendo per sempre le operazioni di I / O sui miei nodes attivi in ​​un cluster di Windows 2008 R2 (in esecuzione di SQL Server 2008 R2). Un fatto interessante è stato che non era né riflessa né nelle statistiche di attesa né nel pssdiag che ho eseguito per il supporto di Microsoft.

Il modo in cui notai un basso I / O era solo guardando i contatori di sistema per il disco fisico. Come ha sottolineato Sam, ho scritto qui e qui

Se NON si verificano problemi di I / O e sono CPU vincolati, suggerisco di iniziare in questo modo:

Indica quali processi e blocchi di T-SQL stanno causando l'utilizzo della CPU più. Nella nostra esperienza, dopo aver risolto il problema con l'I / O (spegnendo HT), abbiamo identificato codice che stava eseguendo terribilmente nel 2008 R2 e facendo bene nel 2005. Ho scritto qui .

Mentre sotto carico elevato, eseguire sp_whoisactive di Adam Machanic. Puoi scaricarlo da qui . Abbiamo sperimentato un utilizzo molto elevato della CPU a causa della quantità eccessiva di letture logiche (20 milioni per query) a causa di un piano veramente difettoso. I nostri processi stavano eseguendo anti-semi join con tavoli che erano partizionati.

La mia prossima raccomandazione è di eseguire il profiler per identificare un insieme di codice T-SQL che sono entrambi alti in letture logiche di I / O e CPU.

Con i passaggi sopra abbiamo potuto sintonizzare i processi offendosi e passare dall'utilizzo CPU sostenuto dell'85% a quasi nulla.

Buona fortuna e vi prego di sentirmi libera di farmi una linea se trovi una correzione come vorrei aggiungere il caso al mio blog.

Grazie

Oscar

Se HT sia buono o cattivo è difficile da individuare.

Dipende in realtà dal model di carico del server basato sull'esperienza e sulla lettura. Cioè quando colpisce le performance è così male : altrimenti non ne accorgi.

La teoria che ho letto è che le discussioni condividono la cache, il che significa che in condizioni avverse each thread può sovrascrivere la cache dell'altro thread. Se non hai molto parallelismo, o il tuo carico è tante brevi interrogazioni, allora non può interessarti.

Ho provato con MAXDOP e affinità del processre (nel mio ultimo ruolo reale di DBA su SQL Server 2000) ma non avrei potuto trovare nulla di concreto: ma solo per il mio negozio in quel momento.

Come prova rapida, è ansible impostare l'affinità del processre per utilizzare solo core fisici (i numbers inferiori) e vedere cosa succede.

Tuttavia, al massimo perdi metà dei tuoi nuclei. Oggi che non import rispetto a quello che stavo giocando con qualche anno fa quando era 2 vs 4 o 4 vs 8. Ora è 8 vs 16 o 16 vs 32.

Modifica: un test di Slava Oks

Purtroppo, non credo che avrai una risposta più definita di "provare a girare il hyperthreading e vedere se ciò aiuta".

Nonostante la risposta utile da Jonathan nel mio thread originale (che hai collegato alla tua domanda), non sono mai riuscito a get alcuna prova definitiva sull'impatto di HT sui server specifici che stavo indagando. Nel mio caso, i server erano già previsti per la sostituzione, quindi semplicemente lasciamo che tali sostituzioni "prendano cura del problema" per così dire.

Il mio consiglio:

Prova un'impostazione di MAX Level of Parallelism a livello di server di 1 . Il parallelo su SQL è più utile per query di esecuzione più grandi e più lunghe, e il tuo carico (presumo) consiste in un numero enorme di query più piccole comunque. Ciò dovrebbe eliminare completamente CXPACKET attende. Ciò potrebbe rendere alcune query individuali eseguite leggermente più a lungo, ma dovrebbe consentire più "throughput" di query totali sul server.

Ho avuto buoni risultati facendo questo su server OLTP. Altri tipi di server (server di reporting, server di elaborazione, data warehousing) hanno sicuramente bisogno di MAXDOP set higher.

E solo per essere chiari, questa impostazione consentirebbe a SQL di utilizzare più thread per each singola tabella in un JOIN, in modo da non eliminare completamente il parallelismo.

Alless vale la pena provare, poiché questa modifica di impostazione ha effetto immediato e non richiede neppure di riavviare il servizio SQL: http://msdn.microsoft.com/en-us/library/ms181007.aspx
Questo significa che potresti tornare indietro immediatamente se le cose cominciarono ad andare all'inferno.

Spegnimento del hyperthreading nel BIOS richiederebbe un riavvio completo del server, quindi è un po 'più rischioso.

Per il record, abbiamo anche avuto performance impreviste male dopo un aggiornamento del server. È risultato che sia dovuto a problemi con il risparmio energetico del BIOS e della CPU. L'impostazione predefinita sul server (HP) era quella di ignorare il controllo OS della velocità della CPU e di utilizzare il proprio algorithm. Cambiando questo al controllo OS e aggiornando il BIOS, sono stati migliorati significativi. C'erano alcune note di rilascio (non sono in grado di trovarle) che c'era un bug del BIOS che stava bloccando la CPU allo stato di performance più basso.

https://serverfault.com/a/196329/6390

Suggerimenti per Linux e Windows Server, quali Ubuntu, Centos, Apache, Nginx, Debian e argomenti di rete.