INTEGRITY is a secure, royalty-free real-time operating system designed for embedded systems that require maximum reliability.

INTEGRITY represents the most advanced RTOS technology on the market today. INTEGRITY was designed from the ground up for 32-bit and 64-bit embedded processors. INTEGRITY achieves unprecedented levels of reliability, availability, and serviceability for applications in imaging, consumer electronics, defense, networking, industrial control, medical and many other industries. INTEGRITY features include:

• Advanced RTOS architecture
• Fast, deterministic real-time response
• Protected virtual address spaces via Memory Management Unit (MMU)
• Guaranteed resource availability
• Multiprocessor support
• Dynamic task download
• Field upgrade and debug
• POSIX.1 conformance
• Comprehensive communications protocols
• Advanced file system support
• Complete USB host stack and class driver support
• Royalty-free licensing

• Point-to-point, asynchronous data streaming between the ARM and DSP
• Messaging between the ARM and DSP
• Bootload the DSP from ARM
• Pre-tested ARM-DSP communications driver support for OMAP
• Scalable footprint on both microprocessors and DSP

• MULTI and AdaMULTI™—integrated development environments to quickly develop, debug, test, and optimize embedded and real-time applications
• TimeMachine™—innovative debugger that lets you go back in time to find the most outrageously difficult bugs—in minutes
• Green Hills® optimizing compilers—generating the smallest and fastest code from C, C++, Ada 95, and FORTRAN

MULTI is a complete integrated development environment for embedded applications using C, C++, Embedded C++ and FORTRAN. MULTI runs on Windows, Linux or UNIX hosts and supports remote debugging to a variety of target environments. MULTI provides a direct graphical interface with all Green Hills compilers. It also supports multi-language development and debugging.

MULTI’s fully integrated development tools for TI OMAP processors include:

• Multi-threaded source level debugger
• Performance Profiler
• Run-time error checking
• Code coverage analysis
• Green Hills ARM instruction set simulator
• INTEGRITY and velOSity kernel awareness
• Builder integration for BIOS and DSP link
• Graphical Project Builder
• Language and API-aware editor
• Version control system
• Real-time trace via ETM

Host-target connectivity is provided through a variety of means, depending on the target environment. MULTI supports TI OMAP processor evaluation boards that can be accessed through:

Bare board access (no RTOS or ROM monitor)—MULTI supports on-chip debugging through JTAG. Multiprocessor-based boards are supported by the Green Hills probe and SuperTrace" probe which lets the MULTI debugger load, control, debug and test a target system without the need for prior board initialization, an RTOS, or even a ROM monitor. RDI targets—MULTI interacts with ARM targets via the RDI debug interface including emulation probes, ROM monitors, and simulators. ROM monitor—MULTI supports targets running ROM monitors using the Angel debug protocol. Operating system support—MULTI can be integrated with a custom RTOS through the Green Hills INDRT API. INDRT provides all the debug information needed by MULTI, and is easily integrated into custom kernel code. INTEGRITY and velOSity support is pre-integrated and MULTI provides kernel-aware debugging for these operating systems. Special commands allow tasks to be stopped upon system events such as task creation.		The MULTI IDE includes the industry’s most powerful and proven tools for developing embedded software with maximum reliability, maximum performance, and minimum code size.
Run-mode debugging—Run-mode enables source debugging of one or more threads of execution within their own colored debug window, allowing the rest of the system to continue to run, handling real-time events. This advanced feature adds very little overhead to the embedded program making it ideal for deeply embedded real-time applications. Instruction set simulators—The instruction set simulators interpretively execute programs on the host PC, Linux, or UNIX workstation without the requirement of target hardware by simulating the execution of the target processor at the instruction level. Green Hills Software’s simarm provides full debug features, host I/O, command window, extended profiling and hardware break-points on the ARM Processor.

Optimizing compilers

Green Hills compilers take advantage of advanced optimization strategies developed for the latest embedded processors. In addition, the Green Hills compiler for ARM generates architecture-specific and even processor-specific optimizations to utilize the pipeline and instruction set characteristics of each supported ARM processor model.

Green Hills offers further optimization through CodeFactor, a link-time optimization, which reduces overall program size by identifying and removing redundant segments of code from object files. Some ARM-specific features included are:

• Processor—One option for each supported ARM model. This setting determines the instructions permitted, as well as the pipeline optimization strategy used.
• Big and Little Endian—Generates code with either Big-Endian or Little-Endian byte order. Depending on the endianness selected, the most significant byte appears at the lowest or highest address.
• CodeFactor linker optimization—A link-time optimization which reduces overall program size by identifying and removing redundant segments of code from object files.
• Vector floating point—In addition to FPA10 and regular software floating point, the compiler uses the Vector floating point (VFP) unit for those processors that support it.

Run-time libraries
A complete implementation of the C, C++, and EC++ libraries are included in compiler distributions. Full featured start up code and libraries include automatic copy of data from ROM to RAM and system call emulation.

Thumb
Green Hills C/C++ compilers can generate code for 16-bit instruction Thumb® mode. Users can link with Green Hills run-time libraries built specifically for Thumb mode. Additionally, Green Hills Software offers CodeBalance®, a powerful utility program that analyzes performance profiling data, enabling the user to make critical execution speed/code size trade-offs. Benchmark tests have proven the effectiveness of the Green Hills compilers in producing the smallest executable file for a given source program. CodeBalance achieves greater code-size reduction with minimal increase in execution time by performing function-specific 16-bit mode compilation.

Compliance with industry standards
Green Hills C/C++ compilers fully conform to ANSI/ISO industry standards, and include optional enforcement of MISRA C programming guidelines.