Your browser does not support JavaScript! Skip to main content
Free 30-day trial Customer portal Careers DO-178C Handbook
 
Rapita Systems
 

Industry leading verification tools & services

Rapita Verification Suite (RVS)

  RapiTest - Unit/system testing   RapiCover - Structural coverage analysis   RapiTime - Timing analysis (inc. WCET)   RapiTask - Scheduling visualization   RapiCoverZero - Zero footprint coverage analysis   RapiTimeZero - Zero footprint timing analysis   RapiTaskZero - Zero footprint scheduling analysis

Multicore verification

  MACH178   Multicore Timing Solution   RapiDaemons

Services

  V & V Services   Qualification   Training   Tool Integration  Support

Industries

  Aerospace (DO-178C)   Automotive (ISO 26262)   Space

Other

  RTBx   Mx-Suite   Software licensing   Product life cycle policy  RVS development roadmap

Latest from Rapita HQ

Latest news

RVS 3.18 Launched
Solid Sands partners with Rapita Systems
Danlaw Acquires Maspatechnologies - Expanding Rapita Systems to Spain
Rapita co-authored paper wins ERTS22 Best paper award
View News

Latest from the Rapita blog

Measuring response times and more with RapiTime
Why mitigating interference alone isn’t enough to verify timing performance for multicore DO-178C projects
There are how many sources of interference in a multicore system?
Supporting modern development methodologies for verification of safety-critical software
View Blog

Latest discovery pages

do178c DO-178C Guidance: Introduction to RTCA DO-178 certification
matlab_simulink MATLAB® Simulink® MCDC coverage and WCET analysis
code_coverage_ada Code coverage for Ada, C and C++
amc-20-193 AMC 20-193
View Discovery pages

Upcoming events

Aerospace Tech Week Europe 2023
2023-03-29
Aeromart Montreal 2023
2023-04-04
Certification Together International Conference
2023-05-10
View Events

Technical resources for industry professionals

Latest White papers

DO178C Handbook
Efficient Verification Through the DO-178C Life Cycle
A Commercial Solution for Safety-Critical Multicore Timing Analysis
Compliance with the Future Airborne Capability Environment (FACE) standard
View White papers

Latest Videos

Streamlined software verification with RVS 3.18
Sequence analysis with RapiTime
Visualize call dependencies with RVS thumbnail
Visualize call dependencies with RVS
Analyze code complexity thumbnail
Analyze code complexity with RVS
View Videos

Latest Case studies

Supporting ISO 26262 ASIL D software verification for EasyMile
RapiCover’s advanced features accelerate the certification of military UAV Engine Control
Front cover of whitepaper collins
Delivering world-class tool support to Collins Aerospace
View Case studies

Other Downloads

 Webinars

 Brochures

 Product briefs

 Technical notes

 Research projects

Discover Rapita

Who we are

The company menu

  • About us
  • Customers
  • Distributors
  • Locations
  • Partners
  • Research projects
  • Contact us

US office

+1 248-957-9801
info@rapitasystems.com
Rapita Systems, Inc.
41131 Vincenti Ct.
Novi
MI 48375
USA

UK office

+44 (0)1904 413945
info@rapitasystems.com
Rapita Systems Ltd.
Atlas House
Osbaldwick Link Road
York, YO10 3JB
UK

Spain office

+34 930 46 42 72
info@rapitasystems.com
Rapita Systems S.L.
Parc UPC, Edificio K2M
c/ Jordi Girona, 1-3, Office 306-307
Barcelona 08034
Spain

Working at Rapita

Careers

Careers menu

  • Current opportunities & application process
  • Working at Rapita
Back to Top

Breadcrumb

  1. Home
  2. RVS
  3. RapiTime
RapiTime

In-depth execution time analysis for critical software

Why choose RapiTime?

  •  Timing analysis (inc. WCET) for Ada, C & C++ on-target & host
  •  Identify code to optimize for worst-case behavior
  •  Debug rare timing events
  •  Simplify verification through integration with your CI tool
  •  Produce evidence for DO-178 and ISO 26262 certification
Multicore timing white paper Request a demo
  • Overview
  • Features
  • Resources
  • Compatibility
  • FAQs

Timing analysis (inc. WCET) for Ada, C & C++ on-target & host

