Gestione della concorrenza e del carico di lavoro in SQL Data WarehouseConcurrency and workload management in SQL Data Warehouse

Per fornire prestazioni stimabili e scalabili, Microsoft Azure SQL Data Warehouse consente di controllare i livelli di concorrenza e le allocazioni di risorse, come la memoria e la classificazione in ordine di priorità della CPU.To deliver predictable performance at scale, Microsoft Azure SQL Data Warehouse helps you control concurrency levels and resource allocations like memory and CPU prioritization. Questo articolo introduce i concetti di gestione della concorrenza e del carico di lavoro, spiegando in che modo entrambe le funzionalità sono state implementate e come vengono controllate nel data warehouse.This article introduces you to the concepts of concurrency and workload management, explaining how both features have been implemented and how you can control them in your data warehouse. La gestione del carico di lavoro di SQL Data Warehouse è concepita per facilitare il supporto di ambienti multiutente.SQL Data Warehouse workload management is intended to help you support multi-user environments. Non è concepita per i carichi di lavoro multi-tenant.It is not intended for multi-tenant workloads.

Limiti di concorrenzaConcurrency limits

SQL Data Warehouse consente un massimo di 1.024 connessioni simultanee.SQL Data Warehouse allows up to 1,024 concurrent connections. Tutte le 1.024 connessioni possono inviare query contemporaneamente.All 1,024 connections can submit queries concurrently. Tuttavia, per ottimizzare la velocità effettiva, SQL Data Warehouse può accodare alcune query per garantire che a ognuna venga assegnata una concessione di memoria minima.However, to optimize throughput, SQL Data Warehouse may queue some queries to ensure that each query receives a minimal memory grant. L'accodamento avviene in fase di esecuzione della query.Queuing occurs at query execution time. Accodando le query quando vengono raggiunti i limiti di concorrenza, SQL Data Warehouse è in grado di aumentare la velocità effettiva totale, assicurando che le query attive ottengano l'accesso alle risorse di memoria critiche necessarie.By queuing queries when concurrency limits are reached, SQL Data Warehouse can increase total throughput by ensuring that active queries get access to critically needed memory resources.

I limiti di concorrenza sono regolati da due concetti, query simultanee e slot di concorrenza.Concurrency limits are governed by two concepts: concurrent queries and concurrency slots. Perché una query venga eseguita, è necessario che rientri nel limite di concorrenza delle query e nell'allocazione di slot di concorrenza.For a query to execute, it must execute within both the query concurrency limit and the concurrency slot allocation.

  • Le query simultanee sono le query in esecuzione contemporaneamente.Concurrent queries are the queries executing at the same time. SQL Data Warehouse supporta fino a 32 query simultanee nelle DWU di dimensioni maggiori.SQL Data Warehouse supports up to 32 concurrent queries on the larger DWU sizes.
  • In base alle Unità Data Warehouse (DWU), vengono allocati slot di concorrenza.Concurrency slots are allocated based on DWU. Ogni 100 DWU, vengono forniti 4 slot di concorrenza.Each 100 DWU provides 4 concurrency slots. Ad esempio, per DW100 vengono allocati 4 slot di concorrenza e per DW1000 ne vengono allocati 40.For example, a DW100 allocates 4 concurrency slots and DW1000 allocates 40. Ogni query utilizza uno o più slot di concorrenza, a seconda della classe di risorse della query.Each query consumes one or more concurrency slots, dependent on the resource class of the query. Le query in esecuzione nella classe di risorse smallrc utilizzano uno slot di concorrenza.Queries running in the smallrc resource class consume one concurrency slot. Le query in esecuzione in una classe di risorse superiore usano più slot di concorrenza.Queries running in a higher resource class consume more concurrency slots.

La tabella seguente descrive i limiti sia per le query simultanee che per gli slot di concorrenza a seconda delle dimensioni della DWU.The following table describes the limits for both concurrent queries and concurrency slots at the various DWU sizes.

Limiti di concorrenzaConcurrency limits

DWUDWU Numero massimo di query simultaneeMax concurrent queries Numero di slot di concorrenza allocatiConcurrency slots allocated
DW100DW100 44 44
DW200DW200 88 88
DW300DW300 1212 1212
DW400DW400 1616 1616
DW500DW500 2020 2020
DW600DW600 2424 2424
DW1000DW1000 3232 4040
DW1200DW1200 3232 4848
DW1500DW1500 3232 6060
DW2000DW2000 3232 8080
DW3000DW3000 3232 120120
DW6000DW6000 3232 240240

Quando viene raggiunta una di queste soglie, le nuove query vengono accodate e vengono eseguite in base al principio FIFO (First-In-First-Out).When one of these thresholds is met, new queries are queued and executed on a first-in, first-out basis. Al termine dell'esecuzione delle query e quando il numero di query e di slot risulta inferiore ai limiti, le code accodate vengono rilasciate.As a queries finishes and the number of queries and slots falls below the limits, queued queries are released.

Nota

selezione eseguite esclusivamente sulle viste del catalogo o sulle viste a gestione dinamica (DMV) non sono disciplinate da nessuno dei limiti di concorrenza.Select queries executing exclusively on dynamic management views (DMVs) or catalog views are not governed by any of the concurrency limits. È possibile monitorare il sistema indipendentemente dal numero di query in esecuzione nel sistema.You can monitor the system regardless of the number of queries executing on it.

Classi di risorseResource classes

Attraverso le classi di risorse è possibile controllare l'allocazione di memoria e cicli di CPU assegnati a una query.Resource classes help you control memory allocation and CPU cycles given to a query. È possibile assegnare due tipi di classi di risorse a un utente sotto forma di ruoli del database.You can assign two types of resource classes to a user in the form of database roles. I due tipi di classi di risorse sono i seguenti:The two types of resource classes are as follows:

  1. Classi di risorse dinamiche (smallrc, mediumrc, largerc, xlargerc), che allocano una quantità variabile di memoria a seconda della DWU corrente.Dynamic Resource Classes (smallrc, mediumrc, largerc, xlargerc) allocate a variable amount of memory depending on the current DWU. Ciò significa che quando si passa a una DWU più grande, le query ottengono automaticamente più memoria.This means that when you scale up to a larger DWU, your queries automatically get more memory.
  2. Classi di risorse statiche (staticrc10, staticrc20, staticrc30, staticrc40, staticrc50, staticrc60, staticrc70, staticrc80), che allocano la stessa quantità di memoria indipendentemente dalla DWU corrente (a condizione che la DWU stessa abbia memoria sufficiente).Static Resource Classes (staticrc10, staticrc20, staticrc30, staticrc40, staticrc50, staticrc60, staticrc70, staticrc80) allocate the same amount of memory regardless of the current DWU (provided that the DWU itself has enough memory). Ciò significa che nelle DWU più grandi è possibile eseguire più query in ogni classe di risorse contemporaneamente.This means that on larger DWUs, you can run more queries in each resource class concurrently.

Agli utenti delle classi smallrc e staticrc10 viene assegnata una quantità di memoria più piccola e ciò permette di sfruttare una concorrenza maggiore.Users in smallrc and staticrc10 are given a smaller amount of memory and can take advantage of higher concurrency. Al contrario, agli utenti delle classi xlargerc e staticrc80 vengono assegnate grandi quantità di memoria e quindi è possibile eseguire contemporaneamente un numero minore di query.In contrast, users assigned to xlargerc or staticrc80 are given large amounts of memory, and therefore fewer of their queries can run concurrently.

Per impostazione predefinita, ogni utente è membro della classe di risorse piccola smallrc.By default, each user is a member of the small resource class, smallrc. Per aumentare la classe di risorse viene usata la procedura sp_addrolemember, mentre per diminuirla viene usata la procedura sp_droprolemember.The procedure sp_addrolemember is used to increase the resource class, and sp_droprolemember is used to decrease the resource class. Questo comando, ad esempio, assegna a loaduser una classe di risorse superiore, largerc:For example, this command would increase the resource class of loaduser to largerc:

EXEC sp_addrolemember 'largerc', 'loaduser'

Query che non rispettano le classi di risorseQueries that do not honor resource classes

Esistono alcuni tipi di query che non traggono vantaggio da un'allocazione di memoria maggiore.There are a few types of queries that do not benefit from a larger memory allocation. Il sistema ignora l'allocazione della classe di risorse ed esegue sempre queste query nella classe di risorse piccola.The system ignores their resource class allocation and always run these queries in the small resource class instead. Se queste query vengono eseguite sempre nella classe di risorse piccola, è possibile eseguirle quando gli slot di concorrenza sono sotto pressione, per non consumare più slot del necessario.If these queries always run in the small resource class, they can run when concurrency slots are under pressure and they won't consume more slots than needed. Vedere Eccezioni della classe di risorse per ulteriori informazioni.See Resource class exceptions for more information.

