Tutorial: Depurar una aplicación de C++ AMPWalkthrough: Debugging a C++ AMP Application

Este tema muestra cómo depurar una aplicación que usa C++ Accelerated Massive Parallelism (C++ AMP) para aprovechar las ventajas de la unidad de procesamiento de gráficos (GPU).This topic demonstrates how to debug an application that uses C++ Accelerated Massive Parallelism (C++ AMP) to take advantage of the graphics processing unit (GPU). Usa un programa de reducción paralelo que realiza la suma de una matriz grande de enteros.It uses a parallel-reduction program that sums up a large array of integers. En este tutorial se muestran las tareas siguientes:This walkthrough illustrates the following tasks:

  • Iniciar al depurador de GPU.Launching the GPU debugger.

  • Inspeccionando los subprocesos de GPU en la ventana subprocesos de GPU.Inspecting GPU threads in the GPU Threads window.

  • Mediante la ventana Pilas paralelas para observar simultáneamente las pilas de llamadas de varios subprocesos GPU.Using the Parallel Stacks window to simultaneously observe the call stacks of multiple GPU threads.

  • Usar la ventana Inspección paralela para inspeccionar los valores de una única expresión en varios subprocesos al mismo tiempo.Using the Parallel Watch window to inspect values of a single expression across multiple threads at the same time.

  • Al marcar, Inmovilizar, reanudación y agrupar los subprocesos de GPU.Flagging, freezing, thawing, and grouping GPU threads.

  • Ejecutar todos los subprocesos de un icono en una ubicación específica en el código.Executing all the threads of a tile to a specific location in code.

Requisitos previosPrerequisites

Antes de empezar este tutorial:Before you start this walkthrough:

  • Lectura Introducción a C++ AMP.Read C++ AMP Overview.

  • Asegúrese de que esa línea números se muestran en el editor de texto.Make sure that line numbers are displayed in the text editor. Para obtener más información, consulte Cómo: mostrar los números de línea en el Editor de.For more information, see How to: Display Line Numbers in the Editor.

  • Asegúrese de que está ejecutando Windows 8 o Windows Server 2012 para admitir la depuración en el emulador de software.Make sure you are running Windows 8 or Windows Server 2012 to support debugging on the software emulator.

    Nota

    Es posible que tu equipo muestre nombres o ubicaciones diferentes para algunos de los elementos de la interfaz de usuario de Visual Studio en las siguientes instrucciones.Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. La edición de Visual Studio que se tenga y la configuración que se utilice determinan estos elementos.The Visual Studio edition that you have and the settings that you use determine these elements. Para obtener más información, vea Personalizar el IDE.For more information, see Personalizing the IDE.

