Patterns for cache optimizations on multi-processor machines

Authors:
Nicholas Chen;Ralph Johnson
Affiliations:
University of Illinois at Urbana-Champaign;University of Illinois at Urbana-Champaign
Venue:
Proceedings of the 2010 Workshop on Parallel Programming Patterns
Year:
2010

Citing 12
Cited 1

Hitting the memory wall: implications of the obvious

ACM SIGARCH Computer Architecture News
Advanced compiler design and implementation

Advanced compiler design and implementation
Cache-conscious structure layout

Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Cache-conscious structure definition

Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Refactoring: improving the design of existing code

Refactoring: improving the design of existing code
Optimizing compilers for modern architectures: a dependence-based approach

Optimizing compilers for modern architectures: a dependence-based approach
A parallel java grande benchmark suite

Proceedings of the 2001 ACM/IEEE conference on Supercomputing
Cache-Oblivious Algorithms

FOCS '99 Proceedings of the 40th Annual Symposium on Foundations of Computer Science
An experimental comparison of cache-oblivious and cache-conscious programs

Proceedings of the nineteenth annual ACM symposium on Parallel algorithms and architectures
Refactoring sequential Java code for concurrency via concurrent libraries

ICSE '09 Proceedings of the 31st International Conference on Software Engineering
A type and effect system for deterministic parallel Java

Proceedings of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications
Patterns of optimized loops

Proceedings of the 2010 Workshop on Parallel Programming Patterns

Comparing parallel performance of Go and C++ TBB on a direct acyclic task graph using a dynamic programming problem

Proceedings of the 50th Annual Southeast Regional Conference

Quantified Score

Hi-index	0.00

Visualization

Abstract

Writing parallel programs that run optimally on multi-processor machines is hard. Programmers not only have to reason about existing cache issues that affect single-threaded programs but also new cache issues that impact multi-threaded programs. Such cache issues are surprisingly common; neglecting them leads to poorly performing programs that do not scale well. We illustrate these common cache issues and show how current tools aid programmers in reliably diagnosing these issues. The goal of our work is to promote discussions on whether such cache issues should be included in the Berkeley Our Pattern Language --- either by incorporating such performance issues directly into each pattern as forces or by creating a supplementary pattern language for general performance optimizations.