The Breezy Access module is currently implemented as a library of C routines. This library is linked with a client application to give that application access to the Breezy API. The following list relates this functionality in detail.
The client can control the execution of the program. The parallel program stops at each synchronization barrier and waits for a request from the client. This request specifies one of the functions described below, or it directs Breezy to continue to the next breakpoint. Breezy guarantees a consistent state of data in the program by allowing breakpoints only during these barriers.
The client can retrieve data from parallel data structures. The client specifies the variable from the program that holds the parallel data object of interest. If this object is a structured object with fields (such as a class), then the client can further specify a particular field within that structure. The user can retrieve this data from all of the distributed elements of the parallel data object, or from a single element in that object.
The client can call specified user-defined functions (or method
invocations on classes) in the parallel program. By
prepending function names in the user program with a particular
string (e.g. UserDefined), the Breezy instrumentation process
notes these particular functions, and adds code that will make
them available to the client during runtime. Note that these can
be methods defined on the elements of a parallel object as well as
regular global functions.
The client can retrieve specific information about the program state. This includes the current location in the source code where the program has paused, and also a list of variables that are currently instantiated parallel objects. The client can retrieve meta-information about the program. This consists of type information for all the parallel structures, and also the names of user-defined functions that are available to be called.
Lastly, Breezy supports communication between the client application and parallel program. This may be desirable for instance if the programmer wants a user-defined function to return a value(s). This can be done in a straightforward manner with a high level communication interface which accesses the transport layer directly, bypassing the Breakpoint Executive and the Breezy Access module.
One of the functions that might be of less obvious use is the ability to get type information about the parallel data objects in the program. This type information may be of interest in itself, as in a debugger application. Also, the client program can make use of type information to interact with the Breezy Access module. Using type information, client applications can be generic, adapting to different parallel programs and data within those programs.