Para crear el proyecto de ejemploTo create the sample project

  1. Inicie Visual Studio.Start Visual Studio.

  2. En la barra de menús, elija Archivo, Nuevo, Proyecto.On the menu bar, choose File, New, Project.

  3. En instalado en el panel Plantillas, elija Visual C++.Under Installed in the templates pane, choose Visual C++.

  4. Elija aplicación de consola Win32, tipo AMPMapReduce en el nombre cuadro y, a continuación, elija la Aceptar botón.Choose Win32 Console Application, type AMPMapReduce in the Name box, and then choose the OK button.

  5. Elija el botón Siguiente.Choose the Next button.

  6. Desactive el encabezado precompilado casilla de verificación y, a continuación, elija la finalizar botón.Clear the Precompiled header check box, and then choose the Finish button.

  7. En el Explorador de soluciones, elimine stdafx.h, targetver.h y stdafx.cpp del proyecto.In Solution Explorer, delete stdafx.h, targetver.h, and stdafx.cpp from the project.

  8. Abra AMPMapReduce.cpp y reemplace su contenido con el código siguiente.Open AMPMapReduce.cpp and replace its content with the following code.

    // AMPMapReduce.cpp defines the entry point for the program.  
    // The program performs a parallel-sum reduction that computes the sum of an array of integers.   
    
    #include <stdio.h>  
    #include <tchar.h>  
    #include <amp.h>  
    
    const int BLOCK_DIM = 32;  
    
    using namespace concurrency;  
    
    void sum_kernel_tiled(tiled_index<BLOCK_DIM> t_idx, array<int, 1> &A, int stride_size) restrict(amp)  
    {  
        tile_static int localA[BLOCK_DIM];  
    
        index<1> globalIdx = t_idx.global * stride_size;  
        index<1> localIdx = t_idx.local;  
    
        localA[localIdx[0]] =  A[globalIdx];  
    
        t_idx.barrier.wait();  
    
        // Aggregate all elements in one tile into the first element.  
        for (int i = BLOCK_DIM / 2; i > 0; i /= 2)   
        {  
            if (localIdx[0] < i)   
            {  
    
                localA[localIdx[0]] += localA[localIdx[0] + i];  
            }  
    
            t_idx.barrier.wait();  
        }  
    
        if (localIdx[0] == 0)  
        {  
            A[globalIdx] = localA[0];  
        }  
    }  
    
    int size_after_padding(int n)  
    {  
        // The extent might have to be slightly bigger than num_stride to   
        // be evenly divisible by BLOCK_DIM. You can do this by padding with zeros.  
        // The calculation to do this is BLOCK_DIM * ceil(n / BLOCK_DIM)  
        return ((n - 1) / BLOCK_DIM + 1) * BLOCK_DIM;  
    }  
    
    int reduction_sum_gpu_kernel(array<int, 1> input)   
    {  
        int len = input.extent[0];  
    
        //Tree-based reduction control that uses the CPU.  
        for (int stride_size = 1; stride_size < len; stride_size *= BLOCK_DIM)   
        {  
            // Number of useful values in the array, given the current  
            // stride size.  
            int num_strides = len / stride_size;    
    
            extent<1> e(size_after_padding(num_strides));  
    
            // The sum kernel that uses the GPU.  
            parallel_for_each(extent<1>(e).tile<BLOCK_DIM>(), [&input, stride_size] (tiled_index<BLOCK_DIM> idx) restrict(amp)  
            {  
                sum_kernel_tiled(idx, input, stride_size);  
            });  
        }  
    
        array_view<int, 1> output = input.section(extent<1>(1));  
        return output[0];  
    }  
    
    int cpu_sum(const std::vector<int> &arr) {  
        int sum = 0;  
        for (size_t i = 0; i < arr.size(); i++) {  
            sum += arr[i];  
        }  
        return sum;  
    }  
    
    std::vector<int> rand_vector(unsigned int size) {  
        srand(2011);  
    
        std::vector<int> vec(size);  
        for (size_t i = 0; i < size; i++) {  
            vec[i] = rand();  
        }  
        return vec;  
    }  
    
    array<int, 1> vector_to_array(const std::vector<int> &vec) {  
        array<int, 1> arr(vec.size());  
        copy(vec.begin(), vec.end(), arr);  
        return arr;  
    }  
    
    int _tmain(int argc, _TCHAR* argv[])  
    {  
        std::vector<int> vec = rand_vector(10000);  
        array<int, 1> arr = vector_to_array(vec);  
    
        int expected = cpu_sum(vec);  
        int actual = reduction_sum_gpu_kernel(arr);  
    
        bool passed = (expected == actual);  
        if (!passed) {  
            printf("Actual (GPU): %d, Expected (CPU): %d", actual, expected);  
        }  
        printf("sum: %s\n", passed  "Passed!" : "Failed!");   
    
        getchar();  
    
        return 0;  
    }  
    
  9. En la barra de menús, pulse Archivo, Guardar todo.On the menu bar, choose File, Save All.

  10. En el Explorador de soluciones, abra el menú contextual para AMPMapReducey, a continuación, elija propiedades.In Solution Explorer, open the shortcut menu for AMPMapReduce, and then choose Properties.

  11. En el páginas de propiedades cuadro de diálogo propiedades de configuración, elija C/C++, encabezados precompilados.In the Property Pages dialog box, under Configuration Properties, choose C/C++, Precompiled Headers.

  12. Para el encabezado precompilado propiedad, seleccione no utilizar encabezados precompiladosy, a continuación, elija la Aceptar botón.For the Precompiled Header property, select Not Using Precompiled Headers, and then choose the OK button.

  13. En la barra de menús, elija Compilar, Compilar solución.On the menu bar, choose Build, Build Solution.

