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...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: Almagor, L., Cooper, Keith D., Grosul, Alexander, Harvey, Timothy J., Reeves, Steven W., Subramanian, Devika, Torczon, Linda, Waterman, Todd
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