What do you need to build, test and tune Moblin applications? Frankly, you can do everything by using tools from one source: Intel. A couple of examples are the Intel Embedded Software Development Tool Suite for Intel Atom processor and Intel Application Software Development Tool Suite for Intel Atom processor. Their components take full advantage of the Eclipse IDE. The Intel tools are commercial tool sets that are installed in addition, and on top of your preexisting GNU toolchain, from the Free Software Foundation.  They go beyond the GNU tools to focus specifically on Moblin development. This article will focus on the Embedded Software Development Suite and next month we’ll discuss the Application Software Development suite.

According to Intel, its toolchain offers faster time-to-market than the GNU tools, and more highly optimized code generation. The Intel tools, because they’re tuned for Moblin, also excel at finding and fixing performance and code-correctness issues. The end result: a faster, better-behaved application that’ll enhance the customer experience.

There are five tools comprising the Intel Embedded Software Development Tool Suite for Intel Atom processors – and one of those tools is only available as part of this special suite.

Note that all of these tools are Linux-based, which means that you’ll need to be using a Linux-based software development workstation. (Because Moblin is Linux, you can also run the tools on your target platform, though I’m not sure why you’d want to; a Moblin netbook is underpowered to use a development system. But it’s nice to have the option.) The Intel suite costs US$1,999 per developer seat, and can be purchased and downloaded directly from Intel.

The five tools are:

* Intel C++ Compiler for Linux OS

* Intel Integrated Performance Primitives Libraries for Linux OS

* Intel JTAG Debugger for Intel Atom processor

* Intel Application Debugger for Intel Atom processor

* Intel VTune Performance Analyzer for Linux OS

Let’s touch briefly on the first two, which are development tools, and then move over and talk about the testing and tuning tools.

The Two Development Tools

The Intel C++ Compiler for Linux OS {http://software.intel.com/en-us/intel-compilers/} is designed to specifically target the Intel Atom processor and optimize for the chip’s scheduler. Because Intel’s compiler designers worked closely with the chip designers, it’s also fine-tuned for other microarchitecture-specific properties of the Atom processor. The Intel compiler is compatible with gcc, the C/C++ compiler in the GNU Compiler Collection, and uses the same binutils.

You've undoubtedly heard of Intel IPP, or the Intel Integrated Performance Primitives. It's a library of highly optimized functions– hand-optimized in fact, to leverage the capabilities of the Intel Atom processor. Included with Intel IPP are functions for multimedia playback/recording, editing, image processing, and network data communications, and a lot more. There are plenty of free code samples to for you to check out, learn from and build upon.

The Three Test/Tune Tools

When you’re dealing with a small-footprint device like a netbook, every millisecond – microsecond – nanosecond counts. (Picoseconds, anyone?) Software flaws, such as inefficient loops or timed-out calls, seriously impact the user experience, and that includes both malfunctioning code and poorly optimized code. While the Intel compiler and performance primitive library can help, ultimately it’s the job of debuggers and performance analyzers to help you ensure that your application is running effectively – and to help you remediate any issues.

The first tool to become friends with is the Intel Application Debugger (which, when purchased outside the suite, comes in a slightly different more native development centric version with the Intel C++ Compiler). The Application Debugger can help with everything from low-level assembler debugging to high-level language C++ application debugging. It includes full execution trace support, which helps to identify errors that are normally hard to detect. What’s particularly important here is that it supports native development and testing of Moblin-based apps. You can run the apps within a KVM environment on the development host before you push them out to an Atom-based netbook.

The Intel JTAG Debugger (only available through the Intel Embedded suite) complements the Application Debugger. JTAG refers to the standard from the Joint Test Action Group, also known as IEEE 1149.1, which defines a remote debugging and testing interface for target devices. The Intel JTAG Debugger provides a system, bootloader and Moblin Linux kernel, as well as facilities for debugging device drivers.

The debuggers will help you find out why your application isn’t running – and fix it. The Intel VTune Performance Analyzer will show you where the running application has performance bottlenecks, and will help you determine where to optimize it. It does that by actually running the code on the target device, along with a small sampling collection. That means that you don’t need to write instrumentation into your code; VTune takes care of everything for you. (You can learn more about VTune in “Getting Started with a Linux Software Development Toolchain,” on the Intel Software Network.)

What Goes Where?

Earlier, I mentioned that you can run development tools on a Moblin netbook – but that you probably wouldn’t want to. Why not? For one thing, there’s raw horsepower. If your development workstation is anything like most developers, you’ve got a screaming quad-core processor, a metric ton of memory, and the fastest disks available to humanity. With all apologies to the netbook folks, there’s no comparison, not for processor-intensive, RAM-hungry compilation and debugging.

Another benefit is the display. While you can connect many netbooks to external screens, your dev workstation probably has at least one 24-inch display. Maybe two.

That means that your development work will be cross-development: Coding on a workstation, with initial testing on the workstation until the application generally runs. At that point, debugging and performance tuning will shift over to a target netbook. Therefore, your IDE, your Intel compiler and performance primitives, and the debuggers will all be installed onto your development workstation. The main VTune console would also go onto your development workstation.

What goes onto the target device? Well, your application, obviously. You’ll also connect your target device (i.e., a netbook) to the network, so that the debuggers on your development workstation can talk to the target via TCP/IP. If you’re using the Intel JTAG Debugger, you’ll use a JTAG device to connect to the netbook’s eXtended Debug Port (XDP) and thus commence remote cross-debugging of your entire platform and system level software.  For remote application debugging, the debugger is a small stub, called idbserver, and it handles application run control and debug events for your test session via TCP/IP.

Included with the VTune Performance Analyzer, there’s a small application, called the VTune Sampling Collector. You’ll want to run that on your target netbook. It’ll gather up data samples while your software is running. After the run is complete, you can copy that file (over the network or using a USB key) over to your development workstation for analysis.

Check Out the Intel Suite

As you can see, Intel has put a lot of thought – and a lot of work – into building a complete toolchain for building Moblin applications. With Moblin v2 here, it’s just what you need to begin writing or porting applications. Learn more about it on the Intel website.

* All names and brands are the property of their respective owners.

Alan Zeichick is principal analyst at Camden Associates, where he advises enterprises about technology challenges, writes for technology print and online publications and speaks at industry events on enterprise IT, networking, security, software engineering and consumer electronics. Meanwhile, as editorial director of BZ Media’s SD Times, Zeichick drives forward the industry newspaper for software development managers.

A former mainframe developer and systems analyst, Zeichick became a technology analyst and journalist in 1984. He has authored more than 3,000 articles, worked with consulting groups, including PricewaterhouseCoopers, IDC and Anderson Consulting, and has spoken at numerous events such as COMDEX, Networld+Interop, Microsoft TechEd, JavaOne and the Software Development Conference.