RapiTask | Rapita Systems

RTOS scheduling visualization

Why choose RapiTask?

Examine Ada, C or C++ applications via scheduling visualization
Locate rare timing events that need attention
Identify bottlenecks in your application by analyzing capacity issues
Compare scheduling algorithms from different RTOSs

Examine Ada, C or C++ applications via scheduling visualization

Understanding your application’s scheduling behavior can help you troubleshoot scheduling issues. RapiTask automatically collects information during program execution, presenting this data so you can follow the events that occurred in the test run.

Providing a timeline of the tasks that ran in your system, a wealth of charts and statistics, RapiTask lets you analyze your system’s scheduling behavior in-depth.

Locate rare timing events that need attention

RapiTask makes it easy to find rare timing events such as priority inversions in your system so you can fix them. By following your system’s tasks throughout execution, you can easily locate rare timing events, which can be visualized easily for example by color coding tasks according to priority.

You can also verify that your highest priority tasks aren’t pre-empted at a glance by using fragmentation charts and statistics.

Identify bottlenecks in your application by analyzing capacity issues

Bottlenecks in critical software can slow the system down or even cause it to fail as timing deadlines are missed. By letting you view the CPU utilization of each task in your system throughout your software execution, RapiTask helps you identify bottlenecks so you can fix them.

Compare scheduling algorithms from different RTOSs

While there are many vendor-specific scheduling visualization tools, these are often only compatible with a single RTOS. RapiTask lets you understand your system’s scheduling behavior through a common framework no matter which RTOS you’re using.

This means less time learning new tools and more time testing and resolving issues.

Product features

System event tracing Automatically analyze the behavior of tasks in your system as it runs.
Discover this feature
Understand scheduling behavior Understand your system's scheduling behavior at a glance.
Discover this feature
Locate rare timing events Scan large traces for specific unusual situations.
Discover this feature
Analyze system capacity issues Identify and analyze capacity issues in your system.
Discover this feature
OS-only instrumentation Collect task scheduling data without instrumenting individual tasks.
Discover this feature
RTOS-independent scheduling visualization Understand program scheduling through a common framework no matter which RTOS you're using.
Discover this feature
Automate testing on host and target Run tests on host computers and test rigs in continuous build environments.
Discover this feature
Analyze code complexity Analyze the complexity of your source code.
Discover this feature
Efficient integration workflow Configure integrations of RVS into your development environment quickly and easily.
Discover this feature
RVS Project Manager Take your test project from creation to completion with an intuitive user-interface.
Discover this feature
Shared integration with instrumentation-based RVS tools After integrating one RVS tool to work a development environment, it is trivial to use others.
Discover this feature
Redact source code for confidentiality Verification can be performed while source code is redacted to support verification by third-party suppliers.
Discover this feature
Portable test environments Multiple users can share the same test environment.
Discover this feature
Easily configurable analysis Apply analysis settings easily using a friendly user interface.
Discover this feature
Customizable workflow Customize the RVS workflow to best meet your needs.
Discover this feature
Template integrations Create and use template integrations to reduce your effort integrating RVS with your system.
Discover this feature
Customizable color scheme Customize the color scheme used to display your results.
Discover this feature
Customizable task colors Customizable task colors help you highlight the tasks you're most interested in.
Discover this feature
Comprehensive verification toolsuite One tool to meet all your software verification needs.
Discover this feature
Code viewer View code with syntax highlighting and color-coding of results.
Discover this feature
Easily filter results Easily filter results to focus your analysis.
Discover this feature
Visualize call dependencies Visualize the call dependencies in your code.
Discover this feature
Advanced search function Search reports for specific elements using advanced queries.
Discover this feature
Invocation Timeline Chart A timeline of your invocations helps you visualize the order of calls and how long each took to execute.
Discover this feature
Integrate with existing build systems Collect data from almost any build system.
Discover this feature
Compiler wrappers The recommended build integration strategy requires little if any change to the development environment.
Discover this feature
Clone integration Copy the build system to build and test code with RVS.
Discover this feature
Flexible integration strategies Collect data from almost any embedded target with flexible collection strategies.
Discover this feature
Multicore support Verify critical multicore systems.
Discover this feature
Low target overheads Fit more tests on your target and reduce the number of builds you need to run.
Discover this feature
Lauterbach debugger Collect verification data from Lauterbach debuggers.
Discover this feature
iSYSTEM debugger Collect verification data from iSYSTEM debuggers.
Discover this feature
Deos Out-of-the-box integration with DDCI-I's Deos operating system.
Discover this feature
C Support for verification of code written in C.
Discover this feature
C++ Support for verification of C++ code.
Discover this feature
Ada Support for verification of code written in Ada.
Discover this feature
Mixed language support Support for verification of code written in multiple languages.
Discover this feature
Assembly Support for verification of Assembly code.
Discover this feature
Compiler extension editor Manage extensions to support non-standard programming languages with an interactive editor.
Discover this feature
Flexible licensing options Select floating or node-locked licenses with annual or perpetual duration.
Discover this feature
Floating licenses Floating licenses support multiple users and shared working environments.
Discover this feature
Node-locked licenses Node-locked licenses support the use of RVS on a single machine.
Discover this feature
Perpetual licenses License RVS for use indefinitely.
Discover this feature
Annual licenses License RVS in annual increments.
Discover this feature
Easy to get started Integration and learning resources help you get started verifying your code in no time.
Discover this feature
Support Dedicated support service to resolve technical issues quickly.
Discover this feature
Training Get up to speed with custom training courses delivered by expert engineers.
Discover this feature
Documentation Learn how to use RVS features with comprehensive documentation in both printed and electronic formats.
Discover this feature
Easily migrate to new versions Easily migrate to new RVS versions with guided migration help.
Discover this feature