Dettagli sull'assegnazione della classe di risorseDetails on resource class assignment

Altri dettagli sulla classe di risorse:A few more details on resource class:

  • Ruolo Alter è obbligatoria per modificare la classe di risorse di un utente.Alter role permission is required to change the resource class of a user.
  • Anche se è possibile aggiungere un utente a una o più classi di risorse superiori, le classi di risorse dinamiche hanno la precedenza su quelle statiche.Although you can add a user to one or more of the higher resource classes, dynamic resource classes take precedence over static resource classes. Ciò significa che se un utente viene assegnato a entrambe le classi mediumrc(dinamica) e staticrc80(statica), la precedenza va a mediumrc.That is, if a user is assigned to both mediumrc(dynamic) and staticrc80(static), mediumrc is the resource class that is honored.
    • Quando un utente è assegnato a più di una classe di risorse in un tipo di classe di risorse specifico (più classi di risorse dinamiche o più classi di risorse statiche), la precedenza va alla classe di risorse superiore.When a user is assigned to more than one resource class in a specific resource class type (more than one dynamic resource class or more than one static resource class), the highest resource class is honored. Ciò significa che se un utente viene assegnato a entrambe le classi mediumrc e largerc, la precedenza va alla classe di risorse superiore (largerc).That is, if a user is assigned to both mediumrc and largerc, the higher resource class (largerc) is honored. Se un utente viene assegnato a entrambe le classi staticrc20 e statirc80, la precedenza va a staticrc80.And if a user is assigned to both staticrc20 and statirc80, staticrc80 is honored.
  • La classe di risorse dell'utente amministratore di sistema non può essere modificata.The resource class of the system administrative user cannot be changed.

Per un esempio dettagliato, vedere Esempio di modifica della classe di risorse di un utente.For a detailed example, see Changing user resource class example.

Allocazione della memoriaMemory allocation

Esistono vantaggi e svantaggi legati all'incremento della classe di risorse dell'utente.There are pros and cons to increasing a user's resource class. Spostando un utente a una classe di risorse superiore, si consente alle rispettive query di accedere a una quantità maggiore di memoria e quindi l'esecuzione delle query è più rapida.Increasing a resource class for a user, gives their queries access to more memory, which may mean queries execute faster. Una quantità maggiore di classi di risorse, tuttavia, riduce anche il numero di query simultanee che è possibile eseguire.However, higher resource classes also reduce the number of concurrent queries that can run. Questo è il compromesso tra il fatto di allocare grandi quantità di memoria a una singola query o consentire l'esecuzione simultanea di altre query che necessitano di allocazioni di memoria.This is the trade-off between allocating large amounts of memory to a single query or allowing other queries, which also need memory allocations, to run concurrently. Se a un utente vengono allocate grandi quantità di memoria per una query, gli altri utenti non potranno accedere alla stessa memoria per eseguire una query.If one user is given high allocations of memory for a query, other users will not have access to that same memory to run a query.

Nella tabella seguente la memoria allocata è associata a ogni distribuzione per classe DWU e classe di risorse.The following table maps the memory allocated to each distribution by DWU and resource class.

Allocazioni di memoria per ogni distribuzione per le classi di risorse dinamiche (MB)Memory allocations per distribution for dynamic resource classes (MB)

DWUDWU smallrcsmallrc mediumrcmediumrc largerclargerc xlargercxlargerc
DW100DW100 100100 100100 200200 400400
DW200DW200 100100 200200 400400 800800
DW300DW300 100100 200200 400400 800800
DW400DW400 100100 400400 800800 1.6001,600
DW500DW500 100100 400400 800800 1.6001,600
DW600DW600 100100 400400 800800 1.6001,600
DW1000DW1000 100100 800800 1.6001,600 3.2003,200
DW1200DW1200 100100 800800 1.6001,600 3.2003,200
DW1500DW1500 100100 800800 1.6001,600 3.2003,200
DW2000DW2000 100100 1.6001,600 3.2003,200 6.4006,400
DW3000DW3000 100100 1.6001,600 3.2003,200 6.4006,400
DW6000DW6000 100100 3.2003,200 6.4006,400 12.80012,800

La tabella seguente indica la memoria allocata a ogni distribuzione in base alla DWU e alla classe di risorse statica.The following table maps the memory allocated to each distribution by DWU and static resource class. Si noti che le classi di risorse superiori hanno memoria ridotta per rispettare i limiti delle DWU globali.Note that the higher resource classes have their memory reduced to honor the global DWU limits.

Allocazioni di memoria per ogni distribuzione per le classi di risorse statiche (MB)Memory allocations per distribution for static resource classes (MB)

DWUDWU staticrc10staticrc10 staticrc20staticrc20 staticrc30staticrc30 staticrc40staticrc40 staticrc50staticrc50 staticrc60staticrc60 staticrc70staticrc70 staticrc80staticrc80
DW100DW100 100100 200200 400400 400400 400400 400400 400400 400400
DW200DW200 100100 200200 400400 800800 800800 800800 800800 800800
DW300DW300 100100 200200 400400 800800 800800 800800 800800 800800
DW400DW400 100100 200200 400400 800800 1.6001,600 1.6001,600 1.6001,600 1.6001,600
DW500DW500 100100 200200 400400 800800 1.6001,600 1.6001,600 1.6001,600 1.6001,600
DW600DW600 100100 200200 400400 800800 1.6001,600 1.6001,600 1.6001,600 1.6001,600
DW1000DW1000 100100 200200 400400 800800 1.6001,600 3.2003,200 3.2003,200 3.2003,200
DW1200DW1200 100100 200200 400400 800800 1.6001,600 3.2003,200 3.2003,200 3.2003,200
DW1500DW1500 100100 200200 400400 800800 1.6001,600 3.2003,200 3.2003,200 3.2003,200
DW2000DW2000 100100 200200 400400 800800 1.6001,600 3.2003,200 6.4006,400 6.4006,400
DW3000DW3000 100100 200200 400400 800800 1.6001,600 3.2003,200 6.4006,400 6.4006,400
DW6000DW6000 100100 200200 400400 800800 1.6001,600 3.2003,200 6.4006,400 12.80012,800

Come si può notare nella tabella precedente, una query in esecuzione in DW2000 nella classe di risorse xlargerc avrà accesso a 6.400 MB di memoria in ognuno dei 60 database distribuiti.From the preceding table, you can see that a query running on a DW2000 in the xlargerc resource class would have access to 6,400 MB of memory within each of the 60 distributed databases. In SQL Data Warehouse sono presenti 60 distribuzioni.In SQL Data Warehouse, there are 60 distributions. Per calcolare quindi l'allocazione totale di memoria per una query in una classe di risorse specifica, è necessario moltiplicare per 60 i valori precedenti.Therefore, to calculate the total memory allocation for a query in a given resource class, the above values should be multiplied by 60.

Allocazioni di memoria a livello di sistema (GB)Memory allocations system-wide (GB)

DWUDWU smallrcsmallrc mediumrcmediumrc largerclargerc xlargercxlargerc
DW100DW100 66 66 1212 2323
DW200DW200 66 1212 2323 4747
DW300DW300 66 1212 2323 4747
DW400DW400 66 2323 4747 9494
DW500DW500 66 2323 4747 9494
DW600DW600 66 2323 4747 9494
DW1000DW1000 66 4747 9494 188188
DW1200DW1200 66 4747 9494 188188
DW1500DW1500 66 4747 9494 188188
DW2000DW2000 66 9494 188188 375375
DW3000DW3000 66 9494 188188 375375
DW6000DW6000 66 188188 375375 750750

Come si può notare in questa tabella di allocazioni di memoria a livello di sistema, a una query in esecuzione in DW2000 nella classe di risorse xlargerc viene allocato un totale di 375 GB di memoria (6.400 MB * 60 distribuzioni/1.024 per la conversione in GB) nell'intero SQL Data Warehouse.From this table of system-wide memory allocations, you can see that a query running on a DW2000 in the xlargerc resource class is allocated a total of 375 GB of memory (6,400 MB * 60 distributions / 1,024 to convert to GB) over the entirety of your SQL Data Warehouse.

Lo stesso calcolo si applica alle classi di risorse statiche.The same calculation applies to static resource classes.

Utilizzo di slot di concorrenzaConcurrency slot consumption

