Inferno Operating System Burns Its Way Into Embedded Systems

The Inferno operating system may be familiar to academics, but it's new to most embedded-systems designers. Released by Vita Nuova of York, England, Inferno and its supporting tools from Lucent Technologies' Bell Labs are now available in the commercial arena.

Like Sun's Jini, Inferno addresses embedded networked applications. Inferno's base language, Limbo, runs on a virtual machine called Dis. This machine has been implemented on a variety of platforms. It can even be found as a plug-in for some web browsers. When it comes to complexity, breadth, and interoperability, however, Inferno and Jini part company. Inferno is simpler than Jini. Limbo is simpler than Jini's base language, Java. Also, Inferno and its tools address the same range of applications as Java, while Jini is just one of Java's aspects.

The Styx protocol, Inferno's underlying architecture, is the key to Inferno's interoperability. All communication is essentially handled through the file system. Users only need the keyword. File-based interoperability is very similar to Unix, where devices and remote file systems are mounted at directories in a local file system. Inferno, however, uses the file system for everything from accessing a domain-name server (DNS) to displaying information in a window on a remote computer.

There's no distinction between a local file and a remote file. Distributed program construction, then, is inherent to Styx's use. This consistency also makes it easier to move services from one part of a system to another. As a result, systems with limited functionality can easily use services on another system.

Styx is very simple. It has just over a dozen functions, including the familiar open, close, read, and write. While it takes little time to master this interface, programmers must still contend with service-specific parameters. For example, writing "www.abc.com" to /net/dns will be followed by a read that would return an IP address like "123.45.67.89."

The protocol is independent of Inferno and Limbo, so it can be implemented in as little as 6 kbytes. An embedded system, such as an Inferno-based system, can support Styx. Other Styx-supporting applications on the network then would be able to access the system. So far, Styx has been implemented on a number of Inferno-independent platforms.

With its small memory footprint, Styx can be used on very compact system-on-silicon solutions where cost is critical. The same device also can coexist in a network with a range of devices. Advanced functionality is often implemented through a directory of files. For instance, a file named ctl is used for control functions, while a data file handles normal services. An interface is a definition of all the files and their interaction.

Inferno, Limbo, and Dis offer advantages in terms of compactness and functionality. Dis is normally implemented with a just-in-time (JIT) compiler that converts bytecodes to machine instructions. Inferno, Limbo, and Dis are built on Styx, which includes support for encryption and authentication.

Making encryption and authentication part of the base implementation is important for most environments where Inferno and Styx will be used. This support adds another level of protection to the usual firewalls protecting a network.

Limbo provides designers with fine control over loadable modules. Modules must be explicitly loaded and unloaded. Since they can be obtained from any source, modules can be downloaded from a remote computer. Also, Limbo implements two types of garbage collection. This allows immediate recovery of noncircular data structures while circular data structures are recovered over a longer period. Java implementations normally use the latter.

A language unto itself, Limbo has strong ties to C and Pascal. It incorporates abstract data types from Winterbottom's Alef, processes from Pike's Newsqueak, and aspects of Hoare's CSP. It supports Unicode, arbitrary lists, tuples, and a pointer with restricted attributes. As with most programming languages, Limbo takes some time to learn. Yet it's not object-oriented, simplifying the learning curve. Limbo also takes advantage of Styx and Inferno features in a variety of ways. These ways aren't so easily replicated, though, in all of the languages where Styx might be implemented.

Inferno, Limbo, and Styx have been used in commercial products. For instance, Inferno manages the switch in Lucent's Pathstar telephone. Along with Styx support, C applications handle low-level routing. Remote management and debugging is simply a matter of mounting the necessary directories at a remote computer running Inferno.

The Inferno package can be obtained via subscription. Most of it is available for public distribution. Although supplied in source form, core portions cannot be distributed except to other licensees. This includes changes that may be folded back into the system in future releases. The terms also deviate from GPL, as derivative works can remain proprietary. These terms may appeal to designers who want tighter control while building IP that uses Inferno.

On the other hand, there are no royalties for distribution of binary versions, distribution of source code to other licensees, or distribution of public portions of the source code. The lack of royalties will be critical to its acceptance in cost-conscious embedded systems. Also, the Styx protocol is royalty free. It can be used and implemented by anyone. The protocol definition is available on Vita Nuova's web site.

Subscriptions for individuals cost $300 per year. The price for organizations is $1000 per year. Academic institutions pay $150 per year. Updates are expected in six-month intervals.

For more information about Inferno and the Styx protocol, visit the company's web site at www.vitanuova.com.