İzlenecek yol: paralel bir uygulama hata ayıklaması

Makale
02/26/2013

Bu izlenecek yolda nasıl kullanılacağını gösterir Paralel görevleri ve Paralel yığınları paralel bir uygulama hata ayıklamak ' ni windows.Anlamanıza ve kullanan kod çalıştırma davranışını doğrulamak bu windows Yardım Görev paralel kitaplığı (tpl) veya Eşzamanlılık çalışma zamanı.Bu izlenecek yolda, yerleşik kesme noktaları olan örnek kodu sağlar.Kod sonları sonra izlenecek yol nasıl kullanılacağını gösterir Paralel görevleri ve Paralel yığınları onu incelemek için windows.

Bu izlenecek yolda, bu görevleri öğretilmektedir:

Tüm iş parçacıklarının çağrı yığınları görünüm nasıl.
Listesini görüntülemek nasıl System.Threading.Tasks.Task , ' % s'uygulama uygulamaiçinde oluşturulan örnekleri.
Görev iş parçacığı yerine gerçek çağrı yığınları nasıl görüntüleneceği.
Koddan gitmek üzere nasıl Paralel görevleri ve Paralel yığınları windows.
Nasıl windows ölçekli gruplandırma, yakınlaştırma ve diğer ilgili özellikleri Bununla.

Önkoşullar

Bu izlenecek yolda, varsayar Yalnızca kendi kodum etkindir.Üzerinde araçları menütıklatın seçenekleri, genişletmek hata ayıklama düğümünü seçin Genelseçip Yalnızca kendi kodum (yalnızca yönetilen) etkinleştirmek. Bu özellikayarlamazsanız, bu yönergeyi kullanmaya devam edebilirsiniz, ancak sonuçlarınızı çizimler farklılık gösterebilir.

C# örnek

C# örnek kullanırsanız, bu yönerge ayrıca harici kod gizliolduğunu varsayar.Harici kod görüntülenip görüntülenmeyeceğini geçiş yapmak için sağ ad tablo üstbilgi Call Stack pencereve sonra seçin ya da temizleyin Göster harici kod. Bu özellikayarlamazsanız, bu yönergeyi kullanmaya devam edebilirsiniz, ancak sonuçlarınızı çizimler farklılık gösterebilir.

C++ örnek

C++ örnek kullanırsanız, bu konudaki harici kod başvurular gözardı edebilirsiniz.Harici kod yalnızca C# örnek için geçerlidir.

Gösterimler

Bu konudaki örneklerde kullanılan C# örnek çalışan bir dört çekirdekli bilgisayara kaydedilir.Bu izlenecek yolu tamamlamak için diğer yapılandırmaları kullanabilseniz de, çizimler bilgisayarınızda görüntülenen alanından farklı olabilir.

Örnek Proje oluşturma

Bu izlenecek yolda örnek kodda bir şey yapmaz bir uygulama için ' dir.hedef , sadece aracı windows için paralel bir uygulama hata ayıklamak ' ni nasıl anlamak sağlamaktır.

oluşturmak için örnek proje

Visual Studio, Dosya menü, Yeni 'ı Proje.
İçinde Yüklü şablonlarbölme, Visual C#, Visual Basicveya Visual C++'ı seçin. Yönetilen diller için emin .NET Framework 4 framework kutusunda görüntülenir.
Seçin Console Application 'ı Tamam.Hata ayıklama yapılandırmavarsayılan olan kalır.
proje.cpp, .cs veya .vb kod dosyasını açın.Boş kod dosyası oluşturmak ' ni içeriğini silin.
Aşağıdaki kod, seçilen dilin boş kod dosyasına yapıştırın.

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

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();
}

#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;
}

Dosya menüsünde, Tümünü Kaydet'i tıklatın.
Üzerinde Yapı menütıklatın Çözüm yeniden.

Dört çağrı olduğunu fark Debugger.Break (DebugBreak C++ örnek) Bu nedenle, kesme noktaları; eklemek gerekmez yalnızca uygulama çalıştıran en çok dört kez hata ayıklayıcıda sonu neden olur.

Paralel yığınları penceresini kullanarak: iş parçacığı görünümü

