Implementation

Products

Name	Details	Operating system	Download
Classic Guard	Our earliest implementation of Relative Debugging is embodied in a version called "Classic Guard". This version has been implemented in most Unix machines, and is command line driven. It has a client server architecture, and uses GDB as the portable debug server implementation. Classic Guard supports both sequential and parallel relative debugging, and has novel features for describing the data decomposition in parallel codes. It supports a range of conventional programming languages, like C, C++, Fortran, etc, and also a data parallel research language called ZPL.		Download
VSGuard	VSGuard is an implementation of relative debugging for the MicrosoftVisual Studio .NET ® environment. VSGuard leverages the .NET Framework, and the Visual Studio Integration Project. It supports all .NET Framework languages, and also legacy Microsoft languages like Visual Basic 6.0 ® and Visual C++ ®. VSGuard is produced and marketed by Guardsoft Pty Ltd.		Download
OneGuard	OneGuard is a version of Guard that is integrated into the SUN Microsystems Sun One Studio environment.
EclipseGuard	Eclipse Guard is a version of Guard integrated into the IBM Eclipse platform. EclipseGuard leverages the flexibility and extensibility of Eclipse. It current works with Java and C/C++, however, this will be extended as new language plug in's are produced.		Download
GuardLite	GuardLite is a command line parallel debugger, without relative debugging. It supports the High Performance Debugger Forum (HPDF) command syntax and works on a range of parallel machines.
Extended GDB	We have extended GDB to support the Guard Architecture Independent Form (AIF) and to allow data transport through binary sockets. This version of GDB also supports ZPL.		Download

The table below summarizes which features have been implemented in the various IDEs.

Feature	Visual Studio .Net	Eclipse	NetBeans
Improved User Interaction
Building assertions interactively
Integrated Data Visualization
Language Neutrality

VSGuard

VSGuard is an implementation of relative debugging for Microsoft's ® Visual Studio ® environment. VSGuard builds on the rich environment provided by Visual Studio, and adds relative debugging functionality seamlessly. Thus, users already familiar with Visual Studio only need to learn a few new commands and concepts to make full use of VSGuard.

Visual Studio allows users to manage two different projects concurrently by building them into a Solution. If you are porting from Visual Basic 6.0 to Visual Basic .NET, VSGuard provides a Wizard that makes it very easy and quick to build two different projects into one Solution. From this point, VSGuard allows you to build assertions between data structures in the two projects. It will run them concurrently, and compare data automatically, reporting differences they occur.

Using this approach, you can test whether a new project performs the same tasks as a previous version, and if it doesn't, you can debug it using VSGuard's powerful assertion mechanism. VSGuard builds on the already powerful techniques used in other test tools, but allows you to trace errors down to an individual source line. What's more, you don't need to capture large trace files, saving both space and time.

How it works

The architecture of VSGuard under Microsoft's Visual Studio ® .NET. Visual Studio .NET is build around a core shell with functionality being provided by commands that are implemented by a set of packages. These packages are conventional COM objects that are activated as a result of user interaction (such as menu selection) within Visual Studio .NET, and also when various asynchronous events occur. This component architecture makes it possible to integrate new functionality into the environment by loading additional packages.

EclipseGuard

EclipseGuard is an implementation of relative debugging for the IBM Eclipse environment.

Using this approach, you can test whether a new project performs the same tasks as a previous version, and if it doesn't, you can debug it using EclipseGuard's powerful assertion mechanism. EclipseGuard builds on the already powerful techniques used in other test tools, but allows you to trace errors down to an individual source line.

How it works

EclipseGuard makes significant use of Eclipse's plug-in and extensibility concept. At its core, Eclipse has a modular Java runtime called Equinox. Equinox is an implementation of the OSGi R4 core framework specification, which provides a set of bundles and services required to support running OSGi-based systems. The platform is the middle tier of the architecture, and consists of a set of components that provide core services and frameworks to higher tiers. The top tier of the architecture incorporates plug-in features that provide the functionality most visible to the users. Importantly, Eclipse plug-ins allow other plug-ins to extend or customize portions of their functionality by declaring extension points and extensions. For example, many programming languages development tools are already available in Eclipse, such as JDT for Java development tools and CDT for C/C++ development tools, and these provide language specific editors, views and debuggers tools, to name a few. Importantly, each of the language plug-ins can be extended by Guard, which allows us to perform relative debugging across multiple languages and development environments.