mpC Workshop

mpC Workshop is an integrated development environment for the mpC parallel programming language. mpC Workshop includes:

mpC Workshop uses the client-server model with GUI environment on the client side and mpC command-line environment on the server side. On the client side you create and edit mpC source files, specify settings for building executables and initiate building and debugging. Client sends commands to server and the server performs them. Executable is built on one of machines and broadcasted to other machines that will take part in execution of the parallel program.

Text editor

The mpC Workshop integrated text editor provides all facilities that can be expected in a usual text editor for programmers. Among text editor features there are: syntax indenting and highlighting, and advanced search facilities. The appearance of the code, that is font style, size, and color, as well as background, is fully customizable.

mpC debugger

The mpC debugger is designed so that it treats a parallel program as a whole, while other parallel debuggers treat a parallel program as a set of independent processes communicating with each other. The mpC debugger provides especially useful facilities for controlling program execution and easy to understand graphical representation of the debugging information. By now, there were no really parallel debuggers for Windows platform on the world market, so the mpC Workshop integrated source-level debugger is the first really parallel debugger for Microsoft Windows.

Click here to view a screenshot

The main features of the mpC debugger are:

Debug cursors

Debug cursors provide especially useful mechanism for controlling parallel programs execution. During debugging each process of a parallel program is associated with some cursor that corresponds to process' current execution point. The cursors that correspond to the same execution point are grouped into one debug cursor. When the debugged program breaks execution all currently existing debug cursors are displayed in a special window. Ideologically, in the mpC debugger you continue execution of cursors. It means that when you move a cursor, you continue execution of all processes corresponding to this cursor. Thus you move not separate processes but groups of processes. This feature is particularly convenient if your parallel program consists of many processes - you needn't group processes before continuing their execution - the debugger does it for you automatically. But if you don't want to continue execution of all the processes that correspond to some debug cursor you can split this cursor into two or more new cursors and continue execution of a part of the processes.

Any debug cursor can be either green or amber or red. Since a parallel program usually consists of many processes, in general there may be several cursors of each color. To continue execution of the processes corresponding to green cursors you can use all of the debugger moving commands. Execution of the processes corresponding to amber cursors can be continued using "go" and "go to cursor" commands only. You can't continue execution of the processes corresponding to red cursors because each of these processes either has finished execution or waits for some message from other processes.

Any green or amber cursor can be split or merged. Splitting cursor means that you divide the group of processes corresponding to one cursor into two or more groups, thus making two or more new cursors. Every new cursor can be recolored. By splitting a green cursor into several ones and making some of the new cursors amber you can select which processes will continue execution.

Click here to view a screenshot

Moving commands

The mpC debugger provides the standard set of debugger moving commands. All step commands are used for processes corresponding to green cursors only, while "go" and "go to cursor" commands can be used for processes corresponding either to green cursors or to both green and amber cursors.

Breakpoints and watchpoints

Just like in any conventional debugger in the mpC debugger you can set breakpoints and watchpoints. By setting a breakpoint you specify the place where processes of your program should stop. A watchpoint is a special breakpoint that stops your program when the value of an expression changes. Since the debugged program is parallel it may happen that not all processes reach a breakpoint - some of the processes may stop before or after the breakpoint. To control in finer detail whether your program stops you can set conditional expression or ignore count for a breakpoint or watchpoint. The conditional expression is evaluated each time the breakpoint is reached and a process stops only if the expression is true. By setting a conditional expression of special kind you can specify for which processes the breakpoint or watchpoint is set.

Watches and quick watches

Watch is an expression that is evaluated every time the debugged program breaks execution. Values of the expression in all processes are displayed in the special window. Unlike watchpoint, watch doesn't cause the program to stop. Another way of viewing values of some expression is using quick watch. Quick watch is an expression that is evaluated only once. A quick watch can be evaluated only when the program is stopped.

Click here to view a screenshot

Network filters

By setting a network filter you can restrict the amount of information displayed in different windows. You can set a network filter for every window, which displays information for each process, for example watch window. By setting network filter you specify the processes, for which information should be displayed.

Click here to view a screenshot

Call stack

Call stack of a process is a list of all functions that were entered but not exited. In the mpC debugger you can easily view or move along of call stack of any process of a parallel program.

Click here to view a screenshot

VPM management tool

The notion of Virtual Parallel Machine is introduced in the mpC programming environment. Virtual Parallel Machine, or just VPM, is a set of computers, called VPM nodes, running an mpC-based program. Two numbers are associated with each VPM node - number of processors on the node and number of processes that will be executed on the node. The Virtual Parallel Machine management tool allows you to manipulate VPMs in a number of ways: create, remove, edit, close and open.

mpC adviser

mpC adviser is a tool that allows viewing not only type of expression but also distribution of expression or statement. It's especially useful when you want to know distribution of left and right operands of some assignment operation. You can use mpC adviser whenever you want - both during debugging, and when you write code.

mpC command-line environment

mpC command-line environment includes a compiler, a run-time support system (RTSS), a library, and a command-line user interface. The compiler translates a source mpC program into the ANSI C program with calls to functions of RTSS. RTSS manages processes, constituting the parallel program, and provides communications. It encapsulates a particular communication platform (currently, a subset of MPI) ensuring platform-independence of the rest of system components.