Efficiently computing static single assignment form and the control dependence graph
ACM Transactions on Programming Languages and Systems (TOPLAS)
Eraser: a dynamic data race detector for multithreaded programs
ACM Transactions on Computer Systems (TOCS)
RecPlay: a fully integrated practical record/replay system
ACM Transactions on Computer Systems (TOCS)
Debugging shared memory parallel programs using record/replay
Future Generation Computer Systems - Tools for program development and analysis
Atomizer: a dynamic atomicity checker for multithreaded programs
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Brook for GPUs: stream computing on graphics hardware
ACM SIGGRAPH 2004 Papers
A relational debugging engine for the graphics pipeline
ACM SIGGRAPH 2005 Papers
SIGGRAPH '05 ACM SIGGRAPH 2005 Courses
A hardware-aware debugger for the OpenGL shading language
Proceedings of the 22nd ACM SIGGRAPH/EUROGRAPHICS symposium on Graphics hardware
BSGP: bulk-synchronous GPU programming
ACM SIGGRAPH 2008 papers
Real-time Reyes-style adaptive surface subdivision
ACM SIGGRAPH Asia 2008 papers
Beyond programmable shading (parts I and II)
ACM SIGGRAPH 2009 Courses
Register allocation for programs in SSA-Form
CC'06 Proceedings of the 15th international conference on Compiler Construction
RenderAnts: interactive Reyes rendering on GPUs
ACM SIGGRAPH Asia 2009 papers
Euro-Par 2010 Proceedings of the 2010 conference on Parallel processing
Softshell: dynamic scheduling on GPUs
ACM Transactions on Graphics (TOG) - Proceedings of ACM SIGGRAPH Asia 2012
Hi-index | 0.00 |
We present a novel framework for debugging GPU stream programs through automatic dataflow recording and visualization. Our debugging system can help programmers locate errors that are common in general purpose stream programs but very difficult to debug with existing tools. A stream program is first compiled into an instrumented program using a compiler. This instrumenting compiler automatically adds to the original program dataflow recording code that saves the information of all GPU memory operations into log files. The resulting stream program is then executed on the GPU. With dataflow recording, our debugger automatically detects common memory errors such as out-of-bound access, uninitialized data access, and race conditions -- these errors are extremely difficult to debug with existing tools. When the instrumented program terminates, either normally or due to an error, a dataflow visualizer is launched and it allows the user to examine the memory operation history of all threads and values in all streams. Thus the user can analyze error sources by tracing through relevant threads and streams using the recorded dataflow. A key ingredient of our debugging framework is the GPU interrupt, a novel mechanism that we introduce to support CPU function calls from inside GPU code. We enable interrupts on the GPU by designing a specialized compilation algorithm that translates these interrupts into GPU kernels and CPU management code. Dataflow recording involving disk I/O operations can thus be implemented as interrupt handlers. The GPU interrupt mechanism also allows the programmer to discover errors in more active ways by developing customized debugging functions that can be directly used in GPU code. As examples we show two such functions: assert for data verification and watch for visualizing intermediate results.