Procedura dettagliata: debug di un'applicazione parallela in Visual Studio (C#, Visual Basic, C++)

Questa procedura dettagliata illustra come usare le finestre Attività parallele e Stack paralleli per eseguire il debug di un'applicazione parallela. Queste finestre consentono di comprendere e verificare il comportamento di runtime del codice che usa la libreria TPL (Task Parallel Library) o il runtime di concorrenza. Questa procedura dettagliata fornisce codice di esempio con punti di interruzione predefiniti. Dopo l'interruzione del codice, la guida dettagliata illustra come usare le finestre Attività parallele e Stack paralleli per esaminarlo.

Questa procedura dettagliata illustra queste attività:

• Come visualizzare gli stack di chiamate di tutti i thread in una sola visualizzazione.

• Come visualizzare l'elenco di System.Threading.Tasks.Task istanze create nell'applicazione.

• Come visualizzare gli stack di chiamate reali delle attività anziché i thread.

• Come passare al codice dalle finestre Attività parallele e Stack paralleli .

• Modalità di ridimensionamento delle finestre tramite raggruppamento, zoom e altre funzionalità correlate.

Prerequisiti

Questa procedura dettagliata presuppone che Just My Code sia abilitato (è abilitato per impostazione predefinita nelle versioni più recenti di Visual Studio). Nel menu Strumenti selezionare Opzioni, espandere il nodo Debug , selezionare Generale e quindi selezionare Abilita Just My Code (solo gestito) . Se non si imposta questa funzionalità, è comunque possibile usare questa procedura dettagliata, ma i risultati potrebbero differire dalle illustrazioni.

Esempio in C#

Se si usa l'esempio C#, questa procedura dettagliata presuppone anche che il codice esterno sia nascosto. Per attivare o disattivare la visualizzazione di codice esterno, fare clic con il pulsante destro del mouse sull'intestazione della tabella Nome della finestra Stack di chiamate e quindi selezionare o deselezionare Mostra codice esterno. Se non si imposta questa funzionalità, è comunque possibile usare questa procedura dettagliata, ma i risultati potrebbero differire dalle illustrazioni.

Esempio di C++

Se si usa l'esempio C++, è possibile ignorare i riferimenti al codice esterno in questo articolo. Il codice esterno si applica solo all'esempio C#.

Illustrazioni

Le illustrazioni in questo articolo vengono registrate in un computer quad core che esegue l'esempio C#. Sebbene sia possibile usare altre configurazioni per completare questa procedura dettagliata, le illustrazioni potrebbero differire da quelle visualizzate nel computer.

Creare il progetto di esempio

Il codice di esempio in questa procedura dettagliata riguarda un'applicazione che non esegue alcuna operazione. Lo scopo dell'esercizio è comprendere come usare le finestre degli strumenti per eseguire il debug di un'applicazione parallela.

1. Aprire Visual Studio e creare un nuovo progetto.

   Se la finestra iniziale non è aperta, scegliere Finestradi avvio>.

   Nella finestra iniziale scegliere Nuovo progetto.

   Nella finestra Crea un nuovo progetto immettere o digitare console nella casella di ricerca. Scegliere quindi C#, C++o Visual Basic dall'elenco Linguaggio e quindi scegliere Windows dall'elenco Piattaforma.

   Dopo aver applicato i filtri del linguaggio e della piattaforma, scegliere l'app console per .NET Core o C++, quindi scegliere Avanti.

   Annotazioni

   Se non vedi il modello corretto, vai a Strumenti>Recupera strumenti e funzionalità... Verrà aperto il programma di installazione di Visual Studio. Scegliere il carico di lavoro Sviluppo di desktop .NET o Sviluppo di applicazioni desktop con C++ e quindi scegliere Modifica.

   Nella finestra Configura il nuovo progetto digitare un nome o usare il nome predefinito nella casella Nome progetto . Quindi, scegliere Avanti o Crea, qualunque opzione sia disponibile.

   Per .NET Core scegliere il framework di destinazione consigliato o .NET 8 e quindi scegliere Crea.

   Appare un nuovo progetto console. Dopo aver creato il progetto, viene visualizzato un file di origine.

2. Aprire il file di codice .cpp, .cs o .vb nel progetto. Eliminare il contenuto per creare un file di codice vuoto.

