RTX64 RTOS, Frequently Asked Questions for Real-Time Windows 10

FAQs About RTX64

The information in this section is up-to-date as of RTX64 4.1.

What is Real-Time?

Real-time describes an application which requires a response to an event within some small upper bounded time frame. Typically, response times are in the millisecond or microsecond time frame.

What is the difference between “Hard” and “Soft” Real-Time?

Hard real-time requires that a response be logically correct and occur before a certain deadline or the result is incorrect, and holds no value.

Soft real-time requires that a response be logically correct and occur before a certain deadline or the result becomes increasingly inaccurate, meaning the result can still hold some value even though it occurred after the required deadline.

What does determinism mean in a real-time environment?

Determinism is defined as the ability to rationally predict, with a degree of precision, when an event will happen. Determinism, combined with a real-time environment, guarantees that an event will happen within a small response time and that the performance of this event is repeatable.

What is a real-time operating system, or RTOS?

A real-time operating system provides determinism and predictability when it responds to a given event through a specialized scheduler.

Is Microsoft® Windows® a real-time operating system?

Windows is usually referred to as a general-purpose operating system because it does not allow applications or kernel-level drivers to completely mask interrupts and gain control over the operating system. Depending on hardware, interrupt latencies under Windows can exhibit very good values, averaging in the microseconds. However, worst-case interrupt latencies are unbounded and can exceed hundreds of milliseconds. Because of these unbound latencies, deterministic response time is not guaranteed, making standard Windows Desktop and Server operating systems unacceptable for real-time use.

What is RTX64?

IntervalZero’s RTX64 software transforms Microsoft Windows into a Real-Time Operating System (RTOS).

For projects that demand a Windows user experience and require hard real-time or determinism, the RTX64 RTOS Platform enables OEMs and end users to capitalize on Windows, x64 multi-core multi-processor technology, symmetric multiprocessing (SMP) and real-time Ethernet – all in a single integrated development environment.

  • Reduce bill of materials (BOM) costs by 25-50%
  • Boost quality and performance
  • Scale quickly and shorten product cycle times
  • Significantly reduce reliance on proprietary hardware such as DSPs

What is SMP?

RTX64 supports Symmetrical Multiprocessor Systems (SMP); a computer architecture that allows operating system tasks and user threads to be scheduled to run on any available processor. With this model, multiple processors can be configured for real-time activities. RTSS threads can be assigned to run on dedicated RTSS processors and they can run concurrently.

When running RTX64 on an SMP-enabled system, you configure how many of the processors are dedicated to Windows and how many are dedicated to the RTX64 Real-time Subsystem (RTSS). RTX64 supports SMP systems that have as many as 64 processors. Of those 64, up to 63 can be dedicated to RTX64 (dependent upon the edition licensed).

How does RTX64 extend Windows to provide “hard” real time?

The overall design of RTX64 affords developers the “best of both worlds” by providing the ability to use all of the features and technologies that Windows offers, in addition to “hard” real-time behavior within an isolated and controlled subsystem. RTX64 includes a real-time enabled Hardware Abstraction Layer (HAL) extension. RTX64 does not replace the existing Windows HAL. This extension maintains interrupt isolation between RTSS and Windows, while providing inter-processors interrupt (IPI) communication between the two. The real-time subsystem schedules its RTSS tasks to execute on separate processors, without any interference from the Windows operating system or Windows processes.

What are the benefits of RTX64?

The RTX64 Runtime enables general-purpose Windows processing and high performance real-time processing and control on commercial-off-the-shelf (COTS) machines. The RTX64 Runtime can be configured to take part in Windows mini-dumps or to take control and safely shutdown real-time processes if Windows encounters a failure.

The RTX64 SDK provides developers with a rich set of inter-process communication and synchronization capabilities, allowing RTSS applications to communicate with Windows applications (32-bit and 64-bit) and share data with them. Additionally, RTX64 provides developers with the ability to directly access I/O port address space, physical memory, or hardware without forcing any driver model on the user.

RTX64 takes full advantage of 64-bit registers and compilers, allowing real-time developers to do the same.

What are the benefits of using RTX64 on an SMP system?

Using RTX64 on an SMP system provides significant benefits, including:

  • Performance Boost – You can have multiple processors dedicated to critical, real-time tasks. You can concurrently run up to 63 real-time threads on a 64-processor system.
  • Performance Scalability – Performance scaling doesn’t require code rewrites. You can adjust the real-time and non real-time performance balance by changing the number of RTSS processors and Windows processors.
  • High Availability – Critical tasks can be scheduled to run on more than one RTSS processor.
  • IRQ Affinity – You can specify a dedicated RTSS processor for processing the input and output of individual pieces of hardware.
  • System Fault Handling – Real-time tasks survive over system crashes.

Can the same application run on any edition of RTX64?

The Runtime is available in several editions, allowing you to license as many processors as are necessary for your solution. The editions of the RTX64 product are:

The edition… Includes support for real-time operations on…
Solo One dedicated RTSS processor
Entry Up to two dedicated RTSS processors
Basic Up to three dedicated RTSS processors
Professional Up to seven dedicated RTSS processors
Premium Up to 15 dedicated RTSS processors
Ultimate Up to 63 dedicated RTSS processors

You can assign available processors to Windows or RTX64 through the RTX64 Activation and Configuration utility. The RTX64 Activation utility automatically detects the total number of processors on your system. For more information, see the topic Configuring your System in the RTX64 Help.

All editions of the runtime include the same features. Applications that are created with the SDK will be able to run on any edition running the same version of RTX64. This allows developers the freedom to develop applications that can be scalable.

How long has RTX64 been around?

The RTX64 product was released in 2013 to provide a real-time subsystem for Windows 7. RTX64 has continued to evolve, and it now supports multi-processors running the following 64-bit operating systems:

  • Windows 10 (up to Semi-Annual Channel Version 2009)
  • Windows 10 IoT Enterprise LTSC (Long Term Servicing Channel Version 2019)

What is the current version of RTX64?

The latest version is RTX64 4.1, released in 2021.

What types of industries or products typically use RTX64?

RTX64 is used in a wide variety of products and vertical markets. Anyone designing an application that requires system control, determinism, or real-time performance on Windows can benefit from incorporating RTX64 into their product design.

RTX64 is used in some of the following markets:

  • Industrial Automation
  • Digital Audio
  • Test & Measurement
  • Medical
  • Military Aerospace