Videos

Downloads

Flyer
Using RVS to support multicore timing analysis

Webinar
Mitigation of Interference in Multicore Processors Webinar

Mitigation of interference in multicore processors for A(M)C 20-193

Brochure
Rapita Systems Brochure

Brochure
Rapita Verification Suite (RVS) Training Brochure

Product brief
Visualising RTOS Scheduling and Event Tracing with RapiTask

News & Blog

Blog
Flexible licensing software fit for modern working

News
Rapita hosts successful webinar with DDC-I

Blog
What are “co-operative” and “pre-emptive” scheduling algorithms?

Blog
Multi-core pitfalls: unintended code synchronization

Blog
Lightweight instrumentation with RapiTask

Blog
Out of the box RVS integration for DDC-I's Deos RTOS

Operating Systems

Type	Operating System
On-target deployment	RVS tools can be used to analyze software run on any host operating system or embedded target (as long as a communication channel is available).
On-host tool	Windows 10 and 11
	Windows Server 2019+
	Variety of Linux distributions (including Ubuntu and Red Hat)
	For older operating systems, contact us.
	RVS tools can be qualified for use on all supported platforms.

Programming languages

Language
Ada
C
C++
Mixed languages

Compilers

RVS is designed to be independent of the target compiler. We have already deployed with the compilers in the list below and can quickly add new compilers as required by our customers.

Vendor	Compiler
AdaCore	GNAT GPL
AdaCore	GNAT Pro
Arm	DS-5
Arm	armcl
Borland	Borland C++
Cosmic Software	--
GNU	GCC
GNU	G++
Greenhills	Ada MULTI
Greenhills	C Multi
IAR Systems	Embedded Workbench
Keil	C51
Microsoft	Visual Studio
NXP	CodeWarrior HCS12
TASKING	CC166
Texas Instruments	CL500
Texas Instruments	CL2000
Wind River	Diab
Wind River	CCPPC

RTOSs

RVS can be used on RTOSs used in the critical software industry. RVS has been used on RTOSs including the following:

RTOS
AUTOSAR Adaptive Platform
AdaCore Ravenscar Profile
Blackberry QNX
DDC-I Deos
ERIKA Enterprise
ESOL eMCOS - AUTOSAR Classic Platform & AUTOSAR Adaptive Platform
FreeRTOS
Green Hills Integrity
Kronosafe Asterios
LynxOS
LynxSecure
MaRTE OS
MICROSAR - AUTOSAR Classic Platform
MicroC/OS
RTXC Quadros
RI850V4 - micro ITRON v4.0 OS
RTEMS
SafeRTOS
SYSGO PikeOS
Vector MICROSAR
Wind River Helix & VxWorks

CPUs

RVS tools can be used to analyze software run on any host operating system or embedded target (as long as a communication channel is available). The following is a non-exhaustive list of CPUs we have worked with.

Vendor	Platform
Arm	ARM7
	ARM9
	ARM10
	ARM11
	Cortex-M
	Cortex-R
	Cortex-A
Analog Devices	Blackfin
	SHARC
	SigmaDSP
	TigerSHARC
	ADSP-21xx
Atmel	AT90CAN128
Cobham Gaisler	LEON3
Cobham Gaisler	LEON4
ESA	LEON2
Freescale (NXP)	68000
	680x0
	ColdFire
	M-CORE
	Power Architecture (MPC5xx, MPC55xx, MPC56xx)
	ARM Cortex-M microcontrollers (Kinetis E series, Kinetis K series, Kinetis L series, Kinetis M series, Kinetis W series).
	56k DSP family
	QorIQ (P2010, P2020, P4080, P5010, P5020, P5021, P5040, T2080)
