The following content has been provided by the University of Erlangen-Nürnberg.

Good morning everybody. It's my pleasure to be here and I'm really impressed to see so many people here

following Wolfgang's call to participate in the seminar.

Let me start with a small story.

I'd like to ask you to follow me into space.

Let's imagine we have a small spacecraft flying in space and they're approaching some object, some planet-like object.

And of course they want to land on this object, so they're approaching the surface of this orb.

And they switch the computer system to take over for the landing approach.

And as they go down, the computer system controls the descent.

But at some point there's an alarm going on. System failure overload.

And well, you know what the typical thing is you do when you have a problem with your computer.

The safest thing or the thing that works in most situations is to switch off the computer to turn it on again, right?

And so the computer system goes into reboot, it reboots, but the same problem occurs again.

So all that the space pilot, the commander can do is take over manual control.

So he takes the joystick that's available and well, his heart rate of course goes up.

So he would like to rely on the computer system, but now he has to do the descent manually.

And fortunately he safely lands the spacecraft on the ground.

Well, I think this is a fictional story, it's not a fictional story actually.

This happened on the 20th of July 1969. It was the first time a human landed on the moon.

So this object was our moon and it was Neil Armstrong who managed to bring the spacecraft down to the ground safely.

So what happened? What was the problem here?

The problem was that we had a computer system and the peripheral system sensors.

And somehow the periphery so to say, the control signals coming from the periphery had too much influence on what was going on on the computer system.

So the interrupts coming from the periphery created overload, created errors in the memory management system.

Well, why do I tell you this story?

This was a pretty simple computer system and now we are moving to quite complex computer systems.

So we are in the age when we move from single core systems to multi core systems and we also use these systems in safety critical applications.

And so we see I think if we look at this simple application, well, a relatively simple system and the problems they had that we have to be very careful when designing the computer systems that use complex hardware that use multiple cores.

So what I want to do today, I want to put some focus on an approach that we envisage that you could use to build multi core computer systems, complex systems in a way that you can still predict timing, that you can plan timing, that you can predict timing and that you can rely on the time.

And you will have to rely on the timing as these systems are really used in safety critical, in life critical applications.

It's not just space flight, it's our cars that we use every day, it's the airplanes, it's medical equipment that relies on these computer systems.

What I want to do in the following minutes, I want first to start with some kind of introduction giving some motivation, points that speak in favor of using multi core systems in these applications.

I then want to summarize some of the crucial problems that nowadays multi core architectures impose on our systems.

And in the final and in the main part I would like to introduce some approach that should allow us to construct time predictable systems where I would like to split this into two sections.

One section dealing with the system level consisting of talking about a system which consists of multiple cores communicating to each other.

And then I would like to go, so to say, at the single core to the single core level and show you some approach how you could make the software, the hardware of the single core time predictable.

Now, why do we want to use multi core systems for embedded systems, for reliable, for dependable embedded systems?

There's a number of points speaking in favor.

First is that of course more and more functions are taken over by computer systems so we need more and more computational power.

And we all know that when we use single core system then we are coming to the limits because we can't make single cores faster and faster.

We're at the limit here. It would take simply too much energy to power up these systems to increase clock frequency again.

So if we are able to use multiple cores running at the lower frequency we can get similar even more computational power than using single core system and even at the cost of less energy.

Another advantage is of course that what we can do if we have multiple cores, if we have different cores, we are not limited to having equal cores.

So we can use heterogeneous hardware and we can adapt the hardware of the different cores to the problems they have to solve.

So we can use signal processor like cores for doing all the signal processing. We can use some more general purpose like cores for other tasks.

So we can adapt, we are flexible to build our system.

Second point is performance.

Well one limit to increasing performance in many applications is described by Elmdahl's law which says that most applications or many applications, many application areas,

they have a limit to putting things in parallel because their dependencies, their precedence constraints between different parts of the task that have to be fulfilled.

So the application per se does not allow for more parallelization.