[MUSIC] Welcome again to the second week of the course on simulation and modeling of natural processes. The aim of this third module is to introduce, one of the core concepts used in high performance computing, which is parallelism. What is the main idea behind parallelism? So when you are trying to solve a problem on a computer, you may think you can just split the work so cut your process in two and make it, execute it on two different processes and hope you will have a gain proportion in the number of processes you are going to solve simultaneously. So how does this work? What are the architectures that exist to do that? First, you have shared memory architectures. So you have many basic building blocks. So a building block for a computer is a CPU, and memory and an I/O device, or input output. So the shared memory takes many of the CPUs and connects them to a single memory. So each CPU can directly read in the memory used by any other CPU and these usually is programmed with the programming language which is called OpenMP. And you have distributed memory architectures where you have all your computers with their own memory and I/O devices which are connected together through a network. So the only way for a CPU to read another CPUs memory is for them to communicate the values stored in the memory through the network. So what is the performance of such architectures? So if we compare the efficiency of one modern processor which usually is measured in flops, which means floating bond operation per second, so which basically measures how many operations on real numbers you can perform in one second. We have that the performance of a modern processor is of about 100 gigaflops. This means about 100 billion operations per second. On the faster supercomputers, as of 4th January of 2015, the fastest supercomputer runs at about 52 petaflops, so it's the theoretical performance which means about 52 billions of billions of flops. So it's about 1 billion times faster than a modern processor. There are extract complications of course when we are trying to parallelize a program. The first thing is that the concept in itself is complex. How to split a problem into many subparts which are as independent as possible is a complicated task. There are of course problems where we simply cannot do that. Here I give you the example on the Fibonacci series, which is so dependent when we compute the number related to the index I to the precedent indexes that the parallelization will be possible but completely inefficient. With this, we end the module on concepts of parallelism. And coming next, we are going to talk about Palabos, which is a parallel lattice Boltzmann solver. Thank you for your attention. [MUSIC]