How is RTX64 packaged?

IntervalZero provides six editions of the RTX64 Runtime product:

The edition… Includes support for real-time operations on…
Solo One dedicated RTSS processor in a uniprocessor or multicore/multiprocessor environment.
Entry Up to two dedicated RTSS processors in a multicore/multiprocessor environment.
Basic Up to three dedicated RTSS processors in a multicore/multiprocessor environment.
Professional Up to seven dedicated RTSS processors in a multicore/multiprocessor environment.
Premium Up to 15 dedicated RTSS processors in a multicore/multiprocessor environment.
Ultimate Up to 63 dedicated RTSS processors in a multicore/multiprocessor environment.

Can I incorporate the installation of RTX64 into my product?

The RTX64 Runtime installations come in several varieties:

  • RTX64 Runtime Install – RTX64 can be installed silently. The installation can be invoked from the command line or used within your own product installation so as not to require user interaction during the installation process.
  • Merge Modules for RTX64 Runtime Features – The RTX64 components are available as merge modules that can be included in the installation of an OEM product. A separate installation places merge modules on the system for your use.

For more information, see the RTX64 Deployment Guide.

What comes with the RTX64 Runtime?

The RTX64 Runtime comes with the following functionality:

  • Extends the Windows HAL to support real-time control and isolation of interrupts
  • Scheduler that schedules across multiple cores in a dedicated configuration
  • Deterministic local memory through configurable process MSpaces.
  • Processing and networking capability through a Network Abstraction Layer (NAL) and an optional RT-TCP/IP protocol stack within the RTSS environment
  • A Control Panel to configure the RTX64 Subsystem
  • The ability to display RTSS process output to a console window that can be configured to display for each real-time application or as a single instance for all real-time applications.
  • A Task Manager utility for viewing real-time processes (.rtss) and Windows processes linked to RTX64 (.exe). You can start new tasks and terminate running tasks using the Task Manager. You can also schedule tasks to start with the Subsystem, and view CPU Usage data for all processors assigned to either Windows or RTX64
  • Monitoring infrastructure that allows developers to profile the behavior of RTSS applications across all RTSS processors. Also included is a simple utility that outputs a readable text file.
  • Latency View tool to view timer latency on Windows and RTSS cores.
  • Command line utilities to view CPU usage and object states.
  • Comprehensive Help files and User Guides

See the RTX vs RTX64 Comparison Guide, available at http://www.intervalzero.com/technical-support/guides-and-minitutorials/ (RTX64 Documentation tab), for information on the differences between RTX64 and RTX.

What comes with the RTX64 SDK?

The RTX64 SDK comes with the following components:

  • Header files and libraries
  • Support for Visual Studio 2019, 2017, and 2015 (deprecated)
  • Microsoft C Runtime support
  • Templates for creating applications and DLLs
  • API code snippets
  • RTX64 WinDbg Extension that extends Microsoft’s 64-bit version of WinDbg and provides a way to analyze and interpret the state of RTSS processes, as well as the RTX64 Subsystem.
  • Tracealyzer for RTX64, a diagnostics tool from Percepio for viewing monitoring session data
  • Symbols to key components of the RTX64 Runtime
  • Comprehensive Help files and MiniTutorials
  • Source code samples to help explain more advanced development topics

How do I activate my copy of RTX64?

RTX64 components must be activated with a valid license before they can be used. You can use the RTX64 Activation and Configuration utility, which appears immediately after program installation, to activate and lock your product to a specific machine or to an IntervalZero-provided small form factor dongle. For information on first activation, see the RTX64 Install Guide for your product, or see the RTX64 Deployment Guide.

The method you use to activate your copy of RTX64 will depend on whether you are connected to the Internet. Videos are available that walk through the process of activating with an Internet connection, and activating without an Internet connection. You can watch the videos at http://www.intervalzero.com/rtx-product-activation/.

Are there any hardware or platform requirements for RTX64?

The RTX64 Runtime runs on any Commercial Off-The-Shelf (COTS) platform that Windows 64-bit supports. RTX64 supports mobile processor, multiprocessor, and multi-core platforms. However, because all systems are not the same, developers need to evaluate the latencies of any platform that they choose to ensure that the platform can support their real-time or control needs. You can use RTX64 with hyper-threaded systems, but it is recommended that you evaluate RTX64 performance to ensure that real-time requirements are achieved when hyper-threading is enabled.

See the RTX64 Processor Compatibility document, available at http://www.intervalzero.com/technical-support/guides-and-minitutorials/, for a listing of compatible processors.

Does RTX64 support processor clusters?

RTX64 can run on systems with up to 64 processors; up to 63 can be assigned to RTX64.

Can RTX64 be used on a mobile processor system?

RTX64 can be used on mobile processor systems. However, since mobile processors use power policy technology to lower processor speed during Windows idle time to conserve energy, long latencies can occur when the processor becomes unavailable during the speed change. RTX64 interacts with Windows Power Management options to disable this functionality which causes the processors to become unavailable. Users have the ability to re-enable Windows Idle detection if their application is able to work with the resulting latency.

Does RTX64 support Windows 10 on x2APIC systems?

No, x2APIC systems are not supported. Only systems that allow for x2APIC to be turned off are supported. The RTX64 installation will disable x2APIC when possible.

Does RTX64 support hyper-threading?

RTX64 can be used on hyper-threading systems. RTX64 treats the logical processor created by Intel Hyper-Threading as a separate processor. Because both logical processors share the same physical processor, one logical processor can adversely affect the performance of the other. It is recommended that you use even numbers of windows processes so a Windows logical processor and an RTSS logical processor do not share the same physical processor. You should also evaluate RTX64 performance to ensure that when hyper-threading is enabled, your real-time requirements are still achieved.

Does antivirus software impact RTX64?

RTX64 Runtime can be run alongside 3rd party antivirus software as long as RTX64 is granted access to the system folders and directories it requires. If RTX64 does not work correctly on a system with a 3rd party antivirus, it is recommend to enter exceptions within the antivirus rules/policies. For instance, you can instruct the antivirus software to ignore the RTX64 components RTX_RTSS, RTX_HALEXT, etc., or to ignore the RTX64 install folder entirely. In some cases you may need to ignore the folder where your binaries are being run from.

See the TechNote RTX64 Compatibility with Microsoft Security Features, available from the Support Site, for information on which Microsoft Security Features can be run on the same system as RTX64 Runtime.

