Welcome to Ram
Meenakshisundaram's Transputer Home Page
sequential computers are
approaching a fundamental physical
limit on their potential power. Such a limit is
the speed of light
The Helios Source Debugger is a parallel source debugger for the Helios
Operating System. It can debug distributed programs running on multiple
processors. Modules that require debugging are re-compiled and linked with debug
libraries. Debug programs automatically locate a debugger server that displays a
source code window for each debug task. Programs can then be debugged in terms
of high level source code objects and extensive range of commands.
Tasks can be single stepped, breakpoints set, traced, and variables examined
and altered. Fork processes subdivide the window into individual debug child
windows. Most of the debugger commands are invoked by either key stroke
sequences or menus. The entire user interface is configurable by the user.
The debugger is supported by the Helios C Compiler and Meiko FORTRAN.
Uni-processor users will also find the debugger a fascinating tool and a great
teaching aid. The Helios Source Debugger provides unique facilities for
debugging multi-processor systems and is highly recommended for all Helios
programmers and software developers.
All debugging is done using high level source code
objects, the debugger opens a source window for every Helios task. The
programmer can then step through this source code, evaluating expressions and
variables, displaying structures and tracing the program flow.
Programs running simultaneously on
multiple processors can be readily debugged using the multiple source windows.
Tasks can be individually single-stepped, traced or run to breakpoints in order
to examine the interaction of multiple tasks. Only those tasks which are to be
debugged need be run under the debugger, other tasks will continue to run
Whenever a new process is created the debugger automatically
splits the current source window to show both processes. Each process can then
be separately debugged.
Very flexible control of program flow is
provided. One or all tasks may be single stepped or run; breakpoints and
watchpoints can be set or a trace run. Single stepping can step through every
statement if required, status indicators show when a task is waiting for some
event, stack backtracing allows active functions to be monitored or to show from
where a function was called.
The debugger allows comprehensive evaluation of
expressions. All operators are supported, complete type and scope information is
available. Any value in a program can be searched for and monitored, structures
are displayed in full, pointers can be evaluated to any specified depth.
The Helios Source Debugger contains a powerful command
language. The user can define macros and set command aliases, he can also have
direct access to the Helios shell commands.
The debugger's user interface is one of its
key features, this may reconfigured to suit a user's particular requirements.
Multiple windows are used to debug tasks that are running in parallel. Debugger
commands may either be invoked as a sequence of key strokes or by selection from
the built in menus, the menus allow both debugger and Helios commands to be run.
The Helios Source Debugger is a Helios
server so it can be run on a separate processor from the programs which are
being debugged if required.
This page is copyright ©1996, Perihelion