Outils de diagnostic parallèles (runtime d'accès concurrentiel)

Article
06/09/2015

Visual Studio fournit une prise en charge étendue du débogage et du profilage d'applications multithread.

Débogage

Le débogueur Visual Studio inclut la fenêtre Piles parallèles, la fenêtre Tâches en parallèle, et la fenêtre Espion parallèle. Pour plus d’informations, consultez Procédure pas à pas : débogage d'une application parallèle et Comment : utiliser la fenêtre Espion parallèle.

Profilage

Les outils de profilage fournissent trois vues de données qui affichent des informations graphiques, tabulaires et numériques concernant la manière dont une application multithread interagit avec elle-même et avec d'autres programmes. Les vues vous permettent d'identifier rapidement les zones à problème et de naviguer à partir de points sur les affichages graphiques vers des piles d'appels, des sites d'appels et du code source. Pour plus d'informations, consultez Visualiseur concurrence.

Suivi d'événements

Le runtime d'accès concurrentiel utilise le Suivi d'événements pour Windows (ETW) pour informer les outils d'instrumentation, tels que les profileurs, lorsque certains événements se produisent. Il peut notamment s'agir des événements suivants : lorsqu'un planificateur est activé ou désactivé, lorsqu'un contexte commence, se termine, se bloque, se débloque ou cède, et lorsqu'un algorithme parallèle commence ou se termine.

Les outils, tel que le Visualiseur concurrence, utilisent cette fonctionnalité. Par conséquent, vous ne devez généralement pas utiliser ces événements directement. Toutefois, ces événements sont utiles lorsque vous développez un profileur personnalisé ou lorsque vous utilisez des outils de suivi d'événements, tel que Xperf.

Le runtime d'accès concurrentiel déclenche ces événements uniquement lorsque le suivi est activé. Appelez la fonction concurrency::EnableTracing pour activer le suivi d'événements et la fonction concurrency::DisableTracing pour désactiver le suivi.

Le tableau suivant décrit les événements que le runtime déclenche lorsque le suivi d'événements est activé :

Événement	Description	Valeur
concurrency::ConcRT_ProviderGuid	Identificateur du fournisseur ETW pour le runtime d'accès concurrentiel.	f7b697a3-4db5-4d3b-be71-c4d284e6592f
concurrency::ContextEventGuid	Marque les événements qui sont associés aux contextes.	5727a00f-50be-4519-8256-f7699871fecb
concurrency::PPLParallelForEventGuid	Marque le début et la fin des appels à l'algorithme concurrency::parallel_for.	31c8da6b-6165-4042-8b92-949e315f4d84
concurrency::PPLParallelForeachEventGuid	Marque le début et la fin des appels à l'algorithme concurrency::parallel_for_each.	5cb7d785-9d66-465d-bae1-4611061b5434
concurrency::PPLParallelInvokeEventGuid	Marque le début et la fin des appels à l'algorithme concurrency::parallel_invoke.	d1b5b133-ec3d-49f4-98a3-464d1a9e4682
concurrency::SchedulerEventGuid	Marque les événements qui sont associés au Planificateur de tâches.	e2091f8a-1e0a-4731-84a2-0dd57c8a5261
concurrency::VirtualProcessorEventGuid	Marque les événements qui sont associés aux processeurs virtuels.	2f27805f-1676-4ecc-96fa-7eb09d44302f

Le runtime d'accès concurrentiel définit, mais ne déclenche pas pour l'instant, les événements suivants. Le runtime réserve ces événements pour une utilisation ultérieure :

L'énumération concurrency::ConcRT_EventType spécifie les opérations qu'un événement peut suivre. Par exemple, au début de l'algorithme parallel_for, le runtime déclenche l'événement PPLParallelForEventGuid et fournit CONCRT_EVENT_START en tant qu'opération. Avant que l'algorithme parallel_for retourne une valeur, le runtime déclenche à nouveau l'événement PPLParallelForEventGuid et fournit CONCRT_EVENT_END en tant qu'opération.

L'exemple suivant montre comment activer le suivi pour un appel à parallel_for. Le runtime n'effectue pas le suivi du premier appel à parallel_for car le suivi n'est pas activé. L'appel à EnableTracing permet au runtime d'effectuer le suivi du deuxième appel à parallel_for.

// etw.cpp 
// compile with: /EHsc 
#include <ppl.h>

using namespace concurrency;

int wmain()
{
   // Perform some parallel work.  
   // Event tracing is disabled at this point.
   parallel_for(0, 10000, [](int i) {
      // TODO: Perform work.
   });

   // Enable tracing for a second call to parallel_for.
   EnableTracing();
   parallel_for(0, 10000, [](int i) {
      // TODO: Perform work.
   });   
   DisableTracing();
}

Le runtime assure le suivi du nombre de fois que vous appelez EnableTracing et DisableTracing. Par conséquent, si vous appelez EnableTracing plusieurs fois, vous devez appeler DisableTracing le même nombre de fois pour désactiver le suivi.

Voir aussi

Concepts

Concurrency Runtime

Partager via