Does RTX64 support Virtual Machines?

Virtual Machines should not be used for deploying RTX64 Runtime products, since the Real-time Subsystem cannot guarantee determinism in a virtual environment. However, virtual machines can be used for development and testing. See the TechNote Virtual Machines Tested with RTX64/RTX for information on Virtual Machines that have been used internally by IntervalZero and are known to work with RTX64.

NOTE:  A dongle is required when licensing RTX64 on a Virtual Machine.

What is needed for application deployment?

To deploy your RTSS application, you must purchase an RTX64 Runtime license for each system on which the application will run. Multiple editions of the RTX64 Runtime are available, allowing you to license only the number of processors that are necessary for your solution. For more information on deploying RTX64, see the RTX64 Deployment Guide.

Can I run the RTX64 Runtime installation from within another installation?

IntervalZero provides the option of a silent command line installation for RTX64, which allows an OEM to wrap the RTX64 installation and hide it within another installation. The RTX64 Runtime components are also available as merge modules that can be included in the installation of an OEM product.

How do I configure my customer’s real-time subsystem?

IntervalZero provides Managed Code and Native Frameworks that can be used to programmatically configure the RTX64 Subsystem. This allows customers to set up their software’s subsystem requirements without requiring anything of their end users.

How can I help debug my customer’s issues?

In Visual Studio, RTX64 provides local and remote launch and attach debugging capabilities for RTSS applications with Visual Studio 2019, 2017, and 2015 (deprecated).

RTX64 also provides excellent flexibility for processing exceptions. You can configure RTX64 to handle exceptions with a structured exception handler; generate a debug break; or stop the process and dump memory.

RTX64 provides a WinDbg Extension that can be used for postmortem debugging of a Windows memory dump file.

RTX64 also provides monitoring functionality that allows you to trace application behavior without requiring code modifications to your real-time application. Tracealyzer, a graphical tool for analyzing monitor session data, is also provided.

Can I limit the functionality that is available to end users?

Yes. Once RTX64 has been successfully installed, all authenticated users who log on to the system can control, configure, and run the RTX64 Subsystem and RTSS applications, even if they are not computer or domain administrators. System administrators can control access to the RTX64 resources by configuring members of the RTX64Administrators and RTX64Users groups. For more information, see the RTX64 Runtime Install Guide.

How does RTX64 reduce development time?

Because RTX64 extends Windows, there is no need to spend time designing and developing an operating system before application development work even begins. RTX64 developers can create user interfaces and applications that take advantage of all the functionality that Windows offers; developers need to focus only on the real-time control pieces required to run an RTSS application. Even components that require real-time control can first be developed as a Windows application and then recompiled as an RTSS application with no code changes.

Since all real-time API (RTAPI) calls are Windows compliant, developers use calls they already know and understand. There is no need to write driver code or follow a strict driver model to configure and use devices.

Do I need special development and debugging tools to develop RTSS applications?

No. RTSS applications are developed with Microsoft Visual Studio. The RTX64 SDK provides a wizard for easy project creation and templates to help you get started. Visual Studio Debugger support lets you debug RTSS applications in a familiar environment. RTX64 supports local and remote debugging through launch and local attach in Visual Studio 2019, 2017, and 2015 (deprecated). A WinDbg Extension is also available for postmortem debugging of Windows memory dump files.

RTX64 also supports use of the Intel C++ Compiler within the Visual Studio IDE.

Can I use Windows API calls or are all RTX64 calls proprietary?

RTX64 supports a subset of over 50 Windows API calls that make sense in a real-time environment.

In addition, RTX64 provides a large selection of real-time API calls that developers use to access the RTSS and system resources. This real-time API (RTAPI) is composed of a set of unique API calls and Windows-based API calls.

The unique real-time API calls are Windows-modeled calls that provide essential programming capabilities required for real-time applications, along with access to the RTSS and system resources. These unique RTAPI calls have no equivalent Windows calls.

The Windows-based API calls that are supported by RTX64 are unlike the unique RTAPI calls in that there are similar functions in the Windows environment; however, these calls require a different implementation than their Windows counterparts to support the real-time requirements of the RTSS. All the Windows -based calls are compatible with Windows programming interface semantics, making it easy for developers already familiar with the Windows API.

How can I take advantage of user-mode memory protection during development?

RTX64 was designed so that developers could design and develop applications as RTSS or Windows applications. When built as a Windows application, developers can take advantage of features like user-mode memory protection and other third-party debugging tools specific to user mode applications. After an application is working as desired, recompile it as an RTSS application which runs in the real-time subsystem on dedicated processors with no code changes required.

Does RTX64 support Structured Exception Handling?

Unlike other applications that run in kernel mode, RTSS applications support structured exception handling. RTX64 lets developers call structured exception handling functions such as try, catch, and throw within their RTSS application. For example, if an application references a NULL pointer, the application can handle the error by terminating or freezing the application that caused the fault without bringing down the system.

Can I use the Microsoft development libraries and technologies such as C Runtime in my RTX64 applications?

RTX64 supports a subset of Microsoft C Runtime calls that you can call from your RTSS application. RTX64 provides Microsoft C Runtime Support for Microsoft Visual Studio 2019, 2017, and 2015 (deprecated).

Does RTX64 support SSE and AVX/AVX2?

Yes. RTX64 supports and saves state information for AVX/AVX2 (YMM0~YMM15), AVX-512, SSE (SSE/SSE2/SSE3/SSE4), and MMX registers, as long as the hardware supports it.

Does RTX64 provide any sample code?

The RTX64 SDK includes a complete API reference guide for all supported functions in addition to small code segments that explain more complex concepts.

The RTX64 SDK also provides source code for a number of sample applications, some of which are the RTX64 measurement tools. These samples can be compiled and run, and show important concepts and application interaction. For customers with support, the IntervalZero Support Site contains several samples and tools for use with RTX64.

Are any measurement tools available?

RTX64 provides tools and APIs that help Developers measure system response and timer latency:

  • SRTM (System Response Timer Measurement) is a command-line application that measures timer latencies and displays results in reports and histograms.
  • KSRTM (Kernel System Response Timer Measurement) is a measurement tool that measures HAL-level timer latencies to the Interrupt Service Routine (ISR) and provides reports and histograms of the results.
  • Latency View is a tool that displays a visual comparison of latency between Windows and RTX64 cores.
  • RtPerfMonitor is a command-line program that displays system information including speed and type of processor running RTX64, HAL type, CPU utilization, and other information that can be used to help measure RTSS application load.
  • Several APIs for profiling across processors, including the following:
  • RtGetThreadTimes retrieves the execution time of a given thread.
  • RtGetProcessTimes retrieves timing information for a given RTSS process.
  • QueryPerformanceCounter and QueryPerformanceFrequency provide accurate time tracing between multiple processors.

