Conferences and supporting programme
Balancing Functional Safety with Performance Intensive Systems
One major driver of autonomous driving systems is the challenge of creating performance intensive systems, where sensor fusion algorithms need to calculate and correlate events related to the surroundings. While autonomous driving is clearly an automotive example, other markets of the embedded industry are also seeking similar challenges, whether we're talking about walking robots or semi-autonomous clinical operation machines. This drives the need for fast multicore CPUs and the usage of GPUs for computation, creating heavy computing platforms. There is little mentioning of real-time behavior and functional safety requirements in these systems, but those topics are important to consider in real applications. This talk will elaborate on this topic and discuss different solutions to these problems. The performance intensiveness of these system relates to the ability to run computation algorithms for transforming and processing sensor data. Considering that different sensors may detect the same objects, there is a timing correlation that needs to be considered when processing samples. Typically, this correlation needs to happen in a small time window and be highly deterministic by nature, which is a clear illustration of a real-time system where a missed sample may have critical consequences. The next challenge is the need for functional safety. In the automotive world the standard is called ISO 26262, which in a simplified way can be interpreted as the software needs to be proven to be free from systematic faults to be able to be used in automotive solutions. In the context of a performance intensive system, this means that all of the code running in the system needs to undergo extensive test and verification as well as deal with process related questions. Additionally, the system itself needs to take care of the random hardware faults that will occur, which adds diagnostic functionality requirements. Understanding the complexity of this effort is important, and why this needs to be considered. So, there is a need for mitigations to solve these challenges. The functional safety standard allows separation of functionality into different elements, each element can then be treated at a different level of criticality as long as the separation method guarantees freedom of interference. The most straight forward separation would be the division into different hardware components, like multiple CPUs, or the division of functionality between heterogeneous CPU cores in modern SOCs. There is also the possibility of division of functionality in software. Such separation can be done with techniques like a separation kernel or a hypervisor. Although similar in their intended architecture, both solutions has advantages and disadvantages. This talk will discuss possible solutions using these techniques where real-time behavior, functional safety and computing power solutions can be achieved.
--- Date: 28.02.2018 Time: 2:00 PM - 2:30 PM Location: Conference Counter NCC Ost