Danlaw, Inc.

MxSuite™ is the most comprehensive automated platform for embedded software verification and validation. Its intuitive graphical interface and reports can be understood by anyone in the organization. MxSuite streamlines the complete software development cycle by using requirement-based tests during Model- based analysis and design (MiL), Software component development (SiL), Rapid prototyping target development (PiL), and on-target ECU testing (HiL).

Highlights

• Out of the box support for popular application life-cycle management systems and continuous integration tools
• Auto-harnesses simulation models, C code, AUTOSAR applications, and test & measurement equipment
• Executes a complete set of test cases ranging from a single ECU to an entire vehicle
• Automatically runs regression tests every time a change is made for a feature, product enhancement, or bug fix
• Monitors tests as they run triggers other tests based on conditions or events
• Imports log files or record ECU signals and messages so engineers can edit and play them back as test cases
• Integrates with industry standard test tools and network interfaces, such as CAN, LIN, Ethernet, MOST, and custom hardware interfaces
• Provides coverage metrics for ISO 26262 compliance

Benefits

• Provides back-to-back testing and equivalence between models, software, and ECU behaviors
• Tests infotainment, powertrain, body, interior, cockpit, battery management, and safety/ADAS functions
• Promotes better team communication with graphical summaries and root symptom details
• Reduces costs by automatic and reusing test cases across all life-cycle stages, such as design, simulation, rapid prototyping, development, implementation, and integration
• Finds bugs and highlights the root error symptoms

For more information: https://www.danlawinc.com/mx-suite/

The potential for increased performance by using multicore processors is not in question. In contexts where software is used for critical systems, however, it is crucial that this performance is both dependable and deterministic.

As experts in multicore timing analysis, we offer help on the path to adopting multicore processors at any stage:

- Evaluating candidate multicore processor technologies
- Understanding how processor configuration can affect software function and performance
- Developing and validating actions to protect against inadvertent processor behaviour
- Identifying constraints on the use of processors, features and resources

Multicore timing analysis services aid in:

- Understanding: Exploration & mitigation of WCET scenarios
- Enabling: Unlocking & configuring optimum performance
- Assuring: Dependable & deterministic systems
- Validating: Meeting requirements and providing evidence

Methodology

Rapita’s methodology for multicore timing analysis is centred around asking the right questions, such as:

- What do we need WCET for?
- How does my system work?
- How is it supposed to work?
- How do I measure how it ‘really’ works?
- Which experiments are needed to provide evidence?

Our methodology uses Barcelona Supercomputing Center’s proven Microbenchmarking technology.

Low-overhead analysis tools

With access to highly-optimized timing analysis and scheduling visualization tools, we offer efficient solutions for even the most difficult problems faced while working with multicore systems.

RapiTime calculates timing metrics such as worst-case execution time from embedded systems, including multicore ones, while RapiTask helps to understand the scheduling behavior of multi-core and multi-threaded systems.

World-leading expertise

Rapita was founded on the development of innovative timing analysis technologies, and has remained at the forefront ever since.. We are continuously involved in world-leading research into novel multicore timing analysis techniques, such as:

- Probabilistic real-time mixed-criticality multicore / manycore control
- Multicore execution of parallelised hard real-time applications
- Parallel software frameworks for time-critical manycore systems
- Probabilistic analyzable real time systems
- Cache optimizations for LEON processors

For more information - https://www.rapitasystems.com/multicore?s=ew-prod

How can RapiTime help you?

RapiTime is an advanced tool for performing timing and worst-case execution time (WCET) analysis, designed specifically to work with embedded targets and to satisfy certification requirements. The timing metrics produced by RapiTime can be used to demonstrate you have satisfied DO-178B/C objectives.

RapiTime combines static and dynamic analysis of your code on target to provide you with detailed information on its timing behavior.

RapiTime lets you automate timing analysis on your embedded system so you can identify timing issues and optimize your code early in the development process, saving you future expense.

Benefits of using RapiTime