By automating code instrumentation and the collection of timing metrics on target, RapiTime reduces the effort needed to understand and verify your code’s timing behavior. Flexible integration strategies ensure efficient verification, regardless of your target hardware.

RapiTime’s hybrid worst-case execution time (WCET) calculation leverages the benefits of static analysis and measurement-based approaches to produce WCET results that represent behavior on the real system and provide a safe upper bound on WCET while minimizing pessimism.

Automatically analyze timing
Optimize for worst-case behavior

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 helps you identify the code elements that have the highest contribution to your system’s worst-case timing behavior. This helps you focus your optimization efforts on the sections of code that are most likely to affect your code’s worst-case 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 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.

Debug rare timing events
continuous integration

Simplify verification through integration with your continuous test tool

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

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

Produce evidence for DO-178 and ISO 26262 certification

Get ready for DO-178C certification with our qualification kits. Our off-the-shelf qualification kits and qualified target integration service help you on the road to qualifying your use of RVS.

Many features of RVS are qualified, including our instrumentation, which has saved customers like Collins Aerospace a huge amount of manual effort.

produce certification evidence

Product features

  • Timing analysis
  • Integrated testing environment
  • Project navigation
  • Integration with build systems
  • Integration with embedded targets
  • Integration with third party tools
  • Language support
  • Licensing
  • Support and training
  • Qualification
  • Execution time analysis Analyze the execution time behavior of code as tested on the embedded hardware.
    Discover this feature
  • Worst-case execution time analysis Produce WCET metrics through a hybrid measurement-based/static analysis approach.
    Discover this feature
  • Response time analysis Analyze software response times.
    Discover this feature
  • Analyze timing behavior across code sequences Collect timing measurements between any points in code.
    Discover this feature
  • Investigate multicore interference effects RapiTime supports the investigation of multicore interference effects and plays a critical role in the MACH178 solution and Multicore Timing Solution.
    Discover this feature
  • Optimize code for timing performance Easily identify code with the the greatest impact on timing performance.
    Discover this feature
  • Produce certification evidence Produce evidence for certification by following a recommended workflow that focuses analysis.
    Discover this feature
  • Capture values from hardware event monitors Capture and view values from hardware event monitors on your multicore platform.
    Discover this feature
  • Automatically merge timing results Automatic data merging supports timing analysis for multicore systems.
    Discover this feature
  • Automate testing on host and target Run tests on host computers and test rigs in continuous build environments.
    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
  • Efficient, configurable analysis Apply instrumentation based on your functions' expected execution frequencies.
    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
  • Assurance issue notification We notify you of issues that may affect the validity of your results as soon as we identify them.
    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
  • Compare reports Compare reports from different builds to track project progress over time.
    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
  • Configurable export formats Export timing results in a variety of formats.
    Discover this feature
  • Timing analysis during unit testing Collect execution time metrics during unit testing to support timing optimization throughout the software life cycle. 
    Discover this feature
  • View detailed timing metrics at a glance Specialized charts and tables make it easy to focus your analysis.  
    Discover this feature
  • Analyze results from multicore timing analysis Capture and easily analyze results from tests for timing behavior in multicore software.
    Discover this feature
  • Execution Time Profile Chart View a histogram of your software's timing behavior to easily identify patterns.
    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
  • Aggregate Profile Chart A configurable chart helps you visualize timing data in the context of your code's call tree.
    Discover this feature
  • Rewind Trace Step through execution traces to investigate timing events using a debugger-like interface.
    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
  • Treemaps View coverage and hierarchy of code at a glance.
    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
  • 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
  • Flexible integration strategies Collect data from almost any embedded target with flexible collection strategies.
    Discover this feature
  • iSYSTEM debugger Collect verification data from iSYSTEM debuggers.
    Discover this feature
  • Lauterbach debugger Collect verification data from Lauterbach debuggers.
    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
  • SCADE Test Test your SCADE models on-host and on-target through all phases of the verification lifecycle.
    Discover this feature
  • Deos Out-of-the-box integration with DDCI-I's Deos operating system.
    Discover this feature
  • C Support for C, Visual StudioTM, GCCTM, DiabTM and TASKINGTM compilers among others.
    Discover this feature
  • C++ Support for C++, Visual StudioTM, GCCTM, DiabTM and TASKINGTM compilers among others.
    Discover this feature
  • Ada Support for Ada 95, 2005 and 2012, GNAT ProTM and Green HillsTM compilers among others.
    Discover this feature
  • Mixed language support Support for mixed languages in the same code base.
    Discover this feature
  • Assembly Support for testing 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 use of RVS within a limited geographical area.
    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
  • 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 skilled field application 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
  • DO-178B/C qualification kit Qualification kits for RVS qualification in DO-178B/C projects.
    Discover this feature
  • Qualified target integration service Additional evidence to qualify the use of RVS in your development environment.
    Discover this feature
  • Qualified instrumenters Qualified instrumentation that doesn't require manual review.
    Discover this feature

