Això

So, let's start.

So last time we ended the lecture with the performance projection.

And the idea is that by 2020 we reach the extra scale category.

So let's calculate it through by using the current top one system, the summit system.

And currently we have theoretical peak performance of 200 petaflops approximately.

And with the LINPACK benchmark we reach around 143 petaflops.

So assuming that we get the same efficiency by just scaling up the number of nodes, we

need to improve this number by 7x so that we reach 1004.5 petaflops something.

So with a theoretical peak performance of 1400 petaflops.

That means that the power consumption will be increased by 7 as well.

So that means that we are at 86 megawatts and the specification of summit is at full

load we get around 91 megawatts.

So the whole facility is specified and designed to or should be specified to draw 91 megawatts

of power.

So that's quite a lot actually.

So it's not a nuclear power plant yet.

So the output of the smallest nuclear power plant I could find information on is at 5000

megawatts something.

But still this is more than some of the low energy countries.

So countries that don't need that much energy.

So for example Sub-Saharan countries would take an year.

So if it runs at full speed all the time.

And the number of RECs would then be 1792 compared to 256 RECs.

This means that we would need to have a better network, a far better network, a huge amount

of energy and the number of cores is increasing rapidly as well.

So we can assume that for the LINPACK benchmark that's probably not a big deal because it's

not communication intensive.

So it's compute bound.

So that might not be a problem but then we would end up with a system that's just designed

for matrix-matrix multiplication which doesn't reflect the applications that should run on

such a thing.

So a similar picture is with the Taihu light, so the number 3 currently, which would need

to be scaled up by a factor of 11.

So since it draws a little bit more power it needs a little bit more power but the overall

picture is the same.

So moving to exascale we have the challenges that we need to increase the on-node parallelism.

So if we want to stay in the same scale of system size because we can't house so many

RECs, this doesn't include even storage and all those cooling facilities etc.

The idea is that we need to increase the on-node parallelism by a factor of between 7 and 11,

taking the current number 1 system.

And of course we should reduce the power consumption.

The next challenge is of course the programmability.

If we increase the on-node parallelism we somehow have to have some tools or programming

languages or libraries or whatever to actually deal with that amount of concurrency.

So if you remember Amdahl's law, whenever we have a serial portion in our code that

hurts us significantly, something needs to be done in that regard.

And what I forgot to add here is of course the challenges regarding the network.

By increasing the number of nodes we have to have some solution for the networking as

well.