You can request a trial version of RVS, which includes RapiTime. You can also arrange a demonstration, where a member of our team will work with you to show the benefits RapiTime can offer you.

If you're interested in RapiTime in academia, you can search for it in the academic press. 

RapiTime is the leading tool for worst-case execution time analysis of critical software.

Used globally in the aerospace and automotive industries, it reduces the cost of analyzing the worst-case timing behavior of critical software.

As part of the RVS toolsuite, it forms part of a software verification solution that also includes tools for functional testing and structural coverage analysis. 

RapiTime works by injecting instrumentation code into source code and executing the native build system so that timing results are collected during program execution. Data can be collected from almost any target hardware by a variety of approaches.

RVS tools support Windows 7 or newer, Windows Server 2008 R2 or newer, and a 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.

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.

RapiTime can be integrated to work with almost any compiler and target hardware. Our integration service promises to deliver a robust integration of RapiTime into your build system.

RapiTime supports C, C++ and Ada projects, including mixed-language ones.

RapiTime is designed to meet the most stringent needs of certification processes, such as the DO-178B/C process used in the aerospace industry and the ISO 26262 process used in the automotive industry. We can provide developer qualification documents, a template integration qualification report and on-site tests to support you in qualifying RapiTime tools in projects requiring certification.

RapiTime includes inbuilt functionality to let you determine the execution time overhead of adding instrumentation to your source code. This overhead can then be automatically subtracted from the timing metrics reported by the tool. 

You can use timing metrics to optimize your code for timing behavior. RapiTime highlights the costliest functions in terms of execution time, guiding you towards the best optimization candidates. By running RapiTime again after you optimize your code, you can determine performance improvements.

As with all RVS tools, RapiTime supports data collection on multicore architectures. RapiTime achieves this by suspending data collection during a task interrupt and reinitializing collection when the task on the current core resumes execution. You can also use RapiTime to identify the interference produced by other cores on your system under test.

RapiTime is a key component of Rapita's MACH¹⁷⁸ solution and Multicore Timing Solution, which analyze the timing behavior of multicore systems.

The worst-case execution time reported by RapiTime is pessimistic, meaning the actual worst-case execution time of your code could not be higher than that reported by RapiTime. This satisfies the stringent requirements of embedded system certification. 

When you run your code on-target, or on-host using a simulator, RapiTime collects several timing metrics. These include worst-case execution time, high and low water mark paths, and minimum, average and maximum execution times for each test of your code. 

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.

RapiTime 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.

The instrumentation overheads for RapiTime tools are very low, and zero-instrumentation overhead can even be supported in some cases, depending on your target hardware and data collection strategy. This means that you can use RapiTime with virtually any target. 

If your available memory is very limited, you can use RapiTime's Time Bands feature to automatically select the depth of instrumentation of your code based on the expected execution frequencies of your code. 

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.

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.

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.

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. 

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. 

We recommend that, when producing timing evidence for certification, you use RapiTime to improve your test data so that the high watermark path and predicted worst-case path align as closely as possible and then perform task boundary only instrumentation to measure the high-watermark execution times. These values will be representative of the estimated worst case times, and the minimal level of instrumentation applied will have a negligible effect on the application's timing behavior.

RapiTime automatically applies instrumentation based on a default instrumentation profile that you select. You can easily configure the instrumentation applied to specific functions or areas of your code using the RVS Project Manager.

You can also use time bands to assign instrumentation automatically based on the expected call frequencies of functions in your code, and set optional rules that reduce or omit instrumentation in functions that don’t require detailed timing information.

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.

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.

RapiTime lets you merge timing results from different builds or test runs into a single report. This supports the collection of timing data from multiple test campaigns and from multiple test rigs.

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.

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.

RapiTime supports multicore timing analysis by enabling the collection and analysis of results when timing tests are run on the multicore platform.

It supports the collection of results by enabling the instrumentation of code so execution time results and values from hardware event monitors that monitor behavior such as cache hits can be collected when the multicore software is run, and by enabling the processing of collected results into an RVS report so the results can be easily analyzed.

RapiTime supports the analysis of collected results by providing helpful charts and visualization tools, allowing filtering of results by test or hardware event, and supporting the comparison of results against baseline control tests. 

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.

Yes. You can use RapiTime to support on target worst-case execution time analysis of your model code as well as any handwritten code you use in your project.

Yes. RVS has an out-of-the-box integration with Deos, which makes it possible to generate an RVS project including a RapiTime 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 RapiTime integration.

In addition to supporting on-target worst-case execution time analysis, the generated integration lets you perform on-target structural coverage analysis with RapiCover and visualize the scheduling behavior of your code with RapiTask.