Programming in Partitioned Global Address Space Model: UPC language as case study

Sunday, May 10, 2009 - 2:00 pm to 5:30 pm. Chellah I Room.

Presented by:

Dr. Jaafar Gaber
Dr. Mohamed Bakhouya
Université de Technologie de Belfort-Montbéliard
Belfort Cedex, France
URL: http://www.utbm.fr

Abstract:

PGAS programming languages provide ease-of-use through a global shared address space while emphasizing performance by providing locality awareness and a partition of the address space. Many new Partitioned Global Address Space (PGAS) programming languages have recently emerged and are becoming ubiquitously available on nearly all modern parallel architectures. Examples of PGAS languages include the Unified Parallel C (UPC), Co-array Fortran, and Titanium languages.

In this tutorial, we will focus on the UPC programming language which is based on C and extended with global pointers and data distribution declarations for shared data. In this language, a number of threads can work independently in a Simple Program Multiple Data (SPMD) model. Threads communicate through the shared memory and can access shared data while a private object may be accessed only by its own thread. The PGAS memory model, used in UPC, supports three different kinds of pointers: private pointers pointing to the shared address space, pointers living in shared space that also point to shared data, and private pointers pointing to data in the thread’s own private space. Using these features, programmers need to only specify the data to be distributed across threads and reference them through special global pointers.

The aim of this tutorial is to show the features provided by PGAS programming model in comparison with the other programming models such as the Message passing and data parallel models. The focus will be on UPC as PGAS-based language by introducing their control structures and by showing its features using examples of programs. Chapters to be addressed are as follows:

• Introductory tutorial

Provides a quick introduction that allows writing first simple programs by introducing the basic execution model in UPC, followed by some of the key UPC features, such as threads, shared and private data, pointers, distribution of work across threads, synchronization of activities between threads.

• Programming view and UPC data types

Gives an overview of parallel programming paradigms by focusing on how data are declared and used.

• Pointers and arrays

Presents various pointers and how they work with arrays.

• Work sharing and domain decomposition

Explains how data and work can be distributed, such as data locality.

• Dynamic shared memory allocation

Presents the usage of dynamic memory allocation in the shared space.

• Synchronization and memory consistency

Explains the effective mechanisms for mutual exclusion, barriers, and memory consistency control.

• Performance tuning and optimization

Presents necessary mechanisms to write efficient UPC applications.