Integrated Development Environment
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.
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.
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.
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.
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.
The Green Hills Compilers use hundreds of the most advanced optimizations to significantly increase program execution speed and decrease size. For example, advanced whole-program optimizations span function call boundaries to allow the Green Hills Compilers to operate on entire source bases. As a result, the Compilers are able to eliminate unnecessary code and variables, inline across modules, and better analyze interprocedural aliases. You can fine-tune Compiler output by enabling different combinations of optimizations and by configuring optimizations on a per-project, per-file, per-function, or even per-source-line basis. On most programs, the Green Hills Compilers offer a 20% improvement in speed over the GNU Compiler.
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, enabling 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.
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.
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.
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%.
The rising complexity of embedded software is driving many government agencies and customers to require device certification to proven industry standards for functional safety.
Green Hills Software meets this demand by offering the first commercially available tools certified to meet the highest levels of tool qualification
- IEC 61508:2010 (Industrial), EN 50128:2011 (Railway) and ISO 26262:2011 (Automotive) functional safety standards
- Certificates received from both TÜV NORD and exida certification bodies
- Satisfies both SIL 4 (Safety Integrity Level) and ASIL D (Automotive Safety Integrity Level) tool qualification requirements—the highest levels achievable
- Supports a broad set of target processors
The benefit to customers seeking product safety certification is simple and profound
- lower cost and time-to-certification,
- reduced product time-to-market, and
- reduced certification maintenance after product release
- supports application development to the highest SIL/ASIL levels
Customers can assign their critical internal development resources to do what they do best – create differentiating products to the marketplace – instead of diverting resources to ancillary certification efforts associated with tools safety qualification.
The certified MULTI tool chain complements Green Hills Software’s INTEGRITY real-time operating system certified offering. Deep working knowledge of safety standards, proven design and development practices, and collaborative engagement with the certification bodies enable Green Hills Software to lead the embedded software community in delivery of safety-certified products and expertise.