Are there limits on the number of threads or objects that can be created in RTX64?

Thread and object creation involves the allocation of several small RTSS structures in addition to the initial space allocated for the thread stack. There are no subsystem limitations on the number of threads. The only limit is the amount of available non-paged memory.

Can my real-time application communicate with a “regular” Windows application?

RTX64 lets Windows and RTSS applications communicate through a number of Inter-Process Communication (IPC) objects. Use the RTAPI functions to create objects that can be viewed and used by Windows processes (32 and 64-bit). Similar to Windows inter-process communication, RTSS and Windows applications create or open handles to named objects or memory regions, allowing simple and standard communication and synchronization between real-time (RTSS) and non-real-time (Windows) applications. Shared memory regions allow Windows and RTSS applications to view the same physical memory without passing additional messages or data between environments.

Standard objects:

  • Event – The event object is a synchronization object. It is useful in sending a signal to a thread, indicating that a particular action has occurred.
  • Mutex – The mutex object is a synchronization object whose state is signaled when it is not owned by any thread and not signaled when the mutex is owned by a thread. The mutex object arbitrates exclusive access to a shared resource.
  • Semaphore – The semaphore object is a synchronization object that maintains a count between zero and a specified maximum value. The count is decreased by one each time a thread completes a wait for the semaphore object; the count is increased by a variable amount at the semaphore release. When the count reaches zero, the semaphore object’s state is no longer signaled and no more threads can complete a wait on the semaphore object until some thread increases the count.
  • Shared Memory – The shared memory object is a region of non-paged physical memory that can be mapped into the virtual address space of a process. When a shared memory object has a name, additional processes may map the region of memory. A shared memory object is accessed with both a handle and a virtual address. In order for a process to completely end its access to a shared memory object it must close any open handles.

How does RTX64 support Plug and Play devices?

RTX64 acquires the resources the device needs from the Windows Plug and Play Manager. To make this possible, a device’s driver must be updated to point to the RTX64 plug and play stub driver. After the device is controlled by RTX64, the device’s resources must be updated to request a unique interrupt that is not already being used by Windows. (Sharing interrupts with Windows would cause determinism to be lost.) Note that a unique interrupt is only needed for devices that use line-based interrupts. Once the device is set up, any RTSS application can access and use the device.

Does RTX64 support Message-based Interrupt (MSI/MSI-X) devices?

RTX64 supports MSI and MSI-X capable devices, providing an alternative to line-based interrupts. This functionality is available on all RTX64 supported operating systems.

How do the RTX64 thread-based priorities relate to the Windows thread priorities?

Windows has a set of 64 priority levels, ranging from 0–63. They are further defined into 4 priority classes, of which the “real-time” priority class is the highest priority class.

The “real-time” priority class, in turn, has 7 levels within the class. RTX64 uses a flat priority scheme of 127 priority levels.

Does RTX64 Support Priority Promotion?

RTX64 provides the option to set one of two priority inversion protocols to handle cases where a higher priority thread is waiting on a mutex held by a lower priority thread:

  • Priority Promotion with Tiered Demotion elevates a low priority thread to the level of the highest priority thread that is waiting for the shared mutex until it has released the mutex requested by a higher priority thread.
  • Disable – Does not elevate priorities in cases where a higher priority thread is waiting on a mutex held by a lower priority thread.

How does RTX64 ensure that Windows does not mask off real-time interrupts?

RTX64 includes a real-time enabled Hardware Abstraction Layer (HAL) extension; this extension does not replace the existing Windows HAL. The extension maintains interrupt isolation between RTSS and Windows. Windows cannot mask (at the interrupt controller level) interrupts managed by RTSS. Windows interrupts are masked on RTSS processors/cores. The real-time HAL extension supports high-resolution clocks and timers for RTSS, while it also supports non real-time clocks and timers for Windows. Other real-time HAL extension features include a software interrupt mechanism between RTSS and Windows, basic exception management, and enhancements for determinism. The HAL timer values can be changed via a predefined value table to as little as 1µs, or can be assigned a custom value using the SDK.

How does RTX64 deal with sharing cache and memory bus with Windows?

RTX64 supports Intel® Resource Director Technology (RDT), which provides a set of resource allocation (or control) capabilities that provide control over how shared resources such as last-level cache (LLC) and memory bandwidth are used by applications. These capabilities include Cache Allocation Technology (CAT) and Memory Bandwidth Allocation (MBA).

As a primary setup for Intel® RDT, RTX64 separates L3/L2 caches space between Windows cores and RTSS cores, thereby removing cache contention from Windows or other system activities. RTX64 sets Windows cores with maximum memory throttle and RTSS cores with zero memory throttle. To further differentiate the performance among the parallel running RTSS threads, RTX64 introduces two RDT modes for CAT and MBA: Flat performance mode and Priority-based CLOS performance mode.

See the RTX64 Help for more information.

What about the Windows “Stop Conditions”?

Windows STOPs, or Bug Checks, are the result of kernel level drivers or operating system components failing safety checks, bringing Windows to a controlled stop. These Windows STOPs are designed to keep data corruption to a minimum and help developers find out what went wrong.

Since the RTSS is able to continue running after Windows issues a STOP, developers can build safe shutdown handling into RTSS applications. RTX64 calls the shutdown handlers when Windows issues a STOP, allowing system real-time components to safely shut down. Once all shutdown handlers finish running, RTX64 lets the Windows shutdown process continue.

If the RTSS determines that Windows needs to be shut down, RTX64 issues a STOP, but instead of displaying the traditional Windows blue screen, RTX64 displays the RTX64 green screen, which contains information about the state of RTX64 at the time of the STOP.

No states are saved when Windows crashes.

FAQs About RTX

The information in this section is up-to-date as of RTX 2016 with Update 3.

What is Real-Time?

Real-time describes an application which requires a response to an event within some small upper bounded time frame. Typically, response times are in the millisecond or microsecond time frame.