Depurar el código de CPUDebugging the CPU Code

En este procedimiento, utilizará al depurador Local de Windows para asegurarse de que el código de CPU en esta aplicación es correcto.In this procedure, you will use the Local Windows Debugger to make sure that the CPU code in this application is correct. El segmento de un código de la CPU en esta aplicación que es especialmente interesante es la for un bucle en el reduction_sum_gpu_kernel (función).The segment of the CPU code in this application that is especially interesting is the for loop in the reduction_sum_gpu_kernel function. Controla la reducción de paralelo basados en árbol que se ejecuta en la GPU.It controls the tree-based parallel reduction that is run on the GPU.

Para depurar el código de CPUTo debug the CPU code

  1. En el Explorador de soluciones, abra el menú contextual para AMPMapReducey, a continuación, elija propiedades.In Solution Explorer, open the shortcut menu for AMPMapReduce, and then choose Properties.

  2. En el páginas de propiedades cuadro de diálogo propiedades de configuración, elija depuración.In the Property Pages dialog box, under Configuration Properties, choose Debugging. Compruebe que depurador Local de Windows está seleccionado en el depurador para iniciar lista.Verify that Local Windows Debugger is selected in the Debugger to launch list.

  3. Volver al Editor de código.Return to the Code Editor.

  4. Establecer puntos de interrupción en las líneas de código que se muestra en la siguiente ilustración (aproximadamente líneas 67 de línea 70).Set breakpoints on the lines of code shown in the following illustration (approximately lines 67 line 70).

    Los puntos de interrupción de CPUCPU breakpoints
    Puntos de interrupción de CPUCPU breakpoints

  5. En la barra de menús, seleccione Depurar, Iniciar depuración.On the menu bar, choose Debug, Start Debugging.

  6. En el locales ventana, observe el valor de stride_size hasta que se alcance el punto de interrupción en la línea 70.In the Locals window, observe the value for stride_size until the breakpoint at line 70 is reached.

  7. En la barra de menús, seleccione Depurar, Detener depuración.On the menu bar, choose Debug, Stop Debugging.

Depurar el código de GPUDebugging the GPU Code

Esta sección muestra cómo depurar el código de GPU, que es el código incluido en el sum_kernel_tiled (función).This section shows how to debug the GPU code, which is the code contained in the sum_kernel_tiled function. El código de GPU calcula la suma de números enteros para cada "bloque" en paralelo.The GPU code computes the sum of integers for each "block" in parallel.

Para depurar el código de GPUTo debug the GPU code

  1. En el Explorador de soluciones, abra el menú contextual para AMPMapReducey, a continuación, elija propiedades.In Solution Explorer, open the shortcut menu for AMPMapReduce, and then choose Properties.

  2. En el páginas de propiedades cuadro de diálogo propiedades de configuración, elija depuración.In the Property Pages dialog box, under Configuration Properties, choose Debugging.

  3. En el depurador para iniciar lista, seleccione depurador Local de Windows.In the Debugger to launch list, select Local Windows Debugger.

  4. En el tipo de depurador lista, compruebe que automática está seleccionada.In the Debugger Type list, verify that Auto is selected.

    Auto es el valor predeterminado.Auto is the default value. Antes de Windows 10, solo GPU es el valor necesario en lugar de automática.Prior to Windows 10, GPU Only is the required value instead of Auto.

  5. Elija el botón Aceptar .Choose the OK button.

  6. Establecer un punto de interrupción en la línea 30, tal como se muestra en la siguiente ilustración.Set a breakpoint at line 30, as shown in the following illustration.

    Los puntos de interrupción GPUGPU breakpoints
    Punto de interrupción GPUGPU breakpoint

  7. En la barra de menús, seleccione Depurar, Iniciar depuración.On the menu bar, choose Debug, Start Debugging. Los puntos de interrupción en el código de CPU en las líneas 67 y 70 no se ejecutan durante la depuración porque esas líneas de código se ejecutan en la CPU de GPU.The breakpoints in the CPU code at lines 67 and 70 are not executed during GPU debugging because those lines of code are executed on the CPU.

