Green Hills, GHS, MULTI, 2000, C, C++, ADA, Ada95, Fortran, Compiler, Simulator, Debugger, RTOS, Velocity, Integrity, BDM, Target Probe, Event Analyzer, TimeMachine, Run Time Analysis, Embedded, TI, OMAP, ARM, OMAP 1510, OMAP 5912, OMAP 1710

TI OMAP Processor Family Embedded Software Solutions

Green Hills Software provides complete solutions for the development of embedded and real-time applications built on TI OMAP processors. With our products and services, you can produce totally reliable, absolutely secure, and maximum performance devices—in the least time and with the lowest development and manufacturing costs.

Real-time operating systems
	INTEGRITY®—royalty-free, POSIX® conformant RTOS for totally reliable and absolutely secure applications
	velOSity™—royalty-free microkernel to rapidly develop high-performance software for cost sensitive devices

Processors Supported
	OMAP 1510 OMAP 5912 OMAP 1710

INTEGRITY RTOS

Blackfin
The INTEGRITY RTOS uses hardware memory
protection to isolate and protect itselft and
user tasks from incorrect operation caused
by accidental errors or malicious tampering.

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

DSP/BIOS link support for INTEGRITY, velOSity, and Linux

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

Software development tools

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 IDE

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.

Integrated OS-aware tools

Green Hills Software offers add-ons to the MULTI toolset that leverage the tight integration between MULTI and the INTEGRITY and velOSity operating systems.

EventAnalyzer
By providing graphical display of system activities over time, the powerful EventAnalyzer enables you to easily and accurately visualize complex, real-time relationships within your system. Using this sophisticated utility you can more readily identify bottlenecks and optimize your entire system. System events charted by the EventAnalyzer include:

Context switches
RTOS kernel calls
Interrupts and exceptions
Status changes
User-defined events

ResourceAnalyzer
Customized for the INTEGRITY and velOSity RTOSes, the ResourceAnalyzer is an advanced run-time analysis tool that helps you visualize how an application consumes resources.With the ResourceAnalyzer you can track CPU and memory usage to maximize the efficiency of tasks and address spaces and improve overall system performance. The ResourceAnalyzer’s display makes it easy to track CPU and memory statistics for an entire embedded system or for any task or address space. At a glance, it shows how these resources are consumed and also warns of potential problems when unexpected values occur. In addition, you can configure the ResourceAnalyzer to focus on only the information significant to your work.

Kernel awareness
MULTI provides a comprehensive picture of kernel objects, tasks, resources, and their status. Without requiring the source, developers can view a complete snapshot of INTEGRITY’s state and can:

Debug and view virtual address spaces
Debug and view physical address spaces
Debug tasks in separate windows
Debug and view virtual or physical address space tasks
View all kernel objects (tasks, semaphores, address spaces)


	Any event displayed in the EventAnalyzer view window can be selected for debugging with a single click, opening a debug window showing that event’s source code, ready to debug.



	The ResourceAnalyzer provides extensive visibility into CPU execution at the task and address space level.

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.