{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/29658"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/29658","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Hardware atomicity for compiler-directed control speculation","abstract":"This dissertation introduces the atomic region as a novel compiler abstraction which eases the development of speculative compiler optimizations. As this dissertation will show, speculation enables a compiler writer to exploit dynamically occurring opportunities which would otherwise be difficult or even impossible to expose. Despite their potential, speculative optimizations typically involve complex implementation and significant compiler re-engineering. In comparison, the atomic region abstraction is both simple to incorporate into a compiler infrastructure and also exposes speculative opportunity to existing and unmodified optimizations. The utility of the atomic region abstraction largely derives from its use of hardware atomicity---the execution of a region of code either completely, and as if all operations in the region occurred at one instant, or not at all. Hardware atomicity is an architectural primitive which provides software with a simple and intuitive model of execution, namely the ability to either explicitly commit or rollback a region of code. The atomic region abstraction leverages hardware atomicity to enable a compiler writer to easily reason about and implement speculative optimization. In the atomic region abstraction, the compiler encapsulates commonly executed regions of the program using the hardware atomicity primitive. This permits the compiler to generate a speculative version of the code where uncommonly executed code paths are completely removed such that they do not need to be considered in (and hence do not constrain) a region's optimization. Pruned paths are converted into assert operations that trigger an abort in the uncommon case that one of these paths is needed. On an abort, hardware reverts state back to the beginning of the region and transfers control to a non-speculative version of the code. Two implementations of the atomic region abstraction are also presented, the first of which demonstrates potential for a 10-15% average performance improvement in the context of a Java Virtual Machine, albeit running on simulated hardware. Incorporation of the atomic region abstraction is shown to be a simple and, thereby, a cost-effective means for exposing speculative optimization opportunities to the compiler. The second implementation leverages a real system to demonstrate that at least some of these gains are achievable in practice. By incorporating the atomic region abstraction into the dynamic translator of the Transmeta Efficeon processor, practical concerns related to the identification of speculative opportunities and adaptation to misspeculations are explored. In the context of this real system, a straightforward implementation using simple control mechanisms is shown to be sufficient to achieve a 3% average performance improvement.","abstract_html":"This dissertation introduces the atomic region as a novel compiler abstraction which eases the development of speculative compiler optimizations. As this dissertation will show, speculation enables a compiler writer to exploit dynamically occurring opportunities which would otherwise be difficult or even impossible to expose. Despite their potential, speculative optimizations typically involve complex implementation and significant compiler re-engineering. In comparison, the atomic region abstraction is both simple to incorporate into a compiler infrastructure and also exposes speculative opportunity to existing and unmodified optimizations. The utility of the atomic region abstraction largely derives from its use of hardware atomicity---the execution of a region of code either completely, and as if all operations in the region occurred at one instant, or not at all. Hardware atomicity is an architectural primitive which provides software with a simple and intuitive model of execution, namely the ability to either explicitly commit or rollback a region of code. The atomic region abstraction leverages hardware atomicity to enable a compiler writer to easily reason about and implement speculative optimization. In the atomic region abstraction, the compiler encapsulates commonly executed regions of the program using the hardware atomicity primitive. This permits the compiler to generate a speculative version of the code where uncommonly executed code paths are completely removed such that they do not need to be considered in (and hence do not constrain) a region's optimization. Pruned paths are converted into assert operations that trigger an abort in the uncommon case that one of these paths is needed. On an abort, hardware reverts state back to the beginning of the region and transfers control to a non-speculative version of the code. Two implementations of the atomic region abstraction are also presented, the first of which demonstrates potential for a 10-15% average performance improvement in the context of a Java Virtual Machine, albeit running on simulated hardware. Incorporation of the atomic region abstraction is shown to be a simple and, thereby, a cost-effective means for exposing speculative optimization opportunities to the compiler. The second implementation leverages a real system to demonstrate that at least some of these gains are achievable in practice. By incorporating the atomic region abstraction into the dynamic translator of the Transmeta Efficeon processor, practical concerns related to the identification of speculative opportunities and adaptation to misspeculations are explored. In the context of this real system, a straightforward implementation using simple control mechanisms is shown to be sufficient to achieve a 3% average performance improvement.","abstract_has_math":false,"creators":["Neelakantam, Naveen"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"Ph.D.","degree_level":"Dissertation","degree_discipline":"Computer Science","degree_department":null,"school":null,"contributors":["Zilles, Craig","Adve, Vikram S.","Hwu, Wen-Mei W.","Rajwar, Ravi","Srinivas, Suresh","Snir, Marc"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2012,"date_issued":"2012-02-06T20:09:25Z","date_published":"2012-02-06T20:09:25Z","updated_at":"2026-07-22T22:25:27Z","subjects":["Hardware Atomicity","Speculative Compiler Optimization","Control Speculation","Hardware/Software Co-design","Dynamic Optimization","Computer Architecture"],"languages":["en"],"rights":["Copyright 2011 by Naveen Neelakantam"],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"http://hdl.handle.net/2142/29658","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Zilles, Craig","Adve, Vikram S.","Hwu, Wen-Mei W.","Rajwar, Ravi","Srinivas, Suresh","Snir, Marc"]},{"key":"dc:creator","label":"Author","values":["Neelakantam, Naveen"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2012-02-06T20:09:25Z","2011-12"]},{"key":"dc:type","label":"Dc Type","values":["Dissertation / Thesis","text"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Dissertation"]},{"key":"thesis:degree_name","label":"Degree Name","values":["Ph.D."]},{"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":["Hardware Atomicity","Speculative Compiler Optimization","Control Speculation","Hardware/Software Co-design","Dynamic Optimization","Computer Architecture"]}]},{"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 by Naveen Neelakantam"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/29658"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["This dissertation introduces the atomic region as a novel compiler abstraction which eases the development of speculative compiler optimizations. As this dissertation will show, speculation enables a compiler writer to exploit dynamically occurring opportunities which would otherwise be difficult or even impossible to expose. Despite their potential, speculative optimizations typically involve complex implementation and significant compiler re-engineering. In comparison, the atomic region abstraction is both simple to incorporate into a compiler infrastructure and also exposes speculative opportunity to existing and unmodified optimizations. The utility of the atomic region abstraction largely derives from its use of hardware atomicity---the execution of a region of code either completely, and as if all operations in the region occurred at one instant, or not at all. Hardware atomicity is an architectural primitive which provides software with a simple and intuitive model of execution, namely the ability to either explicitly commit or rollback a region of code. The atomic region abstraction leverages hardware atomicity to enable a compiler writer to easily reason about and implement speculative optimization. In the atomic region abstraction, the compiler encapsulates commonly executed regions of the program using the hardware atomicity primitive. This permits the compiler to generate a speculative version of the code where uncommonly executed code paths are completely removed such that they do not need to be considered in (and hence do not constrain) a region's optimization. Pruned paths are converted into assert operations that trigger an abort in the uncommon case that one of these paths is needed. On an abort, hardware reverts state back to the beginning of the region and transfers control to a non-speculative version of the code. Two implementations of the atomic region abstraction are also presented, the first of which demonstrates potential for a 10-15% average performance improvement in the context of a Java Virtual Machine, albeit running on simulated hardware. Incorporation of the atomic region abstraction is shown to be a simple and, thereby, a cost-effective means for exposing speculative optimization opportunities to the compiler. The second implementation leverages a real system to demonstrate that at least some of these gains are achievable in practice. By incorporating the atomic region abstraction into the dynamic translator of the Transmeta Efficeon processor, practical concerns related to the identification of speculative opportunities and adaptation to misspeculations are explored. In the context of this real system, a straightforward implementation using simple control mechanisms is shown to be sufficient to achieve a 3% average performance improvement.","Item withdrawn by Katherine Eriksen (eriksen3@illinois.edu) on 2011-11-29T15:20:36Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 2 dissertation.tar.gz: 23492196 bytes, checksum: 1a58f69967305bca0745feebeeedfa58 (MD5) Neelakantam_Naveen.pdf: 1655311 bytes, checksum: 8f90b4b6eabe783462c064abca3503a0 (MD5)","Made available in DSpace on 2012-02-06T20:09:25Z (GMT). No. of bitstreams: 3 Neelakantam_Naveen.pdf: 1655311 bytes, checksum: 8f90b4b6eabe783462c064abca3503a0 (MD5) license.txt: 4068 bytes, checksum: ed8b07d57e2dd24e34e96ff4507ddffa (MD5) dissertation.tar.gz: 23492196 bytes, checksum: 1a58f69967305bca0745feebeeedfa58 (MD5)"]},{"key":"dc:title","label":"Title","values":["Hardware atomicity for compiler-directed control speculation"]}]}],"canonical_facts":{"dc:contributor":["Zilles, Craig","Adve, Vikram S.","Hwu, Wen-Mei W.","Rajwar, Ravi","Srinivas, Suresh","Snir, Marc"],"dc:creator":["Neelakantam, Naveen"],"dc:date":["2012-02-06T20:09:25Z","2011-12"],"dc:description":["This dissertation introduces the atomic region as a novel compiler abstraction which eases the development of speculative compiler optimizations. As this dissertation will show, speculation enables a compiler writer to exploit dynamically occurring opportunities which would otherwise be difficult or even impossible to expose. Despite their potential, speculative optimizations typically involve complex implementation and significant compiler re-engineering. In comparison, the atomic region abstraction is both simple to incorporate into a compiler infrastructure and also exposes speculative opportunity to existing and unmodified optimizations. The utility of the atomic region abstraction largely derives from its use of hardware atomicity---the execution of a region of code either completely, and as if all operations in the region occurred at one instant, or not at all. Hardware atomicity is an architectural primitive which provides software with a simple and intuitive model of execution, namely the ability to either explicitly commit or rollback a region of code. The atomic region abstraction leverages hardware atomicity to enable a compiler writer to easily reason about and implement speculative optimization. In the atomic region abstraction, the compiler encapsulates commonly executed regions of the program using the hardware atomicity primitive. This permits the compiler to generate a speculative version of the code where uncommonly executed code paths are completely removed such that they do not need to be considered in (and hence do not constrain) a region's optimization. Pruned paths are converted into assert operations that trigger an abort in the uncommon case that one of these paths is needed. On an abort, hardware reverts state back to the beginning of the region and transfers control to a non-speculative version of the code. Two implementations of the atomic region abstraction are also presented, the first of which demonstrates potential for a 10-15% average performance improvement in the context of a Java Virtual Machine, albeit running on simulated hardware. Incorporation of the atomic region abstraction is shown to be a simple and, thereby, a cost-effective means for exposing speculative optimization opportunities to the compiler. The second implementation leverages a real system to demonstrate that at least some of these gains are achievable in practice. By incorporating the atomic region abstraction into the dynamic translator of the Transmeta Efficeon processor, practical concerns related to the identification of speculative opportunities and adaptation to misspeculations are explored. In the context of this real system, a straightforward implementation using simple control mechanisms is shown to be sufficient to achieve a 3% average performance improvement.","Item withdrawn by Katherine Eriksen (eriksen3@illinois.edu) on 2011-11-29T15:20:36Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 2 dissertation.tar.gz: 23492196 bytes, checksum: 1a58f69967305bca0745feebeeedfa58 (MD5) Neelakantam_Naveen.pdf: 1655311 bytes, checksum: 8f90b4b6eabe783462c064abca3503a0 (MD5)","Made available in DSpace on 2012-02-06T20:09:25Z (GMT). No. of bitstreams: 3 Neelakantam_Naveen.pdf: 1655311 bytes, checksum: 8f90b4b6eabe783462c064abca3503a0 (MD5) license.txt: 4068 bytes, checksum: ed8b07d57e2dd24e34e96ff4507ddffa (MD5) dissertation.tar.gz: 23492196 bytes, checksum: 1a58f69967305bca0745feebeeedfa58 (MD5)"],"dc:identifier":["http://hdl.handle.net/2142/29658"],"dc:language":["en"],"dc:rights":["Copyright 2011 by Naveen Neelakantam"],"dc:subject":["Hardware Atomicity","Speculative Compiler Optimization","Control Speculation","Hardware/Software Co-design","Dynamic Optimization","Computer Architecture"],"dc:title":["Hardware atomicity for compiler-directed control speculation"],"dc:type":["Dissertation / Thesis","text"],"thesis:degree_discipline":["Computer Science"],"thesis:degree_level":["Dissertation"],"thesis:degree_name":["Ph.D."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:25:27Z"}