Concepts of parallelism

Loading...

来自 University of Geneva 的课程

Simulation and modeling of natural processes

58 个评分

University of Geneva

Simulation and modeling of natural processes

58 个评分

This course gives you an introduction to modeling methods and simulation tools for a wide range of natural phenomena. The different methodologies that will be presented here can be applied to very wide range of topics such as fluid motion, stellar dynamics, population evolution, ... This course does not intend to go deeply into any numerical method or process and does not provide any recipe for the resolution of a particular problem. It is rather a basic guideline towards different methodologies that can be applied to solve any kind of problem and help you pick the one best suited for you. The assignments of this course will be made as practical as possible in order to allow you to actually create from scratch short programs that will solve simple problems. Although programming will be used extensively in this course we do not require any advanced programming experience in order to complete it.

从本节课中

Introduction to programming with Python 3

This module intends to provide the most basic concepts of high performance computing used for modeling purposes. It also aims at teaching the basics of Python 3 which will be the programming language used for the quizzes in this course.

Concepts of parallelism4:20

Palabos, a parallel lattice Boltzmann solver5:06

与讲师见面

Bastien Chopard
Full Professor
Computer Science
Jean-Luc Falcone
Research Associate
Computer Science
Jonas Latt
Senior Lecturer
Computer Science
Orestis Malaspinas
Research Associate
Computer Science Department

[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]

探索我们的目录

免费加入并获得个性化推荐、更新和优惠。

Coursera 致力于普及全世界最好的教育，它与全球一流大学和机构合作提供在线课程。

© 2018 Coursera Inc. 保留所有权利。

通过 App Store 下载

通过 Google Play 获取