3. Incollare il codice seguente per la lingua scelta nel file di codice vuoto.

   C#

   using System;
   using System.Threading;
   using System.Threading.Tasks;
   using System.Diagnostics;
   
   class S
   {
     static void Main()
     {
       pcount = Environment.ProcessorCount;
       Console.WriteLine("Proc count = " + pcount);
       ThreadPool.SetMinThreads(4, -1);
       ThreadPool.SetMaxThreads(4, -1);
   
       t1 = new Task(A, 1);
       t2 = new Task(A, 2);
       t3 = new Task(A, 3);
       t4 = new Task(A, 4);
       Console.WriteLine("Starting t1 " + t1.Id.ToString());
       t1.Start();
       Console.WriteLine("Starting t2 " + t2.Id.ToString());
       t2.Start();
       Console.WriteLine("Starting t3 " + t3.Id.ToString());
       t3.Start();
       Console.WriteLine("Starting t4 " + t4.Id.ToString());
       t4.Start();
   
       Console.ReadLine();
     }
   
     static void A(object o)
     {
       B(o);
     }
     static void B(object o)
     {
       C(o);
     }
     static void C(object o)
     {
       int temp = (int)o;
   
       Interlocked.Increment(ref aa);
       while (aa < 4)
       {
         ;
       }
   
       if (temp == 1)
       {
         // BP1 - all tasks in C
         Debugger.Break();
         waitFor1 = false;
       }
       else
       {
         while (waitFor1)
         {
           ;
         }
       }
       switch (temp)
       {
         case 1:
           D(o);
           break;
         case 2:
           F(o);
           break;
         case 3:
         case 4:
           I(o);
           break;
         default:
           Debug.Assert(false, "fool");
           break;
       }
     }
     static void D(object o)
     {
       E(o);
     }
     static void E(object o)
     {
       // break here at the same time as H and K
       while (bb < 2)
       {
         ;
       }
       //BP2 - 1 in E, 2 in H, 3 in J, 4 in K
       Debugger.Break();
       Interlocked.Increment(ref bb);
   
       //after
       L(o);
     }
     static void F(object o)
     {
       G(o);
     }
     static void G(object o)
     {
       H(o);
     }
     static void H(object o)
     {
       // break here at the same time as E and K
       Interlocked.Increment(ref bb);
       Monitor.Enter(mylock);
       while (bb < 3)
       {
         ;
       }
       Monitor.Exit(mylock);
   
   
       //after
       L(o);
     }
     static void I(object o)
     {
       J(o);
     }
     static void J(object o)
     {
       int temp2 = (int)o;
   
       switch (temp2)
       {
         case 3:
           t4.Wait();
           break;
         case 4:
           K(o);
           break;
         default:
           Debug.Assert(false, "fool2");
           break;
       }
     }
     static void K(object o)
     {
       // break here at the same time as E and H
       Interlocked.Increment(ref bb);
       Monitor.Enter(mylock);
       while (bb < 3)
       {
         ;
       }
       Monitor.Exit(mylock);
   
   
       //after
       L(o);
     }
     static void L(object oo)
     {
       int temp3 = (int)oo;
   
       switch (temp3)
       {
         case 1:
           M(oo);
           break;
         case 2:
           N(oo);
           break;
         case 4:
           O(oo);
           break;
         default:
           Debug.Assert(false, "fool3");
           break;
       }
     }
     static void M(object o)
     {
       // breaks here at the same time as N and Q
       Interlocked.Increment(ref cc);
       while (cc < 3)
       {
         ;
       }
       //BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
       Debugger.Break();
       Interlocked.Increment(ref cc);
       while (true)
         Thread.Sleep(500); // for ever
     }
     static void N(object o)
     {
       // breaks here at the same time as M and Q
       Interlocked.Increment(ref cc);
       while (cc < 4)
       {
         ;
       }
       R(o);
     }
     static void O(object o)
     {
       Task t5 = Task.Factory.StartNew(P, TaskCreationOptions.AttachedToParent);
       t5.Wait();
       R(o);
     }
     static void P()
     {
       Console.WriteLine("t5 runs " + Task.CurrentId.ToString());
       Q();
     }
     static void Q()
     {
       // breaks here at the same time as N and M
       Interlocked.Increment(ref cc);
       while (cc < 4)
       {
         ;
       }
       // task 5 dies here freeing task 4 (its parent)
       Console.WriteLine("t5 dies " + Task.CurrentId.ToString());
       waitFor5 = false;
     }
     static void R(object o)
     {
       if ((int)o == 2)
       {
         //wait for task5 to die
         while (waitFor5) { ;}
   
   
         int i;
         //spin up all procs
         for (i = 0; i < pcount - 4; i++)
         {
           Task t = Task.Factory.StartNew(() => { while (true);});
           Console.WriteLine("Started task " + t.Id.ToString());
         }
   
         Task.Factory.StartNew(T, i + 1 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, i + 2 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, i + 3 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, i + 4 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, (i + 5 + 5).ToString(), TaskCreationOptions.AttachedToParent); //scheduled
   
         //BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died
         Debugger.Break();
       }
       else
       {
         Debug.Assert((int)o == 4);
         t3.Wait();
       }
     }
     static void T(object o)
     {
       Console.WriteLine("Scheduled run " + Task.CurrentId.ToString());
     }
     static Task t1, t2, t3, t4;
     static int aa = 0;
     static int bb = 0;
     static int cc = 0;
     static bool waitFor1 = true;
     static bool waitFor5 = true;
     static int pcount;
     static S mylock = new S();
   }
   

   VB

   Imports System
   Imports System.Threading
   Imports System.Threading.Tasks
   Imports System.Diagnostics
   
   Module S
   
     Sub Main()
   
       pcount = Environment.ProcessorCount
       Console.WriteLine("Proc count = " + pcount.ToString())
       ThreadPool.SetMinThreads(4, -1)
       ThreadPool.SetMaxThreads(4, -1)
   
       t1 = New Task(AddressOf A, 1)
       t2 = New Task(AddressOf A, 2)
       t3 = New Task(AddressOf A, 3)
       t4 = New Task(AddressOf A, 4)
       Console.WriteLine("Starting t1 " + t1.Id.ToString())
       t1.Start()
       Console.WriteLine("Starting t2 " + t2.Id.ToString())
       t2.Start()
       Console.WriteLine("Starting t3 " + t3.Id.ToString())
       t3.Start()
       Console.WriteLine("Starting t4 " + t4.Id.ToString())
       t4.Start()
   
       Console.ReadLine()
     End Sub
     Sub A(ByVal o As Object)
       B(o)
     End Sub
     Sub B(ByVal o As Object)
       C(o)
     End Sub
     Sub C(ByVal o As Object)
   
       Dim temp As Integer = o
   
       Interlocked.Increment(aa)
       While (aa < 4)
       End While
   
       If (temp = 1) Then
         ' BP1 - all tasks in C
         Debugger.Break()
         waitFor1 = False
       Else
         While (waitFor1)
         End While
       End If
       Select Case temp
         Case 1
           D(o)
         Case 2
           F(o)
         Case 3, 4
           I(o)
         Case Else
           Debug.Assert(False, "fool")
       End Select
     End Sub
     Sub D(ByVal o As Object)
       E(o)
     End Sub
     Sub E(ByVal o As Object)
       ' break here at the same time as H and K
       While (bb < 2)
       End While
       'BP2 - 1 in E, 2 in H, 3 in J, 4 in K
       Debugger.Break()
       Interlocked.Increment(bb)
   
       'after
       L(o)
     End Sub
     Sub F(ByVal o As Object)
       G(o)
     End Sub
     Sub G(ByVal o As Object)
       H(o)
     End Sub
     Sub H(ByVal o As Object)
       ' break here at the same time as E and K
       Interlocked.Increment(bb)
       Monitor.Enter(mylock)
       While (bb < 3)
       End While
       Monitor.Exit(mylock)
   
       'after
       L(o)
     End Sub
     Sub I(ByVal o As Object)
       J(o)
     End Sub
     Sub J(ByVal o As Object)
   
       Dim temp2 As Integer = o
   
       Select Case temp2
         Case 3
           t4.Wait()
         Case 4
           K(o)
         Case Else
           Debug.Assert(False, "fool2")
       End Select
     End Sub
     Sub K(ByVal o As Object)
       ' break here at the same time as E and H
       Interlocked.Increment(bb)
       Monitor.Enter(mylock)
       While (bb < 3)
       End While
       Monitor.Exit(mylock)
   
       'after
       L(o)
     End Sub
     Sub L(ByVal oo As Object)
       Dim temp3 As Integer = oo
   
       Select Case temp3
         Case 1
           M(oo)
         Case 2
           N(oo)
         Case 4
           O(oo)
         Case Else
           Debug.Assert(False, "fool3")
       End Select
     End Sub
     Sub M(ByVal o As Object)
       ' breaks here at the same time as N and Q
       Interlocked.Increment(cc)
       While (cc < 3)
       End While
   
       'BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
       Debugger.Break()
       Interlocked.Increment(cc)
       While (True)
         Thread.Sleep(500) '  for ever
       End While
     End Sub
     Sub N(ByVal o As Object)
       ' breaks here at the same time as M and Q
       Interlocked.Increment(cc)
       While (cc < 4)
       End While
       R(o)
     End Sub
     Sub O(ByVal o As Object)
       Dim t5 As Task = Task.Factory.StartNew(AddressOf P, TaskCreationOptions.AttachedToParent)
       t5.Wait()
       R(o)
     End Sub
     Sub P()
       Console.WriteLine("t5 runs " + Task.CurrentId.ToString())
       Q()
     End Sub
     Sub Q()
       ' breaks here at the same time as N and M
       Interlocked.Increment(cc)
       While (cc < 4)
       End While
       ' task 5 dies here freeing task 4 (its parent)
       Console.WriteLine("t5 dies " + Task.CurrentId.ToString())
       waitFor5 = False
     End Sub
     Sub R(ByVal o As Object)
       If (o = 2) Then
         ' wait for task5 to die
         While waitFor5
         End While
   
         '//spin up all procs
         Dim i As Integer
         For i = 0 To pcount - 4 - 1
   
           Dim t As Task = Task.Factory.StartNew(Sub()
                                                   While True
   
                                                   End While
                                                 End Sub)
           Console.WriteLine("Started task " + t.Id.ToString())
         Next
   
         Task.Factory.StartNew(AddressOf T, i + 1 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, i + 2 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, i + 3 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, i + 4 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, (i + 5 + 5).ToString(), TaskCreationOptions.AttachedToParent) ' //scheduled
   
         '//BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died
         Debugger.Break()
   
       Else
         Debug.Assert(o = 4)
         t3.Wait()
       End If
     End Sub
     Sub T(ByVal o As Object)
       Console.WriteLine("Scheduled run " + Task.CurrentId.ToString())
     End Sub
     Private t1, t2, t3, t4 As Task
     Private aa As Integer = 0
     Private bb As Integer = 0
     Private cc As Integer = 0
     Private waitFor1 As Boolean = True
     Private waitFor5 As Boolean = True
     Private pcount As Integer
     Private mylock As New S2()
   End Module
   
   Public Class S2
   
   End Class
   

   C++

   #include "stdafx.h"
   #include <windows.h>
   #include <iostream>
   #include <ppl.h>
   #include <agents.h>
   #include <stdio.h>
   #include <concrtrm.h>
   #include <vector>
   
   CRITICAL_SECTION cs;
   
   using namespace ::std;
   using namespace ::std::tr1;
   using namespace ::Concurrency;
   task_group task4;
   task_group task3;
   task_group task2;
   
   volatile long aa = 0;
   volatile long bb = 0;
   volatile long cc = 0;
   static bool waitFor1 = true;
   static bool waitFor5 = true;
   
   #pragma optimize("", off)
   void Spin()
   {
      for(int i=0;i<50*50000;++i);
   }
   #pragma optimize("",on)
   
   template<class Func>
   class RunFunc
   {
      Func& m_Func;
      int m_o;
   public:
      RunFunc(Func func,int o):m_Func(func),m_o(o){
   
      };
      void operator()()const{
         m_Func(m_o);
      };
   };
   
   void T(int o)
   {
      cout << "Scheduled run \n";
   
   };
   
   void R(int o)
   {
      if (o == 2)
      {
         while (waitFor5) { ;}
         Spin();
   
         //use up all processors but 4 by scheduling 4 non-terminating tasks.
         int numProcsToBurn = GetProcessorCount() - 4;
         int i;
         vector<call<int>*> tasks;
         for (i = 0; i <  numProcsToBurn; i++)
         {
            tasks.push_back(new call<int>([](int i){while(true)Spin();}));
            asend(tasks[i],1);
            cout << "Started task  \n";
         }
   
         task_handle<RunFunc<decltype(T)>> t6(RunFunc<decltype(T)>(T,i + 1 + 5));
         task_handle<RunFunc<decltype(T)>> t7(RunFunc<decltype(T)>(T,i + 2 + 5));
         task_handle<RunFunc<decltype(T)>> t8(RunFunc<decltype(T)>(T,i + 3 + 5));
         task_handle<RunFunc<decltype(T)>> t9(RunFunc<decltype(T)>(T,i + 4 + 5));
         task_handle<RunFunc<decltype(T)>> t10(RunFunc<decltype(T)>(T,i + 5 + 5));
         task2.run(t6);
         task2.run(t7);
         task2.run(t8);
         task2.run(t9);
         task2.run(t10);
      
         //BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died   
         DebugBreak();
      }
      else
      {
         if (o!=4)
            throw;
   
         task3.wait();      
      }
   };
   
   void Q()
   {
      // breaks here at the same time as N and M
      InterlockedIncrement(& cc);
      while (cc < 4)
      {
         ;
      }
      // task 5 dies here freeing task 4 (its parent)
      cout << "t5 dies\n";
      waitFor5 = false;
   };
   
   void P()
   {
      cout << "t5 runs\n";
      Q();
   };
   
   void O(int o)
   {   
      task_group t5;
      t5.run(&P);
      t5.wait();
      R(o);
   };
   
   void N(int o)
   {
      // breaks here at the same time as M and Q
      InterlockedIncrement(&cc);
      while (cc < 4)
      {
         ;
      }
      R(o);
   };
   
   void M(int o)
   {
      // breaks here at the same time as N and Q
      InterlockedIncrement(&cc);
      while (cc < 3)
      {
         ;
      }
      //BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
      DebugBreak();
      InterlockedIncrement(&cc);
      while (true)
         Sleep(500); // for ever
   };
   
   void L(int oo)
   {
      int temp3 = oo;
   
      switch (temp3)
      {
      case 1:
         M(oo);
         break;
      case 2:
         N(oo);
         break;
      case 4:
         O(oo);
         break;
      default:
         throw; //fool3
         break;
      }
   }
   void K(int o)
   {
      // break here at the same time as E and H
      InterlockedIncrement(&bb);
      EnterCriticalSection(&cs);
      while (bb < 3)
      {
         ;
      }
      LeaveCriticalSection(&cs);
      Spin();
   
      //after
      L(o);
   }
   void J(int o)
   {
      int temp2 = o;
   
      switch (temp2)
      {
      case 3:
         task4.wait();
         break;
      case 4:
         K(o);
         break;
      default:
         throw; //fool2
         break;
      }
   }
   static void I(int o)
   {
      J(o);
   }
   static void H(int o)
   {
      // break here at the same time as E and K
      InterlockedIncrement(&bb);
      EnterCriticalSection(&cs);
      while (bb < 3)
      {
         ;
      }
      LeaveCriticalSection(&cs);
      Spin();
   
      //after
      L(o);
   }
   static void G(int o)
   {
      H(o);
   }
   static void F(int o)
   {
      G(o);
   }
   
   static void E(int o)
   {
      // break here at the same time as H and K
      while (bb < 2)
      {
         ;
      }
      //BP2 - 1 in E, 2 in H, 3 in J, 4 in K   
      Spin(); // for native case only
      DebugBreak();
      InterlockedIncrement(&bb);
   
      //after
      L(o);
   
   }
   
   static void D(int o)
   {
      E(o);
   }
   
   static void C(int o)
   {
      int temp = o;
   
      InterlockedIncrement(&aa);
      while (aa < 4)
      {
         ;
      }
   
      if (temp == 1)
      {
         // BP1 - all tasks in C   
         DebugBreak();
         waitFor1 = false;
      }
      else
      {
         while (waitFor1)
         {
            ;
         }
      }
      switch (temp)
      {
      case 1:
         D(o);
         break;
      case 2:
         F(o);
         break;
      case 3:
      case 4:
         I(o);
         break;
      default:
         throw; //fool
         break;
      }
   }
   static void B(int o)
   {
      C(o);
   }
   
   void A(int o)
   {
      B(o);
   }
   int main()
   {
      InitializeCriticalSection(&cs);
   
      task_group tasks;
      task_handle<RunFunc<decltype(A)>> t1(RunFunc<decltype(A)>(A,1));
      tasks.run(t1);
      task_handle<RunFunc<decltype(A)>> t2(RunFunc<decltype(A)>(A,2));
      task2.run(t2);
      task_handle<RunFunc<decltype(A)>> t3(RunFunc<decltype(A)>(A,3));
      task3.run(t3);
      task_handle<RunFunc<decltype(A)>> t4(RunFunc<decltype(A)>(A,4));
      task4.run(t4);
      
      getchar();
      return 1;
   }
   

