Electronic Design

Software Directory: Operating-System Series

Lineo Embedix RealTime
Embedix RealTime is a hard, real-time operating system (RTOS) that implements a split architecture for real-time and nonreal-time applications. This provides the benefits of a hard real-time system without forcing changes to existing nonreal-time Linux applications, such as the Apache Web server.

Hard real-time applications can use the RealTime application interface (RTAI) to communicate with any other application that employs standard interprocess communication mechanisms. Real-time applications, however, can't use many of the standard Linux functions that employ the nonreal-time Linux kernel or application support.

Applications requiring both types of support must be split into real-time and nonreal-time implementations, which offers the advantage of low-latency, predictable response times for hard real-time applications. Also, the split architecture has minimal impact on the rest of the Linux kernel because the RTAI support runs as the lowest-priority task.

Embedix RealTime retains the major benefits of Linux, including symmetrical multiprocessor (SMP) support and open-source heritage. This RTOS also is open source, except for its remote runtime data debugger, R2D2.

Overview
Embedix RealTime is built on a real-time hardware abstraction layer (RTHAL). It provides real-time scheduling and support services through RTAI. Its Linux Real Time (LXRT) support allows some RTAI calls from standard user space applications for interprocess communication between real-time and nonreal-time applications. LXRT support also permits the use of some scheduling- and timing-related functions.

Depending on the hardware platform, Embedix RealTime employs one of three schedulers: the Uniprocessor (UP) scheduler, the Multi-Uniprocessor (MUP) scheduler, or the SMP scheduler. It supports the usual collection of processor families capable of handling memory management units (MMUs).

This RTOS works with a number of the POSIX 1003 standards as well. Some, like the POSIX 1003.1 file-system API, are only available to the nonreal-time applications. Support for the Linux/proc file-system interface provides access to critical information about Linux tasks, modules, services, and processes.

The software uses the X Windows graphics interface. A separate product, Embedix UI (User Interface), is more suited to embedded environments, where direct access to display controllers is available. Embedix UI, which has less overhead than X Windows, works with a variety of third-party graphics packages as well as with remote, network-based user interfaces.

Embedix RealTime benefits from the plethora of Linux network applications and support modules. TCP/IP is the product of choice, while RTnet provides real-time networking support. Network protocol timing is greater than real-time time slices due to networking limitations, but RTnet provides deterministic timing within these limitations.

Although not included, Java support is available from third parties. Embedix RealTime includes Practical Extraction and Report Language (PERL) bindings that allow soft real-time scripting. In many instances, PERL is more efficient in both programmer's time and execution time than writing an application in C or C++.

Development generally occurs via the Embedix Software Development Kit (SDK), which includes Embedix RealTime, Embedix Target Wizard, and Metrowerks CodeWarrior. The Embedix Target Wizard uses Lineo's library-reduction technology, LIPO, to generate a compact embedded image. This can be stored on a disk or in flash memory, or downloaded to an embedded system.

Support for the gdbstubs kernel-module debugger within Embedix RealTime lets standard GNU debugger interfaces, like DDD, be implemented for remote debugging. The proprietary R2D2 permits remote debugging, too. Also, the Linux Trace Toolkit works with Embedix RealTime. LTT tracks tasks on a test system and displays the results graphically so they can be manipulated to highlight timing-related problems.