RapiTime helps you reduce the cost, time and effort you need to perform timing analysis and optimization on even the most complex and demanding safety-critical real-time embedded systems.

You can use RapiTime to automate timing data collection and analysis even on very large systems. In one case study, RapiTime produced in just one day the data that it took the customer 8 months to collect manually.

RapiTime’s minimal overhead means you can perform timing analysis in every test run, making timing information available throughout your development process. This information will help you identify timing issues early in development and minimize WCET.

RapiTime use cases

- Demonstrate that software executes within its time constraints.
- Understand timing behaviour when upgrading to new targets, even multi-core processors.
- Optimize code to upgrade legacy systems.
- Conduct WCET/high water mark analysis.
- Address DO-178B/C guidelines.

How does RapiTime work?

RapiTime performs static analysis of code and instruments it automatically. When you run your code on-target, RapiTime collects a trace of program execution that includes timing data. RapiTime then processes this trace to produce qualifiable reports of the timing behavior of your code that you can view using the RapiTime GUI.

The timing reports RapiTime produces, along with its trace rewind feature, let you quickly identify where your optimization effort will provide the greatest improvements to timing behavior.

RapiTime’s instrumentation process can be customized to suit your timing analysis needs. Whether you need to perform timing analysis with limited target memory, support for large and complex code bases, or to automate timing analysis throughout your development pipeline, RapiTime is the tool you need.

Key features of RapiTime

Timing analysis
Analysis engine
Language support
Build integration
Target integration
Tool qualification
Third party integration
GUI

For more information: https://www.rapitasystems.com/products/RapiTime?s=ew-prod

RapiCover is an advanced tool for performing structural code coverage analysis, designed specifically to work with embedded targets and to satisfy certification requirements. RapiCover supports all coverage metrics required by DO-178B/C and ISO 26262:

• Function coverage
• Statement coverage
• Decision coverage
• MC/DC (modified condition/decision coverage)

Benefits of using RapiCover
RapiCover, the most advanced structural code coverage tool, will help you reduce the effort and time you need to perform structural code coverage analysis.
RapiCover has been designed to improve the coverage analysis processes in the most complex and challenging embedded targets. By using RapiCover you can:

• Complete coverage analysis in fewer test cycles.
• Reduce instrumentation overhead by up to 90% compared to other tools.
• Seamlessly integrate code coverage analysis with your system and build process.
• Reduce your reporting effort by being able to:
  • Combine multiple reports.
  • Merge coverage from different runs and builds.
  • Merge coverage from unit and system level tests.
  • Merge coverage from partial instrumentations and tests.
  • “Justify” untested code (coverage holes) and migrate justifications across builds.
• Reduce your certification effort with our tool qualification kits.

RapiCover use cases

• Identify code uncovered by test requirements.
• Identify test requirements missing for full coverage of your code base.
• Structural code coverage analysis to meet DO-178B/C objectives.
• Structural code coverage analysis to meet ISO 26262 requirements.

How does RapiCover work?
RapiCover analyzes your source code to determine the optimal positions to apply instrumentation for coverage analysis. Integration with RapiCover includes a strategy for efficient collection of map data during your build process. RapiCover uses the map data obtained when you run your code, either on-host or on-target, to generate a coverage report you can view to see the coverage you obtained.
RapiCover’s instrumentation process can be customized to suit your coverage analysis needs. Whether you need to perform incremental coverage, instrument “literal“ or “traditional“ MC/DC decisions or analyze coverage on multi-core architectures, RapiCover is the tool you need.

Key features of RapiCover
Code coverage analysis

• On-host and on-target structural code coverage analysis
• Statement, function, decision and MC/DC coverage
• Coverage of complex code structures
• Fully configurable analysis:
• Supports a very large number of conditions in a decision

Language support

• Ada 83, 95, 2005 and 2012, support for compilers including GNAT Pro and Green Hills
• C and C++, support for compilers including VisualStudio, GCC, Diab and TASKING
• Assembly code insertions
• Mixed language source code

Build integration