Para utilizar la ventana subprocesos de GPUTo use the GPU Threads window

  1. Para abrir la ventana subprocesos de GPU, en la barra de menús, elija depurar, Windows, subprocesos de GPU.To open the GPU Threads window, on the menu bar, choose Debug, Windows, GPU Threads.

    Puede inspeccionar el estado de los subprocesos GPU en la ventana de subprocesos de GPU que aparece.You can inspect the state the GPU threads in the GPU Threads window that appears.

  2. Acoplar la ventana subprocesos de GPU en la parte inferior de Visual Studio.Dock the GPU Threads window at the bottom of Visual Studio. Elija la expanda conmutador de subproceso botón para mostrar los cuadros de texto de mosaico y subproceso.Choose the Expand Thread Switch button to display the tile and thread text boxes. La ventana de subprocesos de GPU muestra el número total de subprocesos de GPU activos y bloqueados, tal como se muestra en la siguiente ilustración.The GPU Threads window shows the total number of active and blocked GPU threads, as shown in the following illustration.

    Ventana subprocesos de GPU con 4 subprocesos activosGPU Threads window with 4 active threads
    Ventana Subprocesos de GPUGPU Threads window

    Hay 313 iconos asignados para este cálculo.There are 313 tiles allocated for this computation. Cada mosaico contiene 32 subprocesos.Each tile contains 32 threads. Dado que la depuración de GPU local aparece en un emulador de software, hay cuatro subprocesos GPU activos.Because local GPU debugging occurs on a software emulator, there are four active GPU threads. Los cuatro subprocesos ejecutan al mismo tiempo las instrucciones y, a continuación, pase juntos a la siguiente instrucción.The four threads execute the instructions simultaneously and then move on together to the next instruction.

    En la ventana de subprocesos GPU, hay cuatro subprocesos GPU active y 28 subprocesos de GPU bloquean en el tile_barrier:: wait instrucción definida en acerca de la línea 21 (t_idx.barrier.wait();).In the GPU threads window, there are four GPU threads active and 28 GPU threads blocked at the tile_barrier::wait statement defined at about line 21 (t_idx.barrier.wait();). Todos los subprocesos GPU 32 pertenecen al primer icono, tile[0].All 32 GPU threads belong to the first tile, tile[0]. Una flecha apunta a la fila que incluye el subproceso actual.An arrow points to the row that includes the current thread. Para cambiar a un subproceso diferente, utilice uno de los métodos siguientes:To switch to a different thread, use one of the following methods:

-   <span data-ttu-id="e676c-179">En la fila para el subproceso cambiar a en la ventana subprocesos de GPU, abra el menú contextual y elija **cambiar a subproceso**.</span><span class="sxs-lookup"><span data-stu-id="e676c-179">In the row for the thread to switch to in the GPU Threads window, open the shortcut menu and choose **Switch To Thread**.</span></span> <span data-ttu-id="e676c-180">Si la fila representa más de un subproceso, se cambiará al primer subproceso según las coordenadas de subproceso.</span><span class="sxs-lookup"><span data-stu-id="e676c-180">If the row represents more than one thread, you will switch to the first thread according to the thread coordinates.</span></span>  

-   <span data-ttu-id="e676c-181">Escriba los valores de mosaico y el subproceso del subproceso en los cuadros de texto correspondientes y, a continuación, elija la **conmutador subproceso** botón.</span><span class="sxs-lookup"><span data-stu-id="e676c-181">Enter the tile and thread values of the thread in the corresponding text boxes and then choose the **Switch Thread** button.</span></span>  

 <span data-ttu-id="e676c-182">La ventana Pila de llamadas muestra la pila de llamadas del subproceso actual de la GPU.</span><span class="sxs-lookup"><span data-stu-id="e676c-182">The Call Stack window displays the call stack of the current GPU thread.</span></span>  

