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

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: Zhang, Chihong, Govindarajan, Ramaswamy, Ryan, Sean, Gao, Guang R.
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&amp;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