SQL Data Warehouse concede più memoria alle query in esecuzione nelle classi di risorse più grandi.SQL Data Warehouse grants more memory to queries running in higher resource classes. La memoria è una risorsa fissa.Memory is a fixed resource. Maggiore sarà la quantità di memoria allocata per ogni query, quindi, minore sarà il numero di richieste simultanee che è possibile eseguire.Therefore, the more memory allocated per query, the fewer concurrent queries can execute. La tabella seguente riprende tutti i concetti descritti finora in un'unica rappresentazione che mostra il numero di slot di concorrenza disponibili per DWU e gli slot usati da ogni classe di risorse.The following table reiterates all of the previous concepts in a single view that shows the number of concurrency slots available by DWU and the slots consumed by each resource class.

Allocazione e consumo degli slot di concorrenza per le classi di risorse dinamicheAllocation and consumption of concurrency slots for dynamic resource classes

DWUDWU Numero massimo di query simultaneeMaximum concurrent queries Numero di slot di concorrenza allocatiConcurrency slots allocated Slot utilizzati da smallrcSlots used by smallrc Slot utilizzati da mediumrcSlots used by mediumrc Slot utilizzati da largercSlots used by largerc Slot utilizzati da xlargercSlots used by xlargerc
DW100DW100 44 44 11 11 22 44
DW200DW200 88 88 11 22 44 88
DW300DW300 1212 1212 11 22 44 88
DW400DW400 1616 1616 11 44 88 1616
DW500DW500 2020 2020 11 44 88 1616
DW600DW600 2424 2424 11 44 88 1616
DW1000DW1000 3232 4040 11 88 1616 3232
DW1200DW1200 3232 4848 11 88 1616 3232
DW1500DW1500 3232 6060 11 88 1616 3232
DW2000DW2000 3232 8080 11 1616 3232 6464
DW3000DW3000 3232 120120 11 1616 3232 6464
DW6000DW6000 3232 240240 11 3232 6464 128128

Allocazione e consumo degli slot di concorrenza per le classi di risorse staticheAllocation and consumption of concurrency slots for static resource classes

DWUDWU Numero massimo di query simultaneeMaximum concurrent queries Numero di slot di concorrenza allocatiConcurrency slots allocated staticrc10staticrc10 staticrc20staticrc20 staticrc30staticrc30 staticrc40staticrc40 staticrc50staticrc50 staticrc60staticrc60 staticrc70staticrc70 staticrc80staticrc80
DW100DW100 44 44 11 22 44 44 44 44 44 44
DW200DW200 88 88 11 22 44 88 88 88 88 88
DW300DW300 1212 1212 11 22 44 88 88 88 88 88
DW400DW400 1616 1616 11 22 44 88 1616 1616 1616 1616
DW500DW500 2020 2020 11 22 44 88 1616 1616 1616 1616
DW600DW600 2424 2424 11 22 44 88 1616 1616 1616 1616
DW1000DW1000 3232 4040 11 22 44 88 1616 3232 3232 3232
DW1200DW1200 3232 4848 11 22 44 88 1616 3232 3232 3232
DW1500DW1500 3232 6060 11 22 44 88 1616 3232 3232 3232
DW2000DW2000 3232 8080 11 22 44 88 1616 3232 6464 6464
DW3000DW3000 3232 120120 11 22 44 88 1616 3232 6464 6464
DW6000DW6000 3232 240240 11 22 44 88 1616 3232 6464 128128

Come si può notare da queste tabelle, l'esecuzione di SQL Data Warehouse come DW1000 alloca un massimo di 32 query simultanee e un totale di 40 slot di concorrenza.From these tables, you can see that SQL Data Warehouse running as DW1000 allocates a maximum of 32 concurrent queries and a total of 40 concurrency slots. Se l'esecuzione avviene da parte di tutti gli utenti nella classe smallrc, vengono consentite 32 query simultanee, poiché ognuna richiede 1 slot di concorrenza.If all users are running in smallrc, 32 concurrent queries would be allowed because each query would consume 1 concurrency slot. Se l'esecuzione avviene da parte di tutti gli utenti di un DW1000 in una classe mediumrc, per ogni query vengono allocati 800 MB a distribuzione, per un'allocazione di memoria totale pari a 47 GB per query, mentre il numero degli utenti simultanei viene limitato a 5 (40 slot di concorrenza, 8 per ogni utente mediumrc).If all users on a DW1000 were running in mediumrc, each query would be allocated 800 MB per distribution for a total memory allocation of 47 GB per query, and concurrency would be limited to 5 users (40 concurrency slots / 8 slots per mediumrc user).

Scelta della classe di risorse appropriataSelecting proper resource class

È buona norma assegnare in modo permanente gli utenti a una classe di risorse invece di modificare la classe di risorse degli utenti.A good practice is to permanently assign users to a resource class rather than changing their resource classes. I caricamenti in tabelle columnstore cluster, ad esempio, creano indici di qualità superiore quando viene allocata una quantità di memoria maggiore.For example, loads to clustered columnstore tables create higher-quality indexes when allocated more memory. Per assicurarsi che caricamenti abbiano accesso alla memoria superiore, creare un utente specifico per il caricamento dei dati e assegnare permanentemente a questo utente una classe di risorse superiore.To ensure that loads have access to higher memory, create a user specifically for loading data and permanently assign this user to a higher resource class. Ci sono alcune procedure consigliate da seguire.There are a couple of best practices to follow here. Come indicato in precedenza, SQL Data Warehouse supporta due tipi di classi di risorse: le classi di risorse statiche e quelle dinamiche.As mentioned above, SQL DW supports two kinds of resource class types: static resource classes and dynamic resource classes.

Procedure consigliate per il caricamentoLoading best practices

  1. Se si prevedono caricamenti con quantità di dati regolari, una classe di risorse statica è una scelta appropriata.If the expectations are loads with regular amount of data, a static resource class is a good choice. In un secondo momento, quando si aumenteranno le prestazioni per ottenere maggiore potenza di calcolo, il data warehouse potrà eseguire più query simultanee per impostazione predefinita, in quanto l'utente che esegue il caricamento non utilizza più memoria.Later, when scaling up to get more computational power, the data warehouse will be able to run more concurrent queries out-of-the-box, as the load user does not consume more memory.
  2. Se si prevedono caricamenti di entità più grande in alcune occasioni, una classe di risorse dinamica è una scelta appropriata.If the expectations are bigger loads in some occasions, a dynamic resource class is a good choice. In un secondo momento, quando si aumenteranno le prestazioni per ottenere maggiore potenza di calcolo, l'utente che esegue il caricamento riceverà più memoria per impostazione predefinita, pertanto i tempi di caricamento saranno più rapidi.Later, when scaling up to get more computational power, the load user will get more memory out-of-the-box, hence allowing the load to perform faster.

La memoria necessaria per elaborare in modo efficiente i caricamenti dipende dalla natura della tabella caricata e dalla quantità di dati elaborati.The memory needed to process loads efficiently depends on the nature of the table loaded and the amount of data processed. Ad esempio, il caricamento di dati nelle tabelle CCI richiede una determinata quantità di memoria per consentire l'ottimizzazione per i rowgroup CCI.For instance, loading data into CCI tables requires some memory to let CCI rowgroups reach optimality. Per altre informazioni, vedere le indicazioni relative a indici columnstore e caricamento di dati.For more details, see the Columnstore indexes - data loading guidance.

Come procedura consigliata, si consiglia di usare almeno 200 MB di memoria per i caricamenti.As a best practice, we advise you to use at least 200MB of memory for loads.

Procedure consigliate per le queryQuerying best practices

