With all the attention paid to Moore’s law and processor wars, you might assume that hardware is the heart of the embedded system. This may have been true five years ago, but with the emergence of the Internet of Things (IoT), software has become king.
“At the hardware level, the IoT is an evolution of what people have been doing for years,” says Richard York, Vice President for Marketing, Embedded Segment, ARM. “At the software level, however, it is much more revolutionary. Key design decisions always come back to software considerations. Choices are based on the way the design team wants to develop the software or what software they want to write. And the designers determine the type of software environment they need, and that directs them to a particular processor family.”
The ascent of software has thrust integrated development environments (IDEs) to the forefront, making them key enablers of the IoT. As such, they must contend with levels of complexity unknown to previous generations of software development tools. In addition, the Internet connection raises the bar on the security that must be integral to the system.
Dealing with Complexity
This level of complexity does not span the full spectrum of IoT devices, but things get complicated for embedded system developers when they move from relatively simple IoT end nodes to systems offering more functionality. These systems incorporate combinations of real-time operating system (RTOS) processors, DSPs, bare-metal systems, and application processors running rich operating systems (OSes) like Linux or Android.
Figure 1. Development of IoT devices that provide rich feature sets requires software development environments capable of working with an assortment of processors and operating systems. (Courtesy of ARM)
This mix of processor and OS types, the sharing of peripheral resources, the intricacies of interprocess communications, and the interdependencies of many of the elements call for levels of visibility and automation that have not been present in previous generations of IDEs. The increase in system complexity also places greater demands on IDE visualization capabilities.
“To design complex systems, you need an IDE sophisticated enough to manage and understand how to talk to the runtime side of things and big cores and little cores, with the Linux or RTOS running on them,” says Felix Baum, Senior Product Manager, Embedded Systems Division, Mentor Graphics. “The challenge is to be able to configure different OSes for different cores, set up interprocess communication channels, and evaluate how the different cores communicate with each other. In the complex systems we have today, with the number of subsystems in play, it is difficult to pinpoint the source of a problem. If you debug one system at a time, it is difficult to see how the various subsystems work as a whole.”
This complexity stems as much from the software as it does from the design demands of the devices being developed. Many of the bigger challenges are about how to handle the increasing complexity of the software itself.
“The problem is that embedded system designers are pulling in open source code, and vendors use large teams of developers, all writing different components,” says David Kleidermacher, Chief Technology Officer, Green Hills Software. “Some are writing Linux code, and some, real-time programs. And you are pulling all this into a single system. So how do you manage that complexity? How do I find the really difficult problems?”
A Holistic Perspective
To meet these challenges, leading IDE providers push the capabilities of their system analysis tools to extend visibility. These tools take analysis beyond measuring critical system metrics — such as interrupt latency, context switch time, and boot time — and provide flight recorder-like functionality. Using trace analysis, profiling, and data visualization, the tools capture, record, and display in real time a holistic view of the execution flow of all the pieces of software running on the cores of the system. In addition to the holistic view, the tools allow developers to drill down to examine specific process levels, visualizing the data in an intuitive way.
Figure 2. Mentor Graphics’ Sourcery CodeBench IDE includes the embedded Sourcery System Analyzer, a specialized tool that helps embedded developers visualize and analyze system data. (Courtesy of Mentor Graphics.)
“You want your IDE to be able to do things like visualize execution flow through a call graph of different functions,” says Green Hills’ Kleidermacher. “There might be different levels, and you might zoom in to see what is happening within a loop and then zoom all the way out and see what’s happening at the system level, where you might have color-coding of the different execution units, processes, and threads.”
Figure 3. Green Hills Software’s TimeMachine debugger allows developers to see what all cores are doing before and upon hitting breakpoints, using color coding to enhance visualization. (Courtesy of Green Hills Software.)
The debugging functions of these tools allow developers to view register and memory values, use execution and data breakpoints to find specific trace data points, and examine RTOS data structures and task interactions. By providing visibility of OS events, the tools enable design teams to identify deadlocks between tasks that cause undesirable system behavior.
Automating for Efficiency
The complexity of the devices being designed and the software running on them pose serious obstacles to companies seeking to abbreviate development cycles. In addition, few if any design teams have expertise in all the technologies combined in SoCs designed for the IoT. Considering these factors, IDEs need to streamline the development process. This is where automation comes into play.
Instead of trying to build a device from scratch, IDEs allow developers to upload SoC models into their tools. Armed with this information, the tools know the types and numbers of components in the system and can use the model to validate software configurations. IDEs also allow developers to take software written for another device and apply it to the new system. The tools are smart enough to reconfigure everything necessary to map the application to the appropriate core.
Automated compilers also eliminate time-consuming “housekeeping” tasks, such as enforcing clean coding conventions, eliminating unnecessary code and variables, and analyzing interprocedural aliases. To take advantage of multicore systems, compilers also automatically analyze system dependencies and link files in parallel.
The Beauty of Isolation
One of the key properties distinguishing IoT embedded systems from non-IoT systems is the IoT device’s connection to the Internet. While this feature creates opportunities for functions and services, it also increases the security threats to which the systems are exposed. In addition, IoT embedded systems integrate critical and noncritical subsystems, creating a need to ensure that the failure of a noncritical system will not compromise the ability of critical systems to continue performing their tasks. Both these factors demand a means of protecting parts of embedded systems from outside influences.
To this end, developers deploy embedded virtualization, a technology that refers to a type-1 hypervisor deployed within the embedded system. Embedded hypervisors allow multiple guest OSes and applications to share the hardware platform and its resources and enable the systems to communicate and interact safely and securely, allowing privileged and non-privileged applications to coexist.
“The IoT is driving interest in embedded processing and connectivity, and virtualization for embedded systems can offer tremendous flexibility and versatility in how software solutions are implemented,” says Bill Morelli, Associate Director, IHS Information Technology and Telecommunications Divisions.
One manifestation of this versatility is the fact that embedded virtualization not only allows multiple OSes to coexist, but it also isolates them and applications from one another, providing containment for security, safety, and reliability. The embedded hypervisor also enables proprietary software and open source software to coexist in isolated environments.
Figure 4. Green Hills Software’s Integrity Secure Virtualization enables safe execution of trusted real-time critical software side-by-side with untrusted applications running on general-purpose operating systems. (Courtesy of Green Hills Software.)
“In the past, we saw a lot of projects looking to virtualize things from a safety perspective,” says Mentor’s Baum. “If you have a system that runs safety-related software, you want to make sure that if a Linux or Android OS runs slow that the safety-related applications remain unaffected."
Where Past and Future Meet
All these developments show that the days when developers could build and configure an embedded system via text and configuration files are in the past. The systems and the software running on them are just too complex. Today, if you are going to build a system, you need an IDE. “If you don’t use an IDE to look over your shoulder to make sure that you are not making mistakes, then compiling, building, configuring, and booting the embedded system will be a very tedious process,” says Mentor’s Baum.
Ironically, the aspects of IDEs that are essential today are the areas that will be further enhanced in the future. Look for vendors to build a tighter bond between IDEs and EDA tools to further automate and consolidate the development process. At the same time, IDE makers will extend visibility. “In the future, we would like to see anybody building any IoT device to be able to take their system and run it in such a way that they have full visibility of every component in the system running concurrently — and have the ability to replay and go back in time,” says Green Hill’s Kleidermacher.