Üzerinde Debug menütıklatın Start Debugging komutunu. İsabet ilk kesme noktası için bekleyin.

Tek bir iş parçacığı çağrı yığını görüntülemek için

Üzerinde Debug menü, Windows 'ı İş. Dock İş Visual Studioaltpencere .
Üzerinde Debug menü, Windows 'ı Call Stack. Dock Call Stackpencere altındaki Visual Studio.
Çift tıklatın, bir iş parçacığı İşgeçerlipencere . Geçerli iş parçacığı sarı bir ok vardır.Geçerli iş parçacığıdeğiştirdiğinizde, kendi çağrı yığını görüntülenir Call Stackpencere.

Paralel incelemek için pencere yığar.

Üzerinde Debug menü, Windows 'ı Paralel yığınları. Emin olun İş sol üst köşedeki kutuya seçilir.

Kullanarak Paralel yığınları pencere, aynı anda tek bir görünümde birden çok çağrı yığınları görüntüleyebilirsiniz.Aşağıdaki resimde gösterildiği Paralel yığınları pencere yukarıdaki Call Stackpencere.

Ana iş parçacığı çağrı yığını bir kutusunda görünür ve diğer dört iş parçacığı için çağrı yığınları başka bir kutu içinde gruplandırılır.Dört iş parçacığı yığın karelerinde aynı yöntem bağlamları paylaştığından birlikte gruplandırılmıştır; diğer bir deyişle, aynı yöntemleri oldukları: A, B, ve C.iş parçacığı kimlikleri ve adları aynı kutusuna paylaşmak iş parçacığı vurgulu üstbilgi görüntülemek için (4 iş parçacıkları).Geçerli iş parçacığı görüntülenen içinde aşağıdaki çizimde gösterildiği gibi kalın.

Sarı ok, geçerli iş parçacığıetkin yığın çerçeve gösterir.Daha fazla bilgi almak için üzerine getirin

Ne kadar ayrıntı göstermek için yığın çerçeveler için ayarlayabilirsiniz (Modül adlarını, Parametre türleri, Parametre adları, Parametre değerlerini, Satır numaralarını ve Bayt kaydırır), sağ Call Stackpencere.

Etrafında bir kutu mavi bir vurgu, geçerli iş parçacığı kutunun bir parçası olduğunu gösterir.Geçerli iş parçacığı tooltip kalın yığını çerçeve ayrıca belirtilir.İş parçacığı pencereana iş parçacığı çift tıklatırsanız, inceleyebileceğiniz mavi açıkton Paralel yığınlarıpencere buna göre hareket eder.

İkinci kesme noktası kadar yürütülmesine devam etmek için

İkinci kesme noktası , üzerinde gelindiğinde kadar yürütülmesine devam etmek için hata ayıklama menütıklatın devam. Aşağıdaki resimde iş parçacığı ağaç ikinci kesme noktasınoktasında gösterir.

İlk kesme noktasınoktasında, tüm dört iş parçacığı s.c yöntemleri için s.b s.a geçti.Bilgi hala görünür Paralel yığınlarıpencere, ancak dört iş parçacığı progressed daha fazla. Bunlardan biri s.d ve sonra g. d. devamıBaşka s.f, s.g ve s.h. devamıİki başkalarının S.I ve s.j ve orada bir tanesine devamı için s.k gitti ve diğer çok olmayan devamı - haricikullanıcı kodu.

Kutusu üstbilgi, örneğin, vurgulu 1 iş parçacığı veya 2 iş parçacıkları, iş parçacığı iş parçacığı kimlikleri görmek için.iş parçacığı kimlikleri artı diğer çerçeve ayrıntılarını görmek için yığın karelerin üzerine getirdiğinizde.Geçerli iş parçacığı mavi vurgu gösterir ve sarý ok geçerli iş parçacığıetkin yığın çerçeve gösterir.

(Çakışan mavi ve kırmızı waved çizgiler) havlu iş parçacığı simgesi noncurrent iş parçacığı etkin yığını çerçeve gösteriyor.İçinde Call Stackpencereçerçeveleri arasında geçiş yapmak için s.b çift tıklatın. Paralel yığınlarıpencere yeşil eğri ok simgesini kullanarak geçerli iş parçacığı geçerli yığın çerçeve gösterir.