Le query hanno diversi requisiti a seconda della complessità.Queries have different requirements depending on their complexity. L'aumento della memoria per ogni query o l'aumento della concorrenza sono entrambi metodi validi per aumentare la velocità effettiva globale a seconda delle esigenze di query.Increasing memory per query or increasing the concurrency are both valid ways to augment overall throughput depending on the query needs.

  1. Se si prevedono query regolari complesse (ad esempio per generare report giornalieri e settimanali) e non è necessario sfruttare la concorrenza, una classe di risorse dinamica è una scelta appropriata.If the expectations are regular, complex queries (for instance, to generate daily and weekly reports) and do not need to take advantage of concurrency, a dynamic resource class is a good choice. Se il sistema ha più dati da elaborare, un aumento delle prestazioni del data warehouse fornisce automaticamente più memoria per l'utente che esegue la query.If the system has more data to process, scaling up the data warehouse will therefore automatically provide more memory to the user running the query.
  2. Se si prevedono modelli di concorrenza variabili o giornalieri (ad esempio se vengono eseguite query sul database tramite un'interfaccia utente Web accessibile su vasta scala), una classe di risorse statica è una scelta appropriata.If the expectations are variable or diurnal concurrency patterns (for instance if the database is queried through a web UI broadly accessible), a static resource class is a good choice. In un secondo momento, quando si aumenteranno le prestazioni del data warehouse, l'utente associato alla classe di risorse statica potrà eseguire automaticamente un numero maggiore di query simultanee.Later, when scaling up to data warehouse, the user associated with the static resource class will automatically be able to run more concurrent queries.

La selezione di una concessione di memoria appropriata a seconda delle esigenze della query non è semplice, perché dipende da molti fattori, come la quantità di dati sottoposti a query, la natura degli schemi di tabella e i vari predicati di gruppo, selezione e join.Selecting proper memory grant depending on the need of your query is non-trivial, as it depends on many factors, such as the amount of data queried, the nature of the table schemas, and various join, selection, and group predicates. Dal punto di vista generale, l'allocazione di più memoria consente tempi più rapidi per il completamento delle query, ma riduce la concorrenza complessiva.From a general standpoint, allocating more memory will allow queries to complete faster, but would reduce the overall concurrency. Se la concorrenza non è un problema, un'allocazione eccessiva di memoria non causa alcun danno.If concurrency is not an issue, over-allocating memory does not harm. Per ottimizzare la velocità effettiva, potrebbe essere necessario provare diversi tipi di classi di risorse.To fine-tune throughput, trying various flavors of resource classes may be required.

È possibile usare la stored procedure seguente per ottenere informazioni sulla concorrenza e sulla concessione di memoria per ogni classe di risorse in un determinato SLO e sulla classe di risorse migliore possibile per operazioni CCI a elevato utilizzo di memoria su una tabella CCI non partizionata con una classe di risorse specifica:You can use the following stored procedure to figure out concurrency and memory grant per resource class at a given SLO and the closest best resource class for memory intensive CCI operations on non-partitioned CCI table at a given resource class:

Descrizione:Description:

Ecco lo scopo della stored procedure:Here's the purpose of this stored procedure:

  1. Aiutare l'utente a ottenere informazioni sulla concorrenza e sulla concessione di memoria per ogni classe di risorse in un determinato SLO.To help user figure out concurrency and memory grant per resource class at a given SLO. L'utente deve specificare NULL sia per lo schema che per il nome di tabella, come illustrato nell'esempio seguente.User needs to provide NULL for both schema and tablename for this as shown in the example below.
  2. Aiutare l'utente a ottenere informazioni sulla classe di risorse migliore possibile per operazioni CCI a elevato utilizzo di memoria (caricamento, copia di tabelle, ricompilazione dell'indice e così via) su una tabella CCI non partizionata con una classe di risorse specifica.To help user figure out the closest best resource class for the memory intensed CCI operations (load, copy table, rebuild index, etc.) on non partitioned CCI table at a given resource class. La stored procedure usa lo schema di tabella per individuare la concessione di memoria necessaria.The stored proc uses table schema to find out the required memory grant for this.

Dipendenze e restrizioni:Dependencies & Restrictions:

  • Questa stored procedure non è progettata per calcolare i requisiti di memoria per una tabella CCI partizionata.This stored proc is not designed to calculate memory requirement for partitioned-cci table.
  • Questa stored procedure non prende in considerazione i requisiti di memoria per la parte SELECT di un'istruzione CTAS/INSERT-SELECT e presuppone che si tratti di un'istruzione SELECT semplice.This stored proc doesn't take memory requirement into account for the SELECT part of CTAS/INSERT-SELECT and assumes it to be a simple SELECT.
  • Questa stored procedure usa una tabella temporanea che quindi può essere usata nella sessione in cui è stata creata la stored procedure.This stored proc uses a temp table so this can be used in the session where this stored proc was created.
  • Questa stored procedure dipende dalle risorse correnti (ad esempio, configurazione hardware e configurazione DMS) e in caso di modifiche non funziona più correttamente.This stored proc depends on the current offerings (e.g. hardware configuration, DMS config) and if any of that changes then this stored proc would not work correctly.
  • Questa stored procedure dipende dal limite di concorrenza esistente e in caso di modifiche non funziona più correttamente.This stored proc depends on existing offered concurrency limit and if that changes then this stored proc would not work correctly.
  • Questa stored procedure dipende dalle classi di risorse esistenti e in caso di modifiche non funziona più correttamente.This stored proc depends on existing resource class offerings and if that changes then this stored proc wuold not work correctly.

Nota

Se non si ottiene alcun output dopo l'esecuzione della stored procedure con i parametri forniti, i motivi potrebbero essere due.If you are not getting output after executing stored procedure with parameters provided then there could be two cases.
1. Uno dei parametri di Data Warehouse contiene un valore SLO non valido1. Either DW Parameter contains invalid SLO value
2. OPPURE non ci sono classi di risorse corrispondenti per l'operazione CCI se è stato fornito il nome della tabella.2. OR there are no matching resource class for CCI operation if table name was provided.
Ad esempio, con DW100, la concessione di memoria massima disponibile è 400 MB e lo schema di tabella è sufficientemente ampio per soddisfare il requisito di 400 MB.For example, at DW100, highest memory grant available is 400MB and if table schema is wide enough to cross the requirement of 400MB.

Esempio d'uso:Usage example:

Sintassi:Syntax:
EXEC dbo.prc_workload_management_by_DWU @DWU VARCHAR(7), @SCHEMA_NAME VARCHAR(128), @TABLE_NAME VARCHAR(128)

  1. @DWU: Fornire un parametro NULL per estrarre la DWU corrente dal database di Data Warehouse oppure fornire una DWU supportata nel formato "DW100"@DWU: Either provide a NULL parameter to extract the current DWU from the DW DB or provide any supported DWU in the form of 'DW100'
  2. @SCHEMA_NAME: Fornire un nome di schema della tabella@SCHEMA_NAME: Provide a schema name of the table
  3. @TABLE_NAME: Fornire un nome di tabella@TABLE_NAME: Provide a table name of the interest

Esempi di esecuzione di questa stored procedure:Examples executing this stored proc:

EXEC dbo.prc_workload_management_by_DWU 'DW2000', 'dbo', 'Table1';  
EXEC dbo.prc_workload_management_by_DWU NULL, 'dbo', 'Table1';  
EXEC dbo.prc_workload_management_by_DWU 'DW6000', NULL, NULL;  
EXEC dbo.prc_workload_management_by_DWU NULL, NULL, NULL;  

La tabella Table1 usata negli esempi precedenti può venire creata come indicato di seguito:Table1 used in the above examples could be created as below:
CREATE TABLE Table1 (a int, b varchar(50), c decimal (18,10), d char(10), e varbinary(15), f float, g datetime, h date);

Ecco la definizione della stored procedure:Here's the stored procedure definition:

-------------------------------------------------------------------------------
-- Dropping prc_workload_management_by_DWU procedure if it exists.
-------------------------------------------------------------------------------
IF EXISTS (SELECT * FROM sys.objects WHERE type = 'P' AND name = 'prc_workload_management_by_DWU')
DROP PROCEDURE dbo.prc_workload_management_by_DWU
GO

-------------------------------------------------------------------------------
-- Creating prc_workload_management_by_DWU.
-------------------------------------------------------------------------------
CREATE PROCEDURE dbo.prc_workload_management_by_DWU
(   @DWU VARCHAR(7),
      @SCHEMA_NAME VARCHAR(128),
       @TABLE_NAME VARCHAR(128)
)
AS
IF @DWU IS NULL
BEGIN
-- Selecting proper DWU for the current DB if not specified.
SET @DWU = (
  SELECT 'DW'+CAST(COUNT(*)*100 AS VARCHAR(10))
  FROM sys.dm_pdw_nodes
  WHERE type = 'COMPUTE')
END

DECLARE @DWU_NUM INT
SET @DWU_NUM = CAST (SUBSTRING(@DWU, 3, LEN(@DWU)-2) AS INT)

-- Raise error if either schema name or table name is supplied but not both them supplied
--IF ((@SCHEMA_NAME IS NOT NULL AND @TABLE_NAME IS NULL) OR (@TABLE_NAME IS NULL AND @SCHEMA_NAME IS NOT NULL))
--     RAISEERROR('User need to supply either both Schema Name and Table Name or none of them')

-- Dropping temp table if exists.
IF OBJECT_ID('tempdb..#ref') IS NOT NULL
BEGIN
  DROP TABLE #ref;
END