Videos

Analyze code complexity thumbnail
Analyze code complexity with RVS
00:00:59 | Feature
 
Visualize call dependencies with RVS thumbnail
Visualize call dependencies with RVS
00:00:33 | Feature
 
Streamlined software verification with RVS 3.18
00:01:30 | Other
 
RVS 3.15 video thumbnail
Multicore timing analysis support with RVS 3.15
00:01:35 | Other
 

Pagination

  • Current page 1
  • Page 2
  • Page 3
  • Next page ›
  • Last page Last »

Downloads

  Technical note
Measuring MATLAB® Simulink® models' worst-case execution time with RapiTime
  Order Information sheet
RapiTime DO-178C Tool Qualification Order Information

Pagination

  • First page « First
  • Previous page ‹
  • Page 1
  • Page 2
  • Page 3
  • Page 4
  • Current page 5
  • Page 6
  • Page 7
  • Page 8
  • Next page ›
  • Last page Last »

News & Blog

News
Launch of RapiTime Object Code Analyser (ROCA) project
News
IXV successfully completes research flight
News
Rapita launches RapiTime DO-178B/DO-330 tool qualification pack for WCET
News
WCET analysis of on-board space software system by RapiTime
News
New C++ support product launched
News
Step back in time with RapiTime

Pagination

  • First page « First
  • Previous page ‹
  • Page 1
  • Page 2
  • Page 3
  • Page 4
  • Current page 5
  • Page 6
  • Page 7
  • Page 8
  • Next page ›
  • Last page Last »

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+
Windows Server 2016+
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
GNAT Pro
Arm DS-5
armcl
Borland Borland C++
Cosmic Software --
GNU GCC
G++
Greenhills Ada MULTI
C Multi
IAR Systems Embedded Workbench
Keil C51
Microsoft Visual Studio
NXP CodeWarrior HCS12
TASKING CC166
Texas Instruments CL500
CL2000
Wind River Diab
CCPPC

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

Frequently asked questions

  • General
  • Qualification and certification
  • Compatibility
  • Licensing and support
