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

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

Débogage

Le débogueur Visual Studio ajoute deux nouvelles fenêtres Piles parallèles et Tâches parallèles. Pour plus d'informations, consultez Procédure pas à pas : débogage d'une application parallèle.

Profilage

Les outils de profilage Visual Studio Team Developer 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é :

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 :

• Concurrency::ConcRTEventGuid

• Concurrency::ScheduleGroupEventGuid

• Concurrency::ChoreEventGuid

• Concurrency::LockEventGuid

• Concurrency::ResourceManagerEventGuid

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

Historique des modifications