Berkeley UPC - Unified Parallel C (A joint project of LBNL and UC Berkeley)

The UPC Language

About this UPC program About this UPC program

 Unified Parallel C (UPC) is an extension of the C programming language designed for high performance computing on large-scale parallel machines.The language provides a uniform programming model for both shared and distributed memory hardware. The programmer is presented with a single shared, partitioned address space, where variables may be directly read and written by any processor, but each variable is physically associated with a single processor. UPC uses a Single Program Multiple Data (SPMD) model of computation in which the amount of parallelism is fixed at program startup time, typically with a single thread of execution per processor.

In order to express parallelism, UPC extends ISO C 99 with the following constructs:

• An explicitly parallel execution model
• A shared address space
• Synchronization primitives and a memory consistency model
• Memory management primitives

The UPC language evolved from experiences with three other earlier languages that proposed parallel extensions to ISO C 99: AC , Split-C, and Parallel C Preprocessor (PCP). UPC is not a superset of these three languages, but rather an attempt to distill the best characteristics of each. UPC combines the programmability advantages of the shared memory programming paradigm and the control over data layout and performance of the message passing programming paradigm.

Our work at UC Berkeley/LBNL

Berkeley UPC downloads since 01/May/2005 Berkeley UPC Runtime: 14191 Berkeley UPC Translator: 2479 Combined Total: 16670

The goal of the Berkeley UPC compiler group is to develop a portable, high performance implementation of UPC for large-scale multiprocessors, PC clusters, and clusters of shared memory multiprocessors.  We are actively developing an open-source UPC compiler suite whose goals are portability and high-performance.

There are three major components to this effort:

• Lightweight Runtime and Networking Layers: On distributed memory hardware, references to remote shared variables usually translate into calls to a communication library. Because of the shared memory abstraction that it offers, UPC encourages a programming style where remote data is accessed with a low granularity (i.e. the granularity of an access is often the size of the primitive C types - int, float, double).  In order to be able to obtain good performance from an implementation, it is therefore important that the overhead of accessing the underlying communication hardware is minimized and the implementation exploits the most efficient hardware mechanisms available.  Our group is thus developing a lightweight communication and run-time layer for global address space programming languages.

  In an effort to make our code useful to other projects, we have separated the UPC-specific parts our runtime layer from the networking logic. If you are implementing your own global address space language (or otherwise need a low-level, portable networking library), you should look at our GASNet library, which currently runs over a wide variety of high-performance networks (as well as over any MPI 1.1 implementation), and which is also being used as the networking layer for the Titanium language (a high-performance parallel dialect of Java).

• Compilation techniques for explicitly parallel languages: The group is working on developing communication optimizations to mask the latency of network communication, aggregate communication into more efficient bulk operations, and cache data locally. UPC allows programmers to specify memory accesses with "relaxed " consistency semantics, which can be exploited by the compiler to hide communication latency by overlapping communications with computation and/or other communication. We are implementing optimizations for the common special cases in UPC where a programmer uses either the default, cyclic block layout for distributed arrays, or a shared array with 'indefinite' blocksize (i.e., existing entirely on one processor). We are also examining optimizations based on avoiding the overhead of shared pointer manipulation when accesses are known to be local.

• Application benchmarks: The group is working on benchmarks and applications to demonstrate the features of the UPC language and compilers, especially targeting problems with irregular computation and communication patterns. This effort will also allow us to determine the potential for optimizations in UPC programs.  In general, applications with fine-grained data sharing benefit from the lightweight communication that underlies UPC implementations, and the shared address space model is especially appropriate when the communication is asynchronous. 

Some of the research findings from this work can be found on our publications page.

Group Members

	Katherine Yelick - Advisor, PI
Dan Bonachea - GASNet, Runtime Rajesh Nishtala - Applications, GASNet	Paul Hargrove - GASNet Filip Blagojevic	Costin Iancu - Compiler Yili Zheng
General contact info Alumni Members: Christian Bell, Wei Chen, Jason Duell, Parry Husbands, Mike Welcome

The Berkeley UPC project is funded by the DOE under based program funding from the Office of Science,
through the DOE PModels project, and from the Department of Defense.

Related Links

• Language Resources:
  • UPC Language - UPC Community website
  • UPC Wiki - Wiki-based documentation and collaboration website for UPC
  • Titanium Language - Java-based language with similar properties to UPC
  • Co-Array Fortran Language, Rice CAF - Fortran-based language with similar properties to UPC
• UPC-related mailing list archives:
  • Announcements: UPC Community Announcements     
  • User help lists: UPC Community Users      Berkeley UPC Users     
  • UPC Subcommittee lists: UPC Libraries      UPC I/O      UPC Collectives      UPC Language Spec     
• Other UPC implementations: (incomplete list)
  
  • HP UPC - for all HP-branded platforms, including Tru64, HPUX and Linux systems
  • Cray UPC - for Cray X1 and future Cray vector-family platforms
  • GCC UPC - for x86, SGI IRIX, Cray T3E
  • IBM UPC - for IBM Blue Gene and AIX SMP's
  • Michigan Tech MuPC - MPI-based reference implementation for Linux and Tru64
• Other external collaborations: (incomplete list)
  
  • TotalView Technologies - TotalView debugger, supports Berkeley UPC
  • University of Florida - Performance analysis tools that use the Berkeley UPC GASP profiling interface
  • George Washington University - UPC-IO, UPC testing and benchmarking suites
• HPC Network hardware supported by Berkeley UPC, via the GASNet communication system: (incomplete list)
  
  • Cray X1 (shmem)
  • SGI Altix (shmem)
  • Quadrics QSNet1/QSNet2 (elan)
  • Mellanox-based Infiniband (vapi) and OpenIB Verbs (ibv)
  • Myricom Myrinet (gm)
  • IBM Deep Computing Messaging Framework (dcmf)
  • Dolphin Interconnect Solutions (sci)
  • IBM Power SP Colony/Federation (lapi)
  • Any MPI-1.1 compliant system (mpi) - portable support
  • Any TCP/IP Ethernet (udp) - portable support

This page last modified on Tuesday, 07-Apr-2009 12:30:34 PDT