İçinde İş pencere, iş parçacıkları arasında geçiş yapmak ve, gözlemek görünümünde Paralel yığınlarıpencere güncelleştirilir.

Başka bir iş parçacığıiçin ya da başka bir çerçeve başka bir iş parçacığı, kısayolmenü kullanarak geçiş yapabilirsiniz Paralel yığınlarıpencere. Örneğin, s.j sağ tıklatın, üzerine İçin anahtar kare, bir komut tıklatın.

s.c sağ tıklatın ve üzerine İçin anahtar kare.Bir komut, geçerli iş parçacığıyığın çerçeve gösteren bir onay işareti vardır.Bu çerçeve (yeşil ok hareket eder) aynı iş parçacığı için geçiş yapabilirsiniz veya (mavi vurgu da taþýnýr) diğer iş parçacığı geçiş yapabilirsiniz.Aşağıdaki resimde, alt menüyü gösterir.

yöntembağlam yalnızca bir yığın çerçeveile ilişkili olduğunda kutusu üstbilgi görüntüler 1 iş parçacığı ve çift tıklatarak onu geçiş yapabilirsiniz. Kendisiyle ilişkilendirilmiş birden fazla çerçeve vardır yöntembağlam ' ı çift tıklatın, sonra menü otomatik olarak açılır. Siyah üçgen sağ yöntem bağlamları üzerinde vurgu gibi dikkat edin.Bu üçgeni tıklatarak kısayol menügörüntüler.

Çok iş parçacığı olan büyük uygulamalar için yalnızca bir alt kümesini iş parçacığı üzerinde odaklanmak isteyebilirsiniz.Paralel yığınlarıçağrı yığınları bayraklı iş parçacıkları için yalnızcapencere görüntüleyebilir. Araç çubuğunda'i Göster yalnızca bayrak liste kutusuyanındaki düğmeyi.

İleri ' İş pencere, bayrak , kendi çağrı yığınları nasıl görünür görmek için birer birer iş parçacıkları Paralel yığınlarıpencere. bayrak kanalları, bir iş parçacığıilk hücreye veya kısayolmenü kullanın. Tıklatın Göster yalnızca bayrak tüm iş parçacıkları yeniden göstermek için araç çubuğu düğmesi .

Üçüncü kesme noktası kadar yürütülmesine devam etmek için

Üçüncü kesme noktası , üzerinde gelindiğinde kadar yürütülmesine devam etmek için hata ayıklama menütıklatın devam.

Aynı yöntem birden çok iş parçacığı olan ancak yöntem çağrı yığınıbaşında değildi yöntem farklı kutularında görünür.Geçerli kesme noktası noktasındaki üç iş parçacığı içinde olduğunu ve üç kutularında görünen s.l örneğidir.s.l. çift tıklatın

Başka nerede görüneceğini görebilecek şekilde s.l diğer iki kutularına kalın olduğuna dikkat edin.Görmek istiyorsanız, s.l çağrısına çerçeve ve hangi çerçeve, çağrı,'ı Yöntemi görünüm Değiştir araç çubuğundaki düğmesini.yöntem aşağıda gösteren Paralel yığınları pencere.

Diyagramı nasıl seçilen yöntem özetlenebilir ve kendi kutusunda görünüm ortasında konumlandırılmış dikkat edin.Callees ve Arayanların üstte ve altta görüntülenir.Tıklatın Geçiş yöntemi View yeniden bu modundan çıkmak için düğme.

kısayolmenü Paralel yığınlarıpencere , aşağıdakileri de vardır diğer öğeler.
- Onaltılı görüntü sayılar ondalık ve onaltılık arasında ipuçlarında geçiş yapar.
- Sembol yük bilgi ve Simge ayarlarını açık kendi iletişim kutuları.
- Kaynak koduna git ve Çözümü Git seçilen yöntem düzenleyici gidin.
- Harici kod Göster kullanıcı kodu olmasa bile tüm kareleri görüntüler.(, Simgeler için bunları olmadığı için soluk olabilir) ilave kareleri uyacak biçimde diyagramı genişletmek görmek için deneyin.
Büyük çizimleri sahip olduğunuzda ve kesme noktasıiçin bir sonraki adım için geçerli iş parçacığıetkin yığını çerçeve otomatik kaydırma görünümüne isteyebilirsiniz; kesme noktası önce Vur, diğer bir deyişle, iş parçacığı .İçinde Paralel yığınları pencere, emin olun Geçerli yığın çerçevesi için otomatik kaydırma araç çubuğundaki düğmeyi açıktır.
Buna geçmeden önce Paralel yığınlarıpencere, tüm yolu sol ve tamamen aşağı kaydırma.

