Finding effective compilation sequences
Most modern compilers operate by applying a fixed, program-independent sequence of optimizations to all programs. Compiler writers choose a single "compilation sequence", or perhaps a couple of compilation sequences. In choosing a sequence, they may consider performance of benchmarks or ot...
Gespeichert in:
Hauptverfasser: | , , , , , , , |
---|---|
Format: | Tagungsbericht |
Sprache: | eng |
Schlagworte: | |
Online-Zugang: | Volltext |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 239 |
---|---|
container_issue | |
container_start_page | 231 |
container_title | |
container_volume | |
creator | Almagor, L. Cooper, Keith D. Grosul, Alexander Harvey, Timothy J. Reeves, Steven W. Subramanian, Devika Torczon, Linda Waterman, Todd |
description | Most modern compilers operate by applying a fixed, program-independent sequence of optimizations to all programs. Compiler writers choose a single "compilation sequence", or perhaps a couple of compilation sequences. In choosing a sequence, they may consider performance of benchmarks or other important codes. These sequences are intended as general-purpose tools, accessible through command-line flags such as -O2 and -O3.Specific compilation sequences make a significant difference in the quality of the generated code, whether compiling for speed, for space, or for other metrics. A single universal compilation sequence does not produce the best results over all programs [8, 10, 29, 32]. Finding an optimal program-specific compilation sequence is difficult because the space of potential sequences is huge and the interactions between optimizations are poorly understood. Moreover, there is no systematic exploration of the costs and benefits of searching for good (i.e., within a certain percentage of optimal) program-specific compilation sequences.In this paper, we perform a large experimental study of the space of compilation sequences over a set of known benchmarks, using our prototype adaptive compiler. Our goal is to characterize these spaces and to determine if it is cost-effective to construct custom compilation sequences. We report on five exhaustive enumerations which demonstrate that 80% of the local minima in the space are within 5 to 10% of the optimal solution. We describe three algorithms tailored to search such spaces and report on experiments that use these algorithms to find good compilation sequences. These experiments suggest that properties observed in the enumerations hold for larger search spaces and larger programs. Our findings indicate that for the cost of 200 to 4,550 compilations, we can find custom sequences that are 15 to 25% better than the human-designed fixed-sequence originally used in our compiler. |
doi_str_mv | 10.1145/997163.997196 |
format | Conference Proceeding |
fullrecord | <record><control><sourceid>proquest_acm_b</sourceid><recordid>TN_cdi_proquest_miscellaneous_31187855</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>31187855</sourcerecordid><originalsourceid>FETCH-LOGICAL-a995-509631f44598160c350d63b900f2b5703f18fcfea1b71c39d029acc224b5d07f3</originalsourceid><addsrcrecordid>eNqNkDtPwzAUhS0BElXJyJ4JFlLujePHHVFFC1Illu6W49jIkEepU34_qYLEynSG8-kc6WPsFmGFWIlHIoWSr85B8oJlpDQKjcg1SLxkC-CyLJBXcM2ylD4AYOqUJlqw-03sm9i_5z4E78b47XM3dIfY2jEOfZ7818n3zqcbdhVsm3z2m0u23zzv1y_F7m37un7aFZZIFAJIcgxVJUijBMcFNJLXBBDKWijgAXVwwVusFTpODZRknSvLqhYNqMCX7G6ePRyH6TmNpovJ-ba1vR9OyXBErbQQf6B1namH4TMZBHO2YWYbZrYxgQ__Ak19jD7wH1rkW9U</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype><pqid>31187855</pqid></control><display><type>conference_proceeding</type><title>Finding effective compilation sequences</title><source>ACM Digital Library Complete</source><creator>Almagor, L. ; Cooper, Keith D. ; Grosul, Alexander ; Harvey, Timothy J. ; Reeves, Steven W. ; Subramanian, Devika ; Torczon, Linda ; Waterman, Todd</creator><creatorcontrib>Almagor, L. ; Cooper, Keith D. ; Grosul, Alexander ; Harvey, Timothy J. ; Reeves, Steven W. ; Subramanian, Devika ; Torczon, Linda ; Waterman, Todd</creatorcontrib><description>Most modern compilers operate by applying a fixed, program-independent sequence of optimizations to all programs. Compiler writers choose a single "compilation sequence", or perhaps a couple of compilation sequences. In choosing a sequence, they may consider performance of benchmarks or other important codes. These sequences are intended as general-purpose tools, accessible through command-line flags such as -O2 and -O3.Specific compilation sequences make a significant difference in the quality of the generated code, whether compiling for speed, for space, or for other metrics. A single universal compilation sequence does not produce the best results over all programs [8, 10, 29, 32]. Finding an optimal program-specific compilation sequence is difficult because the space of potential sequences is huge and the interactions between optimizations are poorly understood. Moreover, there is no systematic exploration of the costs and benefits of searching for good (i.e., within a certain percentage of optimal) program-specific compilation sequences.In this paper, we perform a large experimental study of the space of compilation sequences over a set of known benchmarks, using our prototype adaptive compiler. Our goal is to characterize these spaces and to determine if it is cost-effective to construct custom compilation sequences. We report on five exhaustive enumerations which demonstrate that 80% of the local minima in the space are within 5 to 10% of the optimal solution. We describe three algorithms tailored to search such spaces and report on experiments that use these algorithms to find good compilation sequences. These experiments suggest that properties observed in the enumerations hold for larger search spaces and larger programs. Our findings indicate that for the cost of 200 to 4,550 compilations, we can find custom sequences that are 15 to 25% better than the human-designed fixed-sequence originally used in our compiler.</description><identifier>ISSN: 0362-1340</identifier><identifier>ISBN: 9781581138061</identifier><identifier>ISBN: 1581138067</identifier><identifier>DOI: 10.1145/997163.997196</identifier><language>eng</language><publisher>New York, NY, USA: ACM</publisher><subject>Computing methodologies -- Artificial intelligence -- Control methods ; Computing methodologies -- Artificial intelligence -- Search methodologies ; Software and its engineering -- Software notations and tools -- Compilers ; Theory of computation -- Design and analysis of algorithms -- Algorithm design techniques -- Dynamic programming</subject><ispartof>Proceedings of the 2004 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems, 2004, p.231-239</ispartof><rights>2004 ACM</rights><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>309,310,780,784,789,790,23930,23931,25140,27925</link.rule.ids></links><search><creatorcontrib>Almagor, L.</creatorcontrib><creatorcontrib>Cooper, Keith D.</creatorcontrib><creatorcontrib>Grosul, Alexander</creatorcontrib><creatorcontrib>Harvey, Timothy J.</creatorcontrib><creatorcontrib>Reeves, Steven W.</creatorcontrib><creatorcontrib>Subramanian, Devika</creatorcontrib><creatorcontrib>Torczon, Linda</creatorcontrib><creatorcontrib>Waterman, Todd</creatorcontrib><title>Finding effective compilation sequences</title><title>Proceedings of the 2004 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems</title><description>Most modern compilers operate by applying a fixed, program-independent sequence of optimizations to all programs. Compiler writers choose a single "compilation sequence", or perhaps a couple of compilation sequences. In choosing a sequence, they may consider performance of benchmarks or other important codes. These sequences are intended as general-purpose tools, accessible through command-line flags such as -O2 and -O3.Specific compilation sequences make a significant difference in the quality of the generated code, whether compiling for speed, for space, or for other metrics. A single universal compilation sequence does not produce the best results over all programs [8, 10, 29, 32]. Finding an optimal program-specific compilation sequence is difficult because the space of potential sequences is huge and the interactions between optimizations are poorly understood. Moreover, there is no systematic exploration of the costs and benefits of searching for good (i.e., within a certain percentage of optimal) program-specific compilation sequences.In this paper, we perform a large experimental study of the space of compilation sequences over a set of known benchmarks, using our prototype adaptive compiler. Our goal is to characterize these spaces and to determine if it is cost-effective to construct custom compilation sequences. We report on five exhaustive enumerations which demonstrate that 80% of the local minima in the space are within 5 to 10% of the optimal solution. We describe three algorithms tailored to search such spaces and report on experiments that use these algorithms to find good compilation sequences. These experiments suggest that properties observed in the enumerations hold for larger search spaces and larger programs. Our findings indicate that for the cost of 200 to 4,550 compilations, we can find custom sequences that are 15 to 25% better than the human-designed fixed-sequence originally used in our compiler.</description><subject>Computing methodologies -- Artificial intelligence -- Control methods</subject><subject>Computing methodologies -- Artificial intelligence -- Search methodologies</subject><subject>Software and its engineering -- Software notations and tools -- Compilers</subject><subject>Theory of computation -- Design and analysis of algorithms -- Algorithm design techniques -- Dynamic programming</subject><issn>0362-1340</issn><isbn>9781581138061</isbn><isbn>1581138067</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2004</creationdate><recordtype>conference_proceeding</recordtype><recordid>eNqNkDtPwzAUhS0BElXJyJ4JFlLujePHHVFFC1Illu6W49jIkEepU34_qYLEynSG8-kc6WPsFmGFWIlHIoWSr85B8oJlpDQKjcg1SLxkC-CyLJBXcM2ylD4AYOqUJlqw-03sm9i_5z4E78b47XM3dIfY2jEOfZ7818n3zqcbdhVsm3z2m0u23zzv1y_F7m37un7aFZZIFAJIcgxVJUijBMcFNJLXBBDKWijgAXVwwVusFTpODZRknSvLqhYNqMCX7G6ePRyH6TmNpovJ-ba1vR9OyXBErbQQf6B1namH4TMZBHO2YWYbZrYxgQ__Ak19jD7wH1rkW9U</recordid><startdate>20040611</startdate><enddate>20040611</enddate><creator>Almagor, L.</creator><creator>Cooper, Keith D.</creator><creator>Grosul, Alexander</creator><creator>Harvey, Timothy J.</creator><creator>Reeves, Steven W.</creator><creator>Subramanian, Devika</creator><creator>Torczon, Linda</creator><creator>Waterman, Todd</creator><general>ACM</general><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope></search><sort><creationdate>20040611</creationdate><title>Finding effective compilation sequences</title><author>Almagor, L. ; Cooper, Keith D. ; Grosul, Alexander ; Harvey, Timothy J. ; Reeves, Steven W. ; Subramanian, Devika ; Torczon, Linda ; Waterman, Todd</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a995-509631f44598160c350d63b900f2b5703f18fcfea1b71c39d029acc224b5d07f3</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2004</creationdate><topic>Computing methodologies -- Artificial intelligence -- Control methods</topic><topic>Computing methodologies -- Artificial intelligence -- Search methodologies</topic><topic>Software and its engineering -- Software notations and tools -- Compilers</topic><topic>Theory of computation -- Design and analysis of algorithms -- Algorithm design techniques -- Dynamic programming</topic><toplevel>online_resources</toplevel><creatorcontrib>Almagor, L.</creatorcontrib><creatorcontrib>Cooper, Keith D.</creatorcontrib><creatorcontrib>Grosul, Alexander</creatorcontrib><creatorcontrib>Harvey, Timothy J.</creatorcontrib><creatorcontrib>Reeves, Steven W.</creatorcontrib><creatorcontrib>Subramanian, Devika</creatorcontrib><creatorcontrib>Torczon, Linda</creatorcontrib><creatorcontrib>Waterman, Todd</creatorcontrib><collection>Computer and Information Systems Abstracts</collection><collection>Technology Research Database</collection><collection>ProQuest Computer Science Collection</collection><collection>Advanced Technologies Database with Aerospace</collection><collection>Computer and Information Systems Abstracts Academic</collection><collection>Computer and Information Systems Abstracts Professional</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Almagor, L.</au><au>Cooper, Keith D.</au><au>Grosul, Alexander</au><au>Harvey, Timothy J.</au><au>Reeves, Steven W.</au><au>Subramanian, Devika</au><au>Torczon, Linda</au><au>Waterman, Todd</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Finding effective compilation sequences</atitle><btitle>Proceedings of the 2004 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems</btitle><date>2004-06-11</date><risdate>2004</risdate><spage>231</spage><epage>239</epage><pages>231-239</pages><issn>0362-1340</issn><isbn>9781581138061</isbn><isbn>1581138067</isbn><abstract>Most modern compilers operate by applying a fixed, program-independent sequence of optimizations to all programs. Compiler writers choose a single "compilation sequence", or perhaps a couple of compilation sequences. In choosing a sequence, they may consider performance of benchmarks or other important codes. These sequences are intended as general-purpose tools, accessible through command-line flags such as -O2 and -O3.Specific compilation sequences make a significant difference in the quality of the generated code, whether compiling for speed, for space, or for other metrics. A single universal compilation sequence does not produce the best results over all programs [8, 10, 29, 32]. Finding an optimal program-specific compilation sequence is difficult because the space of potential sequences is huge and the interactions between optimizations are poorly understood. Moreover, there is no systematic exploration of the costs and benefits of searching for good (i.e., within a certain percentage of optimal) program-specific compilation sequences.In this paper, we perform a large experimental study of the space of compilation sequences over a set of known benchmarks, using our prototype adaptive compiler. Our goal is to characterize these spaces and to determine if it is cost-effective to construct custom compilation sequences. We report on five exhaustive enumerations which demonstrate that 80% of the local minima in the space are within 5 to 10% of the optimal solution. We describe three algorithms tailored to search such spaces and report on experiments that use these algorithms to find good compilation sequences. These experiments suggest that properties observed in the enumerations hold for larger search spaces and larger programs. Our findings indicate that for the cost of 200 to 4,550 compilations, we can find custom sequences that are 15 to 25% better than the human-designed fixed-sequence originally used in our compiler.</abstract><cop>New York, NY, USA</cop><pub>ACM</pub><doi>10.1145/997163.997196</doi><tpages>9</tpages></addata></record> |
fulltext | fulltext |
identifier | ISSN: 0362-1340 |
ispartof | Proceedings of the 2004 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems, 2004, p.231-239 |
issn | 0362-1340 |
language | eng |
recordid | cdi_proquest_miscellaneous_31187855 |
source | ACM Digital Library Complete |
subjects | Computing methodologies -- Artificial intelligence -- Control methods Computing methodologies -- Artificial intelligence -- Search methodologies Software and its engineering -- Software notations and tools -- Compilers Theory of computation -- Design and analysis of algorithms -- Algorithm design techniques -- Dynamic programming |
title | Finding effective compilation sequences |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-24T03%3A01%3A20IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_acm_b&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Finding%20effective%20compilation%20sequences&rft.btitle=Proceedings%20of%20the%202004%20ACM%20SIGPLAN/SIGBED%20conference%20on%20Languages,%20compilers,%20and%20tools%20for%20embedded%20systems&rft.au=Almagor,%20L.&rft.date=2004-06-11&rft.spage=231&rft.epage=239&rft.pages=231-239&rft.issn=0362-1340&rft.isbn=9781581138061&rft.isbn_list=1581138067&rft_id=info:doi/10.1145/997163.997196&rft_dat=%3Cproquest_acm_b%3E31187855%3C/proquest_acm_b%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=31187855&rft_id=info:pmid/&rfr_iscdi=true |