- Small-footprint (small as 2KB, automatic scaling)
- Fast execution (sub microsecond context switch)
- Supports all popular processors and tools (see below)
- TraceX system analysis support
- Advanced Technology:
- Event Chaining™
- Performance Metrics
- Execution Profiling
- Run-time and Static Stack Analysis
- Multicore Support (SMP and AMP)
- Downloadable Application Modules
- Memory Protection for Downloadable Application Modules
- Extensive ThreadX ecosystem
- Safety Certifications (DO-178B, FDA510(k), IEC61508, etc)
- Deployed in over 1,000,000,000 devices
- Full Source Code
- Critical Link MityDSP/MityARM
- Energy Micro EFM32
- Fujitsu FM3
- Hitachi H8/300H
- Infineon XMC
- Microchip PIC24/dsPIC
- Microchip PIC32
- Nios II
- Power Architecture
- Renesas RX
- Renesas SH
- Renesas V8xx
- ST Microelectronics STM32
- Synopsys ARC
- TI ARM
- TI MSP430
- Univers A2P
- Xilinx ARM
ThreadX is Field Proven!
ThreadX is Express Logic's advanced Real-Time Operating System (RTOS) designed specifically for deeply embedded applications. ThreadX provides advanced scheduling facilities, message passing, interrupt management, and messaging services, as well as many others. ThreadX has many advanced features, including its picokernel™ architecture, preemption-threshold™ scheduling, event-chaining,™ and a rich set of system services. Combined with its superior ease-of-use, ThreadX is the ideal choice for the most demanding of embedded applications. ThreadX has been deployed in over 1.5 billion electronic products in the areas of consumer devices, medical electronics, and industrial control equipment.
ThreadX is implemented as a C library. Only the features used by the application are brought into the final image. The minimal footprint of ThreadX is under 2KB on Microcontrollers.
Minimal Kernel Size: Under 2K bytes Queue Services: 900 bytes Semaphore Services: 450 bytes Mutex Services: 1200 bytes Block Memory Services: 550 bytes Minimal RAM requirement: 500 bytes Minimal ROM requirement: 2K bytes
* Measurements based on ThreadX V5.1, configured for minimal size
ThreadX helps your application respond to external events faster than ever before. ThreadX is also deterministic. A high priority thread starts responding to an external event on the order of the time it takes to perform a highly optimized ThreadX context switch.
Boot Time: 300 cycles Context Switch Time: <100 cycles Semaphore Get: 30 cycles
* timing based on ThreadX V5.1, configured for maximum performance and minimal size.
Instant OnThreadX requires as little as 300 cycles to initialize and start scheduling application threads. This is hugely important for consumer and medical devices that simply can't afford a long boot time.
ThreadX Safety-Critical Certification Pack - Click Here for More InformationThe ThreadX Certification Pack™ is a 100% complete, turnkey, industry-specific, stand-alone package that provides ALL of the ThreadX evidence needed to certify or successfully submit the ThreadX based product to the highest reliability and criticality levels required for safety-critical Aviation, Medical, and Industrial systems. Certifications supported include DO-178B, ED-12B, DO-278, FDA510(k), IEC-62304, IEC-60601, ISO-14971, UL-1998, IEC-61508, CENELEC EN50128, BS50128, and 49CFR236. Please click on this heading for more information on certification.
Easy To Use
ThreadX is very easy to use. The ThreadX API is both intuitive and highly functional. In addition, the API names are made of real words and not the “alphabet soup” names that are common to other RTOS products. Building a ThreadX application is also easy. Simply include the TX_API.H file in the application software and link the application objects with the ThreadX library. The resulting image is ready for execution – it’s that simple!
ThreadX also boasts the very best documentation. Please review our ThreadX User Guide and see for yourself!
ThreadX is delivered with complete C and assembly source code so you can see exactly how ThreadX operates. If you are used to in-house kernels or had bad experiences with “black box” commercial RTOS products, this should be most comforting.
Complete Multitasking Facilities
ThreadX provides a complete set of multitasking facilities, including:
Threads Application Timers Message Queues Counting Semaphores Mutexes Event Flags Block Memory Pools Byte Memory Pools
The following are highlights of the advanced technology in ThreadX:
Small, fast picokernel™ architecture Dynamically Downloadable Application Modules Memory Protection for Downloadable Modules Automatic scaling (small footprint) Deterministic processing Fast real-time performance Preemptive and cooperative scheduling Flexible thread priority support (32 - 1024 priority levels) Dynamic system object creation Unlimited number of system objects Optimized interrupt handling Preemption-threshold™ Priority inheritance Event-chaining™ Fast software timers Flexible memory utilization Run-time performance metrics Run-time stack analysis Built-in system trace Execution Profiling Vast processor support Vast development tool support Completely endian neutral
ThreadX allows you to create system resources dynamically. There are no predetermined limits on the number of ThreadX resources you can use. Furthermore, the number of system objects does not have any impact on performance.
Downloadable, Memory-Protected Application Modules
Downloadable, memory-protected application modules enable ThreadX-based applications to dynamically load and run additional application threads beyond those linked with the ThreadX kernel, in a secure form, unable to corrupt other threads or the kernel. Applications gain increased functionality without the cost of an increased footprint or additional memory. This technique also provides on-demand reconfiguration and application updates for deployed systems. The ThreadX Downloadable Application Module technology ideally suits situations where application code size exceeds available memory, when new modules need to be added after a product is deployed, or when partial firmware updates are required. Click the menu link above for more information.
Express Logic's innovative Preemption-Threshold technology has been the subject of many white papers, both commercial and academic. Here are several to choose from:
White paper containing an overview of Express Logic's technique of reducing context switches. Overview of Preemption-Threshold Wang, Concordia University, and Saksena, University of Pittsburgh, on Scheduling Fixed-Priority Tasks with Preemption Threshold http://www.cs.utah.edu/~regehr/reading/open_papers/preempt_thresh.pdf R. Ghattas and A. G. Dean. Preemption threshold scheduling: Stack optimality, enhancements and analysis. In RTAS ’07: Proc. of the 13th IEEE Real Time and Embedded Technology and Applications Symposium, 2007. 2007_Preemption-Threshold_Scheduling_Ghattas_and_Dean.pdf G. Yao and G. Buttazzo, Reducing Stack with Intra-Task Threshold Priorities in Real-Time Systems, Proc. of the 10th Int. Conf. on Embedded Software, 2010. 2010_10_PTS_paper_by_Yao_and_Buttazzo.pdf
Another tool for battling un-deterministic priority inversion is the priority inheritance feature found in the ThreadX Mutex object.
ThreadX’s event-chaining technology allows the application to "chain together" various system objects. With the ThreadX event-chaining technology it is very easy for a single thread to block on any number and/or type of system objects. For example, it is very easy for a single thread to suspend waiting for activity on any number of queues, semaphores, etc. Hence, complex system events are much easier to manage and by using less threads - saving both space and CPU cycles. For a brief tutorial on Event Chaining, click HERE
Fast Software Timers
ThreadX application timers are available in one-shot or periodic operation. ThreadX manages activation and expiration without linear searching. This greatly reduces the amount of overhead in timer-centric applications like communications and process control.
Flexible Memory Utilization
ThreadX control blocks and memory areas associated with thread stacks, message queues, and memory pools can be easily located (during run-time) in any address space on your hardware. For example, ThreadX makes it easy to boost the performance of a high-priority thread by placing its stack in a fast memory area.
Run-time Performance Metrics
ThreadX provides optional run-time performance information. This information is available on a per-object basis as well as over an entire object class. For example, if performance information is enabled for thread objects, ThreadX keeps track of thread resumptions, suspensions, preemptions, priority inversions, time-slices, timeouts, and much more for each thread and for all threads collectively. This kind of information is essential for tuning an application as well as helping debug various problems like thread starvation.
Run-time Stack Analysis
ThreadX provides optional run-time stack analysis. If enabled, the ThreadX run-time stack analysis examines thread stack parameters before the thread is scheduled, which helps avoid going off into the weeds caused by typical stack overflow situations. In addition, ThreadX run-time stack analysis keeps track of the stack usage of each thread, which can then be used to tune the thread stack requirements. To learn more, and to find out about other stack analysis tools from Express Logic, please click HERE
Execution Profile Kit (EPK)The ThreadX Execution Profile Kit (EPK) provides an infrastructure for applications to dynamically track execution time for threads, Interrupt Service Routines (ISRs), and idle system conditions. This is especially useful for optimization and tuning the application for maximum performance. However, it is also a valuable debug aid. The EPK relies on "hooks" built into the ThreadX scheduling logic in assembly code that are called on thread entry, thread exit, ISR entry, and ISR exit. The EPK routines calculate the time in between such events and store the delta time in global variables as well as members of the TX_THREAD control block. Please contact your Express Logic representative for more information or to obtain the EPK for your ThreadX application.
Dedicated ISR Stack
ThreadX utilizes a dedicated stack for all ISR processing, thus keeping the thread stack requirements as small as possible.
Built-in System Trace
ThreadX provides an optional system trace capability, designed to be used with our TraceX graphical event-analysis tool. If EVENT_TRACE is enabled, ThreadX stores event information in a circular buffer that can be viewed with TraceX. The size, location, and contents of the trace are under complete application control. The application can also insert custom events into the trace buffer by simply calling an API service. Click HEREto learn about TraceX.
Vast Processor Support
ThreadX currently supports most popular CISC, RISC, and DSP processors. Because of its portable design, ThreadX can be ported to an entirely new processor family within four weeks. Both of these facts help ensure your product's migration path.
Vast Development Tool Support
ThreadX currently supports most of the popular development tools on each processor supported. In addition, ThreadX kernel awareness is available for most popular debuggers, including ARM RealView, Wind River Workbench, IAR C-SPY, Freescale CodeWarrior, Microchip MPLAB, Renesas HEW, Lauterbach TRACE32, Analog VisualDSP, and GHS MULTI.
Express Logic Gets You to Market First
Express Logic products are designed for ease-of-use. Everything from well thought out APIs to simple startup procedures help you get up and running in a matter of hours! This coupled with advanced debugger integration, make our products the easy choice to win the race to market.