TotalView Users Guide - CI Wiki

Debugging IBM Cell Broadband Engine Programs
the PPU and each SPU separately. For example, you can switch from one to
another by diving on it in the Root Window.
The PPU
When debugging Cell programs, you need to be aware of the two different
architectures as they have different behaviors. The PPU is a standard IBM
Linux PowerPC. You interact with programs running on the PPU in exactly
the same way as you interact with standard Linux PowerPC programs.
As it is typical to run multiple Cell machines together, each PPU process
running the same program is placed in one share group. If more than one
executable is being run, each set of identical programs is placed in its own
share group. All of these share groups are contained within one control
group. The way in which TotalView groups processes and threads is identical
to how it groups them on all other architectures.
The SPU
The programs running on the SPU are handled in a slightly different way. On
other architectures, a share group only contains processes. On the Cell,
TotalView places SPU threads that are running the same executable into
separate share groups. That is, on SPUs, a share group contains threads,
not processes. SPU share groups can contain SPU threads running on other
Cells, and these Cells can be within the same blade or within blades in a
cluster.
Cell Programing
While there are several ways to program the Cell, the primary method uses
the front-end PPU to load programs into the SPUs.
The SPU image can be embedded within the same executable that contains
the PPU executable or it can be contained within shared libraries.
PPU and SPU Executable Organization
Typically, a Cell executable file is usually organized in one of the following
ways:
� The PPU executable file contains all code that runs on the PPU and SPUs.
That is, the SPU executables are embedded within a PPU executable file
or shared library.
� The PPU executable file only contains the code that runs on the PPU. The
SPU executable file opened at runtime by a PPU thread using a libspe/
libspe2 function. The opened file is then loaded into the SPU using the
same functions that load an embedded SPU image.
� A combination of the previous two methods.
In general, executing an SPU thread is a multi-step process. The PPU begins
by create an SPE context. This context can be thought of as being a thread
that is not running: it has an address space, registers, MFC state, and so
on.) This thread has all memory, registers, and the like set to zero.
140 Chapter 7: Setting Up Parallel Debugging Sessions