-- Creating ref. temptable (CTAS) to hold mapping info.
-- CREATE TABLE #ref
CREATE TABLE #ref
WITH (DISTRIBUTION = ROUND_ROBIN)
AS 
WITH
-- Creating concurrency slots mapping for various DWUs.
alloc
AS
(
  SELECT 'DW100' AS DWU, 4 AS max_queries, 4 AS max_slots, 1 AS slots_used_smallrc, 1 AS slots_used_mediumrc,
        2 AS slots_used_largerc, 4 AS slots_used_xlargerc, 1 AS slots_used_staticrc10, 2 AS slots_used_staticrc20,
        4 AS slots_used_staticrc30, 4 AS slots_used_staticrc40, 4 AS slots_used_staticrc50,
        4 AS slots_used_staticrc60, 4 AS slots_used_staticrc70, 4 AS slots_used_staticrc80
  UNION ALL
    SELECT 'DW200', 8, 8, 1, 2, 4, 8, 1, 2, 4, 8, 8, 8, 8, 8
  UNION ALL
    SELECT 'DW300', 12, 12, 1, 2, 4, 8, 1, 2, 4, 8, 8, 8, 8, 8
  UNION ALL
    SELECT 'DW400', 16, 16, 1, 4, 8, 16, 1, 2, 4, 8, 16, 16, 16, 16
  UNION ALL
     SELECT 'DW500', 20, 20, 1, 4, 8, 16, 1, 2, 4, 8, 16, 16, 16, 16
  UNION ALL
    SELECT 'DW600', 24, 24, 1, 4, 8, 16, 1, 2, 4, 8, 16, 16, 16, 16
  UNION ALL
    SELECT 'DW1000', 32, 40, 1, 8, 16, 32, 1, 2, 4, 8, 16, 32, 32, 32
  UNION ALL
    SELECT 'DW1200', 32, 48, 1, 8, 16, 32, 1, 2, 4, 8, 16, 32, 32, 32
  UNION ALL
    SELECT 'DW1500', 32, 60, 1, 8, 16, 32, 1, 2, 4, 8, 16, 32, 32, 32
  UNION ALL
    SELECT 'DW2000', 32, 80, 1, 16, 32, 64, 1, 2, 4, 8, 16, 32, 64, 64
  UNION ALL
   SELECT 'DW3000', 32, 120, 1, 16, 32, 64, 1, 2, 4, 8, 16, 32, 64, 64
  UNION ALL
    SELECT 'DW6000', 32, 240, 1, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128
)
-- Creating workload mapping to their corresponding slot consumption and default memory grant.
,map
AS
(
  SELECT 'SloDWGroupC00' AS wg_name,1 AS slots_used,100 AS tgt_mem_grant_MB
  UNION ALL
    SELECT 'SloDWGroupC01',2,200
  UNION ALL
    SELECT 'SloDWGroupC02',4,400
  UNION ALL
    SELECT 'SloDWGroupC03',8,800
  UNION ALL
    SELECT 'SloDWGroupC04',16,1600
  UNION ALL
    SELECT 'SloDWGroupC05',32,3200
  UNION ALL
    SELECT 'SloDWGroupC06',64,6400
  UNION ALL
    SELECT 'SloDWGroupC07',128,12800
)
-- Creating ref based on current / asked DWU.
, ref
AS
(
  SELECT  a1.*
  ,       m1.wg_name          AS wg_name_smallrc
  ,       m1.tgt_mem_grant_MB AS tgt_mem_grant_MB_smallrc
  ,       m2.wg_name          AS wg_name_mediumrc
  ,       m2.tgt_mem_grant_MB AS tgt_mem_grant_MB_mediumrc
  ,       m3.wg_name          AS wg_name_largerc
  ,       m3.tgt_mem_grant_MB AS tgt_mem_grant_MB_largerc
  ,       m4.wg_name          AS wg_name_xlargerc
  ,       m4.tgt_mem_grant_MB AS tgt_mem_grant_MB_xlargerc
  ,       m5.wg_name          AS wg_name_staticrc10
  ,       m5.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc10
  ,       m6.wg_name          AS wg_name_staticrc20
  ,       m6.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc20
  ,       m7.wg_name          AS wg_name_staticrc30
  ,       m7.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc30
  ,       m8.wg_name          AS wg_name_staticrc40
  ,       m8.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc40
  ,       m9.wg_name          AS wg_name_staticrc50
  ,       m9.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc50
  ,       m10.wg_name          AS wg_name_staticrc60
  ,       m10.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc60
  ,       m11.wg_name          AS wg_name_staticrc70
  ,       m11.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc70
  ,       m12.wg_name          AS wg_name_staticrc80
  ,       m12.tgt_mem_grant_MB AS tgt_mem_grant_MB_staticrc80
  FROM alloc a1
  JOIN map   m1  ON a1.slots_used_smallrc     = m1.slots_used
  JOIN map   m2  ON a1.slots_used_mediumrc    = m2.slots_used
  JOIN map   m3  ON a1.slots_used_largerc     = m3.slots_used
  JOIN map   m4  ON a1.slots_used_xlargerc    = m4.slots_used
  JOIN map   m5  ON a1.slots_used_staticrc10    = m5.slots_used
  JOIN map   m6  ON a1.slots_used_staticrc20    = m6.slots_used
  JOIN map   m7  ON a1.slots_used_staticrc30    = m7.slots_used
  JOIN map   m8  ON a1.slots_used_staticrc40    = m8.slots_used
  JOIN map   m9  ON a1.slots_used_staticrc50    = m9.slots_used
  JOIN map   m10  ON a1.slots_used_staticrc60    = m10.slots_used
  JOIN map   m11  ON a1.slots_used_staticrc70    = m11.slots_used
  JOIN map   m12  ON a1.slots_used_staticrc80    = m12.slots_used
-- WHERE   a1.DWU = @DWU
  WHERE   a1.DWU = UPPER(@DWU)
)
SELECT  DWU
,       max_queries
,       max_slots
,       slots_used
,       wg_name
,       tgt_mem_grant_MB
,       up1 as rc
,       (ROW_NUMBER() OVER(PARTITION BY DWU ORDER BY DWU)) as rc_id
FROM
(
    SELECT  DWU
    ,       max_queries
    ,       max_slots
    ,       slots_used
    ,       wg_name
    ,       tgt_mem_grant_MB
    ,       REVERSE(SUBSTRING(REVERSE(wg_names),1,CHARINDEX('_',REVERSE(wg_names),1)-1)) as up1
    ,       REVERSE(SUBSTRING(REVERSE(tgt_mem_grant_MBs),1,CHARINDEX('_',REVERSE(tgt_mem_grant_MBs),1)-1)) as up2
    ,       REVERSE(SUBSTRING(REVERSE(slots_used_all),1,CHARINDEX('_',REVERSE(slots_used_all),1)-1)) as up3
    FROM    ref AS r1
    UNPIVOT
    (
        wg_name FOR wg_names IN (wg_name_smallrc,wg_name_mediumrc,wg_name_largerc,wg_name_xlargerc,
        wg_name_staticrc10, wg_name_staticrc20, wg_name_staticrc30, wg_name_staticrc40, wg_name_staticrc50,
        wg_name_staticrc60, wg_name_staticrc70, wg_name_staticrc80)
    ) AS r2
    UNPIVOT
    (
        tgt_mem_grant_MB FOR tgt_mem_grant_MBs IN (tgt_mem_grant_MB_smallrc,tgt_mem_grant_MB_mediumrc,
        tgt_mem_grant_MB_largerc,tgt_mem_grant_MB_xlargerc, tgt_mem_grant_MB_staticrc10, tgt_mem_grant_MB_staticrc20,
        tgt_mem_grant_MB_staticrc30, tgt_mem_grant_MB_staticrc40, tgt_mem_grant_MB_staticrc50,
        tgt_mem_grant_MB_staticrc60, tgt_mem_grant_MB_staticrc70, tgt_mem_grant_MB_staticrc80)
    ) AS r3
    UNPIVOT
    (
        slots_used FOR slots_used_all IN (slots_used_smallrc,slots_used_mediumrc,slots_used_largerc,
        slots_used_xlargerc, slots_used_staticrc10, slots_used_staticrc20, slots_used_staticrc30,
        slots_used_staticrc40, slots_used_staticrc50, slots_used_staticrc60, slots_used_staticrc70,
        slots_used_staticrc80)
    ) AS r4
) a
WHERE   up1 = up2
AND     up1 = up3
;
-- Getting current info about workload groups.
WITH  
dmv  
AS  
(
  SELECT
          rp.name                                           AS rp_name
  ,       rp.max_memory_kb*1.0/1048576                      AS rp_max_mem_GB
  ,       (rp.max_memory_kb*1.0/1024)
          *(request_max_memory_grant_percent/100)           AS max_memory_grant_MB
  ,       (rp.max_memory_kb*1.0/1048576)
          *(request_max_memory_grant_percent/100)           AS max_memory_grant_GB
  ,       wg.name                                           AS wg_name
  ,       wg.importance                                     AS importance
  ,       wg.request_max_memory_grant_percent               AS request_max_memory_grant_percent
  FROM    sys.dm_pdw_nodes_resource_governor_workload_groups wg
  JOIN    sys.dm_pdw_nodes_resource_governor_resource_pools rp    ON  wg.pdw_node_id  = rp.pdw_node_id
                                                                  AND wg.pool_id      = rp.pool_id
  WHERE   rp.name = 'SloDWPool'
  GROUP BY
          rp.name
  ,       rp.max_memory_kb
  ,       wg.name
  ,       wg.importance
  ,       wg.request_max_memory_grant_percent
)
-- Creating resource class name mapping.
,names
AS
(
  SELECT 'smallrc' as resource_class, 1 as rc_id
  UNION ALL
    SELECT 'mediumrc', 2
  UNION ALL
    SELECT 'largerc', 3
  UNION ALL
    SELECT 'xlargerc', 4
  UNION ALL
    SELECT 'staticrc10', 5
  UNION ALL
    SELECT 'staticrc20', 6
  UNION ALL
    SELECT 'staticrc30', 7
  UNION ALL
    SELECT 'staticrc40', 8
  UNION ALL
    SELECT 'staticrc50', 9
  UNION ALL
    SELECT 'staticrc60', 10
  UNION ALL
    SELECT 'staticrc70', 11
  UNION ALL
    SELECT 'staticrc80', 12
)
,base AS
(   SELECT  schema_name
    ,       table_name
    ,       SUM(column_count)                   AS column_count
    ,       ISNULL(SUM(short_string_column_count),0)   AS short_string_column_count
    ,       ISNULL(SUM(long_string_column_count),0)    AS long_string_column_count
    FROM    (   SELECT  sm.name                                             AS schema_name
                ,       tb.name                                             AS table_name
                ,       COUNT(co.column_id)                                 AS column_count
                           ,       CASE    WHEN co.system_type_id IN (36,43,106,108,165,167,173,175,231,239) 
                                AND  co.max_length <= 32 
                                THEN COUNT(co.column_id) 
                        END                                                 AS short_string_column_count
                ,       CASE    WHEN co.system_type_id IN (165,167,173,175,231,239) 
                                AND  co.max_length > 32 and co.max_length <=8000
                                THEN COUNT(co.column_id) 
                        END                                                 AS long_string_column_count
                FROM    sys.schemas AS sm
                JOIN    sys.tables  AS tb   on sm.[schema_id] = tb.[schema_id]
                JOIN    sys.columns AS co   ON tb.[object_id] = co.[object_id]
                           WHERE tb.name = @TABLE_NAME AND sm.name = @SCHEMA_NAME
                GROUP BY sm.name
                ,        tb.name
                ,        co.system_type_id
                ,        co.max_length            ) a
GROUP BY schema_name
,        table_name
)
, size AS
(
SELECT  schema_name
,       table_name
,       75497472                                            AS table_overhead

,       column_count*1048576*8                              AS column_size
,       short_string_column_count*1048576*32                       AS short_string_size,       (long_string_column_count*16777216) AS long_string_size
FROM    base
UNION
SELECT CASE WHEN COUNT(*) = 0 THEN 'EMPTY' END as schema_name
         ,CASE WHEN COUNT(*) = 0 THEN 'EMPTY' END as table_name
         ,CASE WHEN COUNT(*) = 0 THEN 0 END as table_overhead
         ,CASE WHEN COUNT(*) = 0 THEN 0 END as column_size
         ,CASE WHEN COUNT(*) = 0 THEN 0 END as short_string_size

,CASE WHEN COUNT(*) = 0 THEN 0 END as long_string_size
FROM   base
)
, load_multiplier as 
(
SELECT  CASE 
                     WHEN FLOOR(8 * (CAST (@DWU_NUM AS FLOAT)/6000)) > 0 THEN FLOOR(8 * (CAST (@DWU_NUM AS FLOAT)/6000)) 
                     ELSE 1 
              END AS multipliplication_factor
) 
       SELECT  r1.DWU
       , schema_name
       , table_name
       , rc.resource_class as closest_rc_in_increasing_order
       , max_queries_at_this_rc = CASE
             WHEN (r1.max_slots / r1.slots_used > r1.max_queries)
                  THEN r1.max_queries
             ELSE r1.max_slots / r1.slots_used
                  END
       , r1.max_slots as max_concurrency_slots
       , r1.slots_used as required_slots_for_the_rc
       , r1.tgt_mem_grant_MB  as rc_mem_grant_MB
       , CAST((table_overhead*1.0+column_size+short_string_size+long_string_size)*multipliplication_factor/1048576    AS DECIMAL(18,2)) AS est_mem_grant_required_for_cci_operation_MB       
       FROM    size, load_multiplier, #ref r1, names  rc
       WHERE r1.rc_id=rc.rc_id
                     AND CAST((table_overhead*1.0+column_size+short_string_size+long_string_size)*multipliplication_factor/1048576    AS DECIMAL(18,2)) < r1.tgt_mem_grant_MB
       ORDER BY ABS(CAST((table_overhead*1.0+column_size+short_string_size+long_string_size)*multipliplication_factor/1048576    AS DECIMAL(18,2)) - r1.tgt_mem_grant_MB)