Expand All
  • What is RapiTime? 
  • How does RapiTime work? 
  • Which types of timing data does RapiTime report? 
  • How does RapiTime calculate the worst-case execution time of my software? 
  • How does RapiTime support additional types of timing analysis such as response time analysis? 
  • How does RapiTime help me investigate timing behavior? 
  • How does RapiTime support results collection from multiple builds or test runs? 
  • How does RapiTime support multicore timing analysis? 
  • In addition to guaranteeing that timing deadlines are met, how else can I use RapiTime? 
  • How does RapiTime help me select the instrumentation to apply to my code? 
  • How do I determine the execution time overhead from instrumenting my source code? 
  • Can statistical modeling approaches be used to provide support for timing measurements? 
  • How are my results presented? 
  • How can RVS help me understand my code base? 
  • My project includes subcontracting organization(s) and I have confidentiality concerns. Can RVS help me?  
  • How do I verify my software’s functional and temporal behavior when instrumentation has been applied? 
  • How long has RVS been used for software verification? 
  • How do I learn more about RapiTime? 
  • My software is part of a product that must be certified against a safety guideline. Can RapiTime be qualified for use in my project? 
  • Can I determine timing metrics on my target, which has limited RAM and/or ROM? 
  • Can I use RapiTime to analyze the timing behavior of multicore architectures? 
  • Which languages does RapiTime support? 
  • How large a code base can RVS tools handle? 
  • Which host operating systems can RVS be used on? 
  • Can I use RapiTime with my build system? 
  • Can I use RVS tools with my continuous integration environment? 
  • Which hardware architectures do RVS tools support? 
  • Can I use RapiTime to support worst-case execution time analysis of code in my SCADE project? 
  • Can I use RapiTime to verify my code that runs on Deos? 
  • How does RVS support the analysis of shared code compiled by build systems with multiple executables 
  • How are RVS products licensed? 
  • How does RVS support Enterprise licensing? 
  • Can I create and manage groups for my floating RVS licenses? 
  • What happens if I encounter an issue while using an RVS tool? 
  • How do you support RVS users? 
  • How do I learn more about RapiTime?

    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. 

  • What is RapiTime?

    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. 

  • How does RapiTime work?

    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.

  • Which host operating systems can RVS be used on?

    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.

  • 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 RapiTime with my build system?

    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.

  • Which languages does RapiTime support?

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

  • My software is part of a product that must be certified against a safety guideline. Can RapiTime be qualified for use in my project?

    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.

  • How do I determine the execution time overhead from instrumenting my source code?

    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. 

  • In addition to guaranteeing that timing deadlines are met, how else can I use RapiTime?

    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.

  • Can I use RapiTime to analyze the timing behavior of multicore architectures?

    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 MACH178 solution and Multicore Timing Solution, which analyze the timing behavior of multicore systems.

  • How does RapiTime calculate the worst-case execution time of my software?

    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. 

  • Which types of timing data does RapiTime report?

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

    You can also configure RapiTime to collect additional measurements between any points in your code. This allows you to collect measurements such as response times, periodicity and separation.

  • 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 RapiTimeZero results in continuous integration software, allowing you to track your verification results over time.

  • How does RapiTime help me investigate timing behavior?

    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.

  • Can I determine timing metrics on my target, which has limited RAM and/or ROM?

    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. 

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

  • 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 do I verify my software’s functional and temporal behavior when instrumentation has been applied?

    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.

  • How does RapiTime help me select the instrumentation to apply to my code?

    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.

  • 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 RapiTime support results collection from multiple builds or test runs?

    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.

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

  • How does RapiTime support multicore timing analysis?

    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. 

  • 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 RapiTime to support worst-case execution time analysis of code in my SCADE project?

    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.

  • Can I use RapiTime to verify 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 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.

  • 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 does RapiTime support additional types of timing analysis such as response time analysis?

    RapiTime lets you configure custom sequences to collect measurements for anywhere in your code. You can use this feature to collect a range of timing metrics for your code, such as response times, periodicity and separation.

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

RapiTime success stories

RapiTime has been used by aerospace and automotive companies in the world for timing analysis projects.

How RapiTime automated timing analysis and helped to identify timing hotspots in a military DO-178B project.

How our tools captured worst case timing and stack usage data for DO-178B Level A Embraer Flight Control Systems (FCS).

Learn how RVS tools measured and improved the overall execution time of the flight control system on the M-346.

Learn how RVS tools created a measurement-based analysis of Solar Orbiter on-board software for schedulability.

 

Request Demo

Times are in GMT

What happens next?
We aim to respond to demo requests within 1 working day. 

  • Solutions
    • Rapita Verification Suite
    • RapiTest
    • RapiCover
    • RapiTime
    • RapiTask
    • MACH178

    • Verification and Validation Services
    • Qualification
    • Training
    • Integration
  • Latest
  • Latest menu

    • News
    • Blog
    • Events
    • Videos
  • Downloads
  • Downloads menu

    • Brochures
    • Webinars
    • White Papers
    • Case Studies
    • Product briefs
    • Technical notes
    • Software licensing
  • Company
  • Company menu

    • About Rapita
    • Careers
    • Customers
    • Distributors
    • Industries
    • Locations
    • Partners
    • Research projects
    • Contact
  • Discover
    • AMC 20-193
    • What is CAST-32A?
    • Multicore Timing Analysis
    • MC/DC Coverage
    • Code coverage for Ada, C & C++
    • Embedded Software Testing Tools
    • Aerospace Software Testing
    • Automotive Software Testing
    • Certifying eVTOL
    • DO-178C
    • WCET Tools
    • Worst Case Execution Time
    • Timing analysis (WCET) & Code coverage for MATLAB® Simulink®

All materials © Rapita Systems Ltd. 2023 - All rights reserved | Privacy information | Trademark notice Subscribe to our newsletter