What is the difference between “Hard” and “Soft” Real-Time?

Hard real-time requires that a response be logically correct and occur before a certain deadline or the result is incorrect, and holds no value.

Soft real-time requires that a response be logically correct and occur before a certain deadline or the result becomes increasingly inaccurate, meaning the result can still hold some value even though it occurred after the required deadline.

What does determinism mean in a real-time environment?

Determinism is defined as the ability to rationally predict, with a degree of precision, when an event will happen. Determinism, combined with a real-time environment, guarantees that an event will happen within a small response time and that the performance of this event is repeatable.

What is a real-time operating system, or RTOS?

A real-time operating system provides determinism and predictability when it responds to a given event through a specialized scheduler.

Is Microsoft® Windows® a real-time operating system?

Windows is usually referred to as a general-purpose operating system because it does not allow applications or kernel-level drivers to completely mask interrupts and gain control over the operating system. Depending on hardware, interrupt latencies under Windows can exhibit very good values, averaging in the microseconds. However, worst-case interrupt latencies are unbounded and can exceed hundreds of milliseconds. Because of these unbound latencies, deterministic response time is not guaranteed, making standard Windows Desktop and Server operating systems unacceptable for real-time use.

What is RTX?

IntervalZero’s RTX software transforms Microsoft Windows into a Real-Time Operating System (RTOS).

For projects that demand a Windows user experience and require hard real-time or determinism, the RTX RTOS Platform enables OEMs and end users to capitalize on Windows, x86 multi-core multi-processor technology, symmetric multiprocessing (SMP) and real-time Ethernet – all in a single integrated development environment.

  • Reduce bill of materials (BOM) costs by 25-50%
  • Boost quality and performance
  • Scale quickly and shorten product cycle times
  • Significantly reduce reliance on proprietary hardware such as DSPs and MCUs

IntervalZero’s RTX is a proven, reliable technology that has achieved Safety Integrity Level 3 – SIL-3 – certifications in Industrial Automation and FDA Class II certification with numerous medical equipment manufacturers.

What is SMP?

RTX supports Symmetrical Multiprocessor Systems (SMP); a computer architecture that allows operating system tasks and user threads to be scheduled to run on any available processor. With this model, multiple processors can be configured for real-time activities. RTSS threads can be assigned to run on dedicated RTSS processors and they can run concurrently.

When running RTX on an SMP-enabled system, you configure how many of the processors are dedicated to Windows and how many are dedicated to the RTSS. RTX supports SMP systems that have as many as 32 processors. Of those 32, a maximum of 4 can be dedicated to Windows and up to 31 can be dedicated to RTX (dependent upon the edition licensed).

RTX

How does RTX extend Windows to provide “hard” real time?

The overall design of RTX affords developers the “best of both worlds” by providing the ability to use all of the features and technologies that Windows offers, in addition to “hard” real-time behavior within an isolated and controlled subsystem. RTX includes a real-time enabled Hardware Abstraction Layer (HAL) extension that does not replace the windows HAL. This extension maintains interrupt isolation between RTSS and Windows, while providing inter-processors interrupt (IPI) communication between the two. In a shared environment, the HAL provides a real-time subsystem that includes its own scheduler, which allows all RTSS applications to be prioritized ahead of all Windows applications or Windows operating system functionality. In a dedicated environment, the real-time subsystem schedules its RTSS tasks to execute on separate processors, without any interference from the Windows operating system or Windows processes.

What are the benefits of RTX?

The RTX Runtime enables general-purpose Windows processing and high performance real-time processing and control on commercial-off-the-shelf (COTS) machines. The RTX Runtime can be configured to take part in Windows mini-dumps or to take control and safely shutdown real-time processes if Windows encounters a failure.

The RTX SDK provides developers with a rich set of inter-process communication and synchronization capabilities, allowing RTSS applications to communicate with Windows applications and share data with them. Additionally, RTX provides developers with the ability to directly access I/O port address space, physical memory, or hardware without forcing any driver model on the user.

What are the benefits of using RTX on an SMP system?

Using RTX on an SMP system provides significant benefits, including:

  • Performance Boost – You can have multiple processors dedicated to critical, real-time tasks. You can concurrently run up to 31 real-time threads on a 32-processor system.
  • Performance Scalability – Performance scaling doesn’t require code rewrites. You can adjust the real-time and non-real-time performance balance by changing the number of RTSS processors and Windows processors.
  • High Availability – Critical tasks can be scheduled to run on more than one RTSS processor.
  • IRQ Affinity – You can specify a dedicated RTSS processor for processing the input and output of individual pieces of hardware.
  • System Fault Handling – Real-time tasks survive over system crashes.

Can the same application run on any edition of RTX?

The runtime is available in several editions, allowing you to license as many processors as are necessary for your solution. The editions of the RTX product are:

The edition… Includes support for real-time operations on…
Solo One dedicated RTSS processor in a multicore/multiprocessor environment.
Entry Up to two dedicated RTSS processors in a multicore/multiprocessor environment.
Basic Up to three dedicated RTSS processors in a multicore/multiprocessor environment.
Professional Up to seven dedicated RTSS processors in a multicore/multiprocessor environment.
Premium Up to 15 dedicated RTSS processors in a multicore/multiprocessor environment.
Ultimate Up to 31 dedicated RTSS processors in a multicore/multiprocessor environment.

All editions of the runtime include the same features. Applications that are created with the SDK will be able to run on any edition running the same version of RTX. This allows developers the freedom to develop applications that can be scalable.

How long has RTX been around?

The RTX product was released in 1995 to provide a real-time subsystem for Windows NT. RTX has continued to evolve, providing real-time support for all Microsoft professional operating systems. RTX 2016 supports multi-processors running 32-bit Windows 7 and Windows Embedded Standard 7.

What is the current version of RTX?

The current version of RTX is RTX 2016 with Update 3, released in 2019.

What types of industries or products typically use RTX?

RTX is used in a wide variety of products and vertical markets. Anyone designing an application that requires system control, determinism, or real-time performance on Windows can benefit from incorporating RTX into their product design.

RTX is used in some of the following markets:

  • Industrial Automation
  • Digital Audio
  • Test & Measurement
  • Medical
  • Military Aerospace

How is RTX packaged?

IntervalZero provides six editions of the RTX 2016 Runtime product:

