RapiTimeZero | Rapita Systems

Zero-footprint timing analysis for critical software

Why choose RapiTime^Zero?

Collect timing metrics from systems that produce branch traces
Identify code to optimize for worst-case behavior
Debug rare timing events
Simplify verification through integration with your CI tool
Analyze timing behavior of libraries without source code

Collect timing metrics from systems that produce branch traces

By automatically producing software timing metrics from branch traces, RapiTime^Zero reduces the effort needed to verify software timing behavior. Along with branch traces produced by the system hardware, RapiTime^Zero only needs a disassembly of the application, meaning there’s no need for either source code or instrumentation.

The high-water mark execution time results produced by RapiTime^Zero help you produce evidence that your code meets it timing deadlines.

Identify code to optimize for worst-case behavior

Optimizing code to improve average case performance often has little effect, and may even have a negative effect, on worst-case timing behavior.

RapiTime^Zero helps you identify the code elements that have the highest contribution to your overall execution time. This helps you focus your optimization efforts on the sections of code for which it’s most likely to affect your code’s overall behavior.

Debug rare timing events

During program execution, many events occur, and debugging the source of issues like rare timing events can be like searching for a needle in a haystack.

RapiTime^Zero helps you debug rare timing events in your code by letting you step through your program execution step by step as you would with a code debugger.

Simplify verification through integration with your continuous test tool

Keep your verification on track by using RapiTime^Zero alongside your continuous integration tool. Collect timing results and track your project’s progress over time with our integrations for Jenkins and Bamboo.

By analyzing your code with RapiTime^Zero on every new build, you can easily identify anomalies in execution time results as they happen.

Analyze timing behavior of libraries without source code

RapiTime^Zero lets you analyze the timing behavior of third-party libraries or other pieces of software for which you have no access to the source code.

As RapiTime^Zero analyzes a branch trace and a disassembly to produce timing results, it can produce results even when you don’t have access to source code.

Product features

Zero footprint execution time analysis Zero footprint timing analysis 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
Produce certification evidence Produce evidence for certification.
Discover this feature
Optimize code for timing performance Easily identify code with the the greatest impact on timing performance.
Discover this feature
Automatically merge timing results Merge timing data from different builds or test runs automatically.
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
Compare reports Compare reports from different builds to track project progress over time.
Discover this feature
Configurable export formats Export timing results in a variety of formats.
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
View detailed timing metrics at a glance Specialized charts and tables make it easy to focus your analysis.
Discover this feature
Code viewer View code with syntax highlighting and color-coding of results.
Discover this feature
Rewind Trace Step through execution traces to investigate timing events using a debugger-like interface.
Discover this feature
Execution Time Profile Chart View a histogram of your software's timing behavior to easily identify patterns.
Discover this feature
Aggregate Profile Chart A configurable chart helps you visualize timing data in the context of your code's call tree.
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
Easily filter results Easily filter results to focus your analysis.
Discover this feature
Treemaps View coverage and hierarchy of code at a glance.
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
Jenkins Run RVS automatically through Jenkins to collect and archive results.
Discover this feature
Bamboo Run RVS automatically through Bamboo to collect and archive results.
Discover this feature
Software Configuration Management Integration with Software Configuration Management tools ensures that files can be used across a team.
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
Tutorials Learn how to get the most from our verification solutions with simple, interactive tutorials.
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
Multicore support Verify critical multicore systems.
Discover this feature

Videos

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 development environment, 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 the following:

Compilers
Instruction sets
Branch traces collected from the platform
Real-time operating systems

diagram showing hardware support on zero-footprint software

For a list of components that are already supported, see below. Note that we can add support for some components not listed below.

For detailed information on the requirements for zero-footprint tracing, see our Technical note.

For more information, contact info@rapitasystems.com.

Compilers

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. The compilers PSPs already support are listed below:

Arm Compiler
CC-RH850
Clang
GCC

We can develop support for other compilers. For more information, contact us at info@rapitasystems.com.

Instruction sets

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. The instruction sets PSPs already support are listed below:

68k
AArch64
ARM
PowerPC
RH850
VISIUM
x86