---

Dopo aver aggiornato il file di codice, salvare le modifiche e compilare la soluzione.

1. Scegliere Salva tutto dal menu File.

2. Scegliere Ricompila soluzione dal menu Compila.

Si noti che sono presenti quattro chiamate a Debugger.Break (DebugBreak nell'esempio C++). Pertanto, non è necessario inserire punti di interruzione. L'esecuzione dell'applicazione comporta l'interruzione del debugger fino a quattro volte.

Usare la finestra Stack Paralleli: visualizzazione dei Thread

Per iniziare, scegliere Avvia debug dal menu Debug. Attendere che venga raggiunto il primo punto di interruzione.

Visualizzare lo stack di chiamate di un singolo thread

1. Sul menu Debug, posizionare il puntatore su Windows e quindi selezionare Thread. Ancorare la finestra Threads nella parte inferiore di Visual Studio.

2. Scegliere Windows dal menu Debug e quindi selezionare Stack di chiamate. Ancorare la finestra Stack di chiamate nella parte inferiore di Visual Studio.

3. Fare doppio clic su un thread nella finestra Thread per renderlo corrente. I thread correnti hanno una freccia gialla. Quando si modifica il thread corrente, lo stack di chiamate viene visualizzato nella finestra Stack di chiamate .

Esaminare la finestra Stack paralleli

Nel menu Debug, puntare a Windows e quindi selezionare Parallel Stacks. Accertarsi che Threads sia selezionato nella casella nell'angolo superiore sinistro.

Usando la finestra Stack paralleli , è possibile visualizzare più stack di chiamate contemporaneamente in un'unica visualizzazione. L'illustrazione seguente mostra la finestra Stack paralleli sopra la finestra Stack di chiamate.

Lo stack di chiamate del thread principale viene visualizzato in una casella e gli stack di chiamate per gli altri quattro thread vengono raggruppati in un'altra casella. Quattro thread vengono raggruppati perché i frame dello stack condividono gli stessi contesti di metodo; ovvero si trovano negli stessi metodi: A, Be C. Per visualizzare gli ID thread e i nomi dei thread che condividono la stessa casella, passare il puntatore del mouse sulla casella con l'intestazione ([#] Thread). Il thread corrente viene visualizzato in grassetto.

La freccia gialla indica lo stack frame attivo del thread corrente.

È possibile impostare il livello di dettaglio da visualizzare per gli stack frame (Nomi modulo, Tipi di parametro, Nomi parametri, Valori dei parametri, Numeri di riga e Offset byte) facendo clic con il pulsante destro del mouse nella finestra Stack di chiamate .

Un'evidenziazione blu intorno a una casella indica che il thread corrente fa parte di quella casella. Il thread corrente è indicato anche dal frame dello stack in grassetto nel tooltip. Se si fa doppio clic sul thread principale nella finestra Thread, è possibile osservare che la freccia di evidenziazione nella finestra Stack paralleli si sposta di conseguenza.

Riprendere l'esecuzione fino al secondo punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il secondo punto di interruzione, scegliere Continua dal menu Debug. L'illustrazione seguente mostra l'albero del thread nel secondo punto di interruzione.

Al primo punto di interruzione, quattro thread passavano da S.A a S.B ai metodi S.C. Le informazioni sono ancora visibili nella finestra Parallel Stacks, ma i quattro thread sono ulteriormente progrediti. Uno di loro continuò a S.D e poi S.E. Un altro continuò a S.F, S.G e S.H. Altri due continuarono a S.I e S.J, e da lì uno di loro andò a S.K e l'altro continuò a nonuser External Code.

È possibile passare il puntatore del mouse sugli stack frame per visualizzare gli ID thread e altri dettagli del frame. L'evidenziazione blu indica il thread corrente e la freccia gialla indica lo stack frame attivo del thread corrente.

L'icona dei thread (linee intrecciate) indica gli stack frame attivi dei thread non correnti. Nella finestra Stack di chiamate, fare doppio clic su S.B per cambiare contesto. La finestra Stack paralleli visualizza il frame dello stack attuale del thread correntemente utilizzato, utilizzando un'icona a forma di freccia curva.

Annotazioni

Per una descrizione di tutte le icone nella finestra degli Stack Paralleli, vedere Uso della finestra degli Stack Paralleli.

Nella finestra Thread passare da un thread all'altro e osservare che la visualizzazione nella finestra Stack paralleli viene aggiornata.

È possibile passare a un altro thread o a un altro frame di un altro thread usando il menu di scelta rapida nella finestra Stack paralleli . Ad esempio, fare clic con il pulsante destro del mouse su S.J, scegliere Passa a frame e quindi selezionare un comando.

Fare clic con il pulsante destro del mouse su S.C e scegliere Passa a frame. Uno dei comandi ha un segno di spunta che indica lo stack frame del thread corrente. Puoi passare a quel fotogramma dello stesso thread (si muove solo la freccia curva) oppure puoi passare all'altro thread (anche l'evidenziazione blu si sposta). La figura seguente mostra il sottomenu.

Per le applicazioni di grandi dimensioni con molti thread, è possibile concentrarsi solo su un subset di thread. La finestra Stack paralleli può visualizzare gli stack di chiamate solo per i thread contrassegnati. Per contrassegnare i thread, usare il menu di scelta rapida o la prima cella di un thread.

Sulla barra degli strumenti selezionare il pulsante Mostra solo contrassegnato accanto alla casella di riepilogo.

Ora, nella finestra Stack paralleli vengono visualizzati solo i thread contrassegnati.

Riprendere l'esecuzione fino al terzo punto di interruzione

1. Per riprendere l'esecuzione fino a quando non viene raggiunto il terzo punto di interruzione, scegliere Continua dal menu Debug.

   Quando più thread si trovano nello stesso metodo, ma il metodo non era all'inizio dello stack di chiamate, il metodo viene visualizzato in caselle diverse. Un esempio nel punto di interruzione corrente è S.L, che contiene tre thread e viene visualizzato in tre caselle. Fare doppio clic su S.L.

   

   Si noti che S.L è in grassetto nelle altre due caselle in modo che sia possibile vedere dove appare. Per visualizzare i frame che chiamano in S.L. e i frame in cui S.L. chiama, selezionare il pulsante Attiva/Disattiva visualizzazione metodo sulla barra degli strumenti. La seguente illustrazione mostra la vista del metodo della finestra Stack Paralleli.

   

   Si noti come il diagramma abbia ruotato sul metodo selezionato e lo abbia posizionato nel proprio riquadro al centro della vista. I riceventi e i chiamanti vengono visualizzati rispettivamente nella parte superiore e inferiore. Selezionare di nuovo il pulsante Attiva/Disattiva visualizzazione metodo per lasciare questa modalità.

   Il menu di scelta rapida della finestra Stack paralleli include anche gli altri elementi seguenti.

   • Display esadecimale attiva/disattiva i numeri nelle descrizioni comando tra il formato decimale ed esadecimale.

   • Le impostazioni dei simboli aprono le rispettive finestre di dialogo.

   • Mostra thread in Origine attiva/disattiva la visualizzazione dei marcatori di thread nel codice sorgente, che mostra la posizione dei thread nel codice sorgente.

   • Mostra codice esterno visualizza tutti i fotogrammi anche se non sono nel codice utente. Prova a vedere il diagramma espandersi per accogliere gli altri riquadri (che potrebbero essere disattivati perché non hai simboli per questi).

2. Nella finestra Stack paralleli verificare che il pulsante Scorrimento automatico fino allo stack frame corrente sulla barra degli strumenti sia attivo.

   Quando si dispone di diagrammi di grandi dimensioni e si passa al punto di interruzione successivo, è possibile che la visualizzazione scori automaticamente fino al frame dello stack attivo del thread corrente; ovvero il thread che ha raggiunto prima il punto di interruzione.

3. Prima di continuare, nella finestra Stack paralleli scorrere fino a sinistra e fino al basso.

Riprendere l'esecuzione fino al quarto punto di interruzione

1. Per riprendere l'esecuzione fino a quando non viene raggiunto il quarto punto di interruzione, scegliere Continua dal menu Debug.

   Si noti come la visualizzazione scorre automaticamente nella posizione. È possibile cambiare i thread nella finestra Thread o cambiare stack di chiamate nella finestra Stack di chiamate e notare come la visualizzazione scorre automaticamente al fotogramma corretto. Disattivare l'opzione Scorrimento automatico fino all'opzione Frame dello strumento corrente e visualizzare la differenza.

   La vista a volo d'uccello aiuta anche con i grandi diagrammi nella finestra Stack Paralleli. Per impostazione predefinita, la visualizzazione occhio dell'uccello è attiva. È tuttavia possibile attivarlo facendo clic sul pulsante tra le barre di scorrimento nell'angolo inferiore destro della finestra, come illustrato nella figura seguente.

   

   Nella visualizzazione degli occhi degli uccelli, è possibile spostare il rettangolo per eseguire rapidamente una panoramica intorno al diagramma.

   Un altro modo per spostare il diagramma in qualsiasi direzione consiste nel selezionare un'area vuota del diagramma e trascinarla nel punto desiderato.

   Per ingrandire e ridurre il diagramma, tenere premuto CTRL mentre si sposta la rotellina del mouse. In alternativa, selezionare il pulsante Zoom sulla barra degli strumenti e quindi usare lo strumento Zoom.

2. Prima di continuare, scegliere Arresta debug dal menu Debug per terminare l'esecuzione.

Usare la finestra Attività parallele e la visualizzazione Attività della finestra degli Stack paralleli

Prima di continuare, è consigliabile completare le procedure precedenti.

Riavviare l'applicazione fino a quando non viene raggiunto il primo punto di interruzione:

1. Nel menu Debug selezionare Avvia debug e attendere che venga raggiunto il primo punto di interruzione.

2. Sul menu Debug, posizionare il puntatore su Windows e quindi selezionare Thread. Ancorare la finestra Threads nella parte inferiore di Visual Studio.

3. Scegliere Windows dal menu Debug e selezionare Stack di chiamate. Ancorare la finestra Call Stack nella parte inferiore di Visual Studio.

4. Fare doppio clic su un thread nella finestra Thread per renderlo corrente. I thread correnti hanno la freccia gialla. Quando si modifica il thread corrente, le altre finestre vengono aggiornate. Verranno quindi esaminate le attività.

5. Scegliere Windows dal menu Debug e quindi selezionare Attività. La figura seguente mostra la finestra Attività .

   

   Per ogni attività in esecuzione, è possibile leggerne l'ID, che viene restituito dalla proprietà con lo stesso nome, oltre all'ID e al nome del thread che lo esegue, nonché alla relativa posizione (passando il mouse su di esso visualizza una finestra di suggerimento con l'intero stack delle chiamate). Inoltre, nella colonna Task è possibile visualizzare il metodo passato all'attività; in altre parole, il punto di partenza.

   È possibile ordinare qualsiasi colonna. Si noti il glifo di ordinamento che indica la colonna di ordinamento e la direzione. È anche possibile riordinare le colonne trascinandole verso sinistra o destra.

   La freccia gialla indica l'attività corrente. È possibile cambiare attività facendo doppio clic su un'attività o usando il menu di scelta rapida. Quando si cambia attività, il thread sottostante diventa corrente e le altre finestre vengono aggiornate.

   Quando si passa manualmente da un'attività a un'altra, il contorno della freccia indica il contesto del debugger corrente per un'attività non corrente.

Riprendere l'esecuzione fino al secondo punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il secondo punto di interruzione, scegliere Continua dal menu Debug.

In precedenza, la colonna Stato mostrava tutte le attività come Attivo, ma ora due delle attività sono Bloccate. Le attività possono essere bloccate per molti motivi diversi. Nella colonna Stato passare il puntatore del mouse su un'attività in attesa per scoprire perché è bloccato. Nell'illustrazione seguente, ad esempio, l'attività 11 è in attesa dell'attività 12.

È possibile contrassegnare un'attività facendo clic sul flag nella prima colonna della finestra Attività .

È possibile usare il contrassegno per tenere traccia delle attività tra punti di interruzione diversi nella stessa sessione di debug o per filtrare le attività i cui stack di chiamate vengono visualizzati nella finestra Stack paralleli .

Quando è stata usata la finestra Stack paralleli in precedenza, sono stati visualizzati i thread dell'applicazione. Visualizzare di nuovo la finestra Stack paralleli , ma questa volta visualizzare le attività dell'applicazione. A tale scopo, selezionare Attività nella casella in alto a sinistra. La figura seguente mostra la vista attività.

I thread che attualmente non eseguono attività non sono mostrati nella Visualizzazione attività della finestra Stack paralleli. Inoltre, per i thread che eseguono attività, alcuni stack frame che non sono rilevanti per le attività vengono filtrati dalla parte superiore e inferiore dello stack.

Visualizzare di nuovo la finestra Attività . Fare clic con il pulsante destro del mouse su un'intestazione di colonna per aprire il menu di scelta rapida relativo alla colonna.

È possibile usare il menu di scelta rapida per aggiungere o rimuovere colonne. Ad esempio, la colonna AppDomain non è selezionata; pertanto, non viene visualizzato nell'elenco. Selezionare Padre. La colonna Padre viene visualizzata senza valori per una delle quattro attività.

Riprendere l'esecuzione fino al terzo punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il terzo punto di interruzione, scegliere Continua dal menu Debug.

In questo esempio si noti che l'attività 11 e l'attività 12 sono in esecuzione nello stesso thread (mostra la colonna Assegnazione thread se è nascosta). Queste informazioni non vengono visualizzate nella finestra Thread; vedere queste informazioni qui è un altro vantaggio della finestra Attività. Per confermare questo, consultare la finestra Stack paralleli. Assicurati di visualizzare Attività. È possibile individuare le attività 11 e 12 esaminando le descrizioni comandi nella finestra Stack Paralleli.

Riprendere l'esecuzione fino al quarto punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il terzo punto di interruzione, scegliere Continua dal menu Debug. Selezionare l'intestazione di colonna ID per ordinare in base all'ID. Verrà visualizzata la figura seguente.

L'attività 10 e l'attività 11 sono ora in attesa l'una sull'altra e sono bloccate. Sono inoltre disponibili diverse nuove attività che sono ora pianificate. Le attività pianificate sono attività avviate nel codice ma non ancora eseguite. Di conseguenza, le colonne Location e Thread Assignment mostrano i messaggi predefiniti o sono vuoti.

È possibile raggruppare le attività per colonna. Nella finestra Attività fare clic con il pulsante destro del mouse sull'intestazione di colonna Stato e quindi scegliere Raggruppa per stato. La figura seguente mostra la finestra Attività raggruppata per stato.

È anche possibile raggruppare in base a qualsiasi altra colonna. Raggruppando le attività, è possibile concentrarsi su un subset di attività. Ogni gruppo collassabile ha un conteggio degli elementi che sono raggruppati insieme.

L'ultima funzionalità della finestra Attività da esaminare è il menu di scelta rapida visualizzato quando si fa clic con il pulsante destro del mouse su un'attività.

Il menu di scelta rapida visualizza comandi diversi, a seconda dello stato dell'attività. I comandi possono includere Copia, Seleziona tutto, Visualizzazione esadecimale, Passa all'attività, Blocca thread assegnato, Blocca tutti i thread, ma questo e Thaw Assigned Thread e Flag.

È possibile bloccare il thread sottostante di un'attività o attività oppure bloccare tutti i thread ad eccezione di quello assegnato. Un thread bloccato viene rappresentato nella finestra Attività , così come si trova nella finestra Thread , da un'icona di pausa blu.

Riassunto

Questa procedura dettagliata ha illustrato le finestre del debugger Parallel Tasks e Parallel Stacks . Usare queste finestre su progetti reali che usano codice multithreading. È possibile esaminare il codice parallelo scritto in C++, C# o Visual Basic.

Contenuti correlati

• Debug di applicazioni multithreading
• Esaminare prima il debugger
• debug di codice gestito
• programmazione parallela
• Runtime di concorrenza
• Uso della finestra Stack parallelo
• Uso della finestra delle attività