IBM	PowerPC (PPC) implementations:
	G1 (601)
	G2 (602, 603, 604, 620)
	G3 (740/750)
	7xx/750 family
	G5/970 series
	401
	403
	405
	440 range
Infineon
	XE166 family
	XC 2000 family
	C166 family
	TriCore
	Tricore Aurix
	Tricore Aurix Gen2
	XMC1000
Texas Instruments	TMS320C6x family
	TMS320C28x family
	TMS570 family

Instrumentation-based vs instrumentation-free analysis

Both RapiTask and RapiTask^Zero support task-level scheduling visualization for critical software. Depending on your project and needs, one or both solutions may be better for you. Consult the table below to determine which is best for your project.

Features
Works without source code	No	Yes
Works without Instrumentation	No	Yes
Integration with development environment	Integration needed	No integration needed
Tool qualification support	Yes	Not yet available - contact us
Trace size and data processing time	Depends on applied instrumentation	Typically larger trace and longer data processing times
Supported platforms (target, data collection mechanism)	Flexible, almost any platform supported (see compatibility)	Requirements on platform (branch trace and context switch information must be available), PSP (see compatibility)

Frequently asked questions

Expand All

Which languages does RapiTask support?
RapiTask supports C, C++ and Ada projects, including mixed-language ones.
How do I learn more about RapiTask?
You can request a trial version of RVS, which includes RapiTask. You can also arrange a demonstration, where a member of our team will work with you to show the benefits RapiTask can offer you.

If you’re interested in RapiTask in academia, you can search for it in the academic press.
What is RapiTask?
RapiTask is the leading tool for task-level scheduling analysis of critical software.

Used globally in the aerospace and automotive industries, it reduces the cost of understanding software scheduling behavior and troubleshooting scheduling issues.

As part of the RVS toolsuite, it forms part of a software verification solution that also includes tools for functional testing, structural coverage analysis and worst-case execution time analysis.
How does RapiTask work?
RapiTask provides an RTOS-independent tool for visualization and exploring the scheduling behavior of embedded systems, and rapidly diagnosing and identifying potential problems.

It lets you visualize scheduling behavior across threads and processor cores, and reports response times from your system.
Which host operating systems can RVS be used on?
RVS tools can be run on the following x86-64 operating systems:
- Windows 10 and 11
- Windows Server 2019+
- Variety of Linux distributions (including Ubuntu and Red Hat)
RVS tools can be used on projects with unsupported operating systems by using a clone integration to split the process and delegate parts of it to the unsupported machine.
Which hardware architectures do RVS tools support?
RVS tools can be integrated to work with almost any embedded target. Our engineers can work with you to determine the optimal strategy for integrating the tool with your target, even for multi-core architectures. For more information on the hardware architectures we have integrated RVS tools with, see the compatibility information on our RVS product pages.
Can I use RapiTask with my build system?
RapiTask can be integrated to work with almost any compiler and target hardware. Our integration service promises to deliver a robust integration of RapiTask into your build system.
How are my results presented?
RapiTask displays results in two applications, the RVS Project Manager that is shared with all RVS tools, and an application specifically designed to display task scheduling information. You can synchronize the two applications to ensure that you can easily identify specific timing events in your system.

RapiTask's Invocation Timeline Chart helps you to understand the high-level scheduling behavior of your system at a glance.
Can I use RapiTask to analyze the behavior of multicore architectures?
As with all RVS tools, RapiTask supports data collection on multicore architectures.

RapiTask is a component of Rapita's MACH¹⁷⁸ solution and Multicore Timing Solution, which analyze the timing behavior of multicore systems.
Why do I need RapiTask when I have tools from my RTOS vendor?
RapiTask is OS-agnostic so you can keep the same visualization and metrics if you change OS, and you can use RapiTask results as a point of reference to compare operating systems.

Additionally, you can capture and display custom events not related to the operating system (for example ARINC 429 messages) and display them in the trace.
Can I only use RapiTask with RapiTime, or can I use RapiTask as a standalone tool?
You can use RapiTask as a standalone tool with either automatic or manual instrumentation.
If I have RapiTime, do I still need RapiTask?
RapiTime abstracts away from the OS tasking model and only reports the execution time of a task as if it were the only thing running on the CPU. If you are interested in the response time of your code, or the interaction between tasks and your OS, you'll need RapiTask.
How does RapiTask show OS events such as inter-process communication (semaphores, messages). timers, hardware I/O etc?
RapiTask is OS-agnostic; as with all Rapita tools the integration with the operating environment needs to be customized. If we can get information about items of interest from the OS we can add ‘user events’ to a RapiTask trace.
How large a code base can RVS tools handle?
RVS tools are designed to handle very large code bases. Because of the efficient algorithms used by RVS tools, there is no fundamental limitation to the number of lines of code that RVS can process, and our RVS tools have been used on projects with millions of lines of code.
How are RVS products licensed?
We offer both “Node-locked” and “Floating” licenses, and a license server to support use of our tools in your specific development environment.