FEATURES
  • Microkernel architecture: no
  • MMU support: required
  • SMP: yes
  • Real time: hard, soft
  • Scheduling: priority, custom
  • Priority inheritance: yes
  • Dynamic memory management: yes
  • Garbage collection: no
  • Reflective memory: add on
  • POSIX 1003.1 file system: yes
  • POSIX 1003.1b real time: yes
  • POSIX 1003.1c threads: yes
  • POSIX 1003.2 shell: yes
  • Graphics: X Windows, Embedix UI
  • Clustering: add on
  • Fault tolerance: no
  • Licensing: per developer


  • PLATFORMS
  • Development platforms: Linux
  • Remote debugging: Ethernet, serial, JTAG
  • Target applications: all
  • Target CPUs: x86, MIPS, ARM, PowerPC
  • Java VM: third party
  • Minimum footprint: 1 MB


  • NETWORKING
  • Protocols: TCP/IP, RTnet
  • File server: NFS, SMB
  • CORBA support: third party
  • Servers: Web, FTP, POP3, IMAP
  • Clients: Web, SMTP, SNMP


  • QNX RTOS

    QNX RTOS builds on the Neutrino microkernel and its message-based communication architecture. Messages are an integral part of the operating system (OS), making it somewhat unusual among OSs.

    QNX RTOS is scalable, suiting it for applications ranging from compact, single-processor environments to massive SMP systems. It uses the required memory management unit (MMU) to run the microkernel and all applications in their own protected memory. The microkernel approach allows the loading of OS-level modules as needed.

    The QNet networking technology transparently extends the message-based architecture across a network supporting fault tolerance and on-the-fly load balancing. The messaging system allows multipart messages from the kernel, improving efficiency when messages pass between tasks running on different nodes.

    Neutrino works with a choice of TCP/IP stacks. The Tiny TCP Manager provides a compact TCP/IP stack that works with a host of clients and servers, including FTP and TELNET. The full BSD 4.4 stack supports advanced features, like routing, IP filtering, and multicasting.

    Overview
    Hard real-time support is inherent in QNX RTOS. The microkernel implements only the fundamental OS services, such as threads, message passing, signals, timers, mutexes, and interrupt dispatching. All other facilities are built on top of this base, which uses message passing as the fundamental form of interprocess communication (IPC). The software's process manager handles scheduling and memory management. Because it supports MMUs, this RTOS lets all processes, device drivers, and the microkernel run in their own protected space. Compact system designs can benefit from its execute-in-place (XIP) feature, which permits applications and file systems to run from ROM.

    File-system support runs on top of the microkernel like any ordinary application. File-system modules work with all popular file systems from DOS/Windows to UNIX, as well as with network file systems like NFS. Moreover, other network file systems can be added. A user interface requires only those modules necessary to drive the hardware on the target system. The Photon microGUI even provides a remote user interface for headless embedded designs. Plus, it works with 2D and 3D graphics. The 2D support includes an extensive library of widgets, such as buttons, scrollbars, and list boxes, while the 3D support includes 3D API standards like Glide, making QNX a potential gaming platform.

    The integral X Windows graphics package is a complete implementation of X Windows X11R5 with the Motif user interface that runs on the Photon microGUI. The implementation includes real-time enhancements and X-protocol transaction rates optimized for speed. Literally hundreds of X utilities have been ported to QNX X Windows. The Voyager Web browser is available for Internet appliances. An optional Citrix independent computing architecture (ICA) client enables remote control of Citrix MetaFrame server-based applications. MetaFrame runs on Windows and UNIX. Additional limited remote interaction is supported via the TELNET client and server.

    Metrowerks CodeWarrior is the primary graphics QNX development tool. This cross-platform tool runs on Windows, Solaris, and a self-hosted QNX system named the QNX Realtime Platform. CodeWarrior also supports cross-platform development using GNU (not UNIX) tools. A self-hosted system allows the testing of QNX applications on the host without the need for a target system and remote debugging support.

    QNX RTOS supports IBM's VisualAge Micro Edition, which is a development environment and Java virtual machine (JVM) compatible with Java 2 Micro Edition (J2ME). The development tools can be implemented on the QNX Realtime Platform.

    A Web pad and Internet Appliance Toolkit are other useful developer options. In addition, a large number of 3rd party tools and modules are available for QNX, including open-source, embedded database Berkeley DB from Sleepycat Software.



    FEATURES
  • Microkernel architecture: yes
  • MMU support: yes
  • SMP: yes
  • Real time: hard
  • Scheduling: FIFO, round robin
  • Priority inheritance: yes
  • Dynamic memory management: yes
  • Garbage collection: no
  • Reflective memory: no
  • POSIX 1003.1 file system: yes
  • POSIX 1003.1b real time: yes
  • POSIX 1003.1c threads: yes
  • POSIX 1003.2 shell: no
  • Graphics: Photon microGUI, Mesa, Glide, X Windows, Renderware
  • Clustering: yes
  • Fault tolerance: yes
  • Licensing: per client


  • PLATFORMS
  • Development platforms: Windows, Solaris, QNX
  • Remote debugging: Ethernet, serial
  • Target applications: all
  • Target CPUs: x86, MIPS, PowerPC
  • Java VM: IBM VisualAge Micro Edition
  • Minimum footprint: 1 MB


  • NETWORKING
  • Protocols: TCP/IP, QNet
  • File server: NFS, CIF
  • CORBA support: no
  • Servers: Web, FTP, POP3
  • Clients: Web, SMTP, SNMP, ICA


  • QNX Software Systems Ltd.
    (800) 676-0566
    www.qnx.com

    Wind River VxWorks AE
    Wind River's VxWorks AE (Advanced Edition) is important because it is a superset of the firm's popular VxWorks. VxWorks AE offers a number of enhancements--most importantly, protected domains. With them, developers can select the appropriate level of protection required by a process. For instance, a downloaded application will likely need full protection, whereas a well-tested application that's part of embedded-system base software may need only minimal protection.

    The protected-domain needs MMU support, though VxWorks AE can be used on non-MMU systems if memory protection isn't required. In theory, minimizing the amount of protection will maximize task-switching performance. Also, a task-context switch isn't needed to access services and information in another application in the same protected domain.

    Developers can adjust the security policies imposed on an application without changing the application itself. Experimenting with performance versus security is simply a matter of adjusting policies and testing the newly configured system.

    VxWorks AE is designed for high-availability environments. Its optional alarm and reporting allow dynamic changes to fault-recovery policies while a system is running. The alarm and reporting system can be tied into the hot-swap support based on the PICMG standard. Wind River offers a Hot Swap developers kit.

    Overview
    VxWorks AE is based on the wind microkernel, which supports an unlimited number of tasks. It employs preemptive and round-robin task scheduling with a fast, deterministic task-context switch. The task switching time is based on the protected-domain configuration.

    The software provides VxWorks- and POSIX-compatible programming interfaces, plus interfaces for VxWorks AE-specific features. User interface support is available using Zinc, a GUI suitable for embedded applications.

    It works with major communications protocols, such as TCP/IP. The Wind Web Server is optional. VxWorks AE extends the VxWorks VxFusion message-passing system across node boundaries. Interprocess communication support includes POSIX pipes and message queues, shared memory, and sockets.

    VxDCOM is a compact (280 kB) optional component for providing real-time Distributed Common Object Model (DCOM) support. DCOM is used on Windows clients and servers to implement distributed applications. VxDCOM permits VxWorks AE to be part of this environment.

    VxMP is a multiprocessor option for multiple processors connected via a shared memory bus. While VxMP can support a mix of different processor types, all must be running VxWorks or VxWorks AE. VxMP provides shared memory pools and partitions, queues, semaphores, and a naming service.

    Tornado AE, the primary development tool, incorporates a C/C++ multitasking debugger, a system object browser, an RTOS configuration tool, a project-management tool, and optimized versions of the GNU tools for C and C++. It supports VxWorks AE features, including protected domains and the alarm and notification system. Various connection methods support remote debugging.

    The optional Personal JWorks package provides Java support. It includes PersonalJava classes, a JVM, and Truffle, a graphics toolkit. TurboJ, an ahead-of-time (AOT) Java compiler that translates Java bytecodes into native code, also is available. Executables are larger but faster.

    VxWorks AE uses cross-platform development. Some host-based testing is possible using VxSim, a simulator that runs on a host operating system. VxSim is primarily implemented for application development.



    FEATURES
  • Microkernel architecture: yes
  • MMU support: required
  • SMP: yes
  • Real time: hard
  • Scheduling: priority, round robin
  • Priority inheritance: yes
  • Dynamic memory management: yes
  • Garbage collection: no
  • Reflective memory: no
  • POSIX 1003.1 file system: yes
  • POSIX 1003.1b real time: yes
  • POSIX 1003.1c threads: no
  • POSIX 1003.2 shell: no
  • Graphics: add on
  • Clustering: no
  • Fault tolerance: no
  • Licensing: per client


  • PLATFORMS
  • Development platforms: Windows, Solaris, Linux
  • Remote debugging: Ethernet, serial JTAG
  • Target application: communications
  • Target CPUs: x86, MIPS, ARM, PowerPC, SPARC, 68k
  • Java VM: add on
  • Minimum footprint: 1 MB


  • NETWORKING
  • Protocols: TCP/IP, IPsec, VxFusion
  • File server: NFS, SMB, DOS
  • CORBA support: third party
  • Servers: Web, FTP
  • Clients: Web, SMTP, SNMP


  • Wind River Systems Inc.
    800) 872-4977
    www.windriver.com

    TAGS: Components
    Hide comments

    Comments

    • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

    Plain text

    • No HTML tags allowed.
    • Web page addresses and e-mail addresses turn into links automatically.
    • Lines and paragraphs break automatically.
    Publish