Dördüncü kesme noktası kadar yürütülmesine devam etmek için

kesme noktası dördüncü, üzerinde gelindiğinde kadar yürütülmesine devam etmek için hata ayıklama menütıklatın devam.

Bildirimin nasıl yer içine görünüm autoscrolled.İş parçacıkları geçiş İş pencere veya anahtar yığını çerçeve içinde Call Stackpencere ve dikkat nasıl görünümü her zaman doğru çerçeveautoscrolls. Devre dışı Otomatik kaydırma aracı geçerli kareye seçeneğini ve farkı görüntüleyin.

Kuşbakışı görünüm de büyük diyagramlarında yardımcı olur Paralel yığınlarıpencere. Gördüğünüz Kuşbakışı görünüm aşağıdaki şekilde gösterildiği gibi penceresağ alt köşesinde bulunan kaydırma çubukları arasında düğmesini tıklatarak.

Hızlı bir şekilde Diyagram kaydırmak için dikdörtgen taşıyabilirsiniz.

Diyagramdaki herhangi bir yöne hareket ettirmek için başka bir diyagram boş bir alan tıklatın ve istediğiniz yere sürükleyin yoludur.

yakınlaştırmak ve diyagramın dışına tuşuna basın ve fare tekerleğini taşırken ctrl tuşunu basılı tutun.Alternatif olarak, araç çubuğundaki Yakınlaştır düğmesini tıklatın ve Yakınlaştırma aracını kullanın.

Aynı zamanda yığınları yerine aşağıdan yukarıya, yukarıdan aşağıya bir yönde tıklatarak görüntüleyebilirsiniz araçları menütıklatarak, seçeneklerive sonra seçin veya'nın altındaki seçeneği temizleyin hata ayıklama düğüm.
On geçmeden önce Debug menütıklatın Stop Debugging son yürütülmesine.

Paralel görevleri penceresinde ve Görevler görünümünde paralel yığınları pencere kullanma

Devam etmeden önce önceki yordamları tamamlamanız önerilir.

uygulama kadar ilk kesme noktası yeniden Vur

Üzerinde Debug menütıklatın Start Debugging komutunu ve isabet ilk kesme noktası için bekleyin.
Üzerinde Debug menü, Windows 'ı İş. Dock İş Visual Studioaltpencere .
Üzerinde Debug menü, Windows 'ı tıklatın ve Call Stack. Dock Call Stackpencere altındaki Visual Studio.
Çift tıklatın, bir iş parçacığı İşpencere sayesinde geçerli. Geçerli iş parçacığı sarı bir ok vardır.Windows, geçerli iş parçacığıdeğiştirdiğinizde güncelleştirilir.Daha sonra görevler inceleyeceğiz.
Üzerinde Debug menü, Windows 'ı Paralel görevleri. Aşağıdaki resimde gösterildiği Paralel görevleripencere.

Çalışan her görev için kodu ve adı, (üzerinde görüntüleyen tüm çağrı yığınısahip bir araç ipucu vurgulama) konumuna çalışan iş parçacığı aynı adlı özelliktarafından döndürülen Kimliğini okuyabilirsiniz.Ayrıca, altında görev sütununda, görev; geçildi yöntem görebilir başka bir deyişle, başlangıç noktası.

Herhangi bir sütunu sıralayabilirsiniz.Sıralama sütununu ve yönünü gösterir sıralama karakter dikkat edin.Sola veya sağa sürükleyerek sütunları yeniden düzenleyebilirsiniz.

Sarı ok, geçerli görevgösterir.Görevleri görev çift veya kısayol menükullanarak geçiş yapabilirsiniz.Görevler arasında geçiş yaptığınızda, temel iş parçacığı geçerli olur ve diğer windows güncelleştirilir.

