General
About CSC
Organisation

People
Process for CSC hosting
School Models
Role of Local Organisers
Other Roles

Participants
Past Schools

2004 2005 2006 2007 2008 2009 2010 2011

Diploma at CSC
Sport at CSC
Inverted CSCs

iCSC05 iCSC06 iCSC08 iCSC10 iCSC11

Special schools

School@chep06

Inverted School 2006

CSC 2006

CSC2006 Overview

Practical Information

Programme

Schedule

Lecturers

Participants

Organisers

 
Examination results
 
Grants from EU -FP6

Eligibility Conditions

Level of grant support

How to apply
 

CSC-Live

School at chep06

     

inverted CERN School of Computing 2006 6-8-March 2006, CERN

Programme Overview

Computational Intelligence for HEP Data Analysis

The Art of Designing Parallel Applications

Software Testing: Fundamentals and Best Practices

Schedule

Lecturers

Lecturer Bios

Printable Version

iCSC2006  The Art of Designing Parallel Applications Theme

Details of all lectures

Parallel Computing

   

Tuesday 7 March

 
09:00 - 09:55 Lecture 1

Parallel Computing

 

Marek Biskup

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

 

Synchronizing Threads and Processes

   

Tuesday 7 March

 
10:05 - 11:00

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

 

Design Patterns for Concurrent Objects

   

Tuesday 7 March

 
11:30 - 12:25

Lecture 3

Design Patterns for Concurrent Objects

 

Marek Biskup

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

 

Portable Programming

   

Tuesday 7 March

 
14:00 - 14:55

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

 

Parallel Computing with ROOT and PROOF

 

 

Tuesday 7 March

 
15:05 - 16:00

Lecture 5

Parallel computing with ROOT and PROOF

 

Marek Biskup

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

 

 

 

iCSC
All on iCSCs
News
Registration

Post-reg.

Handouts
Forum
Programme

Computational Intelligence
Theme

Lecture1

Lecture2

Lecture3

Lecture4

Lecture5

All lectures

Parallel Application

Theme

Lecture1

Lecture2

Lecture3

Lecture4

Lecture5

All lectures

SW Testing
Theme

Lecture1

Lecture2

All lectures

Exercises
FAQ
Social Events

Feedback: Computing (dot) School (at) cern (dot) ch
Last update: Thursday, 14. November 2013 11:49

Copyright CERN