We can develop support for other instruction sets. For more information, contact us at info@rapitasystems.com.

Branch traces

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:

^† a modified version is available, which supports zero-footprint analysis
Debuggers	Simulators
Lauterbach TRACE32	QEMU^†
PARTNER-Jet2

We can develop support for other debuggers and simulators. For more information, contact us at info@rapitasystems.com.

*In some cases, other approaches may be possible, such as using a branch map.

Real-time operating systems

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. The RTOSs PSPs already support are listed below:

eMCOS for AUTOSAR Adaptive Platform
eMCOS for AUTOSAR Classic Platform (RV850)
FreeRTOS
SafeRTOS
SYSGO PikeOS®
Bare Metal (no OS)

We can develop support for other real-time operating systems. For more information, contact us at info@rapitasystems.com.

Operating systems

Zero-footprint RVS tools can be used to analyze software run on any host operating system.

Operating System
Windows 10 and 11
Windows Server 2019+
Variety of Linux distributions (including Ubuntu and Red Hat)
For older operating systems, contact us.

Programming languages

Language
Any language that targets machine code
Mixed languages

Multicore systems

Zero-footprint RVS tools can be used to analyze software from multicore systems.

Suitable branch trace(s) can be collected in one of two ways:

Collecting a separate branch trace from each core
Collecting a branch trace that includes results from all cores, where it’s possible to derive the core from which each branch was taken

Instrumentation-based vs instrumentation-free analysis

Both RapiTime and RapiTime^Zero support on-target worst-case execution time analysis 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	In development - contact us for details
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

How are my results presented?
All RVS tools include a friendly user-interface that presents your data in both tabular and graphical formats. Using this interface, you can filter your results to zoom in on target functions, making it easy to find the information you are looking for.

RapiTime includes charts designed to help you easily understand your data:
- Its Treemaps provide a high-level overview of your code base and help you understand the timing behavior of your code at a glance.
- Its Invocation Timeline and Aggregate Profile Charts let you visualize your results in of your code's call tree, identify the calls with the highest execution times, and investigate specific timing events more easily.
You can view RapiTime and RapiTime^Zero results in continuous integration software, allowing you to track your verification results over time.
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 RapiTime Zero?
RapiTime^Zero is an execution time analysis tool that requires no project source code or modification of the development environment being used. To extract execution time information, RapiTime^Zero 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 and functional testing.
How does RapiTime Zero work?
RapiTime^Zero uses two types of inputs from which to analyze software execution times. 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, RapiTime^Zero can understand both the program structure and the events that occurred during the program execution, allowing it to perform execution time analysis and produce execution time results.
Which types of timing data does RapiTime Zero report?
RapiTime^Zero collects and reports data on your code’s worst-case-execution time, high water mark path, and reports minimum, average and maximum execution times for each test.
Can I use RapiTime Zero to analyze the timing behavior of multicore architectures?
As with all RVS tools, RapiTime^Zero supports data collection on multicore architectures. To analyze the timing behavior of multicore architectures, RapiTime^Zero simply needs to know which branches corresponded to which core during program execution. This information can either be inferred by providing an individual branch trace for each core, or a combined trace that includes information on the core on which each branch was taken.
How does RapiTime Zero help me investigate timing behavior?
RapiTime^Zero includes a Rewind Trace utility, which lets you step through the events that occurred during program execution like you can with a debugger. This lets you set breakpoints and easily analyze the execution of your program.
Which languages does RapiTime Zero support?
As RapiTime^Zero analyzes object code directly to produce results, it supports any language that targets machine code.
How do I learn more about RapiTime Zero?
You can request a trial version of RVS, which includes RapiTime^Zero. You can also arrange a demonstration, where a member of our team will work with you to show the benefits that RapiTime^Zero 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.
Can I use RVS tools with my continuous integration environment?
RVS integrates with a range of continuous integration tools, allowing you to collect unit test, coverage and execution time results with every new build, track your verification progress over time and easily identify anomalies in your software's behavior as they are introduced.

