Skip to main content
RapiTest - Functional testing for critical software
RapiCover - Low-overhead coverage analysis for critical software
RapiTime - In-depth execution time analysis for critical software
RapiTask - RTOS scheduling visualization
RVS Qualification Kits - Tool qualification for DO-178 B/C and ISO 26262 projects
RapiCouplingPreview - DCCC analysis
MACH178 - Multicore Avionics Certification for High-integrity DO-178C projects
MACH178 Foundations - Lay the groundwork for A(M)C 20-193 compliance
RapiDaemons - Analyze interference in multicore systems
RTBx - The ultimate data logging solution
Sim68020 - Simulation for the Motorola 68020 microprocessor
Data Coupling & Control Coupling
Training
Consultancy
Tool Integration
Support
RVS 3.24 accelerates multicore software verification
Rapita Systems and Avionyx Announce Strategic Partnership to Offer Best-in-class Avionics Solutions
RVS 3.23 Launched
Rapita System Announces New Distribution Partnership with COONTEC
RVS gets a new timing analysis engine
How to measure stack usage through stack painting with RapiTest
What does AMACC Rev B mean for multicore certification?
How emulation can reduce avionics verification costs: Sim68020
How to achieve multicore DO-178C certification with Rapita Systems
How to achieve DO-178C certification with Rapita Systems
Certifying Unmanned Aircraft Systems
DO-278A Guidance: Introduction to RTCA DO-278 approval
Test what you fly - Real code, Real Conditions Webinar
Avionics Certification Q&A: CERT TALK
XPONENTIAL 2026
DO-178C Multicore In-person Training (Heathrow)
Zero-footprint event-level scheduling analysis for critical software
Why choose RapiTaskZero?
Gain insight into your application through scheduling analysis
Understanding your application’s scheduling behavior can help you troubleshoot scheduling issues. RapiTaskZero 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, RapiTaskZero lets you analyze your system’s scheduling behavior in-depth.
Locate rare timing events that need attention
RapiTaskZero 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.
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, RapiTaskZero 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. RapiTaskZero 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.
Visualize scheduling behavior of libraries without source code
RapiTaskZero lets you analyze the scheduling behavior of third-party libraries or other pieces of software for which you have no access to the source code.
As RapiTaskZero analyzes a branch trace and a disassembly to produce results, it can do so even when you don’t have access to source code.
Product features
-
Zero footprint system event tracing Zero footprint system event tracing for critical software.Discover this feature -
Source to object code traceability Trace results collected from analyzing program execution to source code, where available.Discover this feature -
Platform support Supported compilers, instruction sets, trace capture mechanisms and RTOSs.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 -
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 Efficient integration workflow and inbuilt Platform Support Packages for integrations.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 zero-footprint RVS tools After integrating one zero-footprint RVS tool to work a development environment, it is trivial to use others.Discover this feature -
Portable test environments Multiple users can share the same test environment.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 -
Comprehensive verification toolsuite One tool to meet all your software verification needs.Discover this feature -
Customizable task colors Customizable task colors help you highlight the tasks you're most interested in.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 -
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 -
Comprehensive language support Support for all languages that target machine code through zero-footprint analysis.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 -
Assembly Support for verification of Assembly code.Discover this feature -
Mixed language support Support for verification of code written in multiple languages.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 -
Annual licenses License RVS in annual increments.Discover this feature -
Perpetual licenses License RVS for use indefinitely.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 -
Examples and sandbox projects Examples and sandbox projects help you get started 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 -
Help search Search the help system to find the most relevant resources quickly.Discover this feature -
Multicore support Verify critical multicore systems.Discover this feature -
Easily migrate to new versions Easily migrate to new RVS versions with guided migration help.Discover this feature
News & Blog
Zero-footprint RVS tools such as RapiCoverZero reconstruct information on the behavior of an application when it runs by using branch trace information captured from the platform the application is running on and combining this with information obtained from a disassembly of the application. Visit our platform support page to learn more.
68k
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the 68k instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
AArch64
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the AArch64 instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
Ada
Programming languages
RVS can be used to verify Ada code for requirements-based testing, structural coverage, execution time and scheduling behavior.
CPU
RVS can be used to analyze software running on Arm 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 Arm CPUs we have worked with:
- ARM7
- ARM9
- ARM10
- ARM11
- Cortex-M
- Cortex-R
- Cortex-A
Arm Compiler
Compilers
Zero-footprint RVS is compatible with object code compiled by the Arm Compiler
Platform Support Packages (PSPs) must be able to disassemble executables for further analysis. Typically, tools required for this are supplied as part of a toolchain unique to each compiler.
We can develop support for other compilers. For more information, contact us at
Arm instruction set
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the arm instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
Assembly
Programming languages
RVS can be used to verify Assembly code for structural coverage, execution time and scheduling behavior.
CPU
RVS can be used to analyze software running on Atmel 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 Atmel CPUs we have worked with:
- AT90CAN128
Software Configuration Management (SCM)
RVS tools are designed to work in Software Configuration Management tools such as Azure DevOps.
Software Configuration Management (SCM)
You can run RVS automatically through the Bamboo continuous integration server.
Bare Metal
RTOS
RVS (including zero-footprint tools) supports the verification of code running on Bare Metal (no OS)
C
Programming languages
RVS can be used to verify C code for requirements-based testing, structural coverage, execution time and scheduling behavior.
C++
Programming languages
RVS can be used to verify C++ code for requirements-based testing, structural coverage, execution time and scheduling behavior.
CC-RH850
Compilers
Zero-footprint RVS is compatible with object code compiled by the CC-RH850 compiler
Platform Support Packages (PSPs) must be able to disassemble executables for further analysis. Typically, tools required for this are supplied as part of a toolchain unique to each compiler.
We can develop support for other compilers. For more information, contact us at
Clang
Compilers
Zero-footprint RVS is compatible with object code compiled by the Clang compiler
Platform Support Packages (PSPs) must be able to disassemble executables for further analysis. Typically, tools required for this are supplied as part of a toolchain unique to each compiler.
We can develop support for other compilers. For more information, contact us at
Cobertura
Software Configuration Management (SCM)
RapiCover lets you export structural coverage results in a Cobertura format.
Requirements traceability
RapiTest lets you import requirements from DOORS through ReqIF.
CPU
RVS can be used to analyze software running on ESA 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 ESA CPUs we have worked with:
- LEON2
RTOS
RVS (including zero-footprint tools) support the verification of code using ESOL eMCOS.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.
We can develop support for other real-time operating systems. For more information, contact us at
RTOS
RVS (including zero-footprint tools) supports the verification of code using FreeRTOS.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.
We can develop support for other real-time operating systems. For more information, contact us at
CPU
RVS can be used to analyze software running on FRONTGRADE Gaisler (previously known as Cobham Gaisler) 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 FRONTGRADE Gaisler CPUs we have worked with:
- LEON3
- LEON4
GCC
Compilers
Zero-footprint RVS is compatible with object code compiled by the GCC compiler
Platform Support Packages (PSPs) must be able to disassemble executables for further analysis. Typically, tools required for this are supplied as part of a toolchain unique to each compiler.
We can develop support for other compilers. For more information, contact us at
Software Configuration Management (SCM)
RVS tools are designed to work in Software Configuration Management tools such as GitHub.
Software Configuration Management (SCM)
You can run RVS automatically through continuous integration pipelines in GitLab.
CPU
RVS can be used to analyze software running on IBM 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 IBM PowerPC implementations we have worked with:
- G1 (601)
- G2 (602, 603, 604, 620)
- G3 (740/750)
- 7xx/750 family
- G5/970 series
- 401
- 403
- 405
- 440 range
IBM Engineering Rhapsody
Model-Based Design
CPU
RVS can be used to analyze software running on Infineon 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 Infineon CPUs we have worked with:
- XE166 family
- XC 2000 family
- C166 family
- TriCore
- TriCore Aurix
- TriCore Aurix Gen2
- XMC1000
Requirements traceability
RapiTest has a dedicated integration with the Jama Connect® requirements management and traceability tool
Software Configuration Management (SCM)
You can run RVS automatically through the Jenkins continuous integration server.
Software Configuration Management (SCM)
RapiTest lets you export functional test results in the JUnit format
Lauterbach TRACE32
Debuggers
Zero-footprint RVS tools are with branch traces collected using the Lauterbach TRACE32.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect a branch trace from the platform*. Some targets generate branch traces by default, for example:
- Boards that have been developed to meet at least Class 2 of the Nexus message-based trace protocol
- ARM boards including an ARM ETM component
- Custom boards developed to produce branch traces
A debugger may be used to collect these branch traces from the target. Each Platform Support Package (PSP) is designed to support branch traces collected by a specific debugger.
We can develop support for other debuggers and simulators. For more information, contact us at
Linux
OS (Host)
RVS can run on variety of Linux distributions (including Ubuntu and Red Hat).
For older operating systems, contact us.
Model-Based Design
Microsoft TFS
Software Configuration Management (SCM)
RVS tools are designed to work in Software Configuration Management tools such as Microsoft TFS.
CPU
RVS can be used to analyze software running on Freescale/NXP 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 Freescale (NXP) CPUs we have worked with:
- 68000
- 680x0
- ColdFire
- M-CORE
- Power Architecture (MPC5xx, MPC55xx, MPC56xx, MPC57xx)
- 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)
PARTNER-Jet2
Debuggers
Zero-footprint RVS tools are with branch traces collected using the PARTNER-Jet2.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect a branch trace from the platform*. Some targets generate branch traces by default, for example:
- Boards that have been developed to meet at least Class 2 of the Nexus message-based trace protocol
- ARM boards including an ARM ETM component
- Custom boards developed to produce branch traces
A debugger may be used to collect these branch traces from the target. Simulators may generate branch traces, or it may be possible to modify them to do so. Each Platform Support Package (PSP) is designed to support branch traces collected by a specific debugger or from a specific simulator. The debuggers and simulators PSPs already support are listed below:
We can develop support for other debuggers and simulators. For more information, contact us at
RTOS
RVS (including zero-footprint tools) supports the verification of code using SYSGO PikeOS.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.
We can develop support for other real-time operating systems. For more information, contact us at
Requirements traceability
RapiTest supports integration with the Polarion® ALM™ requirements management and traceability tool
PowerPC
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the PowerPC instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
QEMU
Simulators
Zero-footprint RVS tools support the verification with branch traces generated using the a modified version of the QEMU simulator.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect a branch trace from the platform. Some targets generate branch traces by default, for example:
- Boards that have been developed to meet at least Class 2 of the Nexus message-based trace protocol
- ARM boards including an ARM ETM component
- Custom boards developed to produce branch traces
Simulators may generate branch traces, or it may be possible to modify them to do so. Each Platform Support Package (PSP) is designed to support branch traces collected from a specific simulator.
We can develop support for other debuggers and simulators. For more information, contact us at
Requirements traceability
RapiTest integrates with requirements management software that can produce ReqIF format results.
Requirements traceability
RapiTest lets you import requirements from Reqtify through ReqIF.
RH850
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the RH850 instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
SafeRTOS
RTOS
RVS (including zero-footprint tools) supports the verification of code using SafeRTOS.
For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.
We can develop support for other real-time operating systems. For more information, contact us at
Software Configuration Management (SCM)
RVS tools are designed to work in Software Configuration Management tools such as TeamCity.
CPU
RVS can be used to analyze software running on Texas Instruments 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 TI CPUs we have worked with:
- TMS320C6x family
- TMS320C28x family
- TMS320F28x family
- TMS570 family
VISUM
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the VISUM instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
Requirements traceability
RapiTest lets you import requirements from Visure through ReqIF.
Windows
OS (Host)
RVS can run on Windows 10 and 11.
For older operating systems, contact us.
Windows Server
OS (Host)
RVS can run on Windows Server 2019 and above.
For older operating systems, contact us.
x86
Instruction sets
Zero-footprint RVS tools can analyze disassembled code for the x86 instruction set.
When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools.
We can develop support for other instruction sets. For more information, contact us at
Instrumentation-based vs instrumentation-free analysis
Both RapiTask and RapiTaskZero 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
-
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.
-
What is RapiTask Zero?
RapiTaskZero is a scheduling visualization tool that requires no project source code or modification of the development environment being used. To extract task-level scheduling information from a program, RapiTaskZero analyzes branch trace information collected from a compatible target or data collection mechanism.
As part of the RVS toolsuite, it forms part of a software verification solution that also includes tools for structural coverage analysis, worst-case execution time analysis and functional testing.
-
How does RapiTask Zero work?
RapiTaskZero uses two types of inputs from which to produce task-level scheduling results. The first is the executable file and a disassembly of it, and the second is a branch trace collected while the program under analysis is executed. From these inputs, RapiTaskZero can understand both the program structure and the events that occurred during the program execution, allowing it to perform task-level scheduling analysis and produce results.
-
Why do I need RapiTask Zero when I have tools from my RTOS vendor?
RapiTaskZero is OS-agnostic so you can keep the same visualization and metrics if you change OS, and you can use RapiTaskZero 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.
-
How does RapiTask Zero show OS events such as inter-process communication (semaphores, messages), timers, hardware I/O etc?
RapiTaskZero 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 RapiTaskZero trace.
-
Can I use RapiTask Zero to analyze the behavior of multicore architectures?
As with all RVS tools, RapiTaskZero supports data collection on multicore architectures. To analyze the task-level scheduling behavior of multicore architectures, RapiTaskZero simply needs to know which branches corresponded to which core during program execution. This information can be inferred by providing a combined trace that includes information on the core on which each branch was taken.
-
How are my results presented?
RapiTaskZero 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.
RapiTaskZero 's Invocation Timeline Chart helps you to understand the high-level scheduling behavior of your system at a glance.
-
If I have RapiTime or RapiTime Zero, do I still need RapiTask or RapiTask Zero?
RapiTime and RapiTimeZero abstract away from the OS tasking model and only report 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 or RapiTaskZero.
-
Which languages does RapiTask Zero support?
As RapiTaskZero analyzes object code directly to produce results, it supports any language that targets machine code.
-
How do I learn more about RapiTask Zero?
You can request a trial version of RVS, which includes RapiTaskZero. You can also arrange a demonstration, where a member of our team will work with you to show the benefits that RapiTaskZero can offer you.
-
Which platforms and data collection mechanisms do zero-footprint RVS tools support?
Software analysis by zero-footprint RVS tools has the following requirements:
- The platform (target and any external devices e.g. debuggers) must be capable of producing a branch trace without gaps to ensure that the full program trace can be reconstructed.
- The OS needs to make context switches observable. For some systems, supporting this may require modifications to be made to the OS.
- A Platform Support Package (PSP) is needed for RVS to interface with the platform, including the target hardware and trace capture mechanisms, in order to convert the branch trace into a format that the RVS tool understands and disassemble the executable and parse the resulting object code. PSPs are developed to be compatible with four components of the platform: Compilers, Instruction sets, Branch traces and Real-time operating systems.
For more information on the requirements for software analysis by zero-footprint RVS tools and a list of currently supported platforms, see our Platform support page.
For more detailed information on the requirements, see our Technical note.
-
Can I view my results in the context of my project source code?
If your source code is available, yes. By importing your source code and debug symbols into your RVS project, you can view your results in the context of both your object and source code, and trace between them.
-
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.
-
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.
-
What are Platform Support Packages and why are they needed?
Platform Support Packages are required to support software analysis by zero-footprint RVS tools. They interface between the tools and the platform in order to do the following:
- Convert the specific format of native branch traces generated by the platform into a format that the RVS tool understands and can use for subsequent analysis.
- Disassemble the object code to understand the structure and control flow of the code so this can be used for subsequent analysis.
Each PSP is designed to support various components of a platform. These include:
- The compiler(s) used to generate executables
- The instruction set of object code to be analyzed
- The native branch trace format generated from the platform – this depends on the mechanism used to generate branch traces, which may be the target hardware (or simulator) or a third-party device e.g. debugger.
- The real-time operating system.
Different PSPs are needed to support analysis by zero-footprint RVS tools when any of the above items are different between two platforms. For more information on how PSPs support analysis by zero-footprint RVS tools, see our Requirements for zero-footprint RVS analysis Technical note.
-
Is a Platform Support Package available for my platform?
To see whether we have already developed PSPs compatible with the components on your platform, see our zero-footprint Platform support.
If we have not yet developed PSPs compatible with one or more components of your platform, we may be able to develop them. For more information, contact us at info@rapitasystems.com.
-
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.
-
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.
-
Is instrumentation-based or instrumentation-free analysis best for me?
Both RapiTask and RapiTaskZero 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
RapiTaskZero
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)
-
How does RVS help me get started?
RVS make it easy to get started with a range of resources:
- Interactive tutorials guide you through using each RVS tool.
- Example projects, reports and tests let you explore using RVS with example code, while sandbox projects let you plug in Ada, C and C++ snippets and get started with on-host verification quickly.
- If you’re looking for more detail about specific topics, the RVS documentation is at hand.
And no matter what your question, RVS’s help search can link you to the most helpful resources at the click of a button.