The edition… Includes support for real-time operations on…
Solo One dedicated RTSS processor in a multicore/multiprocessor environment.
Entry Up to two dedicated RTSS processors in a multicore/multiprocessor environment.
Basic Up to three dedicated RTSS processors in a multicore/multiprocessor environment.
Professional Up to seven dedicated RTSS processors in a multicore/multiprocessor environment.
Premium Up to 15 dedicated RTSS processors in a multicore/multiprocessor environment.
Ultimate Up to 31 dedicated RTSS processors in a multicore/multiprocessor environment.

Can I incorporate the installation of RTX into my product?

The RTX 2016 Runtime installations come in several varieties:

  • RTX Install – RTX 2016 can be installed silently. The installation can be invoked from the command line or used within your own product installation so as not to require user interaction during the installation process. The RTX Installer can also be added as a Distribution Share component using the Windows Embedded Standard 7 Image Configuration Editor (ICE). The silent installation is licensed through an OEM/Site license and is also available as an evaluation version.
  • Merge Modules for RTX Runtime Features – The RTX 2016 components are available as merge modules that can be included in the installation of an OEM product and is licensed through an OEM/Site license. A separate installation places merge modules on the system for your use. The merge modules are also available as an evaluation version.

For more information, see the RTX Deployment Guide.

What comes with the RTX Runtime?

The RTX Runtime comes with the following functionality:

  • Extends the Windows HAL to support real-time control and isolation of interrupts
  • Scheduler that schedules all RTSS threads ahead of Windows threads in a shared configuration, or across multiple cores in a dedicated configuration
  • Support for communication between Windows applications and RTSS applications
  • Support for communication between Windows kernel drivers and RTSS applications
  • Networking support for socket level communication to and from RTSS processes
  • A control panel that allows you to configure the RTX Subsystem
  • The ability to display RTSS process output to a console window
  • Command-line utilities to control the starting and stopping of RTSS applications
  • Useful tools that display objects and perform application profiling
  • Comprehensive Help files and User Guides

See the RTX vs RTX64 Comparison Guide, available at http://www.intervalzero.com/technical-support/guides-and-minitutorials/ (RTX64 Documentation tab), for information on the differences between RTX and RTX64.

What comes with the RTX SDK?

The RTX SDK comes with the RTX Runtime environment plus the following components:

  • Header files and libraries
  • Visual Studio Support
  • Supported Versions:
  • Visual Studio 2015
  • Visual Studio 2013
  • Microsoft C Runtime support
  • Wizards
  • Real-Time debugger
  • Debugger Data Extension for Microsoft WinDbg
  • Comprehensive Help files and MiniTutorials
  • Source code sample to help explain more advance development topic

How do I activate my copy of RTX?

RTX components must be activated with a valid license before they can be used. You can use the RTX Activation and Configuration utility, which appears immediately after program installation, to activate and lock your product to a specific machine or to an IntervalZero-provided dongle. For information on first activation, see the RTX Install Guide for your product, or see the RTX Deployment Guide.

The method you use to activate your copy of RTX will depend on whether you are connected to the Internet. Videos are available that walk through the process of activating with an Internet connection, and activating without an Internet connection. You can watch the videos at http://www.intervalzero.com/rtx-product-activation/.

Are there any hardware or platform requirements for RTX?

The RTX Runtime runs on any Commercial Off-The-Shelf (COTS) platform that Windows supports. RTX supports mobile processor, multiprocessor, and multi-core platforms. However, because all systems are not the same, developers need to evaluate the latencies of any platform that they choose to ensure that the platform can support their real-time or control needs. You can use RTX with hyper-threaded systems, but it is recommended that you evaluate RTX performance to ensure that real-time requirements are achieved when hyper-threading is enabled.

Does RTX support processor clusters?

RTX can run on systems with up to 32 processors.

  • Systems with eight or fewer processors, which do not have hardware enforced processor clustering, can run with one to seven processors assigned to Windows and the remaining to RTX.
  • Systems with more than eight processors (but not more than 32) or systems with eight or fewer processors which have hardware enforced processor clusters can run in Dedicated (Cluster) mode only. On these systems, a maximum of four processors can be assigned to Windows and up to 31 can be assigned to RTX.

You can assign available processors to Windows or RTX64 through the RTX64 Activation and Configuration utility. The RTX64 Activation utility automatically detects the total number of processors on your system. For more information, see the topic Configuring your System in the RTX Help.

Can RTX be used on a mobile processor system?

RTX can be used on mobile processor systems. However, since mobile processors use Intel’s SpeedStep® technology to lower processor speed during Windows idle time to conserve energy, long latencies can occur when the processor becomes unavailable during the speed change. RTX can eliminate these possible latencies by not allowing processor speed change.

Does RTX support hyper-threading?

RTX can be used on hyper-threading systems. RTX treats the logical processor created by Intel Hyper-Threading as a separate processor, so you can configure RTX for either shared or dedicated multiprocessor support. Because both logical processors share the same physical processor, one logical processor can adversely affect the performance of the other. It is recommended that you evaluate RTX performance to ensure that when hyper-threading is enabled, your real-time requirements are still achieved.

Does RTX support Physical Address Extension (PAE)?

RTX supports PAE for all versions of Windows that support PAE. Prior to RTX 2009 SP1, PAE was only supported on shared configurations. Since RTX relies on Windows to manage memory paging (the translation from virtual address to physical address), RTX cannot access the physical memory ranges for which Windows does not have page table entries. In order to push for 64-bit Windows, 32-bit Windows limits the main physical memory range up to 4GB, even when the system is booted with PAE enabled.

For more information, see the Microsoft article on PAE at http://technet.microsoft.com/en-us/library/cc736309.

Does RTX support Data Execution Prevention (DEP)?

Yes. Data Execution Prevention (DEP) is supported.

Does RTX have any tools to help determine which platform will work best for my real-time requirements?

The RTX SDK includes a tool called Platform Evaluator that allows you to run a number of latency-measuring tests to determine how well platforms meet your real-time and control needs.

What is needed for application deployment?

To deploy your RTSS application, you must purchase an RTX Runtime license for each system on which the application will run. Multiple editions of the RTX Runtime are available, allowing you to license only the number of processors that are necessary for your solution. For more information on deploying RTX, see the RTX Deployment Guide.

Can I run the RTX Runtime installation from within another installation?

IntervalZero provides the option of a silent command line installation for RTX, which allows an OEM to wrap the RTX installation and hide it within another installation. The RTX 2016 Runtime components are also available as merge modules that can be included in the installation of an OEM product. Evaluation versions are also available.

