Since the very beginning of computers, processors were build with ever-increasing clock frequencies and instruction-level optimizations for faster serial code execution, such as ILP, caches, or speculative engines. Software developers and industry got used to the fact that applications get faster by just exchanging the underlying hardware. For several years now, these rules are proven to be no longer valid. Moore's law about the ever-increasing number of transistors per die is still valid, but decreased structural sizes and increased power consumption demand stalling, or even reduced, clock frequencies. Due to this development, serial execution performance no longer improves automatically with the next processor generation.
In the 'many-core era' that happens now, additional transistors are used not to speed up serial code paths, but to offer multiple execution engines ('cores') per processor. This changes every desktop-, server-, or even mobile system into a parallel computer. The exploitation of additional transistors is therefore now the responsibility of software, which makes parallel programming a mandatory approach for all software with scalability demands.
Introduction | 01:26:25 | |
---|---|---|
Course Design | 00:04:34 | |
Computer Markets | 00:10:12 | |
Three Ways of Doing Anything Faster | 00:17:28 | |
Parallel Hardware | 00:12:01 | |
Parallel Systems | 00:12:00 | |
TOP 500 | 00:17:50 | |
Amdahls Law | 00:12:20 |
Motivation and Shared Memory | 01:29:28 | |
---|---|---|
Short Recab | 00:11:03 | |
Terminology | 00:19:45 | |
Programming Models | 00:11:22 | |
History | 00:04:56 | |
Cooperating Sequential Processes | 00:30:05 | |
Muttual Exclusion Today | 00:09:14 |
Locks and Monitors | 01:27:08 | |
---|---|---|
Recap | 00:11:01 | |
Test-and-Set | 00:16:32 | |
Deadlock? | 00:15:33 | |
Monitors | 00:14:00 | |
Monitors - Example | 00:13:39 | |
Java Example | 00:16:23 |
Multicomputer | 01:22:09 | |
---|---|---|
Recap | 00:13:24 | |
History | 00:14:58 | |
CSP Processes | 00:21:43 | |
Process Description: Pictures | 00:13:00 | |
Mathematical Model | 00:10:38 | |
Task-Channel Model | 00:08:26 |
Parallel Computers | 01:25:23 | |
---|---|---|
Reason for choosing parallel architecture | 00:17:18 | |
Computer classification | 00:12:00 | |
SIMD | 00:07:13 | |
Illiac IV und MasPar MP-1 | 00:17:44 | |
GPGPU Computing | 00:08:22 | |
MIMD - Multiple Instruction Multiple Data | 00:16:37 | |
IBM SP/2 | 00:06:09 |
Programming Models | 01:22:24 | |
---|---|---|
About the Assignments | 00:07:16 | |
Programming Models | 00:12:38 | |
Execution Environment | 00:18:29 | |
Execution Environment for Workloads | 00:16:14 | |
The Parallel Programming Problem | 00:14:23 | |
From Multi-Tasking to Implicit Parallelism | 00:13:24 |
Multicomputer Systems | 01:29:37 | |
---|---|---|
Experimental Approaches | 00:17:29 | |
Cluster Middleware | 00:17:22 | |
Simple Queuing Management Systems | 00:13:54 | |
MPP Properties | 00:12:43 | |
Interconnective Networks | 00:13:19 | |
Theoretical Models for Parallel Computung | 00:14:50 |
OpenMP | 01:33:04 | |
---|---|---|
POSIX Pthreads | 00:09:30 | |
Java | 00:19:14 | |
.NET and C++ | 00:19:58 | |
OpenMP Work Sharing with Loop Parallelizatio | 00:28:32 | |
OpenMP Consistency Model | 00:16:30 |
GPU Computing with OpenCL | 01:07:21 | |
---|---|---|
Parallel Programming Models | 00:12:58 | |
History of GPU Computing | 00:19:25 | |
OpenCL Memory Architecture | 00:09:27 | |
Building and Executing OpenCL Code | 00:06:30 | |
Vector Addition: Kernel | 00:19:01 |
GPU Computing Devices | 01:26:34 | |
---|---|---|
Zur Übung | 00:08:35 | |
The Power of GPU Compute Devices | 00:18:05 | |
Live Demo | 00:14:32 | |
GPU Computing Platforms | 00:18:28 | |
The Power of GPU Computing | 00:16:00 | |
Use Caching: Local, Texture, Constant | 00:10:54 |
Message Passing | 01:29:17 | |
---|---|---|
Assignment No. 3 | 00:05:58 | |
Parallel Programming | 00:13:48 | |
Message Passing Interface (MPI) | 00:17:03 | |
Basic MPI | 00:13:22 | |
Non-Overtaking Message Order | 00:09:30 | |
Asynchronous Communication | 00:17:56 | |
Gather | 00:11:40 |
Implicit Parallelism & Mixed Approaches | 01:26:55 | |
---|---|---|
Implicit Parallelism | 00:11:25 | |
Imperative to Functional | 00:15:13 | |
Functional Programming | 00:18:06 | |
Declarative Programming - Example LINQ | 00:07:42 | |
Scala - Scalable Language | 00:12:42 | |
Scala - Case Classes | 00:11:17 | |
Actor Model | 00:10:30 |
Parallel Algorithms | 01:25:07 | |
---|---|---|
Scala | 00:05:19 | |
Traditional Parallel Programming PGAS | 00:13:40 | |
Parallel Algorithm Design | 00:17:43 | |
Designing Parallel Algorithms - Foster | 00:17:55 | |
Ghost Cells | 00:10:14 | |
Mapping | 00:20:16 |