About CSC

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

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


Inverted School 2006

CSC 2006

CSC2006 Overview

Practical Information






Examination results
Grants from EU -FP6

Eligibility Conditions

Level of grant support

How to apply


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



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.



- Motivation

- Users
- Architectures
- Example: BlueGene/L

- Parallel Desktop Computers: multicore CPUs

Parallel Application Examples
- HEP Data Analysis

Designing a Parallel Application

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


- Motivation

- Architectures

- Computations


Parallel Analysis with Proof

- Selectors

- Selectors Example


Other PROOF Modes

- Sequential Mode

- GRID Mode




All on iCSCs



Computational Intelligence






All lectures

Parallel Application







All lectures

SW Testing



All lectures

Social Events

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

Copyright CERN