Integrated development environments help bring products to market faster and in a disciplined manner. IDEs typically consist of a code editor, a compiler, a debugger and a graphical user interface builder. They are used either for standalone applications or as part of one or more existing and compatible applications.
With IDEs, developers can bridge hardware and software development and use the same tool chain throughout the development organization. Most IDEs provide integrated symbol-browsing and system-viewing capabilities that let developers determine the systemwide impact of modifying a given section of code. In today’s diminished design cycle, which increasingly needs to address the reliability of the final product, IDEs serve as the linchpin for product development.
For this report, we asked some of the best-known IDE providers to explore the best features of their offerings and show how a development team can benefit from those features. We offer nine articles from expert authors representing Accelerated Technology, IBM, MontaVista, QNX, Synopsys, Tensilica, VaST Systems Technology, Wind River and a collaboration between Analog Devices and Green Hills Software.
The ADI/Green Hills authors perhaps put it best when they write that the old rule applies: Designers spend 90 percent of their time executing 10 percent of the application code. A well-tuned IDE can be of great advantage in taking care of the other 90 percent of the application code in a multiple-author, multisite code environment.
IDEs come in all flavors, but the end goal of using one is to write good software. Synopsys, Tensilica and VaST address the challenges of system-on-chip designs, while Accelerated Technology, MontaVista, QNX and Wind River explore embedded-application issues.
The IBM article (see Online Exclusives) expands on what the industry commonly considers an IDE. The author describes the company’s IDE as a platform for tracking an entire project from planning, design and verification through to manufacturing tooling, as well as addressing component sourcing and the bidding process.
By Giuseppe Olivadoti and John S. Greenland Jr.
he reality of software system engineering today is that most multifunction systems are developed in a multisite, multiteam, multiauthor environment. With this distributed development methodology, integrating any combination of third-party, open-source and even intracompany code can be a challenge. Addressing that challenge will work to mitigate both the risk and the effort of developing large-scale, complex, high-performance applications based on today’s modern programmable architectures. Thankfully, embedded development tools such as code-browsing and cross-reference utilities enable developers to quickly wrap their brains around code that is unfamiliar to them.
Cross-reference utilities allow a developer to keep track of related entities and symbols in source code by enabling navigation between references and definitions of objects within the source. An example is referencing third-party libraries through application programming interfaces (APIs).
When using a library written by others, a common task is to fill out a data structure with appropriate values before passing that structure to an API function. Often there are many fields, and it can be difficult to remember what they are all used for. Cross-reference information in the editor allows a developer to quickly navigate to the declaration of the structure and use the comments or context associated with the declaration to provide additional information. This saves time by putting all the information needed to use the library at the developer’s fingertips, rather than in a reference manual that must be hunted down. These types of cross-reference utilities help ease the integration of code that contains limited documentation.
In the same vein are auto-complete functions in the editor. Rather than using cross-referencing to navigate to declarations, auto-complete brings the declarations to the developer. Auto-complete expands text as the developer types functions and variable-symbol names. For functions, a quick keystroke brings up the function prototype, saving the time it takes to look up function argument types.
Once the application is ported to a new processor and integrated with any external code modules, the developer usually engages in an iterative process of tuning the software system. While many development tools perform state-of-the-art optimization techniques from within the compiler and support dead code elimination utilities within a linker, there is an emerging need for system visualization to truly understand and craft the application so that it runs optimally on the processor.
Processors have become so powerful that more than one class of application is usually ported to run on the processor. Compilers are inherently geared for optimizing for speed, space and power for a particular architecture, but don’t provide much information for the system outside the instruction-set architecture. With so many fundamentally different types of applications running on these general-purpose processors, utilities like profile-guided optimization, memory layout profilers, and cache and pipeline visualization tools help the compiler maximize the system’s performance.
An example is Analog Devices Inc.’s Blackfin processor. Since the processor is both a DSP and microcontroller—but with a unified instruction set—it is often used in applications that have a user interface application or a TCP/IP stack that controls the system (control code processing) and at the same time may be encoding or decoding an audio or video data stream (signal processing).
When tuning an application, these kinds of development tools can help in two distinct ways: first, by handling as much of the standard optimization as automatically as possible; and second, by offering the developer insight into places where more advanced optimization can be obtained by understanding the application and the hardware system. Examples of those features are profile-guided optimization (PGO), the memory profiler, and the cache and pipeline viewer.
PGO makes use of a profiling engine to train and direct the compiler toward producing the most optimal code. The best performance increase using PGO is out of control code with lots of error checking. The advantages are somewhat less out of inner-loop-type code, since compilers are already geared to perform maximally in those contexts.
Processors with a fast core clock speed generally incorporate a hierarchal memory design to offer users a small amount of high-speed on-chip memory and a much larger amount of slower, off-chip memory. In high-speed embedded systems, proper memory layout of the application will vastly improve performance.
Graphical linker utilities, in conjunction with the profiling engine, will color objects in memory according to their rate of access. Operating on instructions or data in off-chip memory will greatly limit performance. Understanding what functions and data in the application are accessed most frequently, and where they exist in physical memory, can help the developer move the most frequently accessed items into high-speed internal memory and less frequently accessed items out to slower, less expensive external memory.
In some traditional signal-processing applications, determinism is a key factor in processor choice and system design. Ensuring determinism in a system containing cache memory, where there will be a variance in performance between cache hits and misses, can create much additional work for a developer. A cache viewer makes determining the behavior of the cache memory system much more manageable. By visualizing how the application executes through the cache viewer, the developer is able to determine if there is evidence of cache thrashing or cache conflicts with commonly executed instructions or frequently accessed data. This information could lead to a developer locking information in the cache so that a minimum of real-time code or data needs to be accessed in slower external memory—and is always located in cache.
The same notion of preserving determinism led to the creation of the pipeline viewer. With interlocked pipelined architectures, being able to visualize how each set of instructions propagates through the pipeline is very valuable for uncovering any areas of tight loops that are not operating at their maximum potential. The pipeline viewer, like the cache viewer and the various profiling utilities, works toward the goal of realizing every last bit of performance out of the processor while still offering the developer a simple and intuitive development environment in which to work. It gives the developer the visibility needed to use all the aspects of the architecture in the most efficient way possible.
Using development tools that offer PGO, memory layout, and cache and pipeline visualization dramatically improves a developer’s efficiency when tuning applications. The 90:10 rule applies: 90 percent of the time is spent executing 10 percent of the application code. Nevertheless, the other 90 percent of the code still has to be written, integrated, tested and verified, which is where the code-browsing, cross-reference and auto-complete utilities can create a huge advantage in integrating multiauthor, multisite code and speed time-to-market.