How do I configure my customer’s real-time subsystem?

IntervalZero provides a Properties API that can be used to programmatically configure the RTX Subsystem. This allows customers to set up their software’s subsystem requirements without requiring anything of their end users.

How can I help debug my customer’s issues?

In Visual Studio, RTX provides remote debugging capabilities for RTSS applications with Visual Studio 2015 and Visual Studio 2013.

RTX also provides excellent flexibility for processing exceptions. You can configure RTX to handle exceptions with a structured exception handler; generate a debug break; or stop the process and dump memory.

A tracing API allows developers to create custom trace events that can be included in subsystem traces to help pinpoint problem areas.

RTX can be configured to add active RTSS process information to the Windows minidump file, which can then be analyzed with Microsoft WinDbg. The RTX Debugger Data Extension for WinDbg helps you discover the state of the RTSS and all active RTSS processes at the point of crash, either with live kernel debugging or from a full kernel dump of a customer’s system.

Can I limit the functionality that is available to end users?

Yes. Once RTX has been successfully installed, all authenticated users who log on to the system can control, configure, and run the RTX Subsystem and RTSS applications, even if they are not computer or domain administrators. System administrators can control access to the RTX resources by configuring members of the RTXAdministrators and RTXUsers groups. For more information, see the RTX Install Guide.

How does RTX reduce development time?

Because RTX extends Windows, there is no need to spend time designing and developing an operating system before application development work even begins. RTX developers can create user interfaces and applications that take advantage of all the functionality that Windows offers; developers need to focus only on the real-time control pieces required to run an RTSS application. Even components that require real-time control can first be developed as a Windows application and then recompiled as an RTSS application with no code changes.

Since all real-time API (RTAPI) calls are Win32 compliant, developers use calls they already know and understand. There is no need to write driver code or follow a strict driver model to configure and use devices.

Is RTX 2016 compatible with previously built RTSS applications?

RTX 2016 is binary compatible with RTX 2012 with Update 1 and above.

Do I need special development and debugging tools to develop RTSS applications?

No. RTSS applications are developed with Microsoft Visual Studio. The RTX SDK provides wizards for easy project creation and templates to help you to get started. A Visual Studio Debugger add-in lets you debug RTSS applications in a familiar environment. RTX supports Visual Studio 2015 and Visual Studio 2013.

Because RTSS applications run in kernel mode, they can also be debugged with a kernel-level debugger such as Microsoft WinDbg. The RTX SDK includes an RTX Debugger Data Extension for WinDbg that allows you to view active RTSS processes and objects.

Can I use Win32 API calls or are all RTX calls proprietary?

RTX supports a subset of over 50 Win32 API calls that make sense in a real-time environment.

In addition, RTX provides a large selection of real-time API calls that developers use to access the RTSS and system resources. This real-time API (RTAPI) is composed of a set of unique API calls and Win32-based API calls.

The unique real-time API calls are Win32 modeled calls that provide essential programming capabilities required for real-time applications, along with access to the RTSS and system resources. These unique RTAPI calls have no equivalent Win32 calls.

The Win32-based API calls that are supported by RTX are unlike the RTAPI in that there are similar functions in the Win32 environment; however, these calls require a different implementation than their Win32 counterparts to support the real-time requirements of the RTSS. All the Win32-based calls are compatible with Win32 programming interface semantics, making it easy for developers already familiar with the Windows Win32 API.

How can I take advantage of user-mode memory protection during development?

RTX was designed so that developers could design and develop applications as RTSS or Win32 applications. If built as Win32, developers can take advantage of features like user-mode memory protection and other third-party debugging tools specific to user mode applications. After an application is working as desired, recompile it as an RTSS application which runs in kernel mode with no code changes required.

Does RTX support Structured Exception Handling?

Unlike other applications that run in kernel mode, RTSS applications support structured exception handling. RTX lets developers call structured exception handling functions such as try, catch, and throw within their RTSS application. For example, if an application references a NULL pointer, the application can handle the error by terminating or freezing the application that caused the fault without bringing down the system.

Can I use the Microsoft development libraries and technologies such as C Runtime in my RTX applications?

RTX supports a subset of Microsoft C Runtime calls that you can call from your RTSS application. RTX provides C Runtime Support for Visual Studio 2015 and Visual Studio 2013.

Can I assign multiple IP addresses to a single NIC?

RTX 8.1 and later support “virtual” IPv4 addresses. You can assign up to 32 virtual IP addresses to a single NIC.

Does RTX support SSE and AVX?

Yes. RTX supports and saves state information for AVX/AVX2 (YMM/YMM8), SSE (SSE/SSE2/SSE3/SSE4), and MMX registers, as long as the hardware supports it.

Do I need to use a kernel debugger to debug my RTSS application?

A kernel debugger is not necessary to debug an RTSS application. The RTX SDK includes Visual Studio debugger add-ins that let developers debug real-time or control applications that run in kernel mode from within the familiar Visual Studio development environment. The debugger add-ins for Visual Studio 2015 and Visual Studio 2013 also support remote debugging so developers can remotely debug an RTSS application on a target system that has special hardware requirements.

However, if you prefer using Microsoft’s WinDbg, the RTX SDK provides symbols to help with the debugging of your RTSS application, along with a Debugger Data Extension which allows users to view information about active RTSS processes, threads, and objects. Note that WinDbg cannot be used on dedicated configurations to break in and step through code.

Are any tracing tools available?

The RTX SDK provides a tool called TimeView that lets you set up a system trace. These system traces time stamp and log a configurable set of system and process events, allowing developers to trace the behavior of their real-time application with minimal impact on their system’s real-time performance. The RTAPI also provides instrument tracing functionality within RTSS application.

Does RTX provide any sample code?

The RTX SDK includes a complete API reference guide for all supported functions in addition to small code segments that explain more complex concepts.

The RTX SDK also provides source code for a number of sample applications, some of which are the RTX measurement tools. These samples can be compiled and run, and show important concepts and application interaction.

Are any measurement tools available?