Usar la ventana Pilas paralelasTo use the Parallel Stacks window

  1. Para abrir la ventana Pilas paralelas, en la barra de menús, elija depurar, Windows, pilas paralelas.To open the Parallel Stacks window, on the menu bar, choose Debug, Windows, Parallel Stacks.

    Puede usar la ventana Pilas paralelas para inspeccionar simultáneamente los marcos de pila de varios subprocesos GPU.You can use the Parallel Stacks window to simultaneously inspect the stack frames of multiple GPU threads.

  2. Acoplar la ventana Pilas paralelas en la parte inferior de Visual Studio.Dock the Parallel Stacks window at the bottom of Visual Studio.

  3. Asegúrese de que subprocesos está seleccionado en la lista en la esquina superior izquierda.Make sure that Threads is selected in the list in the upper-left corner. En la siguiente ilustración, la ventana Pilas paralelas muestra una vista con foco de la pila de llamadas de los subprocesos GPU que vio en la ventana subprocesos de GPU.In the following illustration, the Parallel Stacks window shows a call-stack focused view of the GPU threads that you saw in the GPU Threads window.

    Ventana Pilas paralelas con 4 subprocesos activosParallel Stacks window with 4 active threads
    Ventana Pilas paralelasParallel Stacks window

    32 subprocesos fueron de _kernel_stub a la instrucción de expresión lambda en el parallel_for_each llamada de función y, a continuación, en la sum_kernel_tiled función, donde se produce la reducción en paralelo.32 threads went from _kernel_stub to the lambda statement in the parallel_for_each function call and then to the sum_kernel_tiled function, where the parallel reduction occurs. 28 de 32 subprocesos han progresado a la tile_barrier:: wait instrucción y permanecerá bloqueado en línea de 22, mientras que las otras 4 subprocesos permanecen activas en el sum_kernel_tiled función en línea de 30.28 out of the 32 threads have progressed to the tile_barrier::wait statement and remain blocked at line 22, whereas the other 4 threads remain active in the sum_kernel_tiled function at line 30.

 <span data-ttu-id="e676c-193">Puede inspeccionar las propiedades de un subproceso GPU que están disponibles en la ventana subprocesos de GPU en la información sobre datos enriquecido de la ventana Pilas paralelas.</span><span class="sxs-lookup"><span data-stu-id="e676c-193">You can inspect the properties of a GPU thread that are available in the GPU Threads window in the rich DataTip of the Parallel Stacks window.</span></span> <span data-ttu-id="e676c-194">Para ello, sitúe el puntero del mouse sobre el marco de pila de **sum_kernel_tiled**.</span><span class="sxs-lookup"><span data-stu-id="e676c-194">To do this, rest the mouse pointer on the stack frame of **sum_kernel_tiled**.</span></span> <span data-ttu-id="e676c-195">La ilustración siguiente muestra la información sobre datos.</span><span class="sxs-lookup"><span data-stu-id="e676c-195">The following illustration shows the DataTip.</span></span>  

 <span data-ttu-id="e676c-196">![Información sobre datos de la ventana Pilas paralelas](../../parallel/amp/media/campe.png "campe")</span><span class="sxs-lookup"><span data-stu-id="e676c-196">![DataTip for Parallel Stacks window](../../parallel/amp/media/campe.png "campe")</span></span>  

Subprocesos GPU información sobre datosGPU thread DataTip

 <span data-ttu-id="e676c-198">Para obtener más información acerca de la ventana Pilas paralelas, vea [mediante la ventana Pilas paralelas](/visualstudio/debugger/using-the-parallel-stacks-window).</span><span class="sxs-lookup"><span data-stu-id="e676c-198">For more information about the Parallel Stacks window, see [Using the Parallel Stacks Window](/visualstudio/debugger/using-the-parallel-stacks-window).</span></span>  

