Communication Optimizations for Parallel C Programs

Zhu, Yingchun; Hendren, Laurie

doi:10.1006/jpdc.1999.1554

Cited by 9 publications

(6 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For communication analysis and optimization, Zhu and Hendren use compiler analysis to select the "best" place for inserting communication, reduce redundant remote access and increase message aggregation [33]. Significant research effort has been also focused on communication optimizations for data parallel programs [8,18,28].…”

Section: Related Workmentioning

confidence: 99%

Shared memory programming for large scale machines

Barton

Casçaval

Almási

et al. 2006

Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

This paper describes the design and implementation of a scalable run-time system and an optimizing compiler for Unified Parallel C (UPC). An experimental evaluation on BlueGene/L R , a distributed-memory machine, demonstrates that the combination of the compiler with the runtime system produces programs with performance comparable to that of efficient MPI programs and good performance scalability up to hundreds of thousands of processors.Our runtime system design solves the problem of maintaining shared object consistency efficiently in a distributed memory machine. Our compiler infrastructure simplifies the code generated for parallel loops in UPC through the elimination of affinity tests, eliminates several levels of indirection for accesses to segments of shared arrays that the compiler can prove to be local, and implements remote update operations through a lowercost asynchronous message. The performance evaluation uses three well-known benchmarks -HPC RandomAccess, HPC STREAM and NAS CG -to obtain scaling and absolute performance numbers for these benchmarks on up to 131072 processors, the full BlueGene/L machine. These results were used to win the HPC Challenge Competition at SC05 in Seattle WA, demonstrating that PGAS languages support both productivity and performance.

show abstract

Section: Related Workmentioning

confidence: 99%

Shared memory programming for large scale machines

Barton

Casçaval

Almási

et al. 2006

Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

show abstract

“…The work on the EARTH-C compiler was initiated by Laurie Hendren's group at McGill University [10,11,24,30,9,29 I. This compiler was based upon the McCAT compiler [7,8], which is a general framework for analyzing and transforming C programs.…”

Section: Earth-c Compilermentioning

confidence: 99%

“…Other more aggressive analyses and transformations already implemented in the EAtLTH-C compiler (for C and EARTH-C codes) include the following: determining local and non-local references by performing type propagation analysis [30]; using the results of heap and connection analysis for performing optimizations like loop invariant code motion and common subexpression elimination [24]; performing aggressive communication optimizatious like message aggregation and eliminating redundant communication [29]; detecting task and loop-level parallelism in C codes [9]; and performing automatic thread partitioning in the form of a general thread partitioning framework [23].…”

Section: Earth-c Compilermentioning

confidence: 99%

“…In the presence of pointer-based recursive data structures, which are frequently used by dynamic and irregular applications, it is difficult to extract precise information about which memory references are remote and where there may be data dependences. Our experience with the current version of the EARTH-C compiler [10,30,24,29] shows that the compiler frequently generates threads of very low granularity in the presence of dynamic, pointer-based data structures. As a result, the execution time of compiler-generated code can be dominated by context switching costs and poor speedups may be observed.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Automatic compiler techniques for thread coarsening for multithreaded architectures

Zoppetti

Agrawal

Pollock

et al. 2000

Proceedings of the 14th International Conference on Supercomputing

View full text Add to dashboard Cite

Multithreaded architectures are emerging as an important class of parallel machines. By allowing fast context switching between threads on the same processor, these systems hide communication and synchronization latencies and allow scalable parallelism for dynamic and irregular applications. Thread partitioning is the most important task in compiling high-level languages for multithreaded architectures. Non-preemptive multithreaded architectures, which can be built from off-the-shelf components, require that if a thread issues a potentially remote memory request, then any statement that is dependent upon this request must be in a separate thread.When performing thread partitioning on codes that use pointer-based recursive data structures, it is often difficult to extract accurate dependence information. As a result, threads of unnecessarily small granularity get generated, which, because of thread switching costs, leads to increased execution time. In this paper, we present three techniques that lead to improved extraction and representation of dependence information in the presence of structured control flow, references through fields of structures, and pointer-based data structures. The benefit of these techniques is the generation of coarser-grained threads and, therefore, decreased execution time. Our experiments were performed using the EARTH-C compiler and the EARTH multithreaded architecture model emulated on both a cluster of Pentium PCs and a distributed memory multiprocessor. On our set of 6 pointer-based programs, these techniques reduced the static number of threads by 38%. Reductions in execution times ranged from 16% to 45% on the four programs we measured runtime performance.

show abstract

“…Hiding communication latency is widely accepted as one of the most important optimizations in parallel programming [10,11,29]. Application writers and compilers for parallel languages attempt to achieve this by overlapping communication operations with other independent work in the application.…”

Section: Introductionmentioning

confidence: 99%

HUNTing the overlap

Iancu

Husbands

Hargrove

2005

14th International Conference on Parallel Architectures and Compilation Techniques (PACT'05)

View full text Add to dashboard Cite

Hiding communication latency is an important optimization for parallel programs. Programmers or compilers achieve this by using non-blocking communication primitives and overlapping communication with computation or other communication operations. Using non-blocking communication raises two issues: performance and programmability. In terms of performance, optimizers need to find a good communication schedule and are sometimes constrained by lack of full application knowledge. In terms of programmability, efficiently managing nonblocking communication can prove cumbersome for complex applications. In this paper we present the design principles of HUNT, a runtime system designed to search and exploit some of the available overlap present at execution time in UPC programs. Using virtual memory support, our runtime implements demand-driven synchronization for data involved in communication operations. It also employs message decomposition and scheduling heuristics to transparently improve the non-blocking behavior of applications. We provide a user level implementation of HUNT on a variety of modern high performance computing systems. Results indicate that our approach is successful in finding some of the overlap available at execution time. While system and application characteristics influence performance, perhaps the determining factor is the time taken by the CPU to execute a signal handler. Demand driven synchronization at execution time eliminates the need for the explicit management of non-blocking communication. Besides increasing programmer productivity, this feature also simplifies compiler analysis for communication optimizations.

show abstract

Communication Optimizations for Parallel C Programs

Cited by 9 publications

References 15 publications

Shared memory programming for large scale machines

Shared memory programming for large scale machines

Automatic compiler techniques for thread coarsening for multithreaded architectures

HUNTing the overlap

Contact Info

Product

Resources

About