Tuesday 7 March

Parallel Computing

The objective of this lecture is to present  the principles of Parallel Computing, and the key underlying techniques, with a special highlight on the relationships between hardware architecture and the corresponding software techniques.

The lecture targets computer scientists interested in an overview of Parallel Computing, as well as more expert programmers.

No specific knowledge of parallel computing is required but familiarity with parallel programming will help understanding some of the techniques presented in the second part of the lecture.

Supercomputers

- Motivation

- Users
- Architectures
- Example: BlueGene/L

- Parallel Desktop Computers: multicore CPUs

Parallel Application Examples
- HEP Data Analysis

Designing a Parallel Application
- Methodology

- Example - Successive Overrelaxation

- Performance Metrics

Communication within a Parallel Application
- Shared Memory

- Message passing

- Synchronous and Asynchronous Communication

- Transposition Table-driven Scheduling

Sources of Errors
- Deadlock

- Race Condition

- Message Ordering

Higher Level Communication
- MPI
- RPC
- Java RMI

Parallel Application Example - 15 puzzle solver

- Static Job Allocation

- Dynamic Load Balancing

Tuesday 7 March

Lecture 2

Synchronizing Threads and Processes

Marek Biskup

The lecture will give an overview of ways and means of synchronizing threads and processes of a parallel application running on a multi-CPU system.  It is meant for programmers designing multithreaded applications and willing to learn more about general techniques.

It requires basic understanding of multiprogramming computer systems (threads, processes).

Additional knowledge of Java will help in better understanding of the examples.

Introduction and Motivation
- Concurrent Programs

- Example: a Concurrent Web Server

- Parallel Execution

- Processes and Threads

Synchronizing Access to Memory

- Example of Memory Corruption

- Critical Section

- Hardware Support - the test-and-set Instruction

Means of Synchronization

- Mutexes

- Bounded Buffer Example

- Semaphores

- Monitor Objects

- Java Monitors

- Condition Variables

- Bounded Buffer with Monitor Object and Condition

Using Threads

- Java

- Complete Bounded-Buffer example

- C-Language Threads - the pthreads

The new Concurrent Java API

Interprocess Communication in UNIX

Tuesday 7 March

Lecture 3

Design Patterns for Concurrent Objects

Design Patterns are recipes for writing maintainable and reusable object-oriented software.  This lecture presents several patterns used for distributed and multithreaded programming.

The lecture targets programmers interested in making their software more generic and reusable, especially those working on a multithreaded application.  Also programmers interested in Event-Handling Techniques may benefit from it.

Basic knowledge of threads, object oriented programming (classes, objects, methods, inheritance) is required.  Additional knowledge of the classical Design Patterns might help but is not required.

Design Patterns

- Overview

- Example: Proxy pattern

- Example: Abstract Factory pattern

Synchronization Patterns

- Motivation for Synchronization

- Scoped Locking pattern

- Locking in Java - finally statement

- Tread-Safe Interface pattern

- Synchronizing Proxy pattern

- Read-Write Lock pattern

- Double-Checked Locking pattern

- Monitor Object pattern

Concurrency Patterns

- Thread Pool pattern

- Tread Pools in Java

- Leader-Followers pattern

- Thread-Specific Storage pattern

Event-Handling Patterns

- Future pattern

- Futures in Java

- Events

- Event-driven Programming

- Event Loop

- Reactor pattern

- Proactor pattern

- Java AWT Event handling

Tuesday 7 March

Lecture 4

Portable Programming
 

Yushu Yao

As the variety of computer hardware and software systems grows quickly, it becomes more and more important for a developer to design and develop portable applications, so that with the minimum cost, the maximum number of user could benefit from it.

This Lecture begins with an introduction to the portable application design / development process in the software engineering point of view, followed by some practical guidelines of portable C programming. 

The lecture targets the programmers who need his applications to run on different platforms while don’t have many experiences doing it.

Basic knowledge of C is needed for the second part of the lecture.

Basics of Portable Programming

-Definition of Portability

-Measuring Portability

-How to Achieve Portability in the Software Process

Portable Programming With C

Portable Graphics User Interface

An Example to Both Portable and Parallel Computing Project

Tuesday 7 March

Lecture 5

Parallel computing with ROOT and PROOF

Yushu Yao

The lecture consists of two parts. In the first one Yushu Yao presents the ROOT framework as a platform for portable programming. In the second part Marek Biskup describes the PROOF subsystem, which allows parallel data analysis with ROOT.

The lecture is intended for physicists interested in speeding up their analysis by spreading calculations on a cluster of computers. It will also be interesting for computer scientists willing to learn the internals of a parallel application.

No knowledge of the ROOT framework is required but the vocabluary used in the first four lectures may be helpful for understanding all details.

Introduction to ROOT

- ROOT Concepts

- ROOT Data Structures, Trees and Files

A Step-by-Step Example for ROOT beginners

- Create and Fill Trees

- Histogram

- Curve Fitting

PROOF

- Motivation

- Architectures

- Computations

Parallel Analysis with Proof

- Selectors

- Selectors Example

Other PROOF Modes

- Sequential Mode

- GRID Mode