RapiTest, RapiCover and RapiTime (including zero-footprint versions) include custom plugins to integrate with Jenkins and Bamboo. RapiTest and RapiCover results can also be displayed in a range of other continuous integration tools through the JUnit and Cobertura plugins, which are compatible with most continuous integration software.
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.
Can statistical modeling approaches be used to provide support for timing measurements?
In general, statistical modeling approaches are not applicable to timing analysis of software as software timing behavior does not fit standard statistical assumptions.

In some cases, software timing behavior may fit standard statistical assumptions, but this is the exception rather than the rule and must be proven before relying on results from statistical modeling.
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.

Check PSP compatibility
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.
How does RapiTime Zero support results collection from multiple test runs?
RapiTime^Zero lets you merge timing results from different test runs into a single report. This supports the collection of timing data from multiple test campaigns, and lets you merge results from different builds, for example system test and low-level test builds, so long as the functions under test are identical.
Which certification standards and guidelines can RVS help me to achieve?
RVS supports meeting standards and guidelines for verification of mission and safety-critical applications including:
- Civil aerospace software guidelines DO-178C (ED-12C), DO-278A (ED-109), AC 20-193 & AMC 20-193
- Military & defense aerospace standards MIL-HDBK-516C, AA-22-01 AMACC, EMACC, ADSM, Def Stan 00-55 & Def Stan 00-56
- Automotive standard ISO 26262
- Space software standards NASA NPR 7150.2D, ECSS-E-ST-40C
- Other standards based on IEC 61508, including IEC 62279, EN50128 & EN 50657 (rail), IEC 61511 (industrial processes), IEC 61513 (power), IEC 60880 (nuclear) & IEC 62061 (machinery)

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

Both RapiTime and RapiTime^Zero support on-target worst-case execution time analysis 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	RapiTime	RapiTime^Zero
Works without source code	No	Yes
Works without instrumentation	No	Yes
Integration with development environment	Integration needed	No integration needed
Tool qualification support	Yes	In development - contact us for details
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)

Compiler,TI Compiler,Roadmap

Compiler,Diab,Roadmap

Simulator,ARM Fast Models Generic/TarmacTrace,Roadmap

Simulator,TRACE32 Simulator,Roadmap

Simulator,Gremlin,Roadmap

Compiler,Arm Compiler,Already available

Compiler,CC-RH850 ,Already available

Compiler,Clang,Roadmap

Compiler,Code Composer,Roadmap

Compiler,GCC,Already available

Compiler,GNAT,Roadmap

Compiler,Tasking,Roadmap

Compiler,Other compiler,Not on the roadmap

Instruction set,AArch64,Already available

Instruction set,ARM,Already available

Instruction set,AURIX TriCore,Roadmap

Instruction set,PowerPC,Roadmap

Instruction set,RH850,Already available

Instruction set,RISC-V,Roadmap

Instruction set,VISIUM,Already available

Instruction set,x86,Already available

Instruction set,Other instruction set,Not on the roadmap

Debugger,Intel Processor Trace,Roadmap

Debugger,iSystem,Roadmap

Debugger,Lauterbach TRACE32,Already available

Debugger,PARTNER-Jet2,Already available

Debugger,Other debugger,Not on the roadmap

Simulator,ASTC VLAB,Roadmap

Simulator,MachineWare SIM-V,Roadmap

Simulator,QEMU* AArch64,Already available

Simulator,QEMU* Arm,Already available

Simulator,QEMU* x86,Already available

Simulator,Other simulator,Not on the roadmap

RTOS,None (Bare Metal),Already available

RTOS,DDC-I Deos,Roadmap

RTOS,eMCOS for AUTOSAR Adaptive Platform,Already available

RTOS,eMCOS for AUTOSAR Classic Platform (RV850),Already available

RTOS,FreeRTOS,Already available

RTOS,Green Hills INTEGRITY,Roadmap

RTOS,Lynx Software LynxOS,Roadmap

RTOS,SYSGO PikeOS,Roadmap

RTOS,SafeRTOS,Roadmap

RTOS,Wind River VxWorks,Roadmap

RTOS,Other RTOS,Not on the roadmap

Multicore Verification

Engineering Services

Other

Webinars

Brochures

Product briefs

Technical notes

Research projects

Zero-footprint timing analysis for critical software