Efficient State-Diagram Construction Methods for Software Pipelining
State diagram based approach has been proposed as an effective way to model resource constraints in traditional instruction scheduling and software pipelining methods. However, the constructed state diagram for software pipelining method (i) is very large and (ii) contains significant amount of repl...
Gespeichert in:
Hauptverfasser: | , , , |
---|---|
Format: | Buchkapitel |
Sprache: | eng |
Schlagworte: | |
Online-Zugang: | Volltext |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 167 |
---|---|
container_issue | |
container_start_page | 153 |
container_title | |
container_volume | 1575 |
creator | Zhang, Chihong Govindarajan, Ramaswamy Ryan, Sean Gao, Guang R. |
description | State diagram based approach has been proposed as an effective way to model resource constraints in traditional instruction scheduling and software pipelining methods. However, the constructed state diagram for software pipelining method (i) is very large and (ii) contains significant amount of replicated, and hence redundant, information on legal latency sequences. As a result, the construction of state diagrams can take very large computation time.
In this paper, we propose two methods for the efficient construction of state diagrams. In the first method, we relate the construction of state diagram to a well-known problem in graph theory, namely the enumeration of maximal independent sets of a graph. This facilitates the use of an existing algorithm as a direct method for constructing distinct latency sequences. The second method is a heuristic approach which exploits the structure of state diagram construction to eliminate redundancy at the earliest opportunity in an aggressive fashion. The heuristic method uses a surprisingly simple check which is formally shown to completely eliminate redundancy in the state diagram. From our experimental results on two real architectures, both of the two methods show a great reduction in state diagram construction time. |
doi_str_mv | 10.1007/978-3-540-49051-7_11 |
format | Book Chapter |
fullrecord | <record><control><sourceid>proquest_pasca</sourceid><recordid>TN_cdi_pascalfrancis_primary_1577281</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>EBC3087804_17_170</sourcerecordid><originalsourceid>FETCH-LOGICAL-p317t-e77fd965fa868c0424c2201efa78bba84e56a8e5d75bc5f772553590af1dc583</originalsourceid><addsrcrecordid>eNotkM1PAyEQxfEz1tr_wMMevKLMsuzA0dT6kWg00TuhFFq03V0BY_zvpdq5TPLevJfMj5BzYJfAGF4plJRT0TDaKCaAogbYI5Mi8yL-abhPRtACUM4bdUBOt0YrEBAPyYhxVlOFDT8mI1V8VBL4CZmk9M7K8BpUCyNyM_M-2OC6XL1mkx29CWYZzaaa9l3K8cvm0HfVk8urfpEq38fqtff520RXvYTBrUMXuuUZOfJmndxkt8fk7Xb2Nr2nj893D9PrRzpwwEwdol-oVngjW2lZUze2rhk4b1DO50Y2TrRGOrFAMbfCI9ZCcKGY8bCwQvIxufivHUyyZu2j6WxIeohhY-KPBlES5ckxqf_PUnG6pYt63vcfSQPTW7K6INRcF1b6j6Leki0hvuuO_eeXS1m7bcoWMNGs7coM2cWkOZMoWaOhhJDxX8UVdpw</addsrcrecordid><sourcetype>Index Database</sourcetype><iscdi>true</iscdi><recordtype>book_chapter</recordtype><pqid>EBC3087804_17_170</pqid></control><display><type>book_chapter</type><title>Efficient State-Diagram Construction Methods for Software Pipelining</title><source>Springer Books</source><creator>Zhang, Chihong ; Govindarajan, Ramaswamy ; Ryan, Sean ; Gao, Guang R.</creator><contributor>Jähnichen, Stefan ; van Leeuwen, Jan ; Jähnichen, Stefan</contributor><creatorcontrib>Zhang, Chihong ; Govindarajan, Ramaswamy ; Ryan, Sean ; Gao, Guang R. ; Jähnichen, Stefan ; van Leeuwen, Jan ; Jähnichen, Stefan</creatorcontrib><description>State diagram based approach has been proposed as an effective way to model resource constraints in traditional instruction scheduling and software pipelining methods. However, the constructed state diagram for software pipelining method (i) is very large and (ii) contains significant amount of replicated, and hence redundant, information on legal latency sequences. As a result, the construction of state diagrams can take very large computation time.
In this paper, we propose two methods for the efficient construction of state diagrams. In the first method, we relate the construction of state diagram to a well-known problem in graph theory, namely the enumeration of maximal independent sets of a graph. This facilitates the use of an existing algorithm as a direct method for constructing distinct latency sequences. The second method is a heuristic approach which exploits the structure of state diagram construction to eliminate redundancy at the earliest opportunity in an aggressive fashion. The heuristic method uses a surprisingly simple check which is formally shown to completely eliminate redundancy in the state diagram. From our experimental results on two real architectures, both of the two methods show a great reduction in state diagram construction time.</description><identifier>ISSN: 0302-9743</identifier><identifier>ISBN: 3540657177</identifier><identifier>ISBN: 9783540657170</identifier><identifier>EISSN: 1611-3349</identifier><identifier>EISBN: 9783540490517</identifier><identifier>EISBN: 3540490515</identifier><identifier>DOI: 10.1007/978-3-540-49051-7_11</identifier><identifier>OCLC: 934979813</identifier><identifier>LCCallNum: QA75.5-76.95</identifier><language>eng</language><publisher>Germany: Springer Berlin / Heidelberg</publisher><subject>Applied sciences ; Computer science; control theory; systems ; Construction Time ; Exact sciences and technology ; Interference Graph ; Language processing and microprogramming ; Latency Sequence ; Redundancy Constraint ; Software ; State Diagram</subject><ispartof>Compiler Construction, 1999, Vol.1575, p.153-167</ispartof><rights>Springer-Verlag Berlin Heidelberg 1999</rights><rights>1999 INIST-CNRS</rights><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><relation>Lecture Notes in Computer Science</relation></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Uhttps://ebookcentral.proquest.com/covers/3087804-l.jpg</thumbnail><linktopdf>$$Uhttps://link.springer.com/content/pdf/10.1007/978-3-540-49051-7_11$$EPDF$$P50$$Gspringer$$H</linktopdf><linktohtml>$$Uhttps://link.springer.com/10.1007/978-3-540-49051-7_11$$EHTML$$P50$$Gspringer$$H</linktohtml><link.rule.ids>309,310,776,777,781,786,787,790,4036,4037,27906,38236,41423,42492</link.rule.ids><backlink>$$Uhttp://pascal-francis.inist.fr/vibad/index.php?action=getRecordDetail&idt=1577281$$DView record in Pascal Francis$$Hfree_for_read</backlink></links><search><contributor>Jähnichen, Stefan</contributor><contributor>van Leeuwen, Jan</contributor><contributor>Jähnichen, Stefan</contributor><creatorcontrib>Zhang, Chihong</creatorcontrib><creatorcontrib>Govindarajan, Ramaswamy</creatorcontrib><creatorcontrib>Ryan, Sean</creatorcontrib><creatorcontrib>Gao, Guang R.</creatorcontrib><title>Efficient State-Diagram Construction Methods for Software Pipelining</title><title>Compiler Construction</title><description>State diagram based approach has been proposed as an effective way to model resource constraints in traditional instruction scheduling and software pipelining methods. However, the constructed state diagram for software pipelining method (i) is very large and (ii) contains significant amount of replicated, and hence redundant, information on legal latency sequences. As a result, the construction of state diagrams can take very large computation time.
In this paper, we propose two methods for the efficient construction of state diagrams. In the first method, we relate the construction of state diagram to a well-known problem in graph theory, namely the enumeration of maximal independent sets of a graph. This facilitates the use of an existing algorithm as a direct method for constructing distinct latency sequences. The second method is a heuristic approach which exploits the structure of state diagram construction to eliminate redundancy at the earliest opportunity in an aggressive fashion. The heuristic method uses a surprisingly simple check which is formally shown to completely eliminate redundancy in the state diagram. From our experimental results on two real architectures, both of the two methods show a great reduction in state diagram construction time.</description><subject>Applied sciences</subject><subject>Computer science; control theory; systems</subject><subject>Construction Time</subject><subject>Exact sciences and technology</subject><subject>Interference Graph</subject><subject>Language processing and microprogramming</subject><subject>Latency Sequence</subject><subject>Redundancy Constraint</subject><subject>Software</subject><subject>State Diagram</subject><issn>0302-9743</issn><issn>1611-3349</issn><isbn>3540657177</isbn><isbn>9783540657170</isbn><isbn>9783540490517</isbn><isbn>3540490515</isbn><fulltext>true</fulltext><rsrctype>book_chapter</rsrctype><creationdate>1999</creationdate><recordtype>book_chapter</recordtype><recordid>eNotkM1PAyEQxfEz1tr_wMMevKLMsuzA0dT6kWg00TuhFFq03V0BY_zvpdq5TPLevJfMj5BzYJfAGF4plJRT0TDaKCaAogbYI5Mi8yL-abhPRtACUM4bdUBOt0YrEBAPyYhxVlOFDT8mI1V8VBL4CZmk9M7K8BpUCyNyM_M-2OC6XL1mkx29CWYZzaaa9l3K8cvm0HfVk8urfpEq38fqtff520RXvYTBrUMXuuUZOfJmndxkt8fk7Xb2Nr2nj893D9PrRzpwwEwdol-oVngjW2lZUze2rhk4b1DO50Y2TrRGOrFAMbfCI9ZCcKGY8bCwQvIxufivHUyyZu2j6WxIeohhY-KPBlES5ckxqf_PUnG6pYt63vcfSQPTW7K6INRcF1b6j6Leki0hvuuO_eeXS1m7bcoWMNGs7coM2cWkOZMoWaOhhJDxX8UVdpw</recordid><startdate>1999</startdate><enddate>1999</enddate><creator>Zhang, Chihong</creator><creator>Govindarajan, Ramaswamy</creator><creator>Ryan, Sean</creator><creator>Gao, Guang R.</creator><general>Springer Berlin / Heidelberg</general><general>Springer Berlin Heidelberg</general><general>Springer</general><scope>FFUUA</scope><scope>IQODW</scope></search><sort><creationdate>1999</creationdate><title>Efficient State-Diagram Construction Methods for Software Pipelining</title><author>Zhang, Chihong ; Govindarajan, Ramaswamy ; Ryan, Sean ; Gao, Guang R.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-p317t-e77fd965fa868c0424c2201efa78bba84e56a8e5d75bc5f772553590af1dc583</frbrgroupid><rsrctype>book_chapters</rsrctype><prefilter>book_chapters</prefilter><language>eng</language><creationdate>1999</creationdate><topic>Applied sciences</topic><topic>Computer science; control theory; systems</topic><topic>Construction Time</topic><topic>Exact sciences and technology</topic><topic>Interference Graph</topic><topic>Language processing and microprogramming</topic><topic>Latency Sequence</topic><topic>Redundancy Constraint</topic><topic>Software</topic><topic>State Diagram</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Zhang, Chihong</creatorcontrib><creatorcontrib>Govindarajan, Ramaswamy</creatorcontrib><creatorcontrib>Ryan, Sean</creatorcontrib><creatorcontrib>Gao, Guang R.</creatorcontrib><collection>ProQuest Ebook Central - Book Chapters - Demo use only</collection><collection>Pascal-Francis</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Zhang, Chihong</au><au>Govindarajan, Ramaswamy</au><au>Ryan, Sean</au><au>Gao, Guang R.</au><au>Jähnichen, Stefan</au><au>van Leeuwen, Jan</au><au>Jähnichen, Stefan</au><format>book</format><genre>bookitem</genre><ristype>CHAP</ristype><atitle>Efficient State-Diagram Construction Methods for Software Pipelining</atitle><btitle>Compiler Construction</btitle><seriestitle>Lecture Notes in Computer Science</seriestitle><date>1999</date><risdate>1999</risdate><volume>1575</volume><spage>153</spage><epage>167</epage><pages>153-167</pages><issn>0302-9743</issn><eissn>1611-3349</eissn><isbn>3540657177</isbn><isbn>9783540657170</isbn><eisbn>9783540490517</eisbn><eisbn>3540490515</eisbn><abstract>State diagram based approach has been proposed as an effective way to model resource constraints in traditional instruction scheduling and software pipelining methods. However, the constructed state diagram for software pipelining method (i) is very large and (ii) contains significant amount of replicated, and hence redundant, information on legal latency sequences. As a result, the construction of state diagrams can take very large computation time.
In this paper, we propose two methods for the efficient construction of state diagrams. In the first method, we relate the construction of state diagram to a well-known problem in graph theory, namely the enumeration of maximal independent sets of a graph. This facilitates the use of an existing algorithm as a direct method for constructing distinct latency sequences. The second method is a heuristic approach which exploits the structure of state diagram construction to eliminate redundancy at the earliest opportunity in an aggressive fashion. The heuristic method uses a surprisingly simple check which is formally shown to completely eliminate redundancy in the state diagram. From our experimental results on two real architectures, both of the two methods show a great reduction in state diagram construction time.</abstract><cop>Germany</cop><pub>Springer Berlin / Heidelberg</pub><doi>10.1007/978-3-540-49051-7_11</doi><oclcid>934979813</oclcid><tpages>15</tpages><oa>free_for_read</oa></addata></record> |
fulltext | fulltext |
identifier | ISSN: 0302-9743 |
ispartof | Compiler Construction, 1999, Vol.1575, p.153-167 |
issn | 0302-9743 1611-3349 |
language | eng |
recordid | cdi_pascalfrancis_primary_1577281 |
source | Springer Books |
subjects | Applied sciences Computer science control theory systems Construction Time Exact sciences and technology Interference Graph Language processing and microprogramming Latency Sequence Redundancy Constraint Software State Diagram |
title | Efficient State-Diagram Construction Methods for Software Pipelining |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-18T15%3A21%3A09IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_pasca&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=bookitem&rft.atitle=Efficient%20State-Diagram%20Construction%20Methods%20for%20Software%20Pipelining&rft.btitle=Compiler%20Construction&rft.au=Zhang,%20Chihong&rft.date=1999&rft.volume=1575&rft.spage=153&rft.epage=167&rft.pages=153-167&rft.issn=0302-9743&rft.eissn=1611-3349&rft.isbn=3540657177&rft.isbn_list=9783540657170&rft_id=info:doi/10.1007/978-3-540-49051-7_11&rft_dat=%3Cproquest_pasca%3EEBC3087804_17_170%3C/proquest_pasca%3E%3Curl%3E%3C/url%3E&rft.eisbn=9783540490517&rft.eisbn_list=3540490515&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=EBC3087804_17_170&rft_id=info:pmid/&rfr_iscdi=true |