Real-Time OS INTEGRITY INTEGRITY Multivisor µ-velOSity Integrated Development Environment MULTI TimeMachine Hardware Debug Probe SuperTrace Probe Green Hills Probe Timing Analysis Solution SymTA/S
[External Links]
[External Links]
Hardware Automatic Design Tool Accelerate
[External Links]
COMPILER FrontEnd/Liblary DinkumLibrary
[External Links]
Edison Front End
[External Links]

Integrated Development Environment MULTI


Reduce your time to market while developing a superior product. It's not impossible if you’re using tools from Green Hills Software. For decades our customers have used the MULTI IDE and Green Hills Compilers to dramatically improve their debugging productivity. The result? A more reliable product, brought to market more quickly, with lower development costs.

Find and fix bugs faster
Make sense of complex systems
Boost productivity
Maximize performance
Benefit from an expert
Lower your production cost

Find and fix bugs faster

An invaluable part of the TimeMachine tool suite, the PathAnalyzer provides a view of your application’s call stack over time. This powerful display makes complex system execution flow easy-to-understand, enabling you to find bugs faster.

Every feature of our revolutionary Debugger is designed to quickly solve problems that stump traditional tools. It often takes weeks or months to track down problems like inter-task corruptions, missed real-time requirements, and external hardware events. Green Hills' TimeMachine tool suite helps you solve the same problems in hours or even minutes. The TimeMachine tool suite automatically captures program execution data, combining the MULTI Debugger interface with innovative replay debugging capabilities. When debugging with TimeMachine, you can step, run, and debug forwards and backwards through code to pinpoint the root cause of the problem.

At any point in the TimeMachine capture you can:

  • Debug task interactions at the source level
  • Find specific data points by using powerful execution and data breakpoints
  • Examine RTOS data structures
  • Debug virtual memory applications

DoubleCheck, Green Hills' integrated static analyzer, saves you time and money by allowing you to identify programming errors even before running your program. Because DoubleCheck is part of the Green Hills Compilers, there's no setup cost to enabling it. Simply set an option and DoubleCheck reviews source code each time it's compiled. Additionally, DoubleCheck runs much faster than traditional static analysis tools, which means that every developer can have it on all the time.

Run-time error checking complements DoubleCheck by finding bugs that cannot be identified by static analysis alone. Especially heinous bugs remain silent for a long time before failure. With run-time error checking, you're alerted to the cause of the problem when it happens. Fixing a bug is trivial when you're looking directly at it.

Make sense of complex systems

For multicore systems, you can use the Target List in the Debugger to follow application execution from one context to another, watch different threads interact, and sort out complex interdependencies easily.

Debugging complex systems becomes a much simpler task when the information needed to understand system status is at your fingertips. We present important system information in intuitive ways to help you find problems faster:

  • The OSA Explorer provides comprehensive views into the status of kernel objects, tasks, and resources.
  • The Debugger allows complete postmortem application debugging that includes traversing the stack, browsing objects, and viewing memory and registers.
  • The EventAnalyzer shows a timeline of system events occurring at intervals only microseconds apart.

Debugging multicore systems
For projects with multiple threads of execution, multiple cores, multiple boards, or any combination of these, the integrated Target List displays system components hierarchically to simplify debugging and make it easier to see relationships among applications, address spaces, tasks, and threads. Status information is displayed for all components so you can quickly check the system state.

Boost productivity

The MULTI Project Manager simplifies how you build and update your application. Tabbed block diagram and memory layout views provide an at-a-glance understanding of application structure.

Clean code is less likely to contain errors and is easier to test, understand, and modify—all factors that contribute to fewer bugs and greater reliability. The Green Hills Compilers enable enforcement of clean coding conventions via industry standards such as MISRA 2004 as well as GHS Standard Mode, which is a collection of Compiler warnings and errors that enforces a stricter coding standard than regular C and C++ . GHS Standard mode is based on our long history of successfully deployed software and on our collaboration with customers who have achieved the same high level of reliability.

We've simplified building so that you can spend more of your valuable time designing your next product. With the MULTI Builder, there's no complicated build infrastructure to maintain. You can change your build configuration easily. The Builder automatically analyzes the dependencies of your entire project and compiles and links as many files in parallel as possible, taking full advantage of modern multicore systems.

The Builder and other sophisticated features significantly reduce the overhead of project development. A seamlessly integrated project manager, editor, flash programmer, instruction set simulator, and more enable you to jumpstart development and work more efficiently.

Maximize performance

