[Blog] Four reasons why current software development methodologies and tools are facing their limits in the safety and multi-core fastest growing segments of the embedded systems market

Real-time embedded systems are found in every innovative industry like aerospace, automotive, industrial, rail transportation, and medical devices. Breakthroughs in artificial intelligence (AI), industrial IoT (IIoT), autonomous transportation, robotics and smart automation are driving exponential growth in the number and complexity of real-time embedded systems. For example, an S-class Mercedes now runs with 20 million lines of code : the embedded systems that are omnipresent in the car already account for 30% of total car cost and are expected to reach 50% by 2030. These electronics systems now drive the value of smart hardware across industries, but also are at the core of the safety and reliability of equipment. In consequence, certification requirements to electronic standards like ISO-26262 for automotive, DO-178C for aeronautics, IEC-61508 for industrial, and EN-50128 for railways are becoming more stringent and harder to meet.

As the growth in number and complexity of these real-time embedded systems accelerates and regulations raise the bar on reliability of critical systems, another perfect storm is brewing: the rapid adoption of multi-core processors, though necessary to support the computing power requirements of real-time systems, makes it almost impossible to integrate software and hardware using existing software engineering methods when taking advantage of the increased computer power.

Today embedded market industries have to cope with such challenges using software methodologies and tools that are limited on four levels:

1) Long and expensive iterations

The current process of writing software for critical real-time embedded systems requires iterations through the design-coding-integration-testing cycle, with manual calculation of timing and scheduling of individual tasks.
As systems typically operate in a multi-time scale, this traditional software design methodology imply that each functional model is split into sub-models and each of these is sequenced in a way that guarantees functional, performance, and safety constraints.
As systems grow in complexity, the iterative integration process of such systems becomes exponentially complex: there are just too many models and sub-models and dependencies to handle.

2) Non-scalable performance on multi-core

Meeting the performance requirements for real-time embedded systems is increasingly difficult as they grow in complexity. Taking advantage of multi-core processors is the solution. However, while they provide developers with the necessary increase in computing power, the current software development tools are not efficient as the parallelism of task execution requires synchronizing tasks across cores and managing shared memory and hardware. It is not unusual that systems built on multi-core using the current tools end up being less efficient than single-core.

3) Non-exhaustive testing campaigns

Because of non-determinism and uncontrolled temporal behaviors, current systems have a low level of testability that leads to many long tests campaigns, which completeness is complex (almost impossible in practice) to achieve and to demonstrate. With the growth in complexity of embedded systems and extensive usage of multi-core processors, this becomes ever harder to guarantee.
The non-determinism makes it very hard to reproduce, diagnose and fix software defects identified during the testing cycle. In the end, this results in pushing on the market products with hidden defects.

4) Early stage prototyping unrepresentative of the real-time embedded system

The engineering of complex embedded systems requires rapid prototyping and simulation to validate proposed designs at an early stage. This prototyping and simulation phase needs to be accurate enough to prevent costly redesigns at a later stage. The lengthy, costly iterative process of the current software methodology and tools is not adapted for prototyping, and development teams are forced to prototype using different approaches that are not representative enough of what the process will later produce, leading to costly re-engineering cycles.

Engineering organizations are realizing that the current software methodologies have reached their limits and that the market tools that they integrate into their development process do not help them in addressing the limitations described above.

KRONO-SAFE took an innovative approach to the problems, with the following main goals:

  • Simplify and accelerate the development cycle by automating the modifications due to the iterations,
  • Take full advantage of multi-core architecture for performance and efficiency,
  • Ensure by construction deterministic systems to dramatically improve the quality of the system and accelerate the testing cycle (on single and multi-core),
  • Make it easy to perform early stage representative prototyping.

The technology behind KRONO-SAFE tools is founded on a “Time-Triggered” programming paradigm, enabling to design complex real-time applications where both timeliness and determinism are built-in properties. These properties are guaranteed by design by our automated tools, no matter the underlying hardware architecture, on single- and on multi-core processors. In addition to this, key safety properties such as strict temporal and spatial isolation are also automatically enforced, while still offering the highest level of performance.

Want more info? Download the mini-series of whitepapers called “A technology leap to accelerate the development of complex, reliable and scalable embedded systems” at the link http://www.krono-safe.com/whitepapers/