An unrivaled integrated development environment
Used by thousands of developers for over three decades, the MULTI IDE is the industry’s unrivaled integrated development environment used to create, debug, and optimize code for embedded processors. With MULTI, developers can easily see and fix difficult bugs, pinpoint performance bottlenecks, and prevent future problems. Key benefits are: lower cost to deliver on-time software, avoidance of costly recalls due to poor software quality, and lower processor and memory costs because more efficient code uses less memory and smaller CPUs.
The MULTI ecosystem includes all popular processor architectures, runs on Linux or Windows desktops, debugs code from multiple compilers, connects to targets over various links, and supports multiple operating systems running on silicon, simulators, or emulators.
Find and fix bugs faster
In complex real-time systems, unexpected time spent on hunting for sporadic and deeply buried bugs or finding performance bottlenecks can take weeks or even months, potentially risking an on-time product launch.
With MULTI, problems that once took days, weeks, or months are found and fixed in hours or even minutes. In complex systems, the most time-consuming bugs are sporadic, hidden and not evident with code inspection. MULTI enables developers to quickly pinpoint problems caused by memory corruption, unintended dependencies, unexpected interrupts, multicore complexity, inter-task corruptions, opaqueness from missing source code or virtualization, missed real-time requirements, and asynchronous hardware events … just to name a few.
The MULTI Debugger includes three powerful capabilities:
- History viewer shows you how the program got to the current state and what the system was doing
- TimeMachine uses trace data so you can run, step, and analyze back-in-time in the Debugger
- Debug Snapshot saves a debugging session that you can easily share with coworkers
Make sense of complex systems
- How did the program get here?
- Where is time being spent?
- Is the program doing anything unexpected?
These three questions are at the foundation of debugging code and making your system run faster. The History viewer answers these questions.
History viewer displays the last few seconds, minutes or days of program execution across complex heterogenous multicore systems with a natural and intuitive GUI. For the first time you now have a clear, complete view into a murky hardware and software system. You can zoom deeply into processor behavior at the micro-second level or zoom out to see system behavior spanning minutes and days. This new kind of visibility empowers you to find difficult bugs in seconds, see hidden bottlenecks and dependencies, and analyze execution times.
History provides unprecedented visibility into your system by displaying the last few seconds, minutes, or days of program execution across complex heterogenous multicore systems.
By automatically capturing actual program execution data TimeMachine enables the Debugger to run, step and debug code backward to any problem area shown in History. It also powers other tools such as the Profiler.
TimeMachine enables the MULTI Debugger to run, step, and analyze your program forward and backward in time to find the root casue of problems.
Prevent new problems
DoubleCheck, Green Hills Software’s integrated static source code analyzer, saves you time and money by identifying programming errors before running your program. Because DoubleCheck is part of the Green Hills optimizing compilers, there’s no setup hassle, and minimal overhead to use it. Simply set an option and DoubleCheck automatically reviews source code each time it’s compiled. Since it’s part of the compilers, DoubleCheck runs much faster than traditional static analysis tools and that means that every developer can have it turned on all the time.
Moreover, DoubleCheck is more reliable than traditional code reviews and can find bugs that may never show up during regular system testing.
Run-time Error Checking complements DoubleCheck by finding bugs that cannot be identified by static analysis alone. Bugs due to memory corruption are especially heinous and difficult to find, and can remain silent for a long time. With run-time error checking, you’re alerted to the cause of the problem when it happens. Run-time error checking identifies problems such as invalid memory accesses through pointers, out-of-range value assignments, unhandled cases in switch statements, and division by zero.
DoubleCheck lowers development costs by identifying problems early in the "Develop" stage which saves time and resources.
Clean code is less likely to contain errors and is easier to test, understand, and modify. All of these factors contribute to fewer bugs and greater reliability. Green Hills optimizing compilers enable enforcement of clean coding conventions defined by industry standards such as the MISRA 2012 and 2004 coding standards, which include more than one hundred rules for safe programming. You can also elect to enforce a customized subset of these rules to meet specific requirements.
The MULTI Debugger is a powerful tool for examining, monitoring, and changing source code running on complex heterogenous multicore target processors and simulators. When TimeMachine is used, it can even run backward in time. The Debugger is seamlessly integrated with other tools within MULTI and can be invoked by clicking inside various MULTI tools such as the History viewer.
- Debug applications, kernels and device driver code on various operating systems or bare board code
- Debug virtualized operating system kernels and their applications
- One debugger for Run-mode and Freeze-mode debugging and run-control of synchronous (SMP) and asynchronous multicore (AMP)
- Traverse the call stack, view cache, browse objects, and view memory and registers
- Use the OSA Explorer to see deeply into the status of kernel objects, tasks, and resources
- Debug task interactions at the source level
- Find specific data points by using powerful execution and data breakpoints
- Debug code running in virtual address spaces
With the MULTI Debugger, debugging multitask, multicore systems is as straightforward as with single core systems.
When you debug a multitasking application on an OS like INTEGRITY or Linux, MULTI can interact with the multiple tasks in run-mode, freeze-mode, or both modes simultaneously. In run-mode, the operating system kernel continues to run as you halt and examine individual tasks. In freeze-mode, the entire target system stops when you examine tasks.
Key among multicore debugging features is synchronous run control, which halts all cores as a unit when any core encounters a debugging condition. For instance, when a core hits a breakpoint the target list clearly shows:
- which core(s) have hit the breakpoint
- which thread was executing on the core at the time
- what the other cores in the system were doing
MULTI synchronous sun control halts all cores in a multicore system simultaneously. this enables you to debug one core without worrying that operatings running on another core will affect shared memory.
Debug embedded Linux
MULTI for Linux brings advanced debugging to engineers developing embedded Linux software. It dramatically improves their productivity and helps them bring a more reliable, higher-performing product to market faster.
Traditional debugging tools for Linux offer only limited visibility and usefulness. GDB—and front-ends such as Eclipse—are cumbersome to set up, difficult to use, slow in responsiveness, and not always trustworthy when debugging embedded, optimized code.
As a result, developers often resort to the hit-and-miss effectiveness of printf and printk commands. Unfortunately—due partly to the significant performance impact—these techniques introduce their own problems and provide only a limited window into complex system execution.
With MULTI for Linux and Green Hills consulting services, you can now visualize and debug all aspects of an embedded Linux system—including the Linux kernel, kernel threads, interrupt services routines, user mode threads and processes—faster and more easily than ever before.
An IDE that helps you manage your project
The MULTI IDE’s simplified project management frees you to spend more time developing your product. With its Builder, there’s no complicated build infrastructure to maintain, and build configurations can be easily changed. 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.
Along with the Builder, the seamlessly-integrated Project Manager, Editor, Flash Programmer, and Instruction Set Simulator that in their own ways help you spend less time on build management and more on your code.
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. Here green signigies read/write memory and red signifies read-only memory
For applications that require the highest possible performance, the MULTI IDE offers both the industry’s best embedded C/C++ compilers and the best performance analysis tools. To reach the ultimate performance, you can also enlist a Green Hills Software performance-tuning expert for a solution customized to your device.
Generate faster, smaller code
Compilers are the essential ingredient to leverage processor performance and the Green Hills C/C++ optimizing compilers are the best in the industry. On the widely- accepted EEMBC benchmarks for embedded processors 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 compiler optimizations to significantly increase program execution speed and decrease size.
Pinpoint performance bottlenecks
The second key ingredient to maximizing your program’s performance is using the best performance analysis tools. With the help of History and the Profiler tools, you can easily identify and eliminate performance bottlenecks in your code. The result is a faster, more efficient application.
When it comes to maximizing performance, time is the most important dimension to consider. It’s also the dimension that most profiling tools throw away. The innovative History visualization tool provides a high-level, time-based view of every function executed in your program, making it easy to identify patterns in program flow and easily spot where time is being spent. The powerful Profiler provides additional insight into program behavior, using data gathered from trace or instrumented code. It shows how much processor time is consumed by each task, function, source line, and assembly language instruction, making it easy to:
- find performance problems
- find coverage gaps and track test coverage of specific code
- share profile data with other users
- collect and merge profile data from several tests or profile recordings
The Profiler's interface streamlines analyses by showing how often and for how long different tasks, functions, and instructions were run so you can pinpoint where to focus optimization and test efforts.
Benefit from our expert knowledge
To reach the highest possible performance, bring in the performance-tuning experts from Green Hills Software. Our custom services will help you get the most out of our development tools and compilers, assess your design and even create a custom compiler optimization tailored to your goals.
Lower your production cost
In high-production environments, saving even pennies per unit can result in big overall savings. The MULTI IDE can significantly reduce memory and processor costs to boost your bottom line.
Reduce your processor costs
You don’t always need a faster processor to meet increasing performance requirements. Our superior C/C++ compiler optimizations are tuned to get the most out of the processor you use. Additionally, our performance analysis tools such as the History viewer and Profiler give you a bird’s-eye view of where your program is spending its time, helping you to focus your optimization efforts. How much money would you save if you could use a lower-cost processor to meet the same real-time requirements?
Improving your code’s performance pays off because it gives your design more CPU headroom to add more features. It can even enable you to choose a lower cost processor that uses less power and cooling.
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 competing compilers. Additionally, DoubeCheck and the MULTI debugger's Memory Allocations tool help you to make more efficent use of your memory, further reducing the amount of memory you need in your embedded system.
Functional safety confidence
The MULTI C/C++ IDE and toolchain are certified to meet the highest safety levels:
- ISO 26262:2018 (Automotive); IEC 61508:2010 (Industrial); EN 50128:2011 and EN 50657 (Railway) functional safety standards
- Certificates received from both TÜV NORD and exida
- Satisfies the highest achievable levels SIL 4 (Safety Integrity Level) and ASIL D (Automotive Safety Integrity Level) and meets C/C++ run-time libraries certification requirements
- Supported on a broad set of target processors
The benefits are manifold:
- Lower cost and shorter time to certification and production
- Reduced certification maintenance after product release
- Higher quality and confidence targeting code to highest ASIL/SIL levels
Green Hills training and consulting
Green Hills expert training and consulting services provide the most direct route to understanding the full potential of the MULTI IDE, so you can reach maximum productivity in the shortest time.
Managed implementation program
This program is designed to make development teams more efficient—and productive—with the Green Hills Software product environment. Services offered are completely customizable in content and duration and include:
- expert training
- environment setup
- application design mentorship
Our training curriculum spans a wide range of material, from INTEGRITY programming to advanced History-guided debugging. Courses are taught by experts with hands-on experience developing with Green Hills tools. Classes can be taught at your facility and on your schedule, providing maximum value with minimal interruption.
Along with customized training, the managed implementation program offers proactive, ongoing mentorship to ensure you know how to best use our environment as well as have regular access to a Green Hills Software expert.
Open enrollment training
Teams with smaller training budgets can attend our popular open-enrollment courses at scheduled locations around the world. These classes are also perfect for new hires who have just joined a team that has already completed a Green Hills Software training class.