Usar la ventana Inspección paralelaTo use the Parallel Watch window

  1. Para abrir la ventana Inspección paralela, en la barra de menús, elija depurar, Windows, inspección paralela, inspección paralela 1.To open the Parallel Watch window, on the menu bar, choose Debug, Windows, Parallel Watch, Parallel Watch 1.

    Puede utilizar la ventana Inspección paralela para inspeccionar los valores de una expresión en varios subprocesos.You can use the Parallel Watch window to inspect the values of an expression across multiple threads.

  2. Acoplar la ventana Inspección paralela 1 en la parte inferior de Visual Studio.Dock the Parallel Watch 1 window to the bottom of Visual Studio. Hay 32 filas en la tabla de la ventana Inspección paralela.There are 32 rows in the table of the Parallel Watch window. Cada uno de ellos corresponde a un subproceso GPU que aparecían en la ventana subprocesos de GPU y la ventana Pilas paralelas.Each corresponds to a GPU thread that appeared in both the GPU Threads window and the Parallel Stacks window. Ahora, puede escribir expresiones cuyos valores desea inspeccionar en todos los subprocesos GPU 32.Now, you can enter expressions whose values you want to inspect across all 32 GPU threads.

  3. Seleccione el Agregar inspección encabezado de columna, escriba localIdxy, a continuación, elija la tecla ENTRAR.Select the Add Watch column header, enter localIdx, and then choose the Enter key.

  4. Seleccione el Agregar inspección nuevo encabezado de columna, escriba globalIdxy, a continuación, elija la tecla ENTRAR.Select the Add Watch column header again, type globalIdx, and then choose the Enter key.

  5. Seleccione el Agregar inspección nuevo encabezado de columna, escriba localA[localIdx[0]]y, a continuación, elija la tecla ENTRAR.Select the Add Watch column header again, type localA[localIdx[0]], and then choose the Enter key.

    Puede ordenar por una expresión especificada, seleccione el encabezado de columna correspondiente.You can sort by a specified expression by selecting its corresponding column header.

    Seleccione el localA [localIdx [0]] encabezado de columna para ordenar la columna.Select the localA[localIdx[0]] column header to sort the column. La ilustración siguiente muestra los resultados de ordenación por localA [localIdx [0]].The following illustration shows the results of sorting by localA[localIdx[0]].

    Ventana Inspección paralela con resultados ordenadosParallel Watch window with sorted results
    Resultados de la ordenaciónResults of sort

    Puede exportar el contenido de la ventana Inspección paralela a Excel eligiendo el botón de Excel y, a continuación, elegir abierto en Excel.You can export the content in the Parallel Watch window to Excel by choosing the Excel button and then choosing Open in Excel. Si tiene Excel instalado en el equipo de desarrollo, se abrirá una hoja de cálculo de Excel que contiene el contenido.If you have Excel installed on your development computer, this opens an Excel worksheet that contains the content.

  6. En la esquina superior derecha de la ventana Inspección paralela, hay un control de filtro que puede usar para filtrar el contenido mediante el uso de expresiones booleanas.In the upper-right corner of the Parallel Watch window, there's a filter control that you can use to filter the content by using Boolean expressions. Escriba localA[localIdx[0]] > 20000 en el texto del control de filtro y, a continuación, elija la tecla ENTRAR.Enter localA[localIdx[0]] > 20000 in the filter control text box and then choose the Enter key.

    La ventana contiene ahora sólo los subprocesos en los que la localA[localIdx[0]] valor es mayor que 20000.The window now contains only threads on which the localA[localIdx[0]] value is greater than 20000. El contenido todavía está ordenado por la localA[localIdx[0]] columna, que es la acción de ordenación que realizó anteriormente.The content is still sorted by the localA[localIdx[0]] column, which is the sorting action you performed earlier.

Acción de marcar subprocesos GPUFlagging GPU Threads

Puede marcar los subprocesos GPU específicos marcando en la ventana de subprocesos de GPU, la ventana Inspección paralela o la información sobre datos en la ventana Pilas paralelas.You can mark specific GPU threads by flagging them in the GPU Threads window, the Parallel Watch window, or the DataTip in the Parallel Stacks window. Si una fila en la ventana subprocesos de GPU contiene más de un subproceso, marcar esa fila marca todos los subprocesos que están contenidos en la fila.If a row in the GPU Threads window contains more than one thread, flagging that row flags all threads that are contained in the row.

