{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/26124"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/26124","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Refactoring transformations for maintainable, scalable and efficient parallelism","abstract":"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.","abstract_html":"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.","abstract_has_math":false,"creators":["Kjolstad, Fredrik Berg"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"M.S.","degree_level":"Thesis","degree_discipline":"Computer Science","degree_department":null,"school":null,"contributors":["Snir, Marc","Hoefler, Torsten"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2011,"date_issued":"2011-08-25T22:15:01Z","date_published":"2011-08-25T22:15:01Z","updated_at":"2026-07-22T22:25:26Z","subjects":["Refactoring","Program Transformation","Parallelism","High Performance Computing (HPC)","Immutability","Datatypes"],"languages":["en"],"rights":["Copyright 2011 Fredrik Berg Kjolstad"],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"http://hdl.handle.net/2142/26124","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Snir, Marc","Hoefler, Torsten"]},{"key":"dc:creator","label":"Author","values":["Kjolstad, Fredrik Berg"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2011-08-25T22:15:01Z","2011-08"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Thesis"]},{"key":"thesis:degree_name","label":"Degree Name","values":["M.S."]},{"key":"thesis:institution_name","label":"Thesis Institution Name","values":["University of Illinois at Urbana-Champaign"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["Refactoring","Program Transformation","Parallelism","High Performance Computing (HPC)","Immutability","Datatypes"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language","label":"Dc Language","values":["en"]},{"key":"dc:rights","label":"Dc Rights","values":["Copyright 2011 Fredrik Berg Kjolstad"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/26124"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["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.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2011-07-16T15:48:50Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 1 Kjolstad_Fredrik.pdf: 620431 bytes, checksum: cdf32eee7a95cf275c4e760bad4b512d (MD5)","Made available in DSpace on 2011-08-25T22:15:01Z (GMT). No. of bitstreams: 2 Kjolstad_Fredrik.pdf: 620431 bytes, checksum: cdf32eee7a95cf275c4e760bad4b512d (MD5) license.txt: 4066 bytes, checksum: 6e0c4a87b7727942a5ff07c5987c0ada (MD5)"]},{"key":"dc:title","label":"Title","values":["Refactoring transformations for maintainable, scalable and efficient parallelism"]}]}],"canonical_facts":{"dc:contributor":["Snir, Marc","Hoefler, Torsten"],"dc:creator":["Kjolstad, Fredrik Berg"],"dc:date":["2011-08-25T22:15:01Z","2011-08"],"dc:description":["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.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2011-07-16T15:48:50Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 1 Kjolstad_Fredrik.pdf: 620431 bytes, checksum: cdf32eee7a95cf275c4e760bad4b512d (MD5)","Made available in DSpace on 2011-08-25T22:15:01Z (GMT). No. of bitstreams: 2 Kjolstad_Fredrik.pdf: 620431 bytes, checksum: cdf32eee7a95cf275c4e760bad4b512d (MD5) license.txt: 4066 bytes, checksum: 6e0c4a87b7727942a5ff07c5987c0ada (MD5)"],"dc:identifier":["http://hdl.handle.net/2142/26124"],"dc:language":["en"],"dc:rights":["Copyright 2011 Fredrik Berg Kjolstad"],"dc:subject":["Refactoring","Program Transformation","Parallelism","High Performance Computing (HPC)","Immutability","Datatypes"],"dc:title":["Refactoring transformations for maintainable, scalable and efficient parallelism"],"thesis:degree_discipline":["Computer Science"],"thesis:degree_level":["Thesis"],"thesis:degree_name":["M.S."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:25:26Z"}