The AdaMULTI Integrated Development Environment
AdaMULTI is a complete integrated development environment (IDE) for embedded applications using Ada, C, C++, and Embedded C++. AdaMULTI runs on Windows, Solaris, or Linx hosts and supports remote debugging to a variety of target environments. AdaMULTI provides a direct graphical interface with all Green Hills compilers, and supports multi-language development and debugging. AdaMULTI contains all of the tools needed to complete a major programming project:
- Project Builder
- Source-level Debugger
- Text Editor
- Run-Time Error Checking
- Code Coverage Analysis
- Version Control System
- Performance Profiler*
- Graphical Browser
Taken separately, each component of AdaMULTI is one of the most advanced tools of its class. But AdaMULTI is much more than a useful collection of software tools; it is a truly integrated development environment. AdaMULTI's components are aware of each other and communicate among themselves in new and very useful ways, making the whole much greater than the sum.
For example, the simple case of the edit-compile-debug cycle. When an error is discovered with AdaMULTI's Debugger, an Editor can be brought up on the offending line with a single button click. As soon as modifications are made to the file, the Editor automatically checks it out of the Version Control System. Another button click saves the changes and checks the file back in, prompting for a comment. A final click builds the program and reinitializes the Debugger.
AdaMULTI provides the user with a single development environment that is constant across all workstations and PCs. AdaMULTI works the same on every platform: the features, the commands, and the usage are all identical. The user no longer has to worry about host-to-host incompatibilities in languages and makefiles.
With AdaMULTI it really is possible to have a large team of programmers, each using a workstation from a different vendor, working together to develop a single program. The Program Builder and source control system operate across the network of mixed machines to tie programmers into a single coordinated development team.
AdaMULTI can be used with Green Hills Software's optimizing Ada, C, C++, Embedded C++ and FORTRAN compilers or with other compilers that adhere to EABI standards. The Green Hills compilers produce EABI compliant ELF object modules.
AdaMULTI supports a wide variety of real-time operating systems (RTOS). Because AdaMULTI is fully RTOS aware, designers can debug and tune their applications at a task level. Within the AdaMULTI Debugger, designers working with RTOSes from Green Hills Software, a third party, or a home grown RTOS can start and stop tasks, set task-specific breakpoints, and monitor OS resources like buffers, queues, and streams. They can also debug new tasks as they are spawned and watch processes as they communicate through pipes, semaphores, etc.
The entire family of Green Hills Software's safety critical run-time products are supported by the AdaMULTI software development environment. Tightly integrated with INTEGRITY-178B and the bare target Ada run-times, AdaMULTI automates all aspects of embedded, safety-critical software development.
AdaMULTI features Ada and C/C++ compilers, a source-level symbolic debugger, and an automated program builder. AdaMULTI also provides a version control system, the EventAnalyzer, a code performance and coverage profiler, a source code navigation and cross reference browser, a language sensitive editor, dependency and call graph displays, a processor-specific/INTEGRITY-178B simulator, and unit test tools. AdaMULTI also provides the embedded industry's most robust and comprehensive set of debugger-to-processor connectivity options including: serial, ethernet, In-Circuit-Emulators, processor probes, and JTAG/BDM interfaces.
Debugging multi-process programs provides its own unique challenges, and AdaMULTI provides a number of features to assist programmers in this area. The most important of these is that AdaMULTI provides a separate debug window for each process. Users can independently single step, set breakpoints and examine variables in each process, and watch the processes as they communicate with each other using pipes, message queues and shared memory. AdaMULTI can attach to a process that is already running and halt it. AdaMULTI can also detach from a process and allow it to continue on its own.
AdaMULTI is uniquely suited for developing programs on systems consisting of multiple processors because it makes no distinction as to whether the processes being debugged are on the same or on different processors. Since each debug window independently asks its debug server for the model of the processor to which it is attached, AdaMULTI is able to debug systems with multiple mixed processors.