GO

Priorità delle queryQuery importance

SQL Data Warehouse implementa le classi di risorse utilizzando i gruppi del carico di lavoro.SQL Data Warehouse implements resource classes by using workload groups. Esistono in totale otto gruppi di carichi di lavoro che controllano il comportamento delle classi di risorse nelle DWU di varie dimensioni.There are a total of eight workload groups that control the behavior of the resource classes across the various DWU sizes. Per qualsiasi DWU, SQL Data Warehouse usa solo quattro degli otto gruppi del carico di lavoro.For any DWU, SQL Data Warehouse uses only four of the eight workload groups. Il senso di questo approccio è assegnare a ogni gruppo di carichi di lavoro una delle quattro classi di risorse, tra smallrc, mediumrc, largerc o xlargerc.This makes sense because each workload group is assigned to one of four resource classes: smallrc, mediumrc, largerc, or xlargerc. È importante comprendere per alcuni gruppi di carichi di lavoro viene impostato il livello di prioritàpiù elevato.The importance of understanding the workload groups is that some of these workload groups are set to higher importance. La priorità viene usata per la pianificazione della CPU.Importance is used for CPU scheduling. Le query eseguite con priorità alta otterranno tre volte più cicli della CPU rispetto a quelle con priorità media.Queries run with high importance will get three times more CPU cycles than those with medium importance. Di conseguenza, i mapping degli slot della concorrenza determinano anche la priorità della CPU.Therefore, concurrency slot mappings also determine CPU priority. Quando una query utilizza 16 o più slot, viene eseguita con priorità alta.When a query consumes 16 or more slots, it runs as high importance.

Nella tabella seguente vengono riportati i mapping di priorità per ogni gruppo di carichi di lavoro.The following table shows the importance mappings for each workload group.

Mapping dei gruppi di carichi di lavoro agli slot di concorrenza e relativa importanzaWorkload group mappings to concurrency slots and importance

Gruppi di carichi di lavoroWorkload groups Mapping degli slot di concorrenzaConcurrency slot mapping MB/DistribuzioneMB / Distribution Mapping delle prioritàImportance mapping
SloDWGroupC00SloDWGroupC00 11 100100 MediaMedium
SloDWGroupC01SloDWGroupC01 22 200200 MediaMedium
SloDWGroupC02SloDWGroupC02 44 400400 MediaMedium
SloDWGroupC03SloDWGroupC03 88 800800 MediaMedium
SloDWGroupC04SloDWGroupC04 1616 1.6001,600 AltoHigh
SloDWGroupC05SloDWGroupC05 3232 3.2003,200 AltoHigh
SloDWGroupC06SloDWGroupC06 6464 6.4006,400 AltoHigh
SloDWGroupC07SloDWGroupC07 128128 12.80012,800 AltoHigh

Come illustrato nel grafico Allocation and consumption of concurrency slots (Allocazione e utilizzo degli slot di concorrenza), DW500 utilizza 1, 4, 8 o 16 slot di concorrenza per smallrc, mediumrc, largerc e xlargerc rispettivamente.From the Allocation and consumption of concurrency slots chart, you can see that a DW500 uses 1, 4, 8 or 16 concurrency slots for smallrc, mediumrc, largerc, and xlargerc, respectively. È possibile cercare questi valori nel grafico precedente per identificare la priorità di ciascuna classe di risorse.You can look those values up in the preceding chart to find the importance for each resource class.