For more information on our licensing models, see our RVS licensing FAQs.
What happens if I encounter an issue while using an RVS tool?
All RVS licenses include access to our dedicated in-house support team, who will work with you to provide a rapid fix to your issue. This is a critical part of our vision. During 2021, we resolved 63% of our support requests within 7 working days and 93% within 30 working days. We also inform our customers of known issues via our website and email.
How do you support RVS users?
We provide an extensive set of RVS documentation with each of our products, and offer training courses guiding you through the most effective use of RVS tools. All our users can benefit from privileged access to our website, which includes downloads for new product releases.
How long has RVS been used for software verification?
The Rapita Verification Suite (RVS) has been used in the critical embedded industry for over 15 years and supported a number of avionics projects globally. Qualification kits for qualified RVS products have supported more than 20 DO-178B and C certification projects up to and including DAL A.
My project includes subcontracting organization(s) and I have confidentiality concerns. Can RVS help me?
To support verification, RVS stores a copy of your source code in your verification results. RVS lets you remove this copy of your source code from your RVS project, so any subcontracting organizations you’re working with can’t see your proprietary information. A subcontracting organization can then verify aspects of your software using the redacted results, and you can later restore the copy of your source code for your internal use by merging your results.

Note that, as running functional tests requires access to the source code under test, this feature is not available for RapiTest.
How does RVS support Enterprise licensing?
Floating RVS licenses follow an “Enterprise” model. You can use them across geographical boundaries*, in different projects, with different users, and share them with suppliers working on the same project.

^*Some floating licenses may be restricted to use within a specific geographical region. Where this is the case, this is agreed before licenses are issued.
Can I create and manage groups for my floating RVS licenses?
Yes, you can create and manage groups of users for your floating RVS licenses. You can restrict each group to only serve licenses to specific hostnames or IP addresses. This allows you to reserve licenses for specific groups or specific purposes such as supporting the use of RVS on a continuous integration server.

Any licenses that you don’t reserve will remain available as floating licenses that can be shared among different users and geographic locations.
Can I use RapiTask to investigate the scheduling behavior of my code that runs on Deos?
Yes. RVS has an out-of-the-box integration with Deos, which makes it possible to generate an RVS project including a RapiTask integration in just 3 clicks from an existing OpenArbor project.

This benefits from the debug capabilities offered by Deos to automatically apply configuration settings needed for your project and RapiTask integration.

In addition to letting you visualize the scheduling behavior of your code, the generated integration lets you perform on-target structural coverage analysis with RapiCover and on-target worst-case execution time analysis with RapiTime.
How does RVS support the analysis of shared code compiled by build systems with multiple executables?
RVS supports the analysis of shared code compiled by build systems with multiple executables by letting you specify the source files that will be compiled in each executable.

If you have functions that are declared in multiple components with the same name but have different definitions, RVS can treat each such function uniquely, for example to provide separate coverage in RapiCover and separate execution time results in RapiTime.
How can RVS help me understand my code base?
RVS analyzes the structure of your code and presents information on your code’s structure, helping you understand your code and its dependencies in a variety of forms such as the following:
- RVS analyzes the McCabe complexity of your code and presents the complexity of each code element, letting you easily identify code with high complexity.
- RVS Treemaps present the hierarchy of your code’s components and source files graphically.
- RVS lets you view and explore the call dependencies in your code.
Can I use RapiTask if I don’t have access to my project source code?
No, but you can use RapiTask^Zero for your scheduling visualization.

Is instrumentation-based or instrumentation-free analysis best for me?

Both RapiTask and RapiTask^Zero support task-level scheduling visualization for critical software.

Depending on your project and needs, one or both solutions may be better for you. Consult the table below to determine which is best for your project.

Feature	RapiTask	RapiTask^Zero
Works without source code	No	Yes
Works without instrumentation	No	Yes
Integration with development environment	Integration needed	No integration needed
Trace size and data processing time	Depends on applied instrumentation	Typically larger trace and longer data processing times
Supported platforms (target, data collection mechanism)	Flexible, almost any platform supported (see compatibility)	Requirements on platform (branch trace and context switch information must be available), PSP needed (see compatibility)

Multicore Verification

Engineering Services

Other

Webinars

Brochures

Product briefs

Technical notes

Research projects

RTOS scheduling visualization