RTX is specifically designed as a real-time extension to the Windows operating system and is not an RTOS ported to Windows. RTX provides precise control of IRQs, I/O, and memory to ensure that specified tasks execute with proper priority and 100% reliability. By operating in Ring 0, RTX ensures the highest performance and requires minimal configuration, supporting sustained interrupt rates of 30 KHz with an average IST latency of less than one microsecond.

Software engineers using RTX benefit from optimized tools that simplify development by providing the information to quickly and accurately troubleshoot and resolve development issues.

RTX is based on the Windows Win32 API, and because of this, code can be built as windows executables (EXE) that run in Ring 3 to utilize memory protection. They can also be recompiled as a real-time subsystem (RTSS) executable that runs in Ring 0, where performance can be optimized with RTSS applications taking precedent over all Windows applications.

RTX Architecture

RTX architecture is a true extension in that it does not encapsulate Windows and does not interfere with or modify the Windows infrastructure. By maintaining this separation, the RTX real-time subsystem (RTSS) ensures that RTX-based applications survive Windows crashes, or "blue screens." The RTX real-time subsystem is designed around a high-speed scheduler that utilizes both priority driven and preemptive algorithms. RTX supports up to 997 independent processes, with each process supporting unlimited threads. Fine-grained control over applications is assured with 256 levels of assignable thread priority. The RTX scheduler guarantees that critical thread context switches and yields to threads of higher priority occur in the 500 nanosecond to less than two microsecond range.

To facilitate communication and data sharing between RTSS processes and Win32 applications, RTX provides common inter-process communication (IPC) objects, such as events and mutexes, along with shared memory for data sharing. Using shared memory and IPC objects Windows and RTSS applications can share large amounts of data with no performance degradation.

Precise execution of events is critical in a real-time system. To support this precision, RTX provides three clocks on which to base event timers. Clock resolution, depending on the clock used, can be as precise as .001 nanosecond, without any drift. Timer intervals supported are 100, 200, 500 and 1000 microseconds.

The RTX Subsystem provides a high-performance TCP/UDP/IP networking for RTX applications. The RT-TCP/IP Stack supports Internet Protocol version 4 (IPv4) and next generation Internet Protocol version 6 (IPv6). There is also an RTX USB add on component that supports USB 1.1 and USB 2.0 in the real-time environment.

(Click to Enlarge Image)

Development Environment

By providing a comprehensive suite of tools that integrates smoothly into the well-known Microsoft IDE, Visual Studio, software developers can significantly reduce development and debugging time. These tools provide the ability to interactively view the application in real time to understand the interactions between hardware, RTX and the RTSS application, to easily debug and analyze application behavior.

RTX Development Environment Plug-Ins Debugger support provides support for RTSS applications within the Visual Studio IDE.  This debugging support allows debugging of Ring 0 application within a well known User Mode debugger.  The RTX Debugger Support also allows for host-target debugging of RTSS applications. 

RTX Debugger and Data Extension is a powerful plug-in to Microsoft's Kernel Debugger–WinDbg. It provides access to internal RTX data structures while kernel debugging.

RTX Wizards provide support for Visual Studio, which allows developers to quickly generate projects and code frameworks for RTSS applications, device drivers, or network drivers, from provided templates.

RTSS ObjectViewer is a utility that provides access to internal RTX objects in real time to inform the developer of processes, threads, and IPC objects interactions, along with the RTX subsystems memory usage.

TimeView displays the interactions between processes and thread usage within RTX and RTX-based applications. Presents in a text file, all thread switches, context switches and yields along with event tracking data.

PerformanceView monitors CPU utilization for both Windows and RTX, increasing visibility to the developer for RTX-based application CPU usage.

Platform Evaluator is a software tool to document and characterize the real-time capabilities of a uniprocessor Windows® system with RTX installed.


Key Features

• Robust, High-performance Windows RTOS Extension in Ring 0: sustained interrupt rates of 30 KHz
• Smallest operational footprint - 250KB
• Support for all standard Microsoft HALs: including ACPI compliant PIC, uni-processor and multi-processor APIC
• Comprehensive Microsoft Windows operating system support; RTX 7.1 supports: Windows XP Pro, XP Embedded, 2000, Server 2000 and Server 2003. RTX 8.0 also supports: Windows Vista and Vista For Embedded Systems. 
• Win32 API compliant: no need to use code wrappers for API mapping
• Complete x86 CPU support: including multi-processor and multi-core in either shared or dedicated mode
• Microsoft’s Visual Studio 6.0, .NET 2002, .NET 2003 and 2005: develop, compile and debug in the standard Windows development environment
• Priority Inversion Avoidance with Promotion: ensures that lower priority threads do not impact application performance
• Priority-driven or preemptive scheduling: assignable on a per thread basis
• WinSock compliant TCP/IP stack: independent of Windows
• High-speed Inter-Process Communication (IPC) mechanism