Mapping dell'importanza delle classi di risorse in DW500DW500 mapping of resource classes to importance

classe di risorseResource class Gruppo del carico di lavoroWorkload group Numero di slot di concorrenza usatiConcurrency slots used MB/DistribuzioneMB / Distribution prioritàImportance
smallrcsmallrc SloDWGroupC00SloDWGroupC00 11 100100 MediaMedium
mediumrcmediumrc SloDWGroupC02SloDWGroupC02 44 400400 MediaMedium
largerclargerc SloDWGroupC03SloDWGroupC03 88 800800 MediaMedium
xlargercxlargerc SloDWGroupC04SloDWGroupC04 1616 1.6001,600 AltoHigh
staticrc10staticrc10 SloDWGroupC00SloDWGroupC00 11 100100 MediaMedium
staticrc20staticrc20 SloDWGroupC01SloDWGroupC01 22 200200 MediaMedium
staticrc30staticrc30 SloDWGroupC02SloDWGroupC02 44 400400 MediaMedium
staticrc40staticrc40 SloDWGroupC03SloDWGroupC03 88 800800 MediaMedium
staticrc50staticrc50 SloDWGroupC03SloDWGroupC03 1616 1.6001,600 AltoHigh
staticrc60staticrc60 SloDWGroupC03SloDWGroupC03 1616 1.6001,600 AltoHigh
staticrc70staticrc70 SloDWGroupC03SloDWGroupC03 1616 1.6001,600 AltoHigh
staticrc80staticrc80 SloDWGroupC03SloDWGroupC03 1616 1.6001,600 AltoHigh

Per esaminare in dettaglio le differenze nell'allocazione delle risorse di memoria dal punto di vista di resource governor o per analizzare l'utilizzo attivo e cronologico dei gruppi di carichi di lavoro in caso di risoluzione dei problemi, è possibile usare la query DMV seguente:You can use the following DMV query to look at the differences in memory resource allocation in detail from the perspective of the resource governor, or to analyze active and historic usage of the workload groups when troubleshooting.

WITH rg
AS
(   SELECT  
     pn.name                        AS node_name
    ,pn.[type]                        AS node_type
    ,pn.pdw_node_id                    AS node_id
    ,rp.name                        AS pool_name
    ,rp.max_memory_kb*1.0/1024                AS pool_max_mem_MB
    ,wg.name                        AS group_name
    ,wg.importance                    AS group_importance
    ,wg.request_max_memory_grant_percent        AS group_request_max_memory_grant_pcnt
    ,wg.max_dop                        AS group_max_dop
    ,wg.effective_max_dop                AS group_effective_max_dop
    ,wg.total_request_count                AS group_total_request_count
    ,wg.total_queued_request_count            AS group_total_queued_request_count
    ,wg.active_request_count                AS group_active_request_count
    ,wg.queued_request_count                AS group_queued_request_count
    FROM    sys.dm_pdw_nodes_resource_governor_workload_groups wg
    JOIN    sys.dm_pdw_nodes_resource_governor_resource_pools rp    
            ON  wg.pdw_node_id  = rp.pdw_node_id
            AND wg.pool_id      = rp.pool_id
    JOIN    sys.dm_pdw_nodes pn
            ON    wg.pdw_node_id    = pn.pdw_node_id
    WHERE   wg.name like 'SloDWGroup%'
        AND     rp.name = 'SloDWPool'
)
SELECT    pool_name
,        pool_max_mem_MB
,        group_name
,        group_importance
,        (pool_max_mem_MB/100)*group_request_max_memory_grant_pcnt AS max_memory_grant_MB
,        node_name
,        node_type
,       group_total_request_count
,       group_total_queued_request_count
,       group_active_request_count
,       group_queued_request_count
FROM    rg
ORDER BY
    node_name
,    group_request_max_memory_grant_pcnt
,    group_importance
;

Query che rispettano i limiti di concorrenzaQueries that honor concurrency limits

La maggior parte delle query è regolata da classi di risorse.Most queries are governed by resource classes. Queste query devono rientrare in entrambe le soglie delle query simultanee e degli slot di concorrenza.These queries must fit inside both the concurrent query and concurrency slot thresholds. Un utente può scegliere di escludere una query dal modello di slot di concorrenza.A user cannot choose to exclude a query from the concurrency slot model.

Le istruzioni seguenti rispettano le classi di risorse:To reiterate, the following statements honor resource classes:

  • INSERT SELECTINSERT-SELECT
  • AGGIORNAMENTOUPDATE
  • DELETEDELETE
  • SELEZIONARE (quando si esegue una query sulle tabelle utente)SELECT (when querying user tables)
  • ALTER INDEX REBUILDALTER INDEX REBUILD
  • ALTER INDEX REORGANIZEALTER INDEX REORGANIZE
  • MODIFICA TABELLA RICOMPILAZIONEALTER TABLE REBUILD
  • CREATE INDEXCREATE INDEX
  • CREARE L'INDICE COLUMNSTORE CLUSTERCREATE CLUSTERED COLUMNSTORE INDEX
  • CREATE TABLE AS SELECT (CTAS)CREATE TABLE AS SELECT (CTAS)
  • Caricamento dei datiData loading
  • Operazioni di spostamento dati condotte dal Servizio di spostamento dati (DMS)Data movement operations conducted by the Data Movement Service (DMS)

Eccezioni query ai limiti di concorrenzaQuery exceptions to concurrency limits

Alcune query non rispettano la classe di risorse alla quale è assegnato l'utente.Some queries do not honor the resource class to which the user is assigned. Queste eccezioni ai limiti di concorrenza vengono effettuate quando le risorse di memoria necessarie per un particolare comando sono basse, spesso perché il comando è un'operazione dei metadati.These exceptions to the concurrency limits are made when the memory resources needed for a particular command are low, often because the command is a metadata operation. Con queste eccezioni, si intende evitare l'allocazione di più memoria alle query che non ne hanno bisogno.The goal of these exceptions is to avoid larger memory allocations for queries that will never need them. In questi casi, viene sempre usata la classe di risorse piccola predefinita (smallrc), indipendentemente dalla classe di risorse effettivamente assegnata all'utente.In these cases, the default small resource class (smallrc) is always used regardless of the actual resource class assigned to the user. Ad esempio, in smallrc verrà sempre eseguita CREATE LOGIN .For example, CREATE LOGIN will always run in smallrc. Le risorse necessarie per svolgere questa operazione sono molto ridotte e non avrebbe senso includere la query nel modello di slot di concorrenza.The resources required to fulfill this operation are very low, so it does not make sense to include the query in the concurrency slot model. Per queste query non è previsto il limite di 32 utenti simultanei; è possibile eseguire un numero illimitato di queste query fino al limite di 1.024 sessioni.These queries are also not limited by the 32 user concurrency limit, an unlimited number of these queries can run up to the session limit of 1,024 sessions.

Le istruzioni seguenti non rispettano le classi di risorse:The following statements do not honor resource classes:

  • CREATE o DROP TABLECREATE or DROP TABLE
  • ALTER TABLE... SWITCH, SPLIT o MERGE PARTITIONALTER TABLE ... SWITCH, SPLIT, or MERGE PARTITION
  • ALTER INDEX DISABLEALTER INDEX DISABLE
  • DROP INDEXDROP INDEX
  • CREATE, UPDATE o DROP STATISTICSCREATE, UPDATE, or DROP STATISTICS
  • TRUNCATE TABLETRUNCATE TABLE
  • ALTER AUTHORIZATIONALTER AUTHORIZATION
  • CREATE LOGINCREATE LOGIN
  • CREATE, ALTER o DROP USERCREATE, ALTER or DROP USER
  • CREATE, ALTER o DROP PROCEDURECREATE, ALTER or DROP PROCEDURE
  • CREATE o DROP VIEWCREATE or DROP VIEW
  • INSERT VALUESINSERT VALUES
  • SELECT da viste di sistema e DMVSELECT from system views and DMVs
  • EXPLAINEXPLAIN
  • DBCCDBCC