El ile bir görev başka birine geçiş yaparken sarý ok geçer ama beyaz bir ok kesmek hata ayıklayıcı neden görev hala görünüyor.

İkinci kesme noktası kadar yürütülmesine devam etmek için

İkinci kesme noktası , üzerinde gelindiğinde kadar yürütülmesine devam etmek için hata ayıklama menütıklatın devam.

Daha önce Durum sütun olarak çalışan tüm görevleri gösterdi, ancak iki görevleri şimdi bekleniyor.Görevleri farklı nedenlerle bloke edilebilir.İçinde Durum sütun vurgulu neden engellendi öğrenmek için bekleyen görev üzerinde.Örneğin, aşağıdaki çizimde, görev 3 görev 4 bekliyor.

Görev 4, sırasıyla görev 2 atanan iş parçacığı tarafından sahip olunan bir monitörde bekliyor.

bayrak bayrak ilk sütunu tıklatarak görev yapabilirsiniz Paralel görevleripencere.

Aynı hata ayıklama oturumunda farklı Kırılma noktaları arasında görevleri izlemek veya, çağrı yığınları içinde gösterilen görevler için filtre uygulamak için bayrak kullanabilirsiniz Paralel yığınlarıpencere.

Kullanıldığında, Paralel yığınlarıpencere uygulama iş parçacıkları daha önce görüntülediğiniz. Görünüm Paralel yığınlarıpencere yeniden ancak bu kez uygulama görevleri görüntüleyin. Bunu seçerek görevleri kutusunda sol üstte.Aşağıdaki resimde Görevler görünümünde gösterir.

Görevleri yürütülmekte değil iş parçacığı değil Görevler görünümünde gösterilen Paralel yığınlarıpencere. yürütmek görevleri, bazı görevler ilgili olmayan yığın çerçeveler üstünden ve altından yığının filtre de, iş için.

Görünüm Paralel görevleripencere yeniden. Sütun için bir kısayolmenü görmek için herhangi bir sütun üstbilgi sağ tıklatın.

kısayolmenü , eklemek veya sütunları kaldırmak için kullanabilirsiniz. Örneğin, AppDomain sütun seçili değil; Bu nedenle, listede görüntülenmez.Tıklatın üst.Ana dört görevler için değerleri içermeyen sütun görünür.

Üçüncü kesme noktası kadar yürütülmesine devam etmek için

Üçüncü kesme noktası , üzerinde gelindiğinde kadar yürütülmesine devam etmek için hata ayıklama menütıklatın devam.

Yeni bir görev, görev 5, şimdi çalışan ve görev 4 şimdi bekliyor.görev bekletme üzerinden neden vurgulama tarafından görebilirsiniz Durumpencere. İçinde ana sütun, bu görev 4 olan üst görev 5 dikkat edin.

Üst -alt öğeilişkidaha iyi görmek için sağ ana sütun üstbilgi tıklatın ve sonra Üst alt görünümü. Aşağıdaki resimde görmeniz gerekir.

görev 4 ve görev 5 aynı iş parçacığıüzerinde çalışan dikkat edin.Bu bilgileri görüntülenen değil İşpencere; Burada görmekte olan başka bir yararı, Paralel görevleripencere. Bunu doğrulamak için görüntülemek Paralel yığınlarıpencere. Görüntülediğiniz emin görevleri.Görevleri 4 ve 5 içinde çift tıklatarak bulun Paralel görevleripencere. Yaptığınızda, mavi vurgu Paralel yığınlarıpencere güncelleştirilir. Araç ipuçlarını tarayarak görevleri 4 ve 5 de bulun Paralel yığınlarıpencere.

İçinde Paralel yığınları penceres.p sağ tıklatın ve ardından Gitmek için iş parçacığı. pencere iş parçacığı görünümüne geçiş yapar ve karşılık gelen çerçeve görünümde olur.Her iki görevi aynı iş parçacığıüzerinde görebilirsiniz.

Bu görevler görünümünde, başka bir yararı, Paralel yığınları pencerekarşılaştırıldığında, İşpencere.

Dördüncü kesme noktası kadar yürütülmesine devam etmek için

