/>
At many times in the course of developing an application, the developer needs to understand exactly what is happening inside the system. There are complex interactions among tasks, interrupt service routines (ISRs), and other kernel objects such as message queues, mutexes and semaphores. These interactions must often occur within certain time constraints in order to meet timing requirements related to safety or system performance. In systems built around a modern real-time operating system (RTOS), where the processor context is being changed every few hundred microseconds, one may need to know, “What actor was in control of the CPU at a given time?” “What action was taken?” “When did it occur, and why?”



Such things are often very difficult to figure out from studying the code alone. Debuggers are not particularly effective in analyzing such problems in a debug session because a debugger does not address the problems at the desired level. The rough timing of a problem’s appearance is often known but why something goes wrong at that time is what has to be determined. In the end, the developer is left with that age-old recourse of designing and developing test cases that isolate the problem into a repeatable situation. Only then are the questions of who, what, when and why answerable. The result is a lot of extra time and expense focused on problem resolution and can be a major factor in the increasing cost of software development.



Other system concerns include performance issues such as system responsiveness or throughput. The system can be optimized if the developer can successfully manage the relative timing between tasks. Yet this is simply a trial-and-error exercise if there is no way to understand moment by moment system behavior.



The Solution



RTXCview allows the developer to study the detailed runtime behavior of the system as it actually occurred, even in real production code settings RTXCview addresses the questions of who, what, when and why by presenting the runtime information in a unique, highly efficient manner. Traditional runtime viewers show time in the horizontal axis and code entities vertically, similar to a Gantt chart. In systems with only a few tasks and ISRs, the user can spend a lot of time just moving the visible part of the presentation to see what code entity is actually active and for how long.



RTXCview shows everything on a scalable timeline using the vertical axis, allowing the user to zoom in and out to get a different look to address the question of when. The unique presentation allows for zooming in on details, down to microseconds, but also gives a good overview when zooming out over several seconds. The question of who can be easily determined because tasks, threads and interrupt service routines are clearly shown in color-coded sections along the timeline when they are in control of the CPU. Color coding the entities eliminates the need to move focus all over the screen just to locate an actor. In addition, the presentation method also shows the level of interference from higher priority entities, a very important schedulability consideration usually beyond the capability of the traditional runtime viewer.



RTXCview addresses the question of what by showing the timing of kernel services issued by the task, thread and ISR actors. And again, the scalable timeline allows zooming in and out for less or greater detail of this information. The result is a clear understanding of how much time is used for each operation and how these operations (or actors) relate to other operations in frequency, order and timing.



Upon seeing all the information addressing the questions about who, when and what, the answer to why usually becomes clear, leading to a rapid resolution of the issue in question.



The Package



The RTXCview product consists of two parts: a recorder in the RTXC kernel that runs on the target processor and logs system and user events in the target RAM, and a viewer―the RTXCview tool that runs on a host PC.



Instrumentation code in the RTXC kernel service APIs and other important places in the kernel invoke the recorder to store data. The recorder uses a ring buffer to store system data on a continuous basis but the developer can make decisions on when to begin recording and what data to capture so that the trace file is focused on the problem area.



The viewer component of RTXCview presents a unique visualization display to look at the performance of the system over time. And there are other views that show statistical information about processor usage, system loading, execution time and even response time on an entity by entity basis. An example is shown in the screenshot in the top-right area labeled “Actor Information”.



Even though the recorder might collect the user’s selected set of data, the user might choose to present only a subset of that data, thereby simplifying the presentation area of interest. Selection of the displayed classes or objects is under full user control.



RTXCview is available in two versions: a Basic Edition, offering standard features and a Professional Edition, for advanced users who want to “tune” the tool for greater insight.



Benefits of RTXCview



Developers who use RTXCview can avoid “flying blind”, preventing costly field failures by better understanding the interactions of system components.



· Improves runtime insight and understanding which leads to better design and improved system performance/stability



· Helps detect the underlying causes of system failures



· Provides information about CPU usage and the ability to meet deadlines



· Prevents future problems by allowing for trend studies in CPU usage and execution times



User studies have shown that complex timing problems (sometimes referred to as Heisenbugs) can be identified in minutes rather than hours or days using RTXCview.