Para marcar subprocesos GPUTo flag GPU threads

  1. Seleccione el [subproceso] encabezado de columna en la ventana Inspección paralela 1 para ordenar por índice de icono y el índice de subproceso.Select the [Thread] column header in the Parallel Watch 1 window to sort by tile index and thread index.

  2. En la barra de menús, elija depurar, continuar, que hace que los cuatro subprocesos que estaban activas en curso para la barrera siguiente (que se define en línea 32 de AMPMapReduce.cpp).On the menu bar, choose Debug, Continue, which causes the four threads that were active to progress to the next barrier (defined at line 32 of AMPMapReduce.cpp).

  3. Elija el símbolo de marca en el lado izquierdo de la fila que contiene los cuatro subprocesos activos.Choose the flag symbol on the left side of the row that contains the four threads that are now active.

    En la siguiente ilustración muestra los cuatro subprocesos marcados activos en la ventana subprocesos de GPU.The following illustration shows the four active flagged threads in the GPU Threads window.

    Ventana subprocesos de GPU con subprocesos marcadosGPU Threads window with flagged threads
    Subprocesos activos en la ventana Subprocesos de GPUActive threads in the GPU Threads window

    La ventana Inspección paralela y la información sobre datos de la ventana Pilas paralelas ambas indican los subprocesos marcados.The Parallel Watch window and the DataTip of the Parallel stacks window both indicate the flagged threads.

  4. Si desea centrarse en los cuatro subprocesos marca, puede elegir mostrar en los subprocesos de GPU, inspección paralela y ventanas de pilas paralelas, solo los subprocesos marcados.If you want to focus on the four threads that you flagged, you can choose to show, in the GPU Threads, Parallel Watch, and Parallel Stacks windows, only the flagged threads.

    Elija el botón Mostrar solo marcados en cualquiera de las ventanas o bien, en la ubicación de depuración barra de herramientas.Choose the Show Flagged Only button on any of the windows or on the Debug Location toolbar. La siguiente ilustración muestra el botón Mostrar solo marcados en el ubicación de depuración barra de herramientas.The following illustration shows the Show Flagged Only button on the Debug Location toolbar.

    Barra de herramientas de ubicación con el icono Mostrar marcadas únicamente depuraciónDebug Location toolbar with Show Only Flagged icon
    Botón Mostrar solo subprocesos marcadosShow Flagged Only button

    Ahora las ventanas Inspección paralela, subprocesos de GPU y las pilas paralelas mostrarán sólo los subprocesos marcados.Now the GPU Threads, Parallel Watch, and Parallel Stacks windows display only the flagged threads.

Inmovilizar y reanudar subprocesos de GPUFreezing and Thawing GPU Threads

Puede inmovilizar (suspender) y retomar (Reanudar) los subprocesos GPU de la ventana de subprocesos de GPU o en la ventana Inspección paralela.You can freeze (suspend) and thaw (resume) GPU threads from either the GPU Threads window or the Parallel Watch window. Puede inmovilizar y reanudar subprocesos de CPU de la misma manera; Para obtener información, consulte Cómo: utilizar la ventana subprocesos.You can freeze and thaw CPU threads the same way; for information, see How to: Use the Threads Window.

Para inmovilizar y reanudar subprocesos de GPUTo freeze and thaw GPU threads

  1. Elija la mostrar solo subprocesos marcados botón para mostrar todos los subprocesos.Choose the Show Flagged Only button to display all the threads.

  2. En la barra de menús, elija depurar, continuar.On the menu bar, choose Debug, Continue.

  3. Abra el menú contextual para la fila activa y, a continuación, elija inmovilizar.Open the shortcut menu for the active row and then choose Freeze.

    La siguiente ilustración de la ventana de subprocesos de GPU muestra que todos los cuatro subprocesos están inmovilizados.The following illustration of the GPU Threads window shows that all four threads are frozen.

    Ventanas de subprocesos de GPU que muestren subprocesos inmovilizadosGPU Threads windows showing frozen threads
    Subprocesos inmovilizados en la ventana Subprocesos de GPUFrozen threads in the GPU Threads window

    De forma similar, la ventana Inspección paralela muestra que todos los cuatro subprocesos están inmovilizados.Similarly, the Parallel Watch window shows that all four threads are frozen.

  4. En la barra de menús, elija depurar, continuar para permitir que los siguientes cuatro subprocesos GPU transcurrir superan la barrera en línea 22 y para alcanzar el punto de interrupción en la línea 30.On the menu bar, choose Debug, Continue to allow the next four GPU threads to progress past the barrier at line 22 and to reach the breakpoint at line 30. La ventana subprocesos de GPU muestra que los cuatro subprocesos anteriormente inmovilizados quedan inmovilizado y, en el estado activo.The GPU Threads window shows that the four previously frozen threads remain frozen and in the active state.

  5. En la barra de menús, elija depurar, continuar.On the menu bar, choose Debug, Continue.

  6. En la ventana Inspección paralela, también puede reanudar individuales o varios subprocesos GPU.From the Parallel Watch window, you can also thaw individual or multiple GPU threads.

