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

En este tema se 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 de paralelo que realiza la suma de una matriz de enteros grande.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:

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

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

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

  • Mediante el inspección paralela ventana para inspeccionar los valores de una sola 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, congelación, reanudación y agrupación de 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:

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 el 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 el 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;
    }
  1. En la barra de menús, pulse Archivo > Guardar todo.On the menu bar, choose File > Save All.

  2. 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.

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

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

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

Depurar el código de la CPUDebugging the CPU Code

En este procedimiento, usará al depurador de Windows Local para asegurarse de que el código de la 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 la aplicación es especialmente interesante es la for 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 paralela 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 la 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. Vuelva a la 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 en 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 CPU puntos de interrupción de CPUCPU breakpoints CPU breakpoints

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

  6. En el variables locales ventana, observe el valor para stride_size hasta que se alcanza 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

En esta sección se muestra cómo depurar el código GPU, que es el código contenido 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 GPU calcula la suma de enteros para cada "bloque" en paralelo.The GPU code computes the sum of integers for each "block" in parallel.

Para depurar el código 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 GPU punto de interrupción GPUGPU breakpoints GPU 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 la 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 el subprocesos de GPU ventana, 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 la GPU de subprocesos en el subprocesos de GPU ventana que aparece.You can inspect the state the GPU threads in the GPU Threads window that appears.

  2. Acoplar el subprocesos de GPU ventana en la parte inferior de Visual Studio.Dock the GPU Threads window at the bottom of Visual Studio. Elija la expanda subproceso conmutador 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. El subprocesos de GPU ventana 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 activos ventana subprocesos de GPUGPU Threads window with 4 active threads GPU 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 se produce 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 el subprocesos de GPU ventana, hay cuatro subprocesos de GPU activa y bloquean el 28 subprocesos de GPU 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, use uno de los métodos siguientes:To switch to a different thread, use one of the following methods:

    • En la fila para el subproceso cambiar a la subprocesos de GPU ventana, abra el menú contextual y elija cambiar a subproceso.In the row for the thread to switch to in the GPU Threads window, open the shortcut menu and choose Switch To Thread. Si la fila representa más de un subproceso, cambiará al primer subproceso según las coordenadas de subproceso.If the row represents more than one thread, you will switch to the first thread according to the thread coordinates.

    • Escriba los valores de mosaico y el subproceso del subproceso en los cuadros de texto correspondiente y, a continuación, elija el conmutador subproceso botón.Enter the tile and thread values of the thread in the corresponding text boxes and then choose the Switch Thread button.

      El pila de llamadas ventana muestra la pila de llamadas del subproceso actual de la GPU.The Call Stack window displays the call stack of the current GPU thread.

Para usar la ventana Pilas paralelasTo use the Parallel Stacks window

  1. Para abrir el pilas paralelas ventana, 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 el pilas paralelas ventana simultáneamente inspeccionar 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 el pilas paralelas ventana 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, el pilas paralelas ventana muestra una vista centrada de la pila de llamadas de los subprocesos GPU que vio en el subprocesos de GPU ventana.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 activos ventana Pilas paralelasParallel Stacks window with 4 active threads Parallel Stacks window

    32 subprocesos pasaron de _kernel_stub la expresión lambda en el parallel_for_each llamada de función y, a continuación, en el 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 fuera de los 32 subprocesos han progresado en los tile_barrier:: wait instrucción y permanecerá bloqueado en la línea 22, mientras que los 4 subprocesos permanecen activas en el sum_kernel_tiled función en la línea 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.

    Puede inspeccionar las propiedades de un subproceso GPU que están disponibles en el subprocesos de GPU ventana en la información sobre datos enriquecido de los pilas paralelas ventana.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. Para ello, coloque el puntero del mouse sobre el marco de pila de sum_kernel_tiled.To do this, rest the mouse pointer on the stack frame of sum_kernel_tiled. La siguiente ilustración muestra la información sobre datos.The following illustration shows the DataTip.

    Información sobre datos de la ventana Pilas paralelas información sobre datos de subproceso de GPUDataTip for Parallel Stacks window GPU thread DataTip

    Para obtener más información sobre la pilas paralelas ventana, consulte mediante la ventana Pilas paralelas.For more information about the Parallel Stacks window, see Using the Parallel Stacks Window.

