|
 |
|||||||
| ThreadX® Real-Time Operating System |  |
||||||
|
|||||||
| List of Features | |||||||
|
| ||||||
| Fast Real-time Response | |||||||
ThreadX provides fast real-time response for the most demanding embedded applications:
LOW INTERRUPT LATENCY ThreadX is optimized to provide extremely fast interrupt response, on the order of 0.5us on a 200MHz PowerPC. FAST CONTEXT SWITCH The picokernel architecture of ThreadX enables extremely rapid context switching on the order of 1.7us on a 40MHz ARM7 processor. PREEMPTION-THRESHOLD™ ThreadX's preemption-threshold technology is a completely unique addition to the priority based, preemptive scheduling model. Preemptionthreshold allows the application to disable preemption over ranges of priorities instead of disabling preemption of the entire system. Applications can take advantage of this to reduce the number of context switches, eliminate un-deterministic priority inversion, and to create priority classes that execute in a non-preempted fashion. PRIORITY INHERITANCE In addition to using preemptionthreshold to battle un-deterministic priority inversion, ThreadX Version 4 provides optional priority inheritance with its new TX_MUTEX object. FLEXIBLE MEMORY UTILIZATION ThreadX is designed for complete flexibility. Control blocks and memory areas associated with thread stacks, mutexes, message queues, and memory pools can easily be created in any address space of your hardware. For example, ThreadX makes it easy to boost the performance of a highpriority thread by placing its stack in a fast memory area. Equally important, this can be done at run-time based upon your startup code detecting its configuration. DYNAMIC RESOURCE CREATION ThreadX allows you to create system resources dynamically. This is especially important if your application has multiple or dynamic configuration requirements. In addition, there are no predetermined limits on the number of ThreadX resources you can use. The number of system objects does not have any impact on performance. HYBRID KERNEL OBJECTS ThreadX enables you to incorporate control blocks and services into your hybrid services. For example, a service that allows threads to feed from multiple message queues can easily be created by combining message queues with a counting semaphore. SOFTWARE TIMERS ThreadX allows an unlimited number of software timers. Timers operate in either a one-shot or periodic manner. ThreadX software timers are kept in an ordered list of expiration without performing a linear search on each timer activation or timer interrupt condition. This greatly reduces the amount of overhead in timer-centric applications like communication and process control. EVENT FLAGS ThreadX offers 32-bit event flags for application synchronization. In addition, ThreadX provides the ability to automatically clear events during retrieval. COUNTING SEMAPHORES ThreadX provides highly optimized 32-bit counting semaphores that can be used for resource management or input notification. MEMORY ALLOCATION ThreadX provides fast and deterministic block memory allocation as well as traditional heap-like memory allocation. OSEK ThreadX conforms to OSEK/VDX specifications in its implementation of conformance classes, OSEK COM, CAN, and API. ThreadX provides a royalty-free hard real-time RTOS that is ideal for embedded applications in automotive electronics. | |||||||
| ThreadX Kernel Awareness | |||||||
MULTI for ThreadX is fully aware of all seven ThreadX kernel components. MULTI displays live easy-to-understand summary lists and detailed individual views of all ThreadX components:
SYSTEM-LEVEL DEBUGGING MULTI's kernel awareness allows developers to continually observe the status of all threads and other kernel components in a system. Each view is fully customized for the ThreadX kernel and includes a detailed help screen explaining the meaning of each field and how it was derived from the underlying ThreadX data structures to help developers gain familiarity with the internal workings of the ThreadX kernel. Thread information windows, for example, show a thread's current execution state: Ready, Executing, Suspended, Completed, or Terminated. For suspended threads, MULTI provides additional helpful information. In that case, the thread information window shows exactly why the thread is suspended and what specific kernel component is responsible. THREAD-SPECIFIC DEBUGGING MULTI can debug a specific thread by setting thread-specific break-points so that all other threads will continue past the breakpoint. This capability allows the user to debug a single thread even when it uses code that is common to other threads. ADVANCED STACK CHECKING MULTI can detect stack overflow. MULTI's enhanced stack checking and monitoring features provide unprecedented ease-of-use. In all thread views, a stack use indicator shows how much stack is currently in use by that thread. This information identifies threads that are using more stack space than anticipated, ideally before problems occur. Then stack sizes can be adjusted to guard against overflow. MULTI for ThreadX provides optional stack checking to ensure that thread stack sizes are appropriate. Users can check stack use for a single thread or for all threads. In either case, a window displays the peak stack usage as determined by the highest point in the stack that was changed since the thread was created. MEMORY ANALYSIS MULTI for ThreadX contains enhanced views of memory block pools and byte pools intended specifically to help developers find problems with dynamic memory allocation. A single click from a memory pool window brings up a view of all memory blocks or fragments together with their location in memory, their current state and, for byte pool fragments, their size. RUN-MODE DEBUGGING Run-mode Debugging simplifies the design of sophisticated multithreaded applications by enabling designers to debug those applications on a thread-by-thread basis while the application continues to run. Traditional debugging approaches like BDM (background mode debugging) and JTAG generally require that programmers halt their system and stop all threads before they can examine any particular data or thread. Run-mode debugging provides a better gauge of realworld system behavior by enabling programmers to halt and examine specific threads in their system while the remaining threads continue to run. Each time a thread hits a breakpoint, MULTI halts that thread and opens a source code debug window specific to that thread. Programmers can then single-step or browse through the halted thread and read memory and registers, all without disrupting program execution. |
|||||||
| EventAnalyzer™ for ThreadX® | |||||||
| The EventAnalyzer™ for ThreadX® is a powerful tool that enables programmers to understand the complex real-time interactions of their system. Some problems simply cannot be detected with standard debugging techniques. All desired system and user-defined application events can be logged and graphically displayed for easy analysis in the EventAnalyzer GUI. POWERFUL ANALYSIS The EventAnalyzer GUI operates like a high-level logic analyzer. All context switching, thread state changes, ThreadX API calls, and interrupts are logged on the target in real-time. This data is transferred to the host where it is displayed graphically. Enabling and disabling event logging, selecting which events to track, and determining the size of target event buffers is fully controllable by the user. The EventAnalyzer also provides various navigation capabilities that allow the user to zoom into certain areas for greater detail, or alternatively, zoom out to see the big picture, search, hide or display various events, and change the look and feel of task status lines and event icons. LOW INTRUSIVENESS The real-time event information is captured by the high-performance ThreadX kernel in the least intrusivemanner possible. When event logging is enabled, small macros are inserted directly into the core ThreadX services that are responsible for entering the associated event in the event log. This approach leads to the absolute least intrusiveness possible. USER DEFINED EVENTS Users can insert code into their applications to generate logged events. This can be very useful since the user can locate important points in their code and log events that help understand the system better. Also, extra data can be logged such as the values of particular variables. EASY EVENT POOL CONFIGURATION ThreadX stores the real-time event information in a circular buffer whose starting address and size are defined inside the user's link control file. Changing the location or size of the event log is easy. | |||||||
| Integrated Networking | |||||||
|
NetX NetX is is a complete TCP/IP stack designed for speed! From its Piconet™ architecture to the zero-copy API, the entire design around NetX is all about packet processing speed. Under NetX, packet processing is extremely fast. PICONET ARCHITECTURE Piconet Architecture is one that is first and foremost designed for deeply embedded applications with minimal internal function call overhead. Many TCP/IP implementations have a considerable number of function calls sprinkled throughout the packet processing path. Although this might be fine for workstation software, it is not acceptable for performance critical embedded applications. Piconet also means that the entire stack software must be loosely coupled so that only those portions the application uses are brought into the final image. NETX PROTOCOL COMPONENTS NetX is a powerful and lean TCP/IP product. Version 2.0 contains support for basic IP, ICMP, ARP, RARP, UDP, IGMP and TCP protocols. ZERO-COPY API NetX provides zero copy TCP/IP communications to eliminate moving data to and from user buffers. This results in very high-performance and frees cycles back to the application that would otherwise be spent performing meaningless data movements. FLEXIBLE PACKET POOL MANAGEMENT The application may create any number of packet pools in any number of memory areas in the system. These zero-copy packets can be linked with packets from the same pool or even a different pool. A packet can even be created inside of a global C data structure. In addition, calling threads may suspend (with optional timeout) on packet allocation. UDP FAST PATH TECHNOLOGY™ Basic UDP packets that are not fragmented at the IP level pass through NetX without any data copying and without any system context switches. Many commercial network stacks process packets received within a system thread thereby adding a context switch to the packet overhead. In NetX simple UDP packets are delivered directly to the thread suspended waiting for a packet on a specified UDP port. DYNAMIC CREATION NetX allows creation of system resources dynamically. This is especially important if the application has multiple or dynamic configuration requirements. In addition, there are no predetermined limits on the number of NetX resources that can used. | |||||||
| FileX | |||||||
|
FileX provides complete MS-DOS
format media and file management for deeply embedded applications. MULTIPLE MEDIA MANAGEMENT FileX is able to support an unlimited number of physical media. Each media instance has its own distinct memory area and associated driver specified on the tx_media_open API call. LOGICAL SECTOR CACHE FileX maintains an n-deep logical sector cache for each opened media. The depth of the logical sector cache is determined by the amount of memory supplied to FileX with the tx_media_open API call. By reducing the number of whole sector transfers - both to and from the media - the FileX logical sector cache significantly improves performance. CONTIGUOUS FILE SUPPORT In order to improve and make file access time more deterministic, FileX offers contiguous file support though the API service tx_file_allocate. This routine takes looks for a series of adjacent clusters to satisfy the request. DYNAMIC CREATION FileX allows creation of system resources dynamically. This is especially important if the application has multiple or dynamic configuration requirements. In addition, there are no predetermined limits on the number of FileX resources that can be used (media or files). EASY TO INTEGRATE FileX is easily integrated with virtually any FLASH or Media device. Porting FileX is very simple. | |||||||
| Rational Rose® RealTime Integration | |||||||
| ThreadX has been integrated with the Rational Rose® RealTime UML system modeling package. With Rational Rose RealTime, designers can build applications in UML, debug them at the source code level with MULTI, and then run them on ThreadX targets. MULTI fully supports debugging at both the UML and C source code levels simultaneously, fully synchronized for developer flexibility. Rational Rose RealTime's Target Adaptation Layer, available from Green Hills Software, makes it easy to incorporate ThreadX with UML system development. |
|||||||
| Graphics | |||||||
 ThreadX provides extensive support for embedded graphics development through the Portable Embedded Graphics development tools, PEG. PEG consists of a C++ based library and device drivers that make it simple to include powerful graphics in embedded real-time applications. PEG applications can be run in either virtual address spaces or in kernel space, and resides in less than 100KB. It is small, fast and royalty-free, yet powerful enough for advanced real-time graphics needs. |
|||||||
| CORBA ORBs | |||||||
Green Hills Software provides a family of CORBA® ORBs™, Testing Tools, CORBA Services, Training, Consulting Services, and complementary products for use with ThreadX. These products help to develop a robust, scalable and solid communication infrastructure for both your real-time embedded products and for your enterprise applications. ORBexpress™ is the smallest and fastest Object Request Broker® in the world. ORBexpress's unique component architecture, based on over 10 years of successfully fielded applications, enables embedded system engineers to deliver solid products, on schedule, with predictable behavior. With the highest achievable performance and throughput, ORBexpress is suitable for any system with stringent performance requirements. Green Hills provides the following ORBexpress products:
|
|||||||
| Communications Protocols | |||||||
| Green Hills Software provides a total solution that enables embedded system developers to add communications, networking and web management to their designs. These products were developed from the ground up to address the needs of embedded designers. Not only are they complete from a features standpoint, but these products also have minimal system and memory requirements and were designed with portability in mind. |
|||||||
| Web Management and Configuration | |||||||
|
|
|||||||
|
» Back to ThreadX RTOS » RTOS » MULTI IDE » AdaMULTI IDE » Compilers » Communications Software » Custom Development |
|||||||
 |
|
 |
