Arm Forge is a development tool suite for developing, debugging and optimizing CUDA and OpenACC codes such as GeForce, Tesla and the Kepler K80. Arm Forge includes the Arm DDT for parallel and multi-process debugging, and Arm MAP for profiling.
Get a trialArm DDT fully supports applications produced in CUDA C, C++, Fortran and OpenACC. Arm DDT is used for debugging these applications in industries that require high performance computing.
The following sections offer best practices on using Arm DDT for CUDA.
You can set a breakpoint at any line of CUDA source code, in the same way that you can with a CPU debugger. When a block of CUDA threads reaches a specific line, the debugger pauses the whole application.
GPUs include substantial SIMD instructions and allow thousands of active threads to run simultaneously. The debugger enables you to identify and select a specific CUDA thread by its index or select a thread on a particular line of code.
Stepping a thread displays how a kernel progresses, although CUDA GPUs are slightly different to CPUs and execute threads in groups.
Note: Other GPU threads in the same warp (usually 32 threads) progress at the same time. Examine whether the thread you are monitoring moves through the code as intended.
Each CUDA thread has its own register variables but can share other memory with threads in the same block, the whole device or even the host. Make sure that the data resides in the expected type of memory. While single values can be easily identified, it is helpful for identifying unusual values to visualize array data or to filter data.
Tip: Generate a second visualization to compare and check GPU data with the CPU copy.
Before you start your application using Arm DDT, select the option to debug CUDA memory usage. Not all arrays are multiples of the warp-size and it is common to make an error that reads beyond an array in CUDA. While those errors are not always fatal, they do cause non-deterministic behavior that can lead to failure at unexpected times. The debugger identifies these errors so you can fix them to prevent issues.
Use the Arm MAP profiler to examine application performance so that you can optimize the code to achieve prime performance. When you compute intensive code, Arm MAP can help to identify the lines of code which are most time intensive during execution of the host CPU code.
Use the Arm MAP profiler to discover the parts of your code that consume the most CPU time and determine what those lines of code do. If scalar or floating point operations dominate CPU time, GPU usage is likely to be high. However, if I/O, branching or communication dominate the CPU time, you must fix those issues first .
When your optimized CUDA or OpenACC code is in operation, establish whether performance has improved, and identify the next target for optimization. If possible, reduce the frequency of data transfer between CPU and GPU to improve performance, by combining sequences of CPU operations into one large GPU usage.
Note: MAP can provide profile information about source lines or functions for CUDA kernels executed on the GPU, but not for OpenACC kernels.
MAP can get CUDA source line profiling information and show how the CPU and GPU work together.
In one approach to optimization, you can overlap GPU and CPU computation, which CUDA makes easy to do with streams. However, you still need to find out how much time is spent in data transfer. If there is too little time spent waiting at the synchronization stage, the GPU might finish quicker than the CPU, and needs further optimization. If too much time is spent at the synchronization stage, the CPU wastes cycles which could be utilized.