Esempio di modifica della classe di risorse di un utenteChange a user resource class example

  1. Creare un account di accesso: aprire una connessione al database master nel server SQL che ospita il database SQL Data Warehouse ed eseguire i comandi seguenti.Create login: Open a connection to your master database on the SQL server hosting your SQL Data Warehouse database and execute the following commands.

    CREATE LOGIN newperson WITH PASSWORD = 'mypassword';
    CREATE USER newperson for LOGIN newperson;
    

    Nota

    È consigliabile creare un utente nel database master per gli utenti di SQL Data Warehouse di Azure.It is a good idea to create a user in the master database for Azure SQL Data Warehouse users. La creazione di un utente nel database master consente all'utente di accedere tramite strumenti come SSMS senza specificare un nome di database.Creating a user in master allows a user to login using tools like SSMS without specifying a database name. Consente inoltre di usare Esplora oggetti per visualizzare tutti i database in SQL server.It also allows them to use the object explorer to view all databases on a SQL server. Per altre informazioni su creazione e gestione degli utenti, vedere Proteggere un database in SQL Data Warehouse.For more details about creating and managing users, see Secure a database in SQL Data Warehouse.

  2. Creare un utente di SQL Data Warehouse: aprire una connessione al database di SQL Data Warehouse ed eseguire il comando seguente.Create SQL Data Warehouse user: Open a connection to the SQL Data Warehouse database and execute the following command.

    CREATE USER newperson FOR LOGIN newperson;
    
  3. Concedere le autorizzazioni: nell'esempio seguente viene concessa l'autorizzazione CONTROL nel database SQL Data Warehouse.Grant permissions: The following example grants CONTROL on the SQL Data Warehouse database. CONTROL a livello di database corrisponde a db_owner in SQL Server.CONTROL at the database level is the equivalent of db_owner in SQL Server.

    GRANT CONTROL ON DATABASE::MySQLDW to newperson;
    
  4. Aumentare la classe di risorse: per aggiungere un utente a un ruolo di gestione del carico di lavoro più elevato, usare la query seguente.Increase resource class: Use the following query to add a user to a higher workload management role.

    EXEC sp_addrolemember 'largerc', 'newperson'
    
  5. Diminuire la classe di risorse: per rimuovere un utente da un ruolo di gestione del carico di lavoro, usare la query seguente.Decrease resource class: Use the following query to remove a user from a workload management role.

    EXEC sp_droprolemember 'largerc', 'newperson';
    

    Nota

    Non è possibile rimuovere un utente da smallrc.It is not possible to remove a user from smallrc.

Rilevamento di query in coda e altre viste a gestione dinamicaQueued query detection and other DMVs

È possibile utilizzare la DMV sys.dm_pdw_exec_requests per identificare le query in attesa in una coda di concorrenza.You can use the sys.dm_pdw_exec_requests DMV to identify queries that are waiting in a concurrency queue. Le query in attesa di uno slot di concorrenza saranno in stato sospeso.Queries waiting for a concurrency slot will have a status of suspended.

SELECT      r.[request_id]                 AS Request_ID
        ,r.[status]                 AS Request_Status
        ,r.[submit_time]             AS Request_SubmitTime
        ,r.[start_time]                 AS Request_StartTime
        ,DATEDIFF(ms,[submit_time],[start_time]) AS Request_InitiateDuration_ms
        ,r.resource_class                         AS Request_resource_class
FROM    sys.dm_pdw_exec_requests r;

I ruoli di gestione del carico di lavoro possono essere visualizzati con sys.database_principals.Workload management roles can be viewed with sys.database_principals.

SELECT  ro.[name]           AS [db_role_name]
FROM    sys.database_principals ro
WHERE   ro.[type_desc]      = 'DATABASE_ROLE'
AND     ro.[is_fixed_role]  = 0;

La query seguente mostra il ruolo a cui è assegnato ogni utente.The following query shows which role each user is assigned to.

SELECT     r.name AS role_principal_name
        ,m.name AS member_principal_name
FROM    sys.database_role_members rm
JOIN    sys.database_principals AS r            ON rm.role_principal_id        = r.principal_id
JOIN    sys.database_principals AS m            ON rm.member_principal_id    = m.principal_id
WHERE    r.name IN ('mediumrc','largerc', 'xlargerc');

SQL Data Warehouse prevede i tipi di attesa seguenti.SQL Data Warehouse has the following wait types:

  • LocalQueriesConcurrencyResourceType: query che si trovano all'esterno del framework di slot di concorrenza.LocalQueriesConcurrencyResourceType: Queries that sit outside of the concurrency slot framework. Le query DMV e le funzioni di sistema come SELECT @@VERSION sono esempi di query locali.DMV queries and system functions such as SELECT @@VERSION are examples of local queries.
  • UserConcurrencyResourceType: query che si trovano all'interno del framework di slot di concorrenza.UserConcurrencyResourceType: Queries that sit inside the concurrency slot framework. Le query sulle tabelle dell'utente finale rappresentano esempi in cui si usa questo tipo di risorsa.Queries against end-user tables represent examples that would use this resource type.
  • DmsConcurrencyResourceType: attese risultanti dalle operazioni di spostamento dei dati.DmsConcurrencyResourceType: Waits resulting from data movement operations.
  • BackupConcurrencyResourceType: indica che è in esecuzione il backup di un database.BackupConcurrencyResourceType: This wait indicates that a database is being backed up. Il valore massimo per questo tipo di risorsa è 1.The maximum value for this resource type is 1. Se più copie di backup sono stati richieste contemporaneamente, le altre verranno accodate.If multiple backups have been requested at the same time, the others will queue.

La DMV sys.dm_pdw_waits può essere usata per visualizzare le risorse per cui una richiesta è in attesa.The sys.dm_pdw_waits DMV can be used to see which resources a request is waiting for.

SELECT  w.[wait_id]
,       w.[session_id]
,       w.[type]            AS Wait_type
,       w.[object_type]
,       w.[object_name]
,       w.[request_id]
,       w.[request_time]
,       w.[acquire_time]
,       w.[state]
,       w.[priority]
,    SESSION_ID()            AS Current_session
,    s.[status]            AS Session_status
,    s.[login_name]
,    s.[query_count]
,    s.[client_id]
,    s.[sql_spid]
,    r.[command]            AS Request_command
,    r.[label]
,    r.[status]            AS Request_status
,    r.[submit_time]
,    r.[start_time]
,    r.[end_compile_time]
,    r.[end_time]
,    DATEDIFF(ms,r.[submit_time],r.[start_time])        AS Request_queue_time_ms
,    DATEDIFF(ms,r.[start_time],r.[end_compile_time])    AS Request_compile_time_ms
,    DATEDIFF(ms,r.[end_compile_time],r.[end_time])        AS Request_execution_time_ms
,    r.[total_elapsed_time]
FROM    sys.dm_pdw_waits w
JOIN    sys.dm_pdw_exec_sessions s  ON w.[session_id] = s.[session_id]
JOIN    sys.dm_pdw_exec_requests r  ON w.[request_id] = r.[request_id]
WHERE    w.[session_id] <> SESSION_ID();

La DMV sys.dm_pdw_resource_waits mostra solo le attese di risorse utilizzate da una determinata query.The sys.dm_pdw_resource_waits DMV shows only the resource waits consumed by a given query. Il tempo in attesa delle risorse misura solo il tempo richiesto per fornire le risorse, a differenza del tempo di attesa del segnale che rappresenta il tempo impiegato dal server SQL Server sottostante per pianificare la query sulla CPU.Resource wait time only measures the time waiting for resources to be provided, as opposed to signal wait time, which is the time it takes for the underlying SQL servers to schedule the query onto the CPU.

SELECT  [session_id]
,       [type]
,       [object_type]
,       [object_name]
,       [request_id]
,       [request_time]
,       [acquire_time]
,       DATEDIFF(ms,[request_time],[acquire_time])  AS acquire_duration_ms
,       [concurrency_slots_used]                    AS concurrency_slots_reserved
,       [resource_class]
,       [wait_id]                                   AS queue_position
FROM    sys.dm_pdw_resource_waits
WHERE    [session_id] <> SESSION_ID();

L DMV sys.dm_pdw_wait_stats può essere usata per l'analisi della tendenza cronologica delle attese.The sys.dm_pdw_wait_stats DMV can be used for historic trend analysis of waits.

SELECT    w.[pdw_node_id]
,        w.[wait_name]
,        w.[max_wait_time]
,        w.[request_count]
,        w.[signal_time]
,        w.[completed_count]
,        w.[wait_time]
FROM    sys.dm_pdw_wait_stats w;

Passaggi successiviNext steps

Per altre informazioni sulla gestione degli utenti e della sicurezza del database, vedere Proteggere un database in SQL Data Warehouse.For more information about managing database users and security, see Secure a database in SQL Data Warehouse. Per ulteriori informazioni sulle classi di risorse più grandi che possono migliorare le qualità degli indici indice columnstore cluster, vedere Ricompilazione degli indici per migliorare la qualità del segmento.For more information about how larger resource classes can improve clustered columnstore index quality, see [Rebuilding indexes to improve segment quality].