By displaying the length and frequency of INTEGRITY RTOS events, the EventAnalyzer helps you tackle high-level performance problems such as incorrect task priorities, excessive interrupt level processing, too many calls to the operating system, and unexpected task context switches.

Generate faster, smaller code
Green Hills optimizing compilers are the best on the market. On EEMBC benchmarks—the most widely accepted benchmarks in the embedded industry—the Green Hills Compilers consistently outperform competing compilers to generate the fastest and smallest code for 32- and 64-bit processors.

Pinpoint performance bottlenecks
Using Green Hills' exceptional PathAnalyzer, Profiler, and EventAnalyzer, you can easily identify and eliminate performance bottlenecks in your code. The result is a faster, more streamlined application:

  • The truly innovative PathAnalyzer provides a high-level, time-based view of every function executed in your program, making it easy to identify patterns in program flow and see where time is being spent. Instead of showing you only a shadow of your program's execution, the PathAnalyzer provides the entire picture.
  • MULTI's powerful Profiler gives you unequaled insight into program behavior. The Profiler can determine the processor time consumed by each task, function, source line, and assembly language instruction, eanbling you to dramatically increase performance by improving code that accounts for an unnecessarily large percentage of the total execution time.
  • The EventAnalyzer displays the length and frequency of INTEGRITY RTOS events, making it quickly apparent what operations take the most time and where optimization efforts should be focused.

Benefit from an expert

Green Hills software engineers use MULTI and our compilers every day. Our team of productivity consultants can draw on this firsthand experience to ensure that you know how to realize the full potential of your Green Hills products as well. They can

  • configure our tools to meet your specific requirements
  • train you in the best use of our products
  • evalutate your use and identify ways in which you can work more productively

And to obtain the highest possible performance, you can also turn your program over to our performance-tuning experts. For three decades, we've been using our in-depth knowledge and best-in-class tools to beat every competitor on published benchmarks for program speed. We can apply the same techniques that we use internally to make your application run faster. We use our comprehensive knowledge to select optimal compiler optimizations for each part of your program.

Our performance-tuning service is not a commodity, it's a custom service. We'll custom-write compiler optimizations based on our evaluation of your application and use our expertise in embedded systems to make your program run faster. It's not uncommon for our customers to see 300% or more improvement after working with us.

Lower your production cost

MULTI Support

Green Hills Software is continually adding support for new processors and operating systems. If yours is not listed here, please contact Green Hills Software for the latest availability information.

Target processors
  • Power Architecture
  • ARM/Thumb
  • 68K/ColdFire
  • Intel Architecture
  • MIPS
  • XScale
  • V850
  • Blackfin
  • Davinci
  • Tricore
  • SH
  • ARC
  • FR
  • OMAP
Development hosts
  • Windows
  • Solaris
  • Linux
Operating systems
  • Linux
  • ThreadX
  • VxWorks
  • OSE
  • Bare board
  • In-housed
Third-party products
  • Eclipse
  • Rhapsody
  • Emacs
  • vi
  • Subversion
  • ClearCase
  • CVS
  • SourceSafe
  • IDWARF/Stabs
  • C
  • Ada
  • C++
  • EC++

Reduce your processor costs
You don't always need a faster processor to meet increasing performance requirements. Our superior compiler optimizations are tuned to get the most out of whatever chip you use. Additionally, our performance analysis tools such as the PathAnalyzer, Profiler, and EventAnalyzer give you a bird's-eye view of where your program is spending its time, helping you to focus your optimization efforts and speed up your application. How much money would you save if you could use a lower-cost processor to meet the same real-time requirements? Or if you could release a new product without having to produce a new hardware platform to run it on?

Not only will improving your application's performance save you money on the processor itself, lower-cost processors operate at lower clock rates and require less power and cooling. Longer battery life makes your product better and cheaper at the same time.

Reduce your memory costs 
Green Hills Compiler optimizations reduce your memory costs by reducing the size of your executable. Most programs see at least 10% improvement relative to the GNU Compiler. Additionally, DoubleCheck finds memory leaks at compile time, and MULTI's Memory Allocations tool searches for them dynamically at run time.

Maximize savings
Our team of cost reduction experts can help you to reduce your memory and processor requirements without sacrificing features. We have reduced customer memory usage by over 30% and have improved performance by over 300%.

Application Form

Product Inquiry for Green Hills Software
Evaluation Requirement for GHS Products

Related pages

Supported Host Requirement
About Green Hills Software,Inc

Related links
Green Hills Software,Inc