Para usar la ventana Inspección paralelaTo use the Parallel Watch window

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

    Puede usar el inspección paralela ventana para inspeccionar los valores de una expresión entre varios subprocesos.You can use the Parallel Watch window to inspect the values of an expression across multiple threads.

  2. Acoplar el inspección paralela 1 ventana a 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 inspección paralela ventana.There are 32 rows in the table of the Parallel Watch window. Cada uno corresponde a un subproceso GPU que apareció en la ventana subprocesos de GPU y la pilas paralelas ventana.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 32 subprocesos GPU.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 el ENTRAR clave.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 el ENTRAR clave.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 el ENTRAR clave.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 siguiente ilustración 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 ordenados resultados de ordenaciónParallel Watch window with sorted results Results of sort

    Puede exportar el contenido de la inspección paralela ventana de Excel eligiendo el Excel botón y, a continuación, elija abrir 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 inspección paralela ventana, 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. ENTRAR localA[localIdx[0]] > 20000 en el texto del control de filtro y, a continuación, elija el ENTRAR clave.Enter localA[localIdx[0]] > 20000 in the filter control text box and then choose the Enter key.

    La ventana ahora contiene sólo los subprocesos en los que el localA[localIdx[0]] valor es mayor de 20 000.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.

Marcar los subprocesos de GPUFlagging GPU Threads

Puede marcar los subprocesos GPU específicos marcando en el subprocesos de GPU ventana, el inspección paralela ventana o la información sobre datos en el pilas paralelas ventana.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, al marcar esa fila marcas de todos los subprocesos que se encuentran 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 inspección paralela 1 ventana 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 al progreso a la barrera siguiente (definida en la 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 que ahora están activos.Choose the flag symbol on the left side of the row that contains the four threads that are now active.

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

    Ventana subprocesos de GPU con subprocesos marcados subprocesos activos en la ventana subprocesos de GPUGPU Threads window with flagged threads Active threads in the GPU Threads window

    El inspección paralela ventana y la información sobre datos de la pilas paralelas ventana ambos indicar 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 que indican, puede elegir mostrar, en el subprocesos de GPU, inspección paralela, y pilas paralelas windows, solo los marcados subprocesos.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 la mostrar solo marcados botón en cualquiera de las ventanas o en el 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 mostrar solo marcados situado en la 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ón mostrar solo marcados botónDebug Location toolbar with Show Only Flagged icon Show Flagged Only button

    Ahora el subprocesos de GPU, inspección paralela, y pilas paralelas ventanas muestran solo 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) GPU subprocesos desde la subprocesos de GPU ventana o el inspección paralela ventana.You can freeze (suspend) and thaw (resume) GPU threads from either the GPU Threads window or the Parallel Watch window. Puede inmovilizar y descongelar 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 descongelar subprocesos de GPUTo freeze and thaw GPU threads

  1. Elija la mostrar solo 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 de 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 subprocesos de GPU ventana muestra que todos los cuatro subprocesos están inmovilizados.The following illustration of the GPU Threads window shows that all four threads are frozen.

    Windows de subprocesos de GPU que muestra los subprocesos inmovilizados inmovilizar subprocesos la subprocesos de GPU ventanaGPU Threads windows showing frozen threads Frozen threads in the GPU Threads window

    De forma similar, el inspección paralela ventana 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 de GPU para avanza más allá de la barrera en la línea 22 y 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. El subprocesos de GPU ventana muestra que los cuatro subprocesos inmovilizados previamente permanecen 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. Desde el inspección paralela ventana, 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 los 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 subprocesos de GPU ventana 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 desensamblado donde se encuentra cada grupo de subprocesos.The address corresponds to the instruction in disassembly where each group of threads is located. 24 subprocesos que están en la línea 22 donde el 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 la 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 congelado.Four of these threads are frozen. La siguiente ilustración muestra los subprocesos agrupados en el subprocesos de GPU ventana.The following illustration shows the grouped threads in the GPU Threads window.

    Ventana subprocesos de GPU con subprocesos agrupados por dirección agrupar subprocesos en la subprocesos de GPU ventanaGPU Threads window with threads grouped by Address Grouped threads in the GPU Threads window

  2. También puede realizar la Group By operación abriendo el menú contextual de la cuadrícula de datos de la inspección paralela ventana, elija Group Byy, a continuación, elija el menú elemento que corresponde a cómo desea 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

Ejecute 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 para el Editor de código, elija ejecutar Tile actual a Cursor.On the shortcut menu for the Code Editor, choose Run Current Tile To Cursor.

    Los 24 subprocesos que se bloquearon anteriormente en la barrera en la línea 21 han progresado en 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

Información general sobre C++ AMPC++ AMP Overview
Depurar código de GPUDebugging GPU Code
Cómo: Usar la ventana Subprocesos de GPUHow to: Use the GPU Threads Window
Cómo: Usar la ventana Inspección paralelaHow 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