Üçüncü kesme noktası , üzerinde gelindiğinde kadar yürütülmesine devam etmek için hata ayıklama menütıklatın devam. Tıklatın ID kimliğine göre sıralamak için sütun üstbilgiAşağıdaki resimde görmeniz gerekir.

görev 5 tamamlandı çünkü artık görüntülenmez.Bilgisayarınızın kasasındaki değil ve çıkmaz gösterilmez, F11 tuşuna basarak bir kez adım.

Görev 3 ve görev 4 bekleniyor şimdi birbirine bağlı ve kilitli.görev 2 çocukları olan ve şimdi planlanan 5 yeni görevler vardır.Zamanlanmış Görevler, kodda başlatıldı, ancak henüz ÇALIŞTIRMADIYSANIZ görevlerdir.Bu nedenle, kendi yere ve İş parçacığı atama sütunları boş.

Görünüm Paralel yığınlarıpencere yeniden. iş parçacığı kimlikleri ve adlarını gösteren bir araç ipucu her kutu üstbilgi vardır.Görevler görünümünde, geçiş Paralel yığınlarıpencere. Aşağıdaki çizimde gösterildiği gibi görev kimliği ve adı ve görev durum görmek için üstbilgi getirin.

Sütuna göre görevleri grup olabilir.İçinde Paralel görevleri pencere, sağ Durum sütun üstbilgi tıklatın ve sonra duruma göre grup. Aşağıdaki resimde gösterildiği Paralel görevleripencere durumgöre gruplandırılır.

Ayrıca diğer bir sütuna göre grup yapabilirsiniz.Gruplandırma görevlere göre alt görevler üzerinde odaklanabilirsiniz.Daraltılabilir her grup bir arada gruplandırılmış öğeleri sayısı vardır.Ayrıca hızlı bir şekilde bayrak grup içindeki tüm öğeleri tıklatarak yapabilirsiniz bayrağı sağındaki düğmeyi Daralt düğme.

Son özellik Paralel görevleriincelemek içinpencere olan bir görevfarenin sağ düğmesiyle tıklattığınızda görüntülenen kısayolmenü .

görev durum farklı komutlar kısayolmenü görüntüler. Komutları içerebilir kopya, Tümünü Seç, Onaltılı görüntü, görevin geç, Dondurma atanan iş parçacığı, Dondurma tüm iş parçacıkları, ancak bu, ve Çözme atanan iş parçacığı, ve bayrağı.

dondurmak atanan dışındaki tüm iş parçacıkları olabilir veya bir görevveya görevler temel iş parçacığı dondurmak ' ni kullanabilirsiniz.Dondurulmuş bir iş parçacığı gösterilir Paralel görevleri pencere olarak bulunduğu iş parçacıkları pencere, bir mavi duraklatma simgesi.

Özet

Bu izlenecek yolda gösterilen Paralel görevleri ve Paralel yığınları windows hata ayıklayıcı.Bu pencerelerde, çok iş parçacıklı kodunu kullanan gerçek projelerde kullanın.C++, C# veya Visual Basicyazılmış paralel kodu inceleyebilirsiniz.

Ayrıca bkz.

Aracılığıyla paylaş

İzlenecek yol: paralel bir uygulama hata ayıklaması

Önkoşullar

C# örnek

C++ örnek

Gösterimler

Örnek Proje oluşturma

oluşturmak için örnek proje

Paralel yığınları penceresini kullanarak: iş parçacığı görünümü

Tek bir iş parçacığı çağrı yığını görüntülemek için

Paralel incelemek için pencere yığar.

İkinci kesme noktası kadar yürütülmesine devam etmek için

Üçüncü kesme noktası kadar yürütülmesine devam etmek için

Dördüncü kesme noktası kadar yürütülmesine devam etmek için

Paralel görevleri penceresinde ve Görevler görünümünde paralel yığınları pencere kullanma

uygulama kadar ilk kesme noktası yeniden Vur

İkinci kesme noktası kadar yürütülmesine devam etmek için

Üçüncü kesme noktası kadar yürütülmesine devam etmek için

Dördüncü kesme noktası kadar yürütülmesine devam etmek için

Özet

Ayrıca bkz.

Görevler

Kavramlar

Diğer Kaynaklar

Ek kaynaklar