RTX provides a number of tools and APIs that help developers measure system response and timer latency:

  • SRTM (System Response Timer Measurement) – A command-line application that measures timer latencies and displays results in reports and histograms.
  • KSRTM (Kernel System Response Timer Measurement) – A driver and a Win32 utility that measures HAL-level timer latencies and displays results in reports and histograms.
  • RTX Demo – A graphic version of SRTM that displays timer latencies.
  • PerformanceView – A graphical utility that shows CPU utilization by real-time applications, Windows processes, and system idle time. PerformanceView also displays the maximum amount of time RTX has held the CPU on shared systems.
  • ObjectViewer – A graphical utility that displays information for all active objects in the RTSS environment, including thread creation date/time and duration.
  • Several APIs for profiling across processors, including the following:
    • RtGetThreadTimes retrieves the execution time of a given thread.
    • QueryPerformanceCounter and QueryPerformanceFrequency provide accurate time tracing between multiple processors.

Are there limits on the number of threads or objects that can be created in RTX?

Thread and object creation involves the allocation of several small RTSS structures in addition to the initial space allocated for the thread stack. There are no subsystem limitations on the number of threads. The only limit is the amount of available non-paged memory.

Can my real-time application communicate with a “regular” Windows application?

RTX lets Win32 and RTSS applications communicate through a number of Inter-Process Communication (IPC) objects. Use the RTAPIs to create objects that can be viewed and used by Windows processes. Similar to Windows inter-process communication, RTSS and Windows applications create or open handles to named objects or memory regions, allowing simple and standard communication and synchronization between real-time (RTSS) and non-real-time (Windows) applications. Shared memory regions allow Windows and RTSS applications to view the same physical memory without passing additional messages or data between environments.

Standard objects:

  • Event – The event object is a synchronization object. It is useful in sending a signal to a thread, indicating that a particular action has occurred.
  • Mutex – The mutex object is a synchronization object whose state is signaled when it is not owned by any thread and not signaled when the mutex is owned by a thread. The mutex object arbitrates exclusive access to a shared resource.
  • Semaphore – The semaphore object is a synchronization object that maintains a count between zero and a specified maximum value. The count is decreased by one each time a thread completes a wait for the semaphore object; the count is increased by a variable amount at the semaphore release. When the count reaches zero, the semaphore object’s state is no longer signaled and no more threads can complete a wait on the semaphore object until some thread increases the count.
  • Shared Memory – The shared memory object is a region of non-paged physical memory that can be mapped into the virtual address space of a process. When a shared memory object has a name, additional processes may map the region of memory. A shared memory object is accessed with both a handle and a virtual address. In order for a process to completely end its access to a shared memory object it must close any open handles.

Can a Windows driver communicate with my real-time application?

RTX provides a set of real-time Kernel API (RTKAPI) calls that allow Windows drivers to access RTX inter-process communication objects from within a Windows kernel device driver. These RTKAPI calls are analogous to their RTAPI counterparts. For example, RtkOpenSemaphore is analogous to RtOpenSemaphore.

The RTKAPI functions and the RTAPI functions are used in the same way, but RTKAPI functions are used exclusively in the Windows kernel environment.

How does RTX support Plug and Play devices?

RTX acquires the resources the device needs from the Windows Plug and Play Manager. To make this possible, a device’s driver must be updated to point to the RTX plug and play stub driver. After the device is controlled by RTX, the device’s resources must be updated to request a unique interrupt that is not already being used by Windows. (Sharing interrupts with Windows would cause determinism to be lost.) Once the device is set up, any RTSS application can access and use the device.

Does RTX support Message-based Interrupt (MSI/MSI-X) devices?

RTX 8.1 and later support MSI and MSI-X capable devices, providing an alternative to line-based interrupts. This functionality is available on all RTX supported operating systems.

How do the RTX thread-based priorities relate to the Windows thread priorities?

Windows has a set of 32 priority levels, ranging from 0 – 31. They are further defined into 4 priority classes, of which the “real-time” priority class is the highest priority class.

The “real-time” priority class, in turn, has 7 levels within the class. RTX uses a flat priority scheme of 127 priority levels. When there are any RTX tasks or RTX threads that are ready to run, RTX will gain total control of the system resources, regardless of what priority level a Windows thread may be granted.

All RTX priorities are higher than the highest Windows priorities.

The one case where the Windows priority scheme is relative to the RTX scheme is when an RTX application is compiled as a Win32 application and not as a RTSS application. In this case, RTX priority levels are mapped to Windows priority levels. These mappings are fixed and designed to preserve relative ordering among thread priorities.

Does RTX Support Priority Promotion?

RTX provides the option to set one of three priority inversion protocols to handle cases where a higher priority thread is waiting on a mutex held by a lower priority thread:

  • Priority Promotion with Tiered Demotion elevates a low priority thread to the level of the highest priority thread that is waiting for the shared mutex until it has released the mutex requested by a higher priority thread.
  • Priority Promotion with Limited Demotion – Elevates a low priority thread to the level of the highest priority thread that is waiting for the shared mutex until it has released all mutexes that it owns
  • Disable – Does not elevate priorities in cases where a higher priority thread is waiting on a mutex held by a lower priority thread.

How does RTX ensure that Windows does not mask off real-time interrupts?

RTX includes a real-time enabled Hardware Abstraction Layer (HAL) extension; this extension does not replace the existing Windows HAL. The extension maintains interrupt isolation between RTSS and Windows. Windows cannot mask (at the interrupt controller level) interrupts managed by RTSS. Windows interrupts are masked during RTSS processing. The real-time HAL extension supports high-resolution clocks and timers for RTSS, while it also supports non real-time clocks and timers for Windows. Other real-time HAL extension features include a software interrupt mechanism between RTSS and Windows, basic exception management, and enhancements for determinism. The HAL timer values can be changed via a predefined value table to as little as 1µs, or can be assigned a custom value using the SDK.

What about the Windows “Stop Conditions”?

Windows STOPs, or Bug Checks, are the result of kernel level drivers or operating system components failing safety checks, bringing Windows to a controlled stop. These Windows STOPs are designed to keep data corruption to a minimum and help developers find out what went wrong.

Since the RTSS is able to continue running after Windows issues a STOP, developers can build safe shutdown handling into RTSS applications. RTX calls the shutdown handlers when Windows issues a STOP, allowing system real-time components to safely shut down. Once all shutdown handlers finish running, RTX lets the Windows shutdown process continue.

If the RTSS determines that Windows needs to be shut down, RTX issues a STOP, but instead of displaying the traditional Windows blue screen, RTX displays the RTX green screen, which contains information about the state of RTX at the time of the STOP.

No states are saved when Windows crashes.