Refactoring transformations for maintainable, scalable and efficient parallelism

Refactoring;Program Transformation;Parallelism;High Performance Computing (HPC);Immutability;Datatypes

Kjolstad, Fredrik Berg ; Snir ; Marc ; Hoefler ; Torsten

关键词: Refactoring;    Program Transformation;    Parallelism;    High Performance Computing (HPC);    Immutability;    Datatypes;   

Others  :  https://www.ideals.illinois.edu/bitstream/handle/2142/26124/Kjolstad_Fredrik.pdf?sequence=1&isAllowed=y

美国|英语

来源: The Illinois Digital Environment for Access to Learning and Scholarship

【 摘 要 】

Computing is everywhere and our society depends on it. Increased performance over the last decades has allowed us to solve ever more interesting problems. We long relied on frequency scaling and instruction-level parallelism to give us the headroom we needed without disrupting software development, but this came to an end. The burden has now shifted to the programmer who is told to take advantage of a rapidly increasing host of parallel resources. Focus has been on helping him express parallel tasks, but this is not enough. Once parallelism is expressed, the programmer must still efficiently map it to the target system. Furthermore, the programmer who wants his application to survive the next platform must also care about maintainability and scalability.This thesis explores the concept of automated refactoring transformations to make parallel applications maintainable, scalable and efficient. To that end, it develops two novel transformations that target very different application domains. Furthermore, it provides a catalogue of refactoring transformations for the HPC programmer, and argues that the proposed transformations require a new refactoring infrastructure.The first transformation that is developed is targeted at irregular object-oriented shared-memory parallel applications, where too much shared data is a source of bugs and excessive synchronization. The transformation automatically converts mutable Java classes to immutable Java classes, which guarantees that objects instantiated from them will not be altered by other threads.The second transformation targets regular distributed-memory parallel applications that spend significant time packing non-contiguous data into contiguous communication buffers. The transformation automatically replaces the packing code with a datatype that describes the layout of the packed data. This empowers the runtime to optimize the transfer for the target system, for example by exploiting advanced network features such as non-contiguous sends and receives.By providing such parallel refactoring transformations we can improve the productivity of the programmer in his struggle to keep his application running on a plethora of platforms.