Para agrupar subprocesos GPUTo group GPU threads

  1. En el menú contextual para uno de los subprocesos en la subprocesos de GPU ventana, elija Group By, dirección.On the shortcut menu for one of the threads in the GPU Threads window, choose Group By, Address.

    Los subprocesos en la ventana subprocesos de GPU se agrupan por dirección.The threads in the GPU Threads window are grouped by address. La dirección corresponde a la instrucción en el que se encuentra cada grupo de subprocesos de desensamblado.The address corresponds to the instruction in disassembly where each group of threads is located. 24 subprocesos que están en línea 22 donde la tile_barrier:: Wait (método) se ejecuta.24 threads are at line 22 where the tile_barrier::wait Method is executed. 12 subprocesos están en la instrucción de la barrera en línea 32.12 threads are at the instruction for the barrier at line 32. Cuatro de estos subprocesos están marcado.Four of these threads are flagged. Ocho subprocesos están en el punto de interrupción en la línea 30.Eight threads are at the breakpoint at line 30. Cuatro de estos subprocesos están inmovilizada.Four of these threads are frozen. En la siguiente ilustración se muestra los subprocesos agrupados en la ventana subprocesos de GPU.The following illustration shows the grouped threads in the GPU Threads window.

 <span data-ttu-id="e676c-262">![Ventana subprocesos de GPU con subprocesos agrupados por dirección](../../parallel/amp/media/campl.png "campl")</span><span class="sxs-lookup"><span data-stu-id="e676c-262">![GPU Threads window with threads grouped by Address](../../parallel/amp/media/campl.png "campl")</span></span>  

Subprocesos agrupados en la ventana de subprocesos de GPUGrouped threads in the GPU Threads window

  1. También puede realizar la Group By operación abriendo el menú contextual de la cuadrícula de datos de la ventana Inspección paralela, elegir Group Byy, a continuación, elija el elemento de menú que corresponde a cómo desea para agrupar los subprocesos.You can also perform the Group By operation by opening the shortcut menu for the data grid of the Parallel Watch window, choosing Group By, and then choosing the menu item that corresponds to how you want to group the threads.

Todos los subprocesos en ejecución en una ubicación específica en el códigoRunning All Threads to a Specific Location in Code

Ejecutar todos los subprocesos en un icono determinado para la línea que contiene el cursor mediante ejecutar actual icono hasta el Cursor.You run all the threads in a given tile to the line that contains the cursor by using Run Current Tile To Cursor.

Para ejecutar todos los subprocesos en la ubicación marcada por el cursorTo run all threads to the location marked by the cursor

  1. En el menú contextual para los subprocesos inmovilizados, elija reanudar.On the shortcut menu for the frozen threads, choose Thaw.

  2. En el Editor de código, coloque el cursor en la línea 30.In the Code Editor, put the cursor in line 30.

  3. En el menú contextual del Editor de código, elija ejecutar actual icono hasta el Cursor.On the shortcut menu for the Code Editor, choose Run Current Tile To Cursor.

    Los 24 subprocesos que antes estaban bloqueados en la barrera en línea 21 han progresado a línea 32.The 24 threads that were previously blocked at the barrier at line 21 have progressed to line 32. Esto se muestra en el subprocesos de GPU ventana.This is shown in the GPU Threads window.

Vea tambiénSee Also

Introducción a C++ AMP C++ AMP Overview
Depurar código de GPU Debugging GPU Code
Cómo: utilizar la ventana de subprocesos GPU How to: Use the GPU Threads Window
Cómo: utilizar la ventana Inspección paralela How to: Use the Parallel Watch Window
Análisis de código de AMP de C++ con el visualizador de simultaneidadAnalyzing C++ AMP Code with the Concurrency Visualizer