Loading…

Analysis of temporal-based program behavior for improved instruction cache performance

In this paper, we examine temporal-based program interaction in order to improve layout by reducing the probability that program units will conflict in an instruction cache. In that context, we present two profile-guided procedure reordering algorithms. Both techniques use cache line coloring to arr...

Full description

Saved in:
Bibliographic Details
Published in:IEEE transactions on computers 1999-02, Vol.48 (2), p.168-175
Main Authors: Kalamatianos, J., Khalafi, A., Kaeli, D.R., Meleis, W.
Format: Article
Language:English
Subjects:
Citations: Items that this one cites
Items that cite this one
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by cdi_FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73
cites cdi_FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73
container_end_page 175
container_issue 2
container_start_page 168
container_title IEEE transactions on computers
container_volume 48
creator Kalamatianos, J.
Khalafi, A.
Kaeli, D.R.
Meleis, W.
description In this paper, we examine temporal-based program interaction in order to improve layout by reducing the probability that program units will conflict in an instruction cache. In that context, we present two profile-guided procedure reordering algorithms. Both techniques use cache line coloring to arrive at a final program layout and target the elimination of first generation cache conflicts (i.e., conflicts between caller/callee pairs). The first algorithm builds a call graph that records local temporal interaction between procedures. We will describe how the call graph is used to guide the placement step and present methods that accelerate cache line coloring by exploring aggressive graph pruning techniques. In the second approach, we capture global temporal program interaction by constructing a Conflict Miss Graph (CMG). The CMG estimates the worst-case number of misses two competing procedures can inflict upon one another and reducing higher generation cache conflicts. We use a pruned CMG graph to guide cache line coloring. Using several C and C++ benchmarks, we show the benefits of letting both types of graphs guide procedure reordering to improve instruction cache hit rates. To contrast the differences between these two forms of temporal interaction, we also develop new characterization streams based on the Inter-Reference Gap (IRG) model.
doi_str_mv 10.1109/12.752658
format article
fullrecord <record><control><sourceid>proquest_ieee_</sourceid><recordid>TN_cdi_proquest_miscellaneous_27023623</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>752658</ieee_id><sourcerecordid>27023623</sourcerecordid><originalsourceid>FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73</originalsourceid><addsrcrecordid>eNqF0UtLAzEQAOAgCtbqwaunPSketmaSbrI5luILCl7U6zKbnbWRfdRkW-i_N7LFox6GgZlvhoFh7BL4DICbOxAznQmV5UdsAlmmU2MydcwmnEOeGjnnp-wshE_OuRLcTNj7osNmH1xI-joZqN30Hpu0xEBVsvH9h8c2KWmNO9f7pI7h2ljexa7rwuC3dnB9l1i0a0o25KNosbN0zk5qbAJdHPKUvT3cvy6f0tXL4_NysUptPGVItRRYVSavUGpZi6w2WKpcQImQVwAW0YCFTJeUG2lIaGmUJa2NtTqvSi2n7GbcG4_62lIYitYFS02DHfXbUBgwJs7PeZTXf0qRz4UCof6HmguphIzwdoTW9yF4qouNdy36fQG8-HlGAaIYnxHt1WgdEf26Q_MbnzyFBw</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>27023623</pqid></control><display><type>article</type><title>Analysis of temporal-based program behavior for improved instruction cache performance</title><source>IEEE Electronic Library (IEL) Journals</source><creator>Kalamatianos, J. ; Khalafi, A. ; Kaeli, D.R. ; Meleis, W.</creator><creatorcontrib>Kalamatianos, J. ; Khalafi, A. ; Kaeli, D.R. ; Meleis, W.</creatorcontrib><description>In this paper, we examine temporal-based program interaction in order to improve layout by reducing the probability that program units will conflict in an instruction cache. In that context, we present two profile-guided procedure reordering algorithms. Both techniques use cache line coloring to arrive at a final program layout and target the elimination of first generation cache conflicts (i.e., conflicts between caller/callee pairs). The first algorithm builds a call graph that records local temporal interaction between procedures. We will describe how the call graph is used to guide the placement step and present methods that accelerate cache line coloring by exploring aggressive graph pruning techniques. In the second approach, we capture global temporal program interaction by constructing a Conflict Miss Graph (CMG). The CMG estimates the worst-case number of misses two competing procedures can inflict upon one another and reducing higher generation cache conflicts. We use a pruned CMG graph to guide cache line coloring. Using several C and C++ benchmarks, we show the benefits of letting both types of graphs guide procedure reordering to improve instruction cache hit rates. To contrast the differences between these two forms of temporal interaction, we also develop new characterization streams based on the Inter-Reference Gap (IRG) model.</description><identifier>ISSN: 0018-9340</identifier><identifier>EISSN: 1557-9956</identifier><identifier>DOI: 10.1109/12.752658</identifier><identifier>CODEN: ITCOB4</identifier><language>eng</language><publisher>IEEE</publisher><subject>Acceleration ; Algorithms ; Benchmarks ; Coloring ; Construction ; Frequency ; Graphs ; Mathematical models ; Merging ; Microprocessors ; Operating systems ; Performance analysis ; Streams ; Temporal logic</subject><ispartof>IEEE transactions on computers, 1999-02, Vol.48 (2), p.168-175</ispartof><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73</citedby><cites>FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/752658$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>314,780,784,27923,27924,54795</link.rule.ids></links><search><creatorcontrib>Kalamatianos, J.</creatorcontrib><creatorcontrib>Khalafi, A.</creatorcontrib><creatorcontrib>Kaeli, D.R.</creatorcontrib><creatorcontrib>Meleis, W.</creatorcontrib><title>Analysis of temporal-based program behavior for improved instruction cache performance</title><title>IEEE transactions on computers</title><addtitle>TC</addtitle><description>In this paper, we examine temporal-based program interaction in order to improve layout by reducing the probability that program units will conflict in an instruction cache. In that context, we present two profile-guided procedure reordering algorithms. Both techniques use cache line coloring to arrive at a final program layout and target the elimination of first generation cache conflicts (i.e., conflicts between caller/callee pairs). The first algorithm builds a call graph that records local temporal interaction between procedures. We will describe how the call graph is used to guide the placement step and present methods that accelerate cache line coloring by exploring aggressive graph pruning techniques. In the second approach, we capture global temporal program interaction by constructing a Conflict Miss Graph (CMG). The CMG estimates the worst-case number of misses two competing procedures can inflict upon one another and reducing higher generation cache conflicts. We use a pruned CMG graph to guide cache line coloring. Using several C and C++ benchmarks, we show the benefits of letting both types of graphs guide procedure reordering to improve instruction cache hit rates. To contrast the differences between these two forms of temporal interaction, we also develop new characterization streams based on the Inter-Reference Gap (IRG) model.</description><subject>Acceleration</subject><subject>Algorithms</subject><subject>Benchmarks</subject><subject>Coloring</subject><subject>Construction</subject><subject>Frequency</subject><subject>Graphs</subject><subject>Mathematical models</subject><subject>Merging</subject><subject>Microprocessors</subject><subject>Operating systems</subject><subject>Performance analysis</subject><subject>Streams</subject><subject>Temporal logic</subject><issn>0018-9340</issn><issn>1557-9956</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>1999</creationdate><recordtype>article</recordtype><recordid>eNqF0UtLAzEQAOAgCtbqwaunPSketmaSbrI5luILCl7U6zKbnbWRfdRkW-i_N7LFox6GgZlvhoFh7BL4DICbOxAznQmV5UdsAlmmU2MydcwmnEOeGjnnp-wshE_OuRLcTNj7osNmH1xI-joZqN30Hpu0xEBVsvH9h8c2KWmNO9f7pI7h2ljexa7rwuC3dnB9l1i0a0o25KNosbN0zk5qbAJdHPKUvT3cvy6f0tXL4_NysUptPGVItRRYVSavUGpZi6w2WKpcQImQVwAW0YCFTJeUG2lIaGmUJa2NtTqvSi2n7GbcG4_62lIYitYFS02DHfXbUBgwJs7PeZTXf0qRz4UCof6HmguphIzwdoTW9yF4qouNdy36fQG8-HlGAaIYnxHt1WgdEf26Q_MbnzyFBw</recordid><startdate>19990201</startdate><enddate>19990201</enddate><creator>Kalamatianos, J.</creator><creator>Khalafi, A.</creator><creator>Kaeli, D.R.</creator><creator>Meleis, W.</creator><general>IEEE</general><scope>RIA</scope><scope>RIE</scope><scope>AAYXX</scope><scope>CITATION</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope><scope>7SP</scope><scope>F28</scope><scope>FR3</scope></search><sort><creationdate>19990201</creationdate><title>Analysis of temporal-based program behavior for improved instruction cache performance</title><author>Kalamatianos, J. ; Khalafi, A. ; Kaeli, D.R. ; Meleis, W.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>1999</creationdate><topic>Acceleration</topic><topic>Algorithms</topic><topic>Benchmarks</topic><topic>Coloring</topic><topic>Construction</topic><topic>Frequency</topic><topic>Graphs</topic><topic>Mathematical models</topic><topic>Merging</topic><topic>Microprocessors</topic><topic>Operating systems</topic><topic>Performance analysis</topic><topic>Streams</topic><topic>Temporal logic</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Kalamatianos, J.</creatorcontrib><creatorcontrib>Khalafi, A.</creatorcontrib><creatorcontrib>Kaeli, D.R.</creatorcontrib><creatorcontrib>Meleis, W.</creatorcontrib><collection>IEEE All-Society Periodicals Package (ASPP) 1998-Present</collection><collection>IEEE/IET Electronic Library (IEL)</collection><collection>CrossRef</collection><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><collection>Electronics &amp; Communications Abstracts</collection><collection>ANTE: Abstracts in New Technology &amp; Engineering</collection><collection>Engineering Research Database</collection><jtitle>IEEE transactions on computers</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Kalamatianos, J.</au><au>Khalafi, A.</au><au>Kaeli, D.R.</au><au>Meleis, W.</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Analysis of temporal-based program behavior for improved instruction cache performance</atitle><jtitle>IEEE transactions on computers</jtitle><stitle>TC</stitle><date>1999-02-01</date><risdate>1999</risdate><volume>48</volume><issue>2</issue><spage>168</spage><epage>175</epage><pages>168-175</pages><issn>0018-9340</issn><eissn>1557-9956</eissn><coden>ITCOB4</coden><abstract>In this paper, we examine temporal-based program interaction in order to improve layout by reducing the probability that program units will conflict in an instruction cache. In that context, we present two profile-guided procedure reordering algorithms. Both techniques use cache line coloring to arrive at a final program layout and target the elimination of first generation cache conflicts (i.e., conflicts between caller/callee pairs). The first algorithm builds a call graph that records local temporal interaction between procedures. We will describe how the call graph is used to guide the placement step and present methods that accelerate cache line coloring by exploring aggressive graph pruning techniques. In the second approach, we capture global temporal program interaction by constructing a Conflict Miss Graph (CMG). The CMG estimates the worst-case number of misses two competing procedures can inflict upon one another and reducing higher generation cache conflicts. We use a pruned CMG graph to guide cache line coloring. Using several C and C++ benchmarks, we show the benefits of letting both types of graphs guide procedure reordering to improve instruction cache hit rates. To contrast the differences between these two forms of temporal interaction, we also develop new characterization streams based on the Inter-Reference Gap (IRG) model.</abstract><pub>IEEE</pub><doi>10.1109/12.752658</doi><tpages>8</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0018-9340
ispartof IEEE transactions on computers, 1999-02, Vol.48 (2), p.168-175
issn 0018-9340
1557-9956
language eng
recordid cdi_proquest_miscellaneous_27023623
source IEEE Electronic Library (IEL) Journals
subjects Acceleration
Algorithms
Benchmarks
Coloring
Construction
Frequency
Graphs
Mathematical models
Merging
Microprocessors
Operating systems
Performance analysis
Streams
Temporal logic
title Analysis of temporal-based program behavior for improved instruction cache performance
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-08T17%3A04%3A33IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_ieee_&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Analysis%20of%20temporal-based%20program%20behavior%20for%20improved%20instruction%20cache%20performance&rft.jtitle=IEEE%20transactions%20on%20computers&rft.au=Kalamatianos,%20J.&rft.date=1999-02-01&rft.volume=48&rft.issue=2&rft.spage=168&rft.epage=175&rft.pages=168-175&rft.issn=0018-9340&rft.eissn=1557-9956&rft.coden=ITCOB4&rft_id=info:doi/10.1109/12.752658&rft_dat=%3Cproquest_ieee_%3E27023623%3C/proquest_ieee_%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-c340t-732add98da373f25f9ab6821ba18d11caa91c157be8939e27396ce779cc78db73%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_pqid=27023623&rft_id=info:pmid/&rft_ieee_id=752658&rfr_iscdi=true