Optimizing for PowerPC on embedded Linux

Increasing numbers of embedded developers are turning to Linux as the preferred software platform to support compute-intensive applications in networking, wireless infrastructure, storage and imaging. The PowerPC 440 system-on-chip processors, in particular, offer the customer a variety of hardware solutions for these market segments.

It is therefore wise to become familiar with developing and optimizing applications using development tools for specific PowerPC devices running an embedded Linux operating system with an array of cross-development tools.

Early embedded-Linux developers migrating from legacy operating systems discovered they were able to achieve significant time-to-market savings by resetting their tool-centric expectations to a paradigm that emphasized the power of the Linux kernel, direct access to source and native command-line user interfaces. This is not to say that development tools are lacking with Linux. Since the earlier days of embedded Linux, a wide-ranging suite of powerful tools, designed to suit the tastes of developers more accustomed to IDE-based "studio" environments, has emerged through open-source and commercial sources. But it is also important to understand the underlying Linux development process.

As with any embedded target, developers must bootstrap the embedded CPU over a network (bootp/tftp) or via serial download. Typically, the next step is to mount a root file system from an exported directory (via NFS) on the host system.

Such an approach provides developers with transparent, seamless access between the host and target. Code modified on either host or target is immediately available to both, and uploading software to the target is as simple as copying files into the exported directory. Since both cross- and native compilers are provided, developers have the flexibility of developing on host workstations or directly on the target, resources permitting.

Embedded-Linux development leverages compilation and debugging tools already familiar to most developers-the GNU compiler collection (gcc) compiler family and the GNU debugger (gdb)-in both cross- and native compiler versions.

A recent offering in commercial OS products, gcc version 3.3 contains improvements in pipelined CPU support and processor-specific optimizations for the PowerPC architecture, along with improvements in standard C++ language support, especially for templates and exception handling.

Special executables
Meanwhile, gdb 6.0 supports debugging multithreaded Linux applications and the ability to attach to and debug running-process images. It supports debugging new Native Posix Threads Library code, accessing thread-local storage, using separate executables and debugging symbol information, and leveraging additional compiler/Dwarf-based back-trace information. The virtual addressing and memory protection inherent in Linux reduce the need for traditional debug technologies, such as in-circuit emulation.

The same MMU-based technology can also limit the utility of hardware debug to low-level porting activities, because of address mapping and translation-obscuring symbol references. Commercial Linux vendors work closely with hardware tool suppliers to offer source-level real-time debugging of boot code, the Linux kernel and device drivers, with emerging capabilities to address user-space programs and data. Now developers are enjoying the benefits of a fully integrated development environment, built on open-source Eclipse technology (www.eclipse.org), that's designed to ease and accelerate the tasks involved with embedded application development and deployment.

Eclipse can be viewed as a software backplane that provides a plug-in architecture for such key functionality as code browsing and editing, source-level debugging and other capabilities implemented in third-party tools. This open architecture benefits the developers who use Eclipse-based integrated development environments. It also fosters the creation of a growing ecosystem of independent software vendors and other third parties building advanced plug-ins and tools to enhance the Linux development process.

In fact, some development houses choose to create their own plug-ins to customize the IDE for their own specific development processes. Full-featured integrated development environments present the following capabilities:

• Host support with a common look and feel for Linux, Solaris and Windows workstations;
• A platform creation wizard, enabling complete file system generation;
• Context-sensitive editing and language-aware program syntax checking;
• Graphical source code and a project management interface;
• Integrated help and documentation;
• Project wizards to simplify creation of applications and libraries;
• A point-and-click interface for optimization and kernel configuration;
• Tracing tools for system and application event analysis; and
• A graphical wizard-driven revision control client.

Within this development environment, users can instantiate new C and C++ projects with a few mouse clicks using powerful wizard interfaces. Using the integrated code editor, developers create and modify programs, kernel configurations, shell scripts and so on. A few more clicks build the application, with compiler error messages tied back to source files for streamlined correction of source errors. Developers can then leverage wizards to build a complete file system designed for use in solid-state or disk-based storage systems and containing a customized Linux kernel and software stack, including third-party or user-developed applications.

One of the more interesting open-source tools is the Linux Trace Toolkit. Delivering powerful system-level and user-level event-tracing capabilities, LTT consists of a number of target and host-based components. The first set of components includes kernel modifications to enable data capture as well as a target daemon that has been ported to run on PowerPC-based designs. The daemon runs on the embedded target and logs data for later analysis on the host system. Developers copy the trace logs to their host system through FTP or read them directly from an NFS share if the standard Linux development model has been employed. LTT also provides a host-based analyzer to display trace results in a sophisticated graphical layout.

Jacob Lehrbaum (jacob@mvista.com) is product-marketing manager for consumer and mobile products at MontaVista Software Inc. (Sunnyvale, Calif.).