Code density concerns for new architectures
Reducing a program's instruction count can improve cache behavior and bandwidth utilization, lower power consumption, and increase overall performance. Nonetheless, code density is an often overlooked feature in studying processor architectures. We hand-optimize an assembly language embedded be...
Gespeichert in:
Hauptverfasser: | , |
---|---|
Format: | Tagungsbericht |
Sprache: | eng |
Schlagworte: | |
Online-Zugang: | Volltext bestellen |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 464 |
---|---|
container_issue | |
container_start_page | 459 |
container_title | |
container_volume | |
creator | Weaver, V.M. McKee, S.A. |
description | Reducing a program's instruction count can improve cache behavior and bandwidth utilization, lower power consumption, and increase overall performance. Nonetheless, code density is an often overlooked feature in studying processor architectures. We hand-optimize an assembly language embedded benchmark for size on 21 different instruction set architectures, finding up to a factor of three difference in code sizes from ISA alone. We find that the architectural features that contribute most heavily to code density are instruction length, number of registers, availability of a zero register, bit-width, hardware divide units, number of instruction operands, and the availability of unaligned loads and stores. We extend our results to investigate operating system, compiler, and system library effects on code density. We find that the executable starting address, executable format, and system call interface all affect program size. While ISA effects are important, the efficiency of the entire system stack must be taken into account when developing a new dense instruction set architecture. |
doi_str_mv | 10.1109/ICCD.2009.5413117 |
format | Conference Proceeding |
fullrecord | <record><control><sourceid>swepub_6IE</sourceid><recordid>TN_cdi_ieee_primary_5413117</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>5413117</ieee_id><sourcerecordid>oai_research_chalmers_se_8af672fa_ed79_425a_956e_8141bf5f632b</sourcerecordid><originalsourceid>FETCH-LOGICAL-i294t-b1141ddaf4f3b85eb487a20cc8569118849d548b7e7ac9f0faea50535818f0ae3</originalsourceid><addsrcrecordid>eNpFkMtqwzAQRdUXNE3zAaUb74tTjTSSpWVxX4FAF23XQpZHxCWxg-UQ8vd1aWhnc-FeOByGsRvgcwBu7xdl-TgXnNu5QpAAxQm7AhSIiguDp2wiVKFzba0--x-sOGcT4FrmGjlesllKX3w8VBKkmrC7sqspq6lNzXDIQtcG6tuUxa7PWtpnvg-rZqAw7HpK1-wi-nWi2TGn7PP56aN8zZdvL4vyYZk3wuKQVwAIde0jRlkZRRWawgseglHaAhiDtlZoqoIKH2zk0ZNXXEllwETuSU7Z-y837Wm7q9y2bza-P7jON27UoB8pF1Z-vaE-uUTO-KgLEb2jurAOhfLOKj32o0gVVdRSVCP19pfaENEf8_hK-Q0qTWK6</addsrcrecordid><sourcetype>Open Access Repository</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Code density concerns for new architectures</title><source>IEEE Electronic Library (IEL) Conference Proceedings</source><creator>Weaver, V.M. ; McKee, S.A.</creator><creatorcontrib>Weaver, V.M. ; McKee, S.A.</creatorcontrib><description>Reducing a program's instruction count can improve cache behavior and bandwidth utilization, lower power consumption, and increase overall performance. Nonetheless, code density is an often overlooked feature in studying processor architectures. We hand-optimize an assembly language embedded benchmark for size on 21 different instruction set architectures, finding up to a factor of three difference in code sizes from ISA alone. We find that the architectural features that contribute most heavily to code density are instruction length, number of registers, availability of a zero register, bit-width, hardware divide units, number of instruction operands, and the availability of unaligned loads and stores. We extend our results to investigate operating system, compiler, and system library effects on code density. We find that the executable starting address, executable format, and system call interface all affect program size. While ISA effects are important, the efficiency of the entire system stack must be taken into account when developing a new dense instruction set architecture.</description><identifier>ISSN: 1063-6404</identifier><identifier>ISBN: 1424450292</identifier><identifier>ISBN: 9781424450299</identifier><identifier>ISBN: 1424450284</identifier><identifier>ISBN: 9781424450282</identifier><identifier>EISSN: 2576-6996</identifier><identifier>EISBN: 1424450284</identifier><identifier>EISBN: 9781424450282</identifier><identifier>DOI: 10.1109/ICCD.2009.5413117</identifier><language>eng</language><publisher>IEEE</publisher><subject>Assembly ; Bandwidth ; Decoding ; Displays ; Hardware ; Image storage ; Instruction sets ; Libraries ; Linux ; Strips</subject><ispartof>2009 IEEE International Conference on Computer Design, 2009, p.459-464</ispartof><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/5413117$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,776,780,785,786,881,2052,27902,54895</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/5413117$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc><backlink>$$Uhttps://research.chalmers.se/publication/254162$$DView record from Swedish Publication Index$$Hfree_for_read</backlink></links><search><creatorcontrib>Weaver, V.M.</creatorcontrib><creatorcontrib>McKee, S.A.</creatorcontrib><title>Code density concerns for new architectures</title><title>2009 IEEE International Conference on Computer Design</title><addtitle>ICCD</addtitle><description>Reducing a program's instruction count can improve cache behavior and bandwidth utilization, lower power consumption, and increase overall performance. Nonetheless, code density is an often overlooked feature in studying processor architectures. We hand-optimize an assembly language embedded benchmark for size on 21 different instruction set architectures, finding up to a factor of three difference in code sizes from ISA alone. We find that the architectural features that contribute most heavily to code density are instruction length, number of registers, availability of a zero register, bit-width, hardware divide units, number of instruction operands, and the availability of unaligned loads and stores. We extend our results to investigate operating system, compiler, and system library effects on code density. We find that the executable starting address, executable format, and system call interface all affect program size. While ISA effects are important, the efficiency of the entire system stack must be taken into account when developing a new dense instruction set architecture.</description><subject>Assembly</subject><subject>Bandwidth</subject><subject>Decoding</subject><subject>Displays</subject><subject>Hardware</subject><subject>Image storage</subject><subject>Instruction sets</subject><subject>Libraries</subject><subject>Linux</subject><subject>Strips</subject><issn>1063-6404</issn><issn>2576-6996</issn><isbn>1424450292</isbn><isbn>9781424450299</isbn><isbn>1424450284</isbn><isbn>9781424450282</isbn><isbn>1424450284</isbn><isbn>9781424450282</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2009</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><sourceid>RIE</sourceid><recordid>eNpFkMtqwzAQRdUXNE3zAaUb74tTjTSSpWVxX4FAF23XQpZHxCWxg-UQ8vd1aWhnc-FeOByGsRvgcwBu7xdl-TgXnNu5QpAAxQm7AhSIiguDp2wiVKFzba0--x-sOGcT4FrmGjlesllKX3w8VBKkmrC7sqspq6lNzXDIQtcG6tuUxa7PWtpnvg-rZqAw7HpK1-wi-nWi2TGn7PP56aN8zZdvL4vyYZk3wuKQVwAIde0jRlkZRRWawgseglHaAhiDtlZoqoIKH2zk0ZNXXEllwETuSU7Z-y837Wm7q9y2bza-P7jON27UoB8pF1Z-vaE-uUTO-KgLEb2jurAOhfLOKj32o0gVVdRSVCP19pfaENEf8_hK-Q0qTWK6</recordid><startdate>20090101</startdate><enddate>20090101</enddate><creator>Weaver, V.M.</creator><creator>McKee, S.A.</creator><general>IEEE</general><scope>6IE</scope><scope>6IH</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIO</scope><scope>ADTPV</scope><scope>BNKNJ</scope><scope>F1S</scope></search><sort><creationdate>20090101</creationdate><title>Code density concerns for new architectures</title><author>Weaver, V.M. ; McKee, S.A.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i294t-b1141ddaf4f3b85eb487a20cc8569118849d548b7e7ac9f0faea50535818f0ae3</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2009</creationdate><topic>Assembly</topic><topic>Bandwidth</topic><topic>Decoding</topic><topic>Displays</topic><topic>Hardware</topic><topic>Image storage</topic><topic>Instruction sets</topic><topic>Libraries</topic><topic>Linux</topic><topic>Strips</topic><toplevel>online_resources</toplevel><creatorcontrib>Weaver, V.M.</creatorcontrib><creatorcontrib>McKee, S.A.</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan (POP) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP) 1998-present</collection><collection>SwePub</collection><collection>SwePub Conference</collection><collection>SWEPUB Chalmers tekniska högskola</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Weaver, V.M.</au><au>McKee, S.A.</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Code density concerns for new architectures</atitle><btitle>2009 IEEE International Conference on Computer Design</btitle><stitle>ICCD</stitle><date>2009-01-01</date><risdate>2009</risdate><spage>459</spage><epage>464</epage><pages>459-464</pages><issn>1063-6404</issn><eissn>2576-6996</eissn><isbn>1424450292</isbn><isbn>9781424450299</isbn><isbn>1424450284</isbn><isbn>9781424450282</isbn><eisbn>1424450284</eisbn><eisbn>9781424450282</eisbn><abstract>Reducing a program's instruction count can improve cache behavior and bandwidth utilization, lower power consumption, and increase overall performance. Nonetheless, code density is an often overlooked feature in studying processor architectures. We hand-optimize an assembly language embedded benchmark for size on 21 different instruction set architectures, finding up to a factor of three difference in code sizes from ISA alone. We find that the architectural features that contribute most heavily to code density are instruction length, number of registers, availability of a zero register, bit-width, hardware divide units, number of instruction operands, and the availability of unaligned loads and stores. We extend our results to investigate operating system, compiler, and system library effects on code density. We find that the executable starting address, executable format, and system call interface all affect program size. While ISA effects are important, the efficiency of the entire system stack must be taken into account when developing a new dense instruction set architecture.</abstract><pub>IEEE</pub><doi>10.1109/ICCD.2009.5413117</doi><tpages>6</tpages><oa>free_for_read</oa></addata></record> |
fulltext | fulltext_linktorsrc |
identifier | ISSN: 1063-6404 |
ispartof | 2009 IEEE International Conference on Computer Design, 2009, p.459-464 |
issn | 1063-6404 2576-6996 |
language | eng |
recordid | cdi_ieee_primary_5413117 |
source | IEEE Electronic Library (IEL) Conference Proceedings |
subjects | Assembly Bandwidth Decoding Displays Hardware Image storage Instruction sets Libraries Linux Strips |
title | Code density concerns for new architectures |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-02-09T04%3A14%3A29IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-swepub_6IE&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Code%20density%20concerns%20for%20new%20architectures&rft.btitle=2009%20IEEE%20International%20Conference%20on%20Computer%20Design&rft.au=Weaver,%20V.M.&rft.date=2009-01-01&rft.spage=459&rft.epage=464&rft.pages=459-464&rft.issn=1063-6404&rft.eissn=2576-6996&rft.isbn=1424450292&rft.isbn_list=9781424450299&rft.isbn_list=1424450284&rft.isbn_list=9781424450282&rft_id=info:doi/10.1109/ICCD.2009.5413117&rft_dat=%3Cswepub_6IE%3Eoai_research_chalmers_se_8af672fa_ed79_425a_956e_8141bf5f632b%3C/swepub_6IE%3E%3Curl%3E%3C/url%3E&rft.eisbn=1424450284&rft.eisbn_list=9781424450282&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=5413117&rfr_iscdi=true |