• Multiple strategies available: Compiler wrappers, Clone integration, Scripting into build system directly
• Support for very large code bases
• Split instrumentation between build cycles
• Shared integration with other RVS tools
• Build ID support

Target integration

• Support for data collection using CAN, Serial, Ethernet, debuggers and our own RTBx data logger
• Extremely low overhead map data collection can be configured with a single assembly instruction
• No library/run-time dependencies or dynamic memory requirements
• Extremely efficient MC/DC target library
• Collect and report coverage on a per-test basis
• Incremental coverage
• Coverage analysis across power cycles (subject to hardware requirements)
• Freeze and reset coverage collection to eliminate accidental coverage

Justifications

• Assign justifications to explain missing coverage
• Merge justifications from different builds
• Automatic and manual relocation of justifications
• Import justifications from and export to third-party tools
• Multi-user editing support

Tool qualification

• High-quality kit to support DO-178B/C and ISO 26262 tool qualification
• Justification feature fully qualifiable out of the box

For more information: https://www.rapitasystems.com/products/rapicover?s=ew-prod
 

RapiTest drives the inefficiencies out of functional testing in critical software verification projects. By automating the creation and execution of unit, integration and system tests, it reduces the cost of software verification, particularly in the avionics industry.

Testing with RapiTest

RapiTest uses input test suites to automate functional testing by building a test harness, executing tests, collecting data and generating reports.
It accepts a variety of test input formats supplied through a simple user interface. By integrating with your existing build system, RapiTest reduces the overheads needed to get your test project started.

RapiTest supports large testing projects by offering a portable test environment and retaining references to code and its revision in test reports.

Key features

• Automated platform for unit and system testing both on-target and on-host. Integrate testing into your existing build process to improve the efficiency of your testing.
• Efficient test generation. Minimize build cycles and test rig utilization by running multiple tests per build.
• Fast incremental builds. RapiTest builds only critical files when your code base changes, even in systems with very large code bases.
• Minimize “usercode” by writing tests in the powerful spreadsheet and script formats of RapiTest. These let you write test cases for generics or multi-dimensional tables without “usercode”.
• Portable test environments. Share test environments between multiple testers, even where source code is unavailable to them.
• Advanced support for Ada. RapiTest handles even the most complex Ada code constructs such as generics, nested functions and private types.
• Flexible stubbing options. Write both simple and complex behavior for stubbed functions easily. RapiTest supports all types of stubbing behavior, including stubs, fakes, mocks, spies and dummies.
• Interface with other RVS plug-ins. Integrate coverage, timing and scheduling analysis into your testing process.

Automation of software testing
RapiTest makes it easy to write, run and report on software tests by providing an automated workflow that can be managed through a simple user interface or the command line:

• Generate test templates quickly
• Automate on-target and on-host testing with fast incremental builds and efficient test generation
• Highlight failed tests to review, rewrite and rerun
• Merge reports from different test runs and builds

Powerful test formats
A testing tool is only as powerful as its inputs. The test authoring technology behind RapiTest makes it quick and easy to write tests:

• Minimize usercode by defining even complex tests easily using spreadsheet or script formats
• Write a variety of stub behaviors without usercode

Easy to use, easy to manage
RapiTest is designed for ease of use, even in large scale projects including multiple test engineers and sites. It provides support through the following features:

• Analyze source code only once per project to reduce unnecessary overheads
• Portable test environments let you use a single project file throughout a team
• Add files such as requirements to projects for better traceability
• A variety of results filtering and search options to highlight project progress over time
• Easy to follow tutorials and detailed documentation

Language support

• Ada 83-2012, support for GNAT Pro^TM and Green Hills^TM compilers among others
  • Handles even the most complex code constructs such as generics, nested functions and private types
  • Support for C and agreed C++ language features

Get ready for certification
RapiTest is built with safety in mind. It's DO-178B/C qualification kits and qualified target integration kits help reduce the cost of certification.

For more information: https://www.rapitasystems.com/products/rapitest?s=ew-prod