GPU621/OpenMP Debugging
Group Members
Process and thread
Process
A process is the instance of a computer program that is being executed by one or many threads.
Thread
A thread is a sequence of instructions to which the operating system grants processor time. Every process that is running in the operating system consists of at least one thread. Processes that have more than one thread are called multithreaded.
Multiple Processes Debug
Visual Studio can debug a solution that has several processes. You can start and switch between processes, break, continue, and step through source, stop debugging, and end or detach from individual processes.
Create two projects
To test it, the best way with Visual Studio is creating two projects.
- 1. Create a new project of Visual Studio
- 2. Add a new project within the Solution
- 3. Add test files on each projects
Start debugging with multiple processes
If you have more than one project in a project solution, you can choose which projects the debugger starts.
Follow this:
- Select the solution in Solution Explorer and then select the Properties icon in the toolbar, or right-click the solution and select Properties.
- On the Properties page, select Common Properties > Startup Project.
- Select Current selection, Single startup project and a project file, or Multiple startup projects.
- If you select Multiple startup projects, you can change the startup order and action to take for each project: Start, Start without debugging, or None.
- Select Apply, or OK to apply and close the dialog.
Attach to a process
The debugger can also attach to apps running in processes outside of Visual Studio, including on remote devices. After we attach to an app, we can use the Visual Studio debugger.
Follow this:
- With the app running, select Debug > Attach to Process.
- In the Attach to Process dialog box, select the process from the Available Processes list, and then select Attach.
Use the Registry Editor to automatically start a process in the debugger
We might need to debug the startup code for an app that is launched by another process. You can have the debugger launch and automatically attach to the app.
Follow this:
- Start the Windows Registry Editor by running regedit.exe.
- In Registry Editor, navigate to HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution Options.
- Select the folder of the app that you want to start in the debugger.
- If the app isn't listed as a child folder, right-click Image File Execution Options, select New > Key, and type the app name. Or, right-click the new *key in the tree, select Rename, and then enter the app name.
- Right-click the new key in the tree and select New > String Value.
- Change the name of the new value from New Value #1 to debugger.
- Right-click debugger and select Modify.
Debug with multiple processes
When debugging an app with several processes, the breaking, stepping, and continuing debugger commands affect all processes by default. You can change this option.
Follow this:
- Under Tools (or Debug) > Options > Debugging > General, select or clear the Break all processes when one process breaks check box.
Switch between processes
Only one process should be active in the debugger at any given time. We can set the active or current process in the Debug Location toolbar, or in the Processes window. To switch between processes, both processes must be in break mode.
To set the current process from the Debug Location toolbar:
- To open the Debug Location toolbar, select View > Toolbars > Debug Location.
- During debugging, on the Debug Location toolbar, select the process you want to set as the current process from the Process dropdown.
To set the current process from the Processes window:
- To open the Processes window, while debugging, select Debug > Windows > Processes.
- In the Processes window, the current process is marked by a yellow arrow. Double-click the process you want to set as the current process.
User Interface
For processes, the primary tools are the Attach to Process dialog box, the Processes window, and the Debug Location toolbar.
For threads, the primary tools for debugging threads are the Threads window, thread markers in source windows, Parallel Stacks window, Parallel Watch window, and the Debug Location toolbar.
Attach to Process dialog box
The Attach to Process dialog box shows outside processes to be attached to the visual Studio debugger.
You can attach the following processes
- Process name (.exe)
- Process ID number
- Menubar Title
- Type (Managed v4.0; Managed v2.0, v1.1, v1.0; x86; x64; IA64)
- User Name (account name)
- Session number
Action you can perform
- Select a process to attach to
- Select a remote computer
- Change transport type for connecting to remote computers
Processes window
The Process Window shows processes attached to the Visual Studio debugger. You can choose one of the processes during debugging mode.
Threads window
Setup:
How to Use:
Columns:
Flag Denotes which threads a user would like to pay special attention to.
Current Thread An arrow in this column indicates the current thread.
ID Displays a thread's identification number.
Managed ID Displays managed identification numbers.
Category Shows a thread's category. Categories are: User Interface Threads, Remote Call Procedure Handlers, or Worker Threads.
Name Identifies each thread by name.
Location Shows where a thread runs.
Priority Shows the precedence assigned to a thread by the system (hidden by default).
Affinity Mask Shows the affinity mask for a thread. Affinity mask determines which processors a thread can run on. This column is hidden by default.
Suspended Count This determines if a thread can run. This column is hidden by default.
Process Name Displays the name of the process to which a thread belongs. This column is hidden by default.
Process ID Displays the ID of the process to which a thread belongs. This column is hidden by default.
Transport Qualifier Identifies the machine to which the debugger is connected.
Source window
Setup:
How to Use:
Debug Location toolbar
You can set the active or current process in the Debug Location toolbar.
Debug Location toolbar has the following options:
- Current process
- Suspend the application
- Resume the application
- Suspend and shut down the application
- Current thread
- Toggle current thread flag state
- Show only flagged threads
- Show only current process
- Current stack frame
With this options you can perform the following actions:
- Switch to another process
- Suspend, resume, or shut down the application
- Switch to another thread in current process
- Switch to another stack frame in current thread
- Flag or unflag current threads
- Show only flagged threads
- Show only the current process
Parallel Stacks window
Setup:
How to Use:
Features:
Parallel Tasks window
Parallel Watch window
Setup:
How To Use:
Features:
Walkthrough
Case A - Using the Thread window
The following example of how to use Visual Studio's thread window was performed on Microsoft Visual Studio 2019 with Intel OneAPI Libraries and Intel Visual C++ Compiler.; This is the code used in the example.
#include <iostream>
#include <omp.h>
using namespace std;
int main()
{
printf("num of default usable thread is %d \n\n", omp_get_max_threads());
// serial ver
printf("num of thread currently using is %d \n", omp_get_num_threads());
printf("working thread num is %d \n", omp_get_thread_num());
printf("\n");
#pragma omp parallel
{
#pragma omp single // set openMP ver
{
printf("num of thread currently using is %d \n", omp_get_num_threads());
}
printf("working thread num is %d \n", omp_get_thread_num());
}
printf("\n");
#pragma omp parallel num_threads(8)
{
#pragma omp single // set openMP with num of threads ver
{
printf("num of thread currently using is %d \n", omp_get_num_threads());
}
printf("working thread num is %d \n", omp_get_thread_num());
}
printf("\n");
return 0;
}
serial region
auto OpenMP parallel region
OpenMP parallel region thread number decided (8)
Case B - Using the Parallel Stacks and the Parallel Watch Window
Setup:
Walkthrough:
Setup:
Walkthrough: