<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<meta http-equiv="x-ua-compatible" content="ie=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1">

	<title>gem5</title>

	<!-- SITE FAVICON -->
	<link rel="shortcut icon" type="image/gif" href="/assets/img/gem5ColorVert.gif"/>

	<link rel="canonical" href="http://localhost:4000/publications/">
	<link href='https://fonts.googleapis.com/css?family=Open+Sans:400,300,700,800,600' rel='stylesheet' type='text/css'>
	<link href='https://fonts.googleapis.com/css?family=Muli:400,300' rel='stylesheet' type='text/css'>

	<!-- FAVICON -->
	<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">

	<!-- BOOTSTRAP -->
	<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">

	<!-- CUSTOM CSS -->
	<link rel="stylesheet" href="/css/main.css">
</head>


<body>
	<nav class="navbar navbar-expand-md navbar-light bg-light">
  <a class="navbar-brand" href="/">
		<img src="/assets/img/gem5ColorLong.gif" alt="gem5" height=45px>
	</a>
  <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNavDropdown" aria-controls="navbarNavDropdown" aria-expanded="false" aria-label="Toggle navigation">
    <span class="navbar-toggler-icon"></span>
  </button>
  <div class="collapse navbar-collapse" id="navbarNavDropdown">
    <ul class="navbar-nav ml-auto">
      <li class="nav-item ">
        <a class="nav-link" href="/">Home</a>
      </li>

			<li class="nav-item dropdown active">
				<a class="nav-link dropdown-toggle" href="/about" id="navbarDropdownMenuLink" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
					About
				</a>
				<div class="dropdown-menu" aria-labelledby="navbarDropdownMenuLink">
          <a class="dropdown-item" href="/about">About</a>
          <a class="dropdown-item" href="/publications">Publications</a>
          <a class="dropdown-item" href="/governance">Governance</a>
				</div>
			</li>

			<li class="nav-item dropdown ">
				<a class="nav-link dropdown-toggle" href="#" id="navbarDropdownMenuLink" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
					Documentation
				</a>
				<div class="dropdown-menu" aria-labelledby="navbarDropdownMenuLink">
					<!-- Pull navigation from _data/documentation.yml -->
					
            <a class="dropdown-item" href="/introduction">Introduction</a>
					
            <a class="dropdown-item" href="/building">Getting Started</a>
					
            <a class="dropdown-item" href="/environment">Modifying/Extending</a>
					
            <a class="dropdown-item" href="/MSIintro">Modeling Cache Coherence with Ruby</a>
					
				</div>
			</li>

      <li class="nav-item ">
        <a class="nav-link" href="/contributing">Contributing</a>
      </li>

			<li class="nav-item ">
        <a class="nav-link" href="/search">Search</a>
      </li>
    </ul>
  </div>
</nav>

	<main>
		<br><br>
<div class="container">

  <h1 class="title">Publications</h1>
  <br>
  <div class="toc">
    <ul id="markdown-toc">
  <li><a href="#original-paper" id="markdown-toc-original-paper">Original Paper<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#original-paper"></span></a></li>
  <li><a href="#special-features-of-gem5" id="markdown-toc-special-features-of-gem5">Special Features of gem5<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#special-features-of-gem5"></span></a>    <ul>
      <li><a href="#gpus" id="markdown-toc-gpus">GPUs<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#gpus"></span></a></li>
      <li><a href="#dram-controller-dram-power-estimation" id="markdown-toc-dram-controller-dram-power-estimation">DRAM Controller, DRAM Power Estimation<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#dram-controller-dram-power-estimation"></span></a></li>
      <li><a href="#kvm" id="markdown-toc-kvm">KVM<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#kvm"></span></a></li>
      <li><a href="#elastic-traces" id="markdown-toc-elastic-traces">Elastic Traces<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#elastic-traces"></span></a></li>
      <li><a href="#systemc-couping" id="markdown-toc-systemc-couping">SystemC Couping<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#systemc-couping"></span></a></li>
    </ul>
  </li>
  <li><a href="#other-publications-related-to-gem5" id="markdown-toc-other-publications-related-to-gem5">Other Publications related to gem5<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#other-publications-related-to-gem5"></span></a></li>
  <li><a href="#publications-using-gem5--m5" id="markdown-toc-publications-using-gem5--m5">Publications using gem5 / m5<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#publications-using-gem5-m5"></span></a>    <ul>
      <li><a href="#2017" id="markdown-toc-2017">2017<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2017"></span></a></li>
      <li><a href="#2016" id="markdown-toc-2016">2016<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2016"></span></a></li>
      <li><a href="#2015" id="markdown-toc-2015">2015<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2015"></span></a></li>
      <li><a href="#2014" id="markdown-toc-2014">2014<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2014"></span></a></li>
      <li><a href="#2013" id="markdown-toc-2013">2013<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2013"></span></a></li>
      <li><a href="#2012" id="markdown-toc-2012">2012<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2012"></span></a></li>
      <li><a href="#2011" id="markdown-toc-2011">2011<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2011"></span></a></li>
      <li><a href="#2010" id="markdown-toc-2010">2010<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2010"></span></a></li>
      <li><a href="#2009" id="markdown-toc-2009">2009<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2009"></span></a></li>
      <li><a href="#2008" id="markdown-toc-2008">2008<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2008"></span></a></li>
      <li><a href="#2007" id="markdown-toc-2007">2007<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2007"></span></a></li>
      <li><a href="#2006" id="markdown-toc-2006">2006<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2006"></span></a></li>
      <li><a href="#2005" id="markdown-toc-2005">2005<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2005"></span></a></li>
      <li><a href="#2004" id="markdown-toc-2004">2004<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2004"></span></a></li>
      <li><a href="#2003" id="markdown-toc-2003">2003<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2003"></span></a></li>
      <li><a href="#2002" id="markdown-toc-2002">2002<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2002"></span></a></li>
    </ul>
  </li>
  <li><a href="#derivative-projects" id="markdown-toc-derivative-projects">Derivative projects</a>    <ul>
      <li><a href="#mv5" id="markdown-toc-mv5">MV5</a></li>
      <li><a href="#gem5-gpu" id="markdown-toc-gem5-gpu">gem5-gpu</a></li>
    </ul>
  </li>
</ul>

<p>If you use gem5 in your research, we would appreciate a citation to the original paper in any publications you produce. Moreover, we would appreciate if you cite also the speacial features of gem5 which have been developed and contributed to the main line since the publication of the original paper in 2011. In other words, if you use feature X please also cite the according paper Y from the list below.</p>

<h1 id="original-paper">Original Paper<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#original-paper"></span></h1>
<hr />
<ul>
  <li><a href="http://dx.doi.org/10.1145/2024716.2024718"><strong>The gem5 Simulator</strong></a>. Nathan Binkert, Bradford Beckmann, Gabriel Black, Steven K. Reinhardt, Ali Saidi, Arkaprava Basu, Joel Hestness, Derek R. Hower, Tushar Krishna, Somayeh Sardashti, Rathijit Sen, Korey Sewell, Muhammad Shoaib, Nilay Vaish, Mark D. Hill, and David A. Wood. May 2011, ACM SIGARCH Computer Architecture News.</li>
</ul>

<h1 id="special-features-of-gem5">Special Features of gem5<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#special-features-of-gem5"></span></h1>
<hr />
<h2 id="gpus">GPUs<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#gpus"></span></h2>

<ul>
  <li>
    <p><a href="https://doi.org/10.1109/HPCA.2018.00058"><strong>Lost in Abstraction: Pitfalls of Analyzing GPUs at the Intermediate Language Level</strong></a>. Anthony Gutierrez, Bradford M. Beckmann, Alexandru Dutu, Joseph Gross, John Kalamatianos, Onur Kayiran, Michael LeBeane, Matthew Poremba, Brandon Potter, Sooraj Puthoor, Matthew D. Sinclair, Mark Wyse, Jieming Yin, Xianwei Zhang, Akshay Jain, Timothy G. Rogers. In Proceedings of the 24th IEEE International Symposium on High-Performance Computer Architecture (HPCA), February 2018.</p>
  </li>
  <li>
    <p><a href="http://ieeexplore.ieee.org/document/7482100/"><strong>NoMali: Simulating a realistic graphics driver stack using a stub GPU</strong></a>. René de Jong, Andreas Sandberg. In Proceedings of the International Symposium on Performance Analysis of Systems and Software (ISPASS), March 2016.</p>
  </li>
  <li>
    <p><a href="http://research.cs.wisc.edu/multifacet/papers/cal14_gem5gpu.pdf"><strong>gem5-gpu: A Heterogeneous CPU-GPU Simulator</strong></a>. Jason Power, Joel Hestness, Marc S. Orr, Mark D. Hill, David A. Wood. Computer Architecture Letters vol. 13, no. 1, Jan 2014</p>
  </li>
</ul>

<h2 id="dram-controller-dram-power-estimation">DRAM Controller, DRAM Power Estimation<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#dram-controller-dram-power-estimation"></span></h2>

<ul>
  <li>
    <p><a href="http://www.ics.ele.tue.nl/~mhansson/documents/pdf/2014-ispass.pdf"><strong>Simulating DRAM controllers for future system architecture exploration</strong></a>. Andreas Hansson, Neha Agarwal, Aasheesh Kolli, Thomas Wenisch and Aniruddha N. Udipi. In Proceedings of the International Symposium on Performance Analysis of Systems and Software (ISPASS), March 2014.</p>
  </li>
  <li>
    <p><a href="http://www.drampower.info"><strong>DRAMPower: Open-source DRAM Power &amp; Energy Estimation Tool</strong></a>. Karthik Chandrasekar, Christian Weis, Yonghui Li, Sven Goossens, Matthias Jung, Omar Naji, Benny Akesson, Norbert Wehn, and Kees Goossens, URL: <a href="http://www.drampower.info">http://www.drampower.info</a>.</p>
  </li>
</ul>

<h2 id="kvm">KVM<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#kvm"></span></h2>

<ul>
  <li><a href="http://ieeexplore.ieee.org/document/7314164/"><strong>Full Speed Ahead: Detailed Architectural Simulation at Near-Native Speed</strong></a>. Andreas Sandberg, Nikos Nikoleris, Trevor E. Carlson, Erik Hagersten, Stefanos Kaxiras, David Black-Schaffer. 2015 IEEE International Symposium on Workload Characterization</li>
</ul>

<h2 id="elastic-traces">Elastic Traces<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#elastic-traces"></span></h2>

<ul>
  <li><a href="https://doi.org/10.1109/SAMOS.2016.7818336"><strong>Exploring system performance using elastic traces: Fast, accurate and portable</strong></a>. Radhika Jagtap, Matthias Jung, Stephan Diestelhorst, Andreas Hansson, Norbert Wehn. IEEE International Conference on Embedded Computer Systems: Architectures, Modeling and Simulation (SAMOS), 2016</li>
</ul>

<h2 id="systemc-couping">SystemC Couping<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#systemc-couping"></span></h2>

<ul>
  <li><a href="http://samos-conference.com/Resources_Samos_Websites/Proceedings_Repository_SAMOS/2017/49_Final_Paper.pdf"><strong>System Simulation with gem5 and SystemC: The Keystone for Full Interoperability</strong></a>. C. Menard, M. Jung, J. Castrillon, N. Wehn. IEEE International Conference on Embedded Computer Systems Architectures Modeling and Simulation (SAMOS), July, 2017</li>
</ul>

<h1 id="other-publications-related-to-gem5">Other Publications related to gem5<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#other-publications-related-to-gem5"></span></h1>
<hr />
<ul>
  <li>
    <p><a href="http://simplessd.camelab.org"><strong>Enabling Realistic Logical Device Interface and Driver for NVM Express Enabled Full System Simulations</strong></a>. Donghyun Gouk, Jie Zhang and Myoungsoo Jung. IFIP International Conference on Network and Parallel Computing (NPC) and Invited for International Journal of Parallel Programming (IJPP), 2017</p>
  </li>
  <li>
    <p><a href="https://arxiv.org/pdf/1705.06419.pdf"><strong>SimpleSSD: Modeling Solid State Drives for Holistic System Simulation</strong></a>. Myoungsoo Jung, Jie Zhang, Ahmed Abulila, Miryeong Kwon, Narges Shahidi, John Shalf, Nam Sung Kim and Mahmut Kandemir. IEEE Computer Architecture Letters (CAL), 2017</p>
  </li>
  <li>
    <p>“dist-gem5: Distributed Simulation of Computer Clusters,” Mohammad Alian, Gabor Dozsa, Umur Darbaz, Stephan Diestelhorst, Daehoon Kim, and Nam Sung Kim. IEEE International Symposium on Performance Analysis of Systems (ISPASS), April 2017</p>
  </li>
  <li>
    <p><a href="https://publish.illinois.edu/icsl-pdgem5/publications"><strong>pd-gem5: Simulation Infrastructure for Parallel/Distributed Computer Systems</strong></a>. Mohammad Alian, Daehoon Kim, and Nam Sung Kim. Computer Architecture Letters (CAL), 2016.</p>
  </li>
  <li>
    <p><a href="http://www.ics.ele.tue.nl/~mhansson/documents/pdf/2015-ispass.pdf"><strong>A Full-System Approach to Analyze the Impact of Next-Generation Mobile Flash Storage</strong></a>. Rene de Jong and Andreas Hansson. In Proceedings of the International Symposium on Performance Analysis of Systems and Software (ISPASS), March 2015.</p>
  </li>
  <li>
    <p><a href="https://doi.org/10.1109/ISPASS.2014.6844457"><strong>Sources of Error in Full-System Simulation</strong></a>. A. Gutierrez, J. Pusdesris, R.G. Dreslinski, T. Mudge, C. Sudanthi, C.D. Emmons, M. Hayenga, and N. Paver. In Proceedings of the International Symposium on Performance Analysis of Systems and Software (ISPASS), March 2014.</p>
  </li>
  <li>
    <p><a href="http://www.ics.ele.tue.nl/~mhansson/documents/pdf/2013-mascots.pdf"><strong>Introducing DVFS-Management in a Full-System Simulator</strong></a>. Vasileios Spiliopoulos, Akash Bagdia, Andreas Hansson, Peter Aldworth and Stefanos Kaxiras. In Proceedings of the 21st International Symposium on Modeling, Analysis &amp; Simulation of Computer and Telecommunication Systems (MASCOTS), August 2013.</p>
  </li>
  <li><a href="http://dx.doi.org/10.1109/ReCoSoC.2012.6322869"><strong>Accuracy Evaluation of GEM5 Simulator System</strong></a>. A. Butko, R. Garibotti, L. Ost, and G. Sassatelli. In the proceeding of the IEEE International Workshop on Reconfigurable Communication-centric Systems-on-Chip (ReCoSoC), York, United Kingdom, July 2012.</li>
  <li><a href="http://dx.doi.org/10.1109/MM.2006.82"><strong>The M5 Simulator: Modeling Networked Systems</strong></a>. N. L. Binkert, R. G. Dreslinski, L. R. Hsu, K. T. Lim, A. G. Saidi, S. K. Reinhardt. IEEE Micro, vol. 26, no. 4, pp. 52-60, July/August, 2006.</li>
  <li><a href="http://dx.doi.org/10.1145/1105734.1105747"><strong>Multifacet’s General Execution-driven Multiprocessor Simulator (GEMS) Toolset</strong></a>. Milo M.K. Martin, Daniel J. Sorin, Bradford M. Beckmann, Michael R. Marty, Min Xu, Alaa R. Alameldeen, Kevin E. Moore, Mark D. Hill, and David A. Wood. Computer Architecture News (CAN), September 2005.</li>
</ul>

<h1 id="publications-using-gem5--m5">Publications using gem5 / m5<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#publications-using-gem5-m5"></span></h1>
<hr />
<h2 id="2017">2017<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2017"></span></h2>

<ul>
  <li>
    <p>[<a href="https://chess.eecs.berkeley.edu/pubs/1194/KimEtAl_CyPhy17.pdf">https://chess.eecs.berkeley.edu/pubs/1194/KimEtAl_CyPhy17.pdf</a><strong>An Integrated Simulation Tool for Computer Architecture and Cyber-Physical Systems</strong>]. Hokeun Kim, Armin Wasicek, and Edward A. Lee. In Proceedings of the 6th Workshop on Design, Modeling and Evaluation of Cyber-Physical Systems (CyPhy’17), Seoul, Korea, October 19, 2017.</p>
  </li>
  <li>
    <p>[<a href="http://www.lirmm.fr/~sassate/ADAC/wp-content/uploads/2017/06/opensuco17.pdf">http://www.lirmm.fr/~sassate/ADAC/wp-content/uploads/2017/06/opensuco17.pdf</a><strong>Efficient Programming for Multicore Processor Heterogeneity: OpenMP versus OmpSs</strong>]. Anastasiia Butko, Florent Bruguier, Abdoulaye Gamatié and Gilles Sassatelli. In Open Source Supercomputing (OpenSuCo’17) Workshop co-located with ISC’17, June 2017.</p>
  </li>
  <li>
    <p>[<a href="https://hal-lirmm.ccsd.cnrs.fr/lirmm-01467328">https://hal-lirmm.ccsd.cnrs.fr/lirmm-01467328</a><strong>MAGPIE: System-level Evaluation of Manycore Systems with Emerging Memory Technologies</strong>]. Thibaud Delobelle, Pierre-Yves Péneau, Abdoulaye Gamatié, Florent Bruguier, Sophiane Senni, Gilles Sassatelli and Lionel Torres, 2nd International Workshop on Emerging Memory Solutions (EMS) co-located with DATE’17, March 2017.</p>
  </li>
</ul>

<h2 id="2016">2016<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2016"></span></h2>

<ul>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/document/7776838">http://ieeexplore.ieee.org/document/7776838</a><strong>An Agile Post-Silicon Validation Methodology for the Address Translation Mechanisms of Modern Microprocessors</strong>]. G. Papadimitriou, A. Chatzidimitriou, D. Gizopoulos, R. Morad, IEEE Transactions on Device and Materials Reliability (TDMR 2016), Volume: PP, Issue: 99, December 2016.</p>
  </li>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/document/7753339">http://ieeexplore.ieee.org/document/7753339</a><strong>Unveiling Difficult Bugs in Address Translation Caching Arrays for Effective Post-Silicon Validation</strong>]. G. Papadimitriou, D. Gizopoulos, A. Chatzidimitriou, T. Kolan, A. Koyfman, R. Morad, V. Sokhin, IEEE International Conference on Computer Design (ICCD 2016), Phoenix, AZ, USA, October 2016.</p>
  </li>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/document/7833682/">http://ieeexplore.ieee.org/document/7833682/</a><strong>Loop optimization in presence of STT-MRAM caches: A study of performance-energy tradeoffs</strong>]. Pierre-Yves Péneau, Rabab Bouziane, Abdoulaye Gamatié, Erven Rohou, Florent Bruguier, Gilles Sassatelli, Lionel Torres and Sophiane Senni, 26th International Workshop on Power and Timing Modeling, Optimization and Simulation (PATMOS), September 21-23 2016.</p>
  </li>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/abstract/document/7774439">http://ieeexplore.ieee.org/abstract/document/7774439</a><strong>Full-System Simulation of big.LITTLE Multicore Architecture for Performance and Energy Exploration</strong>]. Anastasiia Butko, Florent Bruguier, Abdoulaye Gamatié, Gilles Sassatelli, David Novo, Lionel Torres and Michel Robert. Embedded Multicore/Many-core Systems-on-Chip (MCSoC), 2016 IEEE 10th International Symposium on, September 21-23, 2016.</p>
  </li>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/document/7448986">http://ieeexplore.ieee.org/document/7448986</a><strong>Exploring MRAM Technologies for Energy Efficient Systems-On-Chip</strong>]. Sophiane Senni, Lionel Torres, Gilles Sassatelli, Abdoulaye Gamatié and Bruno Mussard, IEEE Journal on Emerging and Selected Topics in Circuits and Systems , Volume: 6, Issue: 3, Sept. 2016.</p>
  </li>
  <li>
    <p>[<a href="https://cpc2016.infor.uva.es/wp-content/uploads/2016/06/CPC2016_paper_11.pdf">https://cpc2016.infor.uva.es/wp-content/uploads/2016/06/CPC2016_paper_11.pdf</a><strong>Architectural exploration of heterogeneous memory systems</strong>]. Marcos Horro, Gabriel Rodríguez, Juan Touriño and Mahmut T. Kandemir. 19th Workshop on Compilers for Parallel Computing (CPC), July 2016.</p>
  </li>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/document/7604675">http://ieeexplore.ieee.org/document/7604675</a><strong>ISA-Independent Post-Silicon Validation for the Address Translation Mechanisms of Modern Microprocessors</strong>]. G. Papadimitriou, A. Chatzidimitriou, D. Gizopoulos and R. Morad, IEEE International Symposium on On-Line Testing and Robust System Design (IOLTS 2016), Sant Feliu de Guixols, Spain, July 2016.</p>
  </li>
  <li>
    <p><a href="http://ieeexplore.ieee.org/document/7482075"><strong>Anatomy of microarchitecture-level reliability assessment: Throughput and accuracy</strong></a>. A.Chatzidimitriou, D.Gizopoulos, IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), Uppsala, Sweden, April 2016.</p>
  </li>
  <li>
    <p><a href="http://ieeexplore.ieee.org/document/7482089"><strong>Agave: A benchmark suite for exploring the complexities of the Android software stack</strong></a>. Martin Brown, Zachary Yannes, Michael Lustig, Mazdak Sanati, Sally A. McKee, Gary S. Tyson, Steven K. Reinhardt, IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), Uppsala, Sweden, April 2016.</p>
  </li>
</ul>

<h2 id="2015">2015<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2015"></span></h2>

<ul>
  <li>
    <p>[<a href="http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=7314163">http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=7314163</a><strong>Differential Fault Injection on Microarchitectural Simulators</strong>]. M.Kaliorakis, S.Tselonis, A.Chatzidimitriou, N.Foutris, D.Gizopoulos, IEEE International Symposium on Workload Characterization (IISWC), Atlanta, GA, USA, October 2015.</p>
  </li>
  <li>
    <p><a href="http://www.esug.org/wiki/pier/Conferences/2015/International-Workshop-IWST_15"><strong>Live Introspection of Target-Agnostic JIT in Simulation</strong></a>. B. Shingarov. International Workshop IWST’15 in cooperation with ACM, Brescia, Italy, 2015.</p>
  </li>
  <li>
    <p><a href="http://dx.doi.org/10.1109/TCAD.2015.2448684"><strong>Security in MPSoCs: A NoC Firewall and an Evaluation Framework</strong></a>. M.D. Grammatikakis, K. Papadimitriou, P. Petrakis, A. Papagrigoriou, G. Kornaros, I. Christoforakis, O. Tomoutzoglou, G. Tsamis and M. Coppola. In IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (TCAD), vol.34, no.8, pp.1344-1357, Aug. 2015</p>
  </li>
  <li>
    <p><a href="http://dx.doi.org/10.1145/2792982"><strong>DPCS: Dynamic Power/Capacity Scaling for SRAM Caches in the Nanoscale Era.</strong></a> Mark Gottscho, Abbas BanaiyanMofrad, Nikil Dutt, Alex Nicolau, and Puneet Gupta. ACM Transactions on Architecture and Code Optimization (TACO), Vol. 12, No. 3, Article 27. Pre-print June 2015, published August 2015, print October 2015.</p>
  </li>
  <li>
    <p><a href="http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=7108455"><strong>A predictable and command-level priority-based DRAM controller for mixed-criticality systems</strong></a>. Hokeun Kim, David Broman, Edward A. Lee, Michael Zimmer, Aviral Shrivastava, Junkwang Oh. Proceedings of the 21st IEEE Real-Time and Embedded Technology and Application Symposium (RTAS), Seattle, WA, USA, April, 2015.</p>
  </li>
  <li>
    <p><a href="http://spicy2015.di.unimi.it/index.php?pageid=program"><strong>Security Enhancements for Building Saturation-free, Low-Power NoC-based MPSoCs</strong></a>. Kyprianos Papadimitriou, Polydoros Petrakis, Miltos Grammatikakis, Marcello Coppola. In IEEE Conference on Communications and Network Security (CNS) - 1st IEEE Workshop on Security and Privacy in Cybermatics, Florence, Italy, 2015</p>
  </li>
  <li>
    <p><a href="http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=7309629"><strong>Design Exploration For Next Generation High-Performance Manycore On-chip Systems: Application To big.LITTLE Architectures</strong></a>. Anastasiia Butko, Abdoulaye Gamatie, Gilles Sassatelli, Lionel Torres and Michel Robert. VLSI (ISVLSI), 2015 IEEE Computer Society Annual Symposium on, July 10, 2015</p>
  </li>
  <li>
    <p>[<a href="http://dx.doi.org/10.1007/s11227-014-1375-7">http://dx.doi.org/10.1007/s11227-014-1375-7</a> <strong>Gem5v: a modified gem5 for simulating virtualized systems]</strong>. Seyed Hossein Nikounia, Siamak Mohammadi. Springer Journal of Supercomputing. The source code is available [<a href="https://github.com/nikoonia/gem5v">https://github.com/nikoonia/gem5v</a> <strong>here]</strong>.</p>
  </li>
  <li>
    <p><a href="http://dx.doi.org/10.1145/2693433.2693440"><strong>Micro-architectural simulation of embedded core heterogeneity with gem5 and McPAT</strong></a>. Fernando A. Endo, Damien Couroussé, Henri-Pierre Charles. RAPIDO ‘15 Proceedings of the 2015 Workshop on Rapid Simulation and Performance Evaluation: Methods and Tools. January 2015.</p>
  </li>
  <li>
    <p><a href="http://ieeexplore.ieee.org/xpl/articleDetails.jsp?tp=&amp;arnumber=7059093&amp;queryText%3DA+trace-driven+approach+for+fast+and+accurate+simulation+of+manycore+architectures"><strong>A trace-driven approach for fast and accurate simulation of manycore architectures</strong></a>. Anastasiia Butko, Rafael Garibotti, Luciano Ost, Vianney Lapotre, Abdoulaye Gamatie, Gilles Sassatelli and Chris Adeniyi-Jones. Design Automation Conference (ASP-DAC), 2015 20th Asia and South Pacific. January 19, 2015</p>
  </li>
</ul>

<h2 id="2014">2014<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2014"></span></h2>

<ul>
  <li>
    <p><a href="https://doi.org/10.1109/SAMOS.2014.6893211"><strong>Evaluating Private vs. Shared Last-Level Caches for Energy Efficiency in Asymmetric Multi-Cores</strong></a>. A. Gutierrez, R.G. Dreslinski, and Trevor Mudge. In Proceedings of the 14th International Conference on Embedded Computer Systems: Architectures, Modeling, and Simulation (SAMOS), 2014.</p>
  </li>
  <li>
    <p>[<a href="http://dx.doi.org/10.1109/HPCC.2014.173">http://dx.doi.org/10.1109/HPCC.2014.173</a> <strong>Security Effectiveness and a Hardware Firewall for MPSoCs]</strong>. M. D. Grammatikakis, K. Papadimitriou, P. Petrakis, A. Papagrigoriou, G. Kornaros, I. Christoforakis and M. Coppola. In 16th IEEE International Conference on High Performance Computing and Communications - Workshop on Multicore and Multithreaded Architectures and Algorithms, 2014, pp. 1032-1039 Aug. 2014</p>
  </li>
  <li>
    <p>[<a href="http://dx.doi.org/10.1145/2541940.2541951">http://dx.doi.org/10.1145/2541940.2541951</a> <strong>Integrated 3D-Stacked Server Designs for Increasing Physical Density of Key-Value Stores]</strong>. Anthony Gutierrez, Michael Cieslak, Bharan Giridhar, Ronald G. Dreslinski, Luis Ceze, and Trevor Mudge. ASPLOS XIX</p>
  </li>
  <li>
    <p>[<a href="http://dx.doi.org/10.1145/2593069.2593184">http://dx.doi.org/10.1145/2593069.2593184</a> <strong>Power / Capacity Scaling: Energy Savings With Simple Fault-Tolerant Caches]</strong>. Mark Gottscho, Abbas BanaiyanMofrad, Nikil Dutt, Alex Nicolau, and Puneet Gupta. DAC, 2014.</p>
  </li>
  <li>
    <p><a href="http://dx.doi.org/10.1093/comjnl/bxu104">”‘Write-Aware Replacement Policies for PCM-Based Systems “’</a>. R. Rodríguez-Rodríguez, F. Castro, D. Chaver*, R. Gonzalez-Alberquilla, L. Piñuel and F. Tirado. The Computer Journal, 2014.</p>
  </li>
  <li>
    <p><a href="http://dx.doi.org/10.1109/SAMOS.2014.6893220">”‘Micro-architectural simulation of in-order and out-of-order ARM microprocessors with gem5 “’</a>. Fernando A. Endo, Damien Couroussé, Henri-Pierre Charles. 2014 International Conference on Embedded Computer Systems: Architectures, Modeling, and Simulation (SAMOS XIV). July 2014.</p>
  </li>
</ul>

<h2 id="2013">2013<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2013"></span></h2>

<ul>
  <li><a href="http://doi.acm.org/10.1145/2485922.2485923"><strong>Continuous Real-World Inputs Can Open Up Alternative Accelerator Designs</strong></a>. Bilel Belhadj, Antoine Joubert, Zheng Li, Rodolphe Héliot, and Olivier Temam. ISCA ‘13</li>
  <li><em>Cache Coherence for GPU Architectures.</em> Inderpreet Singh, Arrvindh Shriraman, Wilson WL Fung, Mike O’Connor, and Tor M. Aamodt. HPCA, 2013.</li>
  <li><em>Navigating Heterogeneous Processors with Market Mechanisms.</em> Marisabel Guevara, Benjamin Lubin, and Benjamin C. Lee. HPCA, 2013</li>
  <li><em>Power Struggles: Revisiting the RISC vs. CISC Debate on Contemporary ARM and x86 Architectures</em>. Emily Blem, Jaikrishnan Menon, and Karthikeyan Sankaralingam. HPCA 2013.</li>
  <li><a href="http://dx.doi.org/10.1109/HPCA.2013.6522321"><strong>Coset coding to extend the lifetime of memory</strong></a>. Adam N. Jacobvitz, Robert Calderbank, Daniel J. Sorin. HPCA ‘13.</li>
  <li><a href="http://dx.doi.org/10.1145/2445572.2445577"><strong>The McPAT Framework for Multicore and Manycore Architectures: Simultaneously Modeling Power, Area, and Timing</strong></a>. Sheng Li, Jung Ho Ahn, Richard D. Strong, Jay B. Brockman, Dean M. Tullsen, Norman P. Jouppi. ACM Transactions on Architecture and Code Optimization (TACO), Volume 10, Issue 1, April 2013</li>
  <li><a href="http://dx.doi.org/10.2200/S00531ED1V01Y201308CAC026"><strong>Optimization and Mathematical Modeling in Computer Architecture</strong></a> Nowatzki, T., Ferris, M., Sankaralingam, K., Estan, C., Vaish, N., &amp; Wood, David A. (2013). Synthesis Lectures on Computer Architecture, 8(4), 1-144.</li>
  <li><a href="http://doi.ieeecomputersociety.org/10.1109/MM.2013.73"><strong>Limits of Parallelism and Boosting in Dim Silicon</strong></a>. Nathaniel Pinckney, Ronald G. Dreslinski, Korey Sewell, David Fick, Trevor Mudge, Dennis Sylvester, David Blaauw, IEEE Micro, vol. 33, no. 5, pp. 30-37, Sept.-Oct., 2013</li>
</ul>

<h2 id="2012">2012<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2012"></span></h2>

<ul>
  <li><em>Hardware Prefetchers for Emerging Parallel Applications</em>, Biswabandan Panda, Shankar Balachandran. In the proceedings of the IEEE/ACM Parallel Architectures and Compilation Techniques,PACT, Minneapolis, October 2012.</li>
  <li><a href="https://doi.org/10.1145/2380403.2380433"><strong>Lazy Cache Invalidation for Self-Modifying Codes</strong></a>. A. Gutierrez, J. Pusdesris, R.G. Dreslinski, and T. Mudge. In the proceedings of the International Conference on Compilers, Architecture and Synthesis for Embedded Systems (CASES), Tampere, Finland, October 2012.</li>
  <li><em>Accuracy Evaluation of GEM5 Simulator System</em>. A. Butko, R. Garibotti, L. Ost, and G. Sassatelli. In the proceeding of the IEEE International Workshop on Reconfigurable Communication-centric Systems-on-Chip (ReCoSoC), York, United Kingdom, July 2012.</li>
  <li><em>Viper: Virtual Pipelines for Enhanced Reliability</em>. A. Pellegrini, J. L. Greathouse, and V. Bertacco. In the proceedings of the International Symposium on Computer Architecture (ISCA), Portland, OR, June 2012.</li>
  <li><a href="http://dx.doi.org/10.1109/ISCA.2012.6237026"><strong>Reducing memory reference energy with opportunistic virtual caching</strong></a>. Arkaprava Basu, Mark D. Hill, Michael M. Swift. In the proceedings of the 39th International Symposium on Computer Architecture (ISCA 2012).</li>
  <li><a href="http://www.cse.psu.edu/~axj936/docs/Revive-DAC-2012.pdf"><strong>Cache Revive: Architecting Volatile STT-RAM Caches for Enhanced Performance in CMPs</strong></a>. Adwait Jog, Asit Mishra, Cong Xu, Yuan Xie, V. Narayanan, Ravi Iyer, Chita Das. In the proceedings oF the IEEE/ACM Design Automation Conference (DAC), San Francisco, CA, June 2012.</li>
</ul>

<h2 id="2011">2011<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2011"></span></h2>

<ul>
  <li><a href="https://doi.org/10.1109/IISWC.2011.6114205"><strong>Full-System Analysis and Characterization of Interactive Smartphone Applications</strong></a>. A. Gutierrez, R.G. Dreslinski, T.F. Wenisch, T. Mudge, A. Saidi, C. Emmons, and N. Paver. In the proceeding of the IEEE International Symposium on Workload Characterization (IISWC), pages 81-90, Austin, TX, November 2011.</li>
  <li><em>Universal Rules Guided Design Parameter Selection for Soft Error Resilient Processors,</em> L. Duan, Y. Zhang, B. Li, and L. Peng. Proceedings of the International Symposium on Performance Analysis of Systems and Software(ISPASS), Austin, TX, April 2011.</li>
</ul>

<h2 id="2010">2010<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2010"></span></h2>

<ul>
  <li><em>Using Hardware Vulnerability Factors to Enhance AVF Analysis,</em> V. Sridharan, D. R. Kaeli. Proceedings of the International Symposium on Computer Architecture (ISCA-37), Saint-Malo, France, June 2010.</li>
  <li><em>Leveraging Unused Cache Block Words to Reduce Power in CMP Interconnect,</em> H. Kim, P. Gratz. IEEE Computer Architecture Letters, vol. 99, (RapidPosts), 2010.</li>
  <li><em>A Fast Timing-Accurate MPSoC HW/SW Co-Simulation Platform based on a Novel Synchronization Scheme,</em> Mingyan Yu, Junjie Song, Fangfa Fu, Siyue Sun, and Bo Liu. Proceedings of the International MultiConfernce of Engineers and Computer Scientists. 2010 <a href="http://www.iaeng.org/publication/IMECS2010/IMECS2010_pp1396-1400.pdf">pdf</a></li>
  <li><em>Simulation of Standard Benchmarks in Hardware Implementations of L2 Cache Models in Verilog HDL,</em> Rosario M. Reas, Anastacia B. Alvarez, Joy Alinda P. Reyes, Computer Modeling and Simulation, International Conference on, pp. 153-158, 2010 12th International Conference on Computer Modelling and Simulation, 2010</li>
  <li><em>A Simulation of Cache Sub-banking and Block Buffering as Power Reduction Techniques for Multiprocessor Cache Design,</em> Jestoni V. Zarsuela, Anastacia Alvarez, Joy Alinda Reyes, Computer Modeling and Simulation, International Conference on, pp. 515-520, 2010 12th International Conference on Computer Modelling and Simulation, 2010</li>
</ul>

<h2 id="2009">2009<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2009"></span></h2>

<ul>
  <li><em>Efﬁcient Implementation of Decoupling Capacitors in 3D Processor-DRAM Integrated Computing Systems.</em> Q. Wu, J. Lu, K. Rose, and T. Zhang. Great Lakes Symposium on VLSI. 2009.</li>
  <li><em>Evaluating the Impact of Job Scheduling and Power Management on Processor Lifetime for Chip Multiprocessors.</em> A. K. Coskun, R. Strong, D. M. Tullsen, and T. S. Rosing. Proceedings of the eleventh international joint conference on Measurement and modeling of computer systems. 2009.</li>
  <li>” Devices and architectures for photonic chip-scale integration.” J. Ahn, M. Fiorentino1, R. G. Beausoleil, N. Binkert, A. Davis, D. Fattal, N. P. Jouppi, M. McLaren, C. M. Santori, R. S. Schreiber, S. M. Spillane, D. Vantrease and Q. Xu. Journal of Applied Physics A: Materials Science &amp; Processing. February 2009.</li>
  <li>
    <p><em>System-Level Power, Thermal and Reliability Optimization.</em> C. Zhu. Thesis at Queen’s University. 2009.</p>
  </li>
  <li><em>A light-weight fairness mechanism for chip multiprocessor memory systems.</em> M. Jahre, L. Natvig. Proceedings of the 6th ACM conference on Computing Frontiers. 2009.</li>
  <li><em>Decoupled DIMM: building high-bandwidth memory system using low-speed DRAM devices.</em> H. Zheng, J. Lin, Z. Zhang, and Z. Zhu. International Symposium on Computer Architecture (ISCA). 2009.</li>
  <li>
    <p><em>On the Performance of Commit-Time-Locking Based Software Transactional Memory.</em> Z. He and B. Hong. The 11th IEEE International Conference on. High Performance Computing and Communications (HPCC-09). 2009.</p>
  </li>
  <li><em>A Quantitative Study of Memory System Interference in Chip Multiprocessor Architectures.</em> M. Jahre, M. Grannaes and L. Natvig. The 11th IEEE International Conference on. High Performance Computing and Communications (HPCC-09). 2009.</li>
  <li><em>Hardware Support for Debugging Message Passing Applications for Many-Core Architectures.</em> C. Svensson. Masters Thesis at the University of Illinois at Urbana-Champaign, 2009.</li>
  <li><em>Initial Experiments in Visualizing Fine-Grained Execution of Parallel Software Through Cycle-Level Simulation.</em> R. Strong, J. Mudigonda, J. C. Mogul, N. Binkert. USENIX Workshop on Hot Topics in Parallelism (HotPar). 2009.</li>
  <li><em>MPreplay: Architecture Support for Deterministic Replay of Message Passing Programs on Message Passing Many-core Processors.</em> C. Erik-Svensson, D. Kesler, R. Kumar, and G. Pokam. University of Illinois Technical Report number UILU-09-2209.</li>
  <li><em>Low-power Inter-core Communication through Cache Partitioning in Embedded Multiprocessors.</em> C. Yu, X. Zhou, and P. Petrov .Symposium on Integrated Circuits and System Design (sbcci). 2009.</li>
  <li><em>Integrating NAND flash devices onto servers.</em> D. Roberts, T. Kgil, T. Mudge. Communications of the ACM (CACM). 2009.</li>
  <li><em>A High-Performance Low-Power Nanophotonic On-Chip Network.</em> Z. Li, J. Wu, L. Shang, A. Mickelson, M. Vachharajani, D. Filipovic, W. Park∗ and Y. Sun. International Symposium on Low Power Electronic Design (ISLPED). 2009.</li>
  <li><em>Core monitors: monitoring performance in multicore processors.</em> P. West, Y. Peress, G. S. Tyson, and S. A. McKee. Computing Frontiers. 2009.</li>
  <li><em>Parallel Assertion Processing using Memory Snapshots.</em> M. F. Iqbal, J. H. Siddiqui, and D. Chiou. Workshop on Unique Chips and Systems (UCAS). April 2009.</li>
  <li><em>Leveraging Memory Level Parallelism Using Dynamic Warp Subdivision.</em> J. Meng, D. Tarjan, and K. Skadron. Univ. of Virginia Dept. of Comp. Sci. Tech Report (CS-2009-02).</li>
  <li><em>Reconfigurable Multicore Server Processors for Low Power Operation.</em> R. G. Dreslinski, D. Fick, D. Blaauw, D. Sylvester and T. Mudge. 9th International Symposium on Systems, Architectures, MOdeling and Simulation (SAMOS). July 2009.</li>
  <li><em>Near Threshold Computing: Overcoming Performance Degradation from Aggressive Voltage Scaling</em> R. G. Dreslinski, M. Wieckowski, D. Blaauw, D. Sylvester, and T. Mudge. Workshop on Energy Efficient Design (WEED), June 2009.</li>
  <li>
    <p><em>Workload Adaptive Shared Memory Multicore Processors with Reconfigurable Interconnects.</em> S. Akram, R. Kumar, and D. Chen. IEEE Symposium on Application Specific Processors, July 2009.</p>
  </li>
  <li><em>Eliminating Microarchitectural Dependency from Architectural Vulnerability.</em> V. Sridharan, D. R. Kaeli. Proceedings of the 15th International Symposium on High-Performance Computer Architecture (HPCA-15), February 2009.</li>
  <li><em>Producing Wrong Data Without Doing Anything Obviously Wrong!</em> T. Mytkowicz, A. Diwan, M. Hauswirth, P. F. Sweeney. Proceedings of the 14th international conference on Architectural support for programming languages and operating systems (ASPLOS). 2009.</li>
  <li><em>End-To-End Performance Forecasting: Finding Bottlenecks Before They Happen</em> A. Saidi, N. Binkert, S. Reinhardt, T. Mudge. Proceedings of the 36th International Symposium on Computer Architecture (ISCA-36), June 2009.</li>
  <li><em>Fast Switching of Threads Between Cores.</em> R. Strong, J. Mudigonda, J. C. Mogul, N. Binkert, D. Tullsen. ACM SIGOPS Operating Systems Review. 2009.</li>
  <li><em>Express Cube Topologies for On-Chip Interconnects.</em> B. Grot, J. Hestness, S. W. Keckler, O. Mutlu. Proceedings of the 15th International Symposium on High-Performance Computer Architecture (HPCA-15), February 2009.</li>
  <li><em>Enhancing LTP-Driven Cache Management Using Reuse Distance Information.</em> W. Lieu, D. Yeung. Journal of Instruction-Level Parallelism 11 (2009).</li>
</ul>

<h2 id="2008">2008<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2008"></span></h2>

<ul>
  <li><em>Analyzing the Impact of Data Prefetching on Chip MultiProcessors.</em> N. Fukumoto, T. Mihara, K. Inoue, and K. Murakami. Asia-Pacific Computer Systems Architecture Conference. 2008.</li>
  <li>
    <p><em>Historical Study of the Development of Branch Predictors.</em> Y. Peress. Masters Thesis at Florida State University. 2008.</p>
  </li>
  <li><em>Hierarchical Domain Partitioning For Hierarchical Architectures.</em> J. Meng, S. Che, J. W. Sheaffer, J. Li, J. Huang, and K. Skadron. Univ. of Virginia Dept. of Comp. Sci. Tech Report CS-2008-08. 2008.</li>
  <li>
    <p><em>Memory Access Scheduling Schemes for Systems with Multi-Core Processors.</em> H. Zheng, J. Lin, Z. Zhang, and Z. Zhu. International Conference on Parallel Processing, 2008.</p>
  </li>
  <li><em>Register Multimapping: Reducing Register Bank Conflicts Through One-To-Many Logical-To-Physical Register Mapping.</em> N. L. Duong and R. Kumar. Tehnical Report CHRC-08-07.</li>
  <li><em>Cross-Layer Custimization Platform for Low-Power and Real-Time Embedded Applications.</em> X. Zhou. Dissertation at the University of Maryland. 2008.</li>
  <li><em>Probabilistic Replacement: Enabling Flexible Use of Shared Caches for CMPs.</em> W. Liu and D. Yeung. University of Maryland Technical Report UMIACS-TR-2008-13. 2008.</li>
  <li><em>Observer Effect and Measurement Bias in Performance Analysis</em>. T. Mytkowicz, P. F. Sweeney, M. Hauswirth, and A. Diwan. University of Colorado at Boulder Technical Report CU-CS 1042-08. June, 2008.</li>
  <li><em>Power-Aware Dynamic Cache Partitioning for CMPs.</em> I. Kotera, K. Abe, R. Egawa, H. Takizawa, and H. Kobayashi. 3rd International Conference on High Performance and Embedded Architectures and Compilers (HiPEAC). 2008.</li>
  <li><em>Modeling of Cache Access Behavior Based on Zipf’s Law.</em> I. Kotera, H. Takizawa, R. Egawa, H. Kobayashi. MEDEA 2008.</li>
  <li>
    <p><em>Hierarchical Verification for Increasing Performance in Reliable Processors.</em> J. Yoo, M. Franklin. Journal of Electronic Testing. 2008.</p>
  </li>
  <li>
    <p><em>Transaction-Aware Network-on-Chip Resource Reservation.</em> Z. Li, C. Zhu, L. Shang, R. Dick, Y. Sun. Computer Architecture Letters. Volume PP, Issue 99, Page(s):1 - 1.</p>
  </li>
  <li>
    <p><em>Predictable Out-of-order Execution Using Virtual Traces.</em> J. Whitham, N. Audsley. Proceedings of the 29th IEEE Real-time Systems Symposium, December 2008. <a href="http://www.jwhitham.org.uk/pubs/vt1.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>Architectural and Compiler Mechanisms for Acelerating Single Thread Applications on Multicore Processors.</em> H. Zhong. Dissertation at The University of Michigan. 2008.</p>
  </li>
  <li>
    <p><em>Mini-Rank: Adaptive DRAM Architecture for Improving Memory Power Efficiency.</em> H. Zheng, J. Lin, Z. Zhang, E. Gorbatov, H. David, Z. Zhu. Proceedings of the 41st Annual Symposium on Microarchitecture (MICRO-41), November 2008.</p>
  </li>
  <li>
    <p><em>Reconfigurable Energy Efficient Near Threshold Cache Architectures.</em> R. Dreslinski, G. Chen, T. Mudge, D. Blaauw, D. Sylvester, K. Flautner. Proceedings of the 41st Annual Symposium on Microarchitecture (MICRO-41), November 2008.</p>
  </li>
  <li>
    <p><em>Distributed and low-power synchronization architecture for embedded multiprocessors.</em> C. Yu, P. Petrov. Internation Conference on Hardware/Software Codesign and System Synthesis (CODES+ISSS), October 2008.</p>
  </li>
  <li>
    <p><em>Thermal Monitoring Mechanisms for Chip Multiprocessors.</em> J. Long, S.O. Memik, G. Memik, R. Mukherjee. ACM Transactions on Architecture and Code Optimization (TACO), August 2008.</p>
  </li>
  <li>
    <p><em>Multi-optimization power management for chip multiprocessors.</em> K. Meng, R. Joseph, R. Dick, L. Shang. Proceedings of the 17th international conference on Parallel Architectures and Compilation Techniques (PACT), 2008.</p>
  </li>
  <li>
    <p>” Three-Dimensional Chip-Multiprocessor Run-Time Thermal Management.” C. Zhu, Z. Gu, L. Shang, R.P. Dick, R. Joseph. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (TCAD), August 2008.</p>
  </li>
  <li>
    <p>” Latency and bandwidth efficient communication through system customization for embedded multiprocessors”. C. Yu and P. Petrov. DAC 2008, June 2008.</p>
  </li>
  <li>
    <p><em>Corona: System Implications of Emerging Nanophotonic Technology</em>. D. Vantrease, R. Schreiber, M. Monchiero, M. McLaren, N., P. Jouppi, M. Fiorentino, A. Davis, N. Binkert, R. G. Beausoleil, and J. Ahn. Proceedings of the 35th International Symposium on Computer Architecture (ISCA-35), June 2008.</p>
  </li>
  <li>
    <p><em>Improving NAND Flash Based Disk Caches</em>. T. Kgil, D. Roberts and T. N. Mudge. Proceedings of the 35th International Symposium on Computer Architecture (ISCA-35), June 2008.</p>
  </li>
  <li>
    <p><em>A Taxonomy to Enable Error Recovery and Correction in Software</em>. V. Sridharan, D. A. Liberty, and D. R. Kaeli. Workshop on Quality-Aware Design (W-QUAD), in conjunction with the 35th International Symposium on Computer Architecture (ISCA-35), June 2008.</p>
  </li>
  <li>
    <p><em>Quantifying Software Vulnerability</em>. V. Sridharan and D. R. Kaeli. First Workshop on Radiation Effects and Fault Tolerance in Nanometer Technologies, in conjunction with the ACM International Conference on Computing Frontiers, May 2008.</p>
  </li>
  <li>
    <p><em>Core Monitors: Monitoring Performance in Multicore Processors.</em> P. West. Masters Thesis at Florida State University. April 2008.</p>
  </li>
  <li>
    <p><em>Full System Critical Path Analysis.</em> A. Saidi, N. Binkert, T. N. Mudge, and S. K. Reinhardt. 2008 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), April 2008.</p>
  </li>
  <li>
    <p><em>A Power and Temperature Aware DRAM Architecture.</em> S. Liu, S. O. Memik, Y. Zhang, G. Memik. 45th annual conference on Design automation (DAC), 2008.</p>
  </li>
  <li>
    <p><em>Streamware: Programming General-Purpose Multicore Processors Using Streams.</em> J. Gummaraju, J. Coburn, Y. Turner, M. Rosenblum. Procedings of the Thirteenth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), March 2008.</p>
  </li>
  <li>
    <p><em>Application-aware snoop filtering for low-power cache coherence in embedded multiprocessors</em>. X. Zhou, C. Yu, A. Dash, and P. Petrov. Transactions on Design Automation of Electronic Systems (TODAES). January 2008.</p>
  </li>
  <li><em>An approach for adaptive DRAM temperature and power management</em>. Song Liu, S. O. Memik, Y. Zhang, and G. Memik. Proceedings of the 22nd annual international conference on Supercomputing. 2008.</li>
</ul>

<h2 id="2007">2007<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2007"></span></h2>

<ul>
  <li><em>Modeling and Characterizing Power Variability in Multicore Architectures.</em> K. Meng, F. Huebbers, R, Joseph, and Y. Ismail. ISPASS-2007.</li>
  <li><em>A High Performance Adaptive Miss Handling Architecture for Chip Multiprocessors.</em> M. Jahre, and L. Natvig. HiPEAC Journal 2007.</li>
  <li><em>Performance Effects of a Cache Miss Handling Architecture in a Multi-core Processor.</em> M. Jahre and L. Natvig. NIK-2007 conference. 2007.</li>
  <li>
    <p><em>Prioritizing Verification via Value-based Correctness Criticality.</em> J. Yoo, M. Franklin. Proceedings of the 25th International Conference on Computer Design (ICCD), 2007.</p>
  </li>
  <li>
    <p><em>DRAM-Level Prefetching for Fully-Buffered DIMM: Design, Performance and Power Saving.</em> J. Lin, H. Zheng, Z. Zhu, Z. Zhang ,H. David. ISPASS 2007.</p>
  </li>
  <li>
    <p>” Virtual Exclusion: An architectural approach to reducing leakage energy in caches for multiprocessor systems”. M. Ghosh, H. Lee. Proceedings of the International Conference on Parallel and Distributed Systems. December 2007.</p>
  </li>
  <li>
    <p><em>Dependability-Performance Trade-off on Multiple Clustered Core Processors</em>. T. Funaki, T. Sato. Proceedings of the 4th International Workshop on Dependable Embedded Systems. October 2007.</p>
  </li>
  <li>
    <p><em>Predictive Thread-to-Core Assignment on a Heterogeneous Multi-core Processor</em>. T. Sondag, V. Krishnamurthy, H. Rajan. PLOS ‘07: ACM SIGOPS 4th Workshop on Programming Languages and Operating Systems. October 2007.</p>
  </li>
  <li>
    <p><em>Power deregulation: eliminating off-chip voltage regulation circuitry from embedded systems</em>. S. Kim, R. P. Dick, R. Joseph. 5th IEEE/ACM International Conference on Hardware/Software Co-Design and System Synthesis (CODES+ISSS). October 2007.</p>
  </li>
  <li>
    <p><em>Aggressive Snoop Reduction for Synchronized Producer-Consumer Communication in Energy-Efficient Embedded Multi-Processors</em>. C. Yu, P. Petrov. 5th IEEE/ACM International Conference on Hardware/Software Co-Design and System Synthesis (CODES+ISSS). October 2007.</p>
  </li>
  <li>
    <p><em>Three-Dimensional Multiprocessor System-on-Chip Thermal Optimization</em>. C. Sun, L. Shang, R.P. Dick. 5th IEEE/ACM International Conference on Hardware/Software Co-Design and System Synthesis (CODES+ISSS). October 2007.</p>
  </li>
  <li>
    <p><em>Sampled Simulation for Multithreaded Processors</em>. M. Van Biesbrouck. (Thesis) UC San Diego Technical Report CS2007-XXXX. September 2007.</p>
  </li>
  <li>
    <p><em>Representative Multiprogram Workloads for Multithreaded Processor Simulation</em>. M. Van Biesbroucky, L. Eeckhoutz, B. Calder. IEEE International Symposium on Workload Characterization (IISWC). September 2007.</p>
  </li>
  <li>
    <p><em>The Interval Page Table: Virtual Memory Support in Real-Time and Memory-Constrained Embedded Systems</em>. X. Zhou, P. Petrov. Proceedings of the 20th annual conference on Integrated circuits and systems design. 2007.</p>
  </li>
  <li>
    <p><em>A power-aware shared cache mechanism based on locality assessment of memory reference for CMPs</em>. I. Kotera, R. Egawa, H. Takizawa, H. Kobayashi. Proceedings of the 2007 workshop on MEmory performance: DEaling with Applications, systems and architecture (MEDEA). September 2007.</p>
  </li>
  <li>
    <p><em>Architectural Support for the Stream Execution Model on General-Purpose Processors</em>. J. Gummaraju, M. Erez, J. Coburn, M. Rosenblum, W. J. Dally. The Sixteenth International Conference on Parallel Architectures and Compilation Techniques (PACT). September 2007.</p>
  </li>
  <li>
    <p><em>An Energy Efficient Parallel Architecture Using Near Threshold Operation</em>. R. Dreslinski, B. Zhai, T. Mudge, D. Blaauw, D. Sylvester. The Sixteenth International Conference on Parallel Architectures and Compilation Techniques (PACT). September 2007.</p>
  </li>
  <li>
    <p><em>When Homogeneous becomes Heterogeneous: Wearout Aware Task Scheduling for Streaming Applications</em>. D. Roberts, R. Dreslinski, E. Karl, T. Mudge, D. Sylvester, D. Blaauw. Workshop on Operationg System Support for Heterogeneous Multicore Architectures (OSHMA). September 2007.</p>
  </li>
  <li>
    <p>” On-Chip Cache Device Scaling Limits and Effective Fault Repair Techniques in Future Nanoscale Technology”. D. Roberts, N. Kim,T. Mudge. Digital System Design Architectures, Methods and Tools (DSD). August 2007.</p>
  </li>
  <li>
    <p><em>Energy Efficient Near-threshold Chip Multi-processing</em>. B. Zhai, R. Dreslinski, D. Blaauw, T. Mudge, D. Sylvester. International Symposium on Low Power Electronics and Design (ISLPED). August 2007.</p>
  </li>
  <li>
    <p>” A Burst Scheduling Access Reordering Mechanism”. J. Shao, B.T. Davis. IEEE 13th International Symposium on High Performance Computer Architecture (HPCA). 2007.</p>
  </li>
  <li>
    <p><em>Enhancing LTP-Driven Cache Management Using Reuse Distance Information</em>. W. Liu, D. Yeung. University of Maryland Technical Report UMIACS-TR-2007-33. June 2007.</p>
  </li>
  <li>
    <p><em>Thermal modeling and management of DRAM memory systems</em>. J. Lin, H. Zheng, Z. Zhu, H. David, and Z. Zhang. Proceedings of the 34th Annual international Symposium on Computer Architecture (ISCA). June 2007.</p>
  </li>
  <li>
    <p><em>Duplicating and Verifying LogTM with OS Support in the M5 Simulator</em>. G. Blake, T. Mudge. Sixth Annual Workshop on Duplicating, Deconstructing, and Debunking (WDDD). June 2007.</p>
  </li>
  <li>
    <p><em>Analysis of Hardware Prefetching Across Virtual Page Boundaries</em>. R. Dreslinski, A. Saidi, T. Mudge, S. Reinhardt. Proc. of the 4th Conference on Computing Frontiers. May 2007.</p>
  </li>
  <li>
    <p><em>Reliability in the Shadow of Long-Stall Instructions</em>. V. Sridharan, D. Kaeli, A. Biswas. Third Workshop on Silicon Errors in Logic - System Effects (SELSE-3). April 2007.</p>
  </li>
  <li><em>Extending Multicore Architectures to Exploit Hybrid Parallelism in Single-thread Applications</em>. H. Zhong, S. A. Lieberman, S. A. Mahlke. Proc. 13th Intl. Symposium on High Performance Computer Architecture (HPCA). February 2007.</li>
</ul>

<h2 id="2006">2006<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2006"></span></h2>

<ul>
  <li>
    <p><em>Evaluation of the Data Vortex Photonic All-Optical Path Interconnection Network for Next-Generation Supercomputers</em>. W. C. Hawkins. Dissertation at Georgia Tech. December 2006.</p>
  </li>
  <li>
    <p><em>Running the manual: an approach to high-assurance microkernel development</em>. P. Derrin, K. Elphinstone, G. Klein, D. Cock, M. M. T. Chakravarty. Proceedings of the 2006 ACM SIGPLAN workshop on Haskell. 2006.</p>
  </li>
  <li>
    <p><em>The Filter Checker: An Active Verification Management Approach</em>. J. Yoo, M. Franklin. 21st IEEE International Symposium on Defect and Fault-Tolerance in VLSI Systems (DFT’06), 2006.</p>
  </li>
  <li>
    <p><em>Physical Resource Matching Under Power Asymmetry</em>. K. Meng, F. Huebbers, R. Joseph, Y. Ismail. Presented at the 2006 P=ac2 Conference. 2006. <a href="http://www.ece.northwestern.edu/~rjoseph/publications/man-asymmetry.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>Process Variation Aware Cache Leakage Management</em>. K. Meng, R. Joseph. Proceedings of the 2006 International Symposium on Low Power Electronics and Design (ISLPED). October 2006.</p>
  </li>
  <li>
    <p><em>FlashCache: a NAND flash memory file cache for low power web servers</em>. T. Kgil, T. Mudge. Proceedings of the 2006 international conference on Compilers, Architecture and Synthesis for Embedded Systems (CASES). October 2006.</p>
  </li>
  <li>
    <p><em>PicoServer: Using 3D Stacking Technology To Enable A Compact Energy Efficient Chip Multiprocessor</em>. T. Kgil, S. D’Souza, A. Saidi, N. Binkert, R. Dreslinski, S. Reinhardt, K. Flautner, T. Mudge. 12th Int’l Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). October 2006.</p>
  </li>
  <li>
    <p><em>Integrated Network Interfaces for High-Bandwidth TCP/IP</em>. N. L. Binkert, A. G. Saidi, S. K. Reinhardt. 12th Int’l Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). October 2006.</p>
  </li>
  <li>
    <p><em>Communist, utilitarian, and capitalist cache policies on CMPs: caches as a shared resource</em>. L. R. Hsu, S. K. Reinhardt, R. Iyer, S. Makineni. Proc. 15th Int’l Conf. on Parallel Architectures and Compilation Techniques (PACT), September 2006.</p>
  </li>
  <li>
    <p><em>Impact of CMP Design on High-Performance Embedded Computing</em>. P. Crowley, M. A. Franklin, J. Buhler, and R. D. Chamberlain. Proc. of 10th High Performance Embedded Computing Workshop. September 2006.</p>
  </li>
  <li>
    <p><em>BASS: A Benchmark suite for evaluating Architectural Security Systems</em>. J. Poe, T. Li. ACM SIGARCH Computer Architecture News. Vol. 34, No. 4, September 2006.</p>
  </li>
  <li>
    <p><em>The M5 Simulator: Modeling Networked Systems</em>. N. L. Binkert, R. G. Dreslinski, L. R. Hsu, K. T. Lim, A. G. Saidi, S. K. Reinhardt. IEEE Micro, vol. 26, no. 4, pp. 52-60, July/August, 2006.<a href="http://csdl2.computer.org/persagen/DLAbsToc.jsp?resourcePath=/dl/mags/mi/&amp;toc=comp/mags/mi/2006/04/m4toc.xml&amp;DOI=10.1109/MM.2006.82">Link</a></p>
  </li>
  <li>
    <p><em>Considering All Starting Points for Simultaneous Multithreading Simulation</em>. M. Van Biesbrouck, L. Eeckhout, B. Calder. Proc. of the Int’l Symp. on Performance Analysis of Systems and Software (ISPASS). 2006.<a href="http://www.cse.ucsd.edu/users/calder/papers/ISPASS-06-CoPhaseAllPairs.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>Dynamic Thread Assignment on Heterogeneous Multiprocessor Architectures</em>. M. Becchi, P. Crowley. Proc. of the 3rd Conference on Computing Frontiers. pp29-40. May 2006. <a href="http://portal.acm.org/ft_gateway.cfm?id=1128029&amp;type=pdf&amp;coll=GUIDE&amp;dl=GUIDE&amp;CFID=15151515&amp;CFTOKEN=6184618">pdf</a></p>
  </li>
  <li>
    <p><em>Integrated System Architectures for High-Performance Internet Servers</em>. N. L. Binkert. Dissertation at the University of Michigan. February 2006.</p>
  </li>
  <li>
    <p><em>Exploring Salvage Techniques for Multi-core Architectures</em>. R. Joseph. 2nd Workshop on High Performance Computing Reliability Issues. February 2006. <a href="http://www.ece.northwestern.edu/~rjoseph/publications/hpcri-salvage.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>A Simple Integrated Network Interface for High-Bandwidth Servers</em>. N. L. Binkert, A. G. Saidi, S. K. Reinhardt. University of Michigan Technical Report CSE-TR-514-06, January 2006. <a href="http://www.eecs.umich.edu/techreports/cse/2006/CSE-TR-514-06.pdf">pdf</a></p>
  </li>
</ul>

<h2 id="2005">2005<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2005"></span></h2>

<ul>
  <li>
    <p><em>Software Defined Radio - A High Performance Embedded Challenge</em>. H. lee, Y. Lin, Y. Harel, M. Woh, S. Mahlke, T. Mudge, K. Flautner. Proc. 2005 Int’l Conf. on High Performance Embedded Architectures and Compilers (HiPEAC). November 2005. <a href="http://www.eecs.umich.edu/~sdrg/lee-hipeac05.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>How to Fake 1000 Registers</em>. D. W. Oehmke, N. L. Binkert, S. K. Reinhardt, and T. Mudge. Proc. 38th Ann. Int’l Symp. on Microarchitecture (MICRO), November 2005. <a href="http://www.eecs.umich.edu/~stever/pubs/micro05.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>Virtualizing Register Context</em>. D. W. Oehmke. Dissertation at the University of Michigan, 2005. <a href="http://www.eecs.umich.edu/~tnm/theses/davidO.pdf">pdf</a></p>
  </li>
  <li><em>Performance Validation of Network-Intensive Workloads on a Full-System Simulator</em>. A. G. Saidi, N. L. Binkert, L. R. Hsu, and S. K. Reinhardt. First Ann. Workshop on Iteraction between Operating System and Computer Architecture (IOSCA), October 2005. <a href="http://www.eecs.umich.edu/~stever/pubs/iosca05.pdf">pdf</a>
    <ul>
      <li>An extended version appears as University of Michigan Technical Report CSE-TR-511-05, July 2005. <a href="http://www.eecs.umich.edu/techreports/cse/2005/CSE-TR-511-05.pdf">pdf</a></li>
    </ul>
  </li>
  <li>
    <p><em>Performance Analysis of System Overheads in TCP/IP Workloads</em>. N. L. Binkert, L. R. Hsu, A. G. Saidi, R. G. Dreslinski, A. L. Schultz, and S. K. Reinhardt. Proc. 14th Int’l Conf. on Parallel Architectures and Compilation Techniques (PACT), September 2005. <a href="http://www.eecs.umich.edu/~stever/pubs/pact05.pdf">pdf</a></p>
  </li>
  <li><em>Sampling and Stability in TCP/IP Workloads</em>. L. R. Hsu, A. G. Saidi, N. L. Binkert, and S. K. Reinhardt. Proc. First Annual Workshop on Modeling, Benchmarking, and Simulation (MoBS), June
    <ol>
      <li><a href="http://www.eecs.umich.edu/~stever/pubs/mobs05.pdf">pdf</a></li>
    </ol>
  </li>
  <li>
    <p><em>A Unified Compressed Memory Hierarchy</em>. E. G. Hallnor and S. K. Reinhardt. Proc. 11th Int’l Symp. on High-Performance Computer Architecture (HPCA), February 2005. <a href="http://www.eecs.umich.edu/~stever/pubs/hpca05.pdf">pdf</a></p>
  </li>
  <li><em>Analyzing NIC Overheads in Network-Intensive Workloads</em>. N. L. Binkert, L. R. Hsu, A. G. Saidi, R. G. Dreslinski, A. L. Schultz, and S. K. Reinhardt. Eighth Workshop on Computer Architecture Evaluation using Commercial Workloads (CAECW), February 2005. <a href="http://tesla.hpl.hp.com/caecw05/binkert-caecw8.pdf">pdf</a>
    <ul>
      <li>An extended version appears as University of Michigan Technical Report CSE-TR-505-04, December 2004. <a href="http://www.eecs.umich.edu/techreports/cse/2004/CSE-TR-505-04.pdf">pdf</a></li>
    </ul>
  </li>
</ul>

<h2 id="2004">2004<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2004"></span></h2>

<ul>
  <li>
    <p><em>Emulation of realisitic network traffic patterns on an eight-node data vortex interconnection network subsytem</em>. B. Small, A. Shacham, K. Bergman, K. Athikulwongse, C. Hawkins, and D.S. Will. Journal of Optical Networking Vol. 3, No.11, pp 802-809, November 2004. <a href="http://lightwave.ee.columbia.edu/files/Small2004.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>ChipLock: Support for Secure Microarchitectures</em>. T. Kgil, L Falk, and T. Mudge. Proc. Workshop on Architectural Support for Security and Anti-virus (WASSA), October 2004, pp. 130-139. <a href="http://www.eecs.umich.edu/~tnm/papers/wassa04.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>Design and Applications of a Virtual Context Architecture</em>. D. Oehmke, N. Binkert, S. Reinhardt, and T. Mudge. University of Michigan Technical Report CSE-TR-497-04, September 2004. <a href="http://www.eecs.umich.edu/techreports/cse/2004/CSE-TR-497-04.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>The Performance Potential of an Integrated Network Interface</em>. N. L. Binkert, R. G. Dreslinski, E. G. Hallnor, L. R. Hsu, S. E. Raasch, A. L. Schultz, and S. K. Reinhardt. Proc. Advanced Networking and Communications Hardware Workshop (ANCHOR), June 2004. <a href="http://www.eecs.umich.edu/~stever/pubs/anchor04.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>A Co-Phase Matrix to Guide Simultaneous Multithreading Simulation</em>. M. Van Biesbrouck, T. Sherwood, and B. Calder. IEEE International Symposium on Performance Analysis and Software (ISPASS), March 2004. <a href="http://www.cs.ucsd.edu/~calder/papers/ISPASS-04-CoPhaseMatrix.pdf">pdf</a></p>
  </li>
  <li>
    <p><em>A Compressed Memory Hierarchy using an Indirect Index Cache</em>. E. G. Hallnor and S. K. Reinhardt. Proc. 3rd Workshop on Memory Performance Issues (WMPI), June 2004. <a href="http://www.eecs.umich.edu/~stever/pubs/wmpi04.pdf">pdf</a></p>
    <ul>
      <li>An extended version appears as University of Michigan Technical Report CSE-TR-488-04, March 2004. <a href="http://www.eecs.umich.edu/techreports/cse/2004/CSE-TR-488-04.pdf">pdf</a></li>
    </ul>
  </li>
</ul>

<h2 id="2003">2003<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2003"></span></h2>

<ul>
  <li><em>The Impact of Resource Partitioning on SMT Processors</em>. S. E. Raasch and S. K. Reinhardt. Proc. 12th Int’l Conf. on Parallel Architectures and Compilation Techniques (PACT), pp. 15-25, Sept.
    <ol>
      <li><a href="http://www.eecs.umich.edu/~stever/pubs/pact03.pdf">pdf</a></li>
    </ol>
  </li>
  <li><em>Network-Oriented Full-System Simulation using M5</em>. N. L. Binkert, E. G. Hallnor, and S. K. Reinhardt. Sixth Workshop on Computer Architecture Evaluation using Commercial Workloads (CAECW), February
    <ol>
      <li><a href="http://www.eecs.umich.edu/~stever/pubs/caecw03.pdf">pdf</a></li>
    </ol>
  </li>
  <li><em>Design, Implementation and Use of the MIRV Experimental Compiler for Computer Architecture Research</em>. D. A. Greene. Dissertation at the Universtiy of Michigan, 2003. [<a href="http://www.eecs.umich.edu/~tnm/theses/daveg.pdg">http://www.eecs.umich.edu/~tnm/theses/daveg.pdg</a>“&gt;pdf ]</li>
</ul>

<h2 id="2002">2002<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/#2002"></span></h2>

<ul>
  <li><em>A Scalable Instruction Queue Design Using Dependence Chains</em>. S. E. Raasch, N. L. Binkert, and S. K. Reinhardt. Proc. 29th Annual Int’l Symp. on Computer Architecture (ISCA), pp. 318-329, May 2002. <a href="http://www.eecs.umich.edu/~stever/pubs/isca02_segiq.pdf">pdf</a> <a href="http://www.eecs.umich.edu/~stever/pubs/isca02_segiq.ps">ps</a> <a href="http://www.eecs.umich1111/~stever/pubs/isca02_segiq.ps.gz">ps.gz</a></li>
</ul>

<h1 id="derivative-projects">Derivative projects</h1>
<hr />
<p>Below is a list of projects that are based on gem5, are extensions of gem5, or use gem5.</p>

<h2 id="mv5">MV5</h2>

<ul>
  <li>MV5 is a reconfigurable simulator for heterogeneous multicore architectures. It is based on M5v2.0 beta 4.</li>
  <li>Typical usage: simulating data-parallel applications on SIMT cores that operate over directory-based cache hierarchies. You can also add out-of-order cores to have a heterogeneous system, and all different types of cores can operate under the same address space through the same cache hierarchy.</li>
  <li>Research projects based on MV5 have been published in ISCA’10, ICCD’09, and IPDPS’10.</li>
</ul>

<h3 id="features">Features<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/projects/#features"></span></h3>

<ul>
  <li>Single-Instruction, Multiple-Threads (SIMT) cores</li>
  <li>Directory-based Coherence Cache: MESI/MSI. (Not based on gems/ruby)</li>
  <li>Interconnect: Fully connected and 2D Mesh. (Not based on gems/ruby)</li>
  <li>Threading API/library in system emulation mode (No support for full-system simulation. A benchmark suite using the thread API is provided)</li>
</ul>

<h3 id="resources">Resources<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/projects/#resources"></span></h3>

<ul>
  <li>Home Page: <a href="https://sites.google.com/site/mv5sim/home">1</a></li>
  <li>Tutorial at ISPASS ‘11: <a href="https://sites.google.com/site/mv5sim/tutorial">2</a></li>
  <li>Google group: <a href="http://groups.google.com/group/mv5sim">3</a></li>
</ul>

<h2 id="gem5-gpu">gem5-gpu</h2>

<ul>
  <li>Merges 2 popular simulators: gem5 and gpgpu-sim</li>
  <li>Simulates CPUs, GPUs, and the interactions between them</li>
  <li>Models a flexible memory system with support for heterogeneous processors and coherence</li>
  <li>Supports full-system simulation through GPU driver emulation</li>
</ul>

<h3 id="resources-1">Resources<span class="anchor" data-clipboard-text="http://new.gem5.org/publications/projects/#resources-1"></span></h3>

<ul>
  <li>Home Page: <a href="https://gem5-gpu.cs.wisc.edu">4</a></li>
  <li>Overview slides: <a href="http://gem5.org/wiki/images/7/7d/2012_12_gem5_gpu.pdf">5</a></li>
  <li>Mailing list: <a href="http://groups.google.com/group/gem5-gpu-dev">6</a></li>
</ul>

  </div>

</div>

<!-- button to scroll to top of page -->
<button onclick="topFunction()" id="myBtn" title="Go to top">&#9651;</button>

	</main>

	<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js" integrity="sha384-ZMP7rVo3mIykV+2+9J3UJ46jBk0WLaUAdn689aCwoqbBJiSnjAK/l8WvCWPIPm49" crossorigin="anonymous"></script>
	<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js" integrity="sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy" crossorigin="anonymous"></script>

	<script>
	  // When the user scrolls down 20px from the top of the document, show the button
	  window.onscroll = function() {scrollFunction()};

	  function scrollFunction() {
	      if (document.body.scrollTop > 100 || document.documentElement.scrollTop > 20) {
	          document.getElementById("myBtn").style.display = "block";
	      } else {
	          document.getElementById("myBtn").style.display = "none";
	      }
	  }

	  // When the user clicks on the button, scroll to the top of the document
	  function topFunction() {
	      document.body.scrollTop = 0;
	      document.documentElement.scrollTop = 0;
	  }
	</script>

</body>

<footer class="page-footer">
	<div class="container">
		<div class="row">

			<div class="col-12 col-sm-4">
				<p><a href="/about">About</a></p>
				<p><a href="/publications">Publications</a></p>
				<p><a href="/contributing">Contributing</a></p>
				<p><a href="/governance">Governance</a></p>
			</div><br>

			<div class="col-12 col-sm-4">
				<p><a href="/introduction">Documentation</a></p>
				<p><a href="http://gem5.org/Documentation">Old Documentation</a></p>
				<p><a href="https://gem5.googlesource.com/public/gem5">Source</a></p>
			</div><br>

			<div class="col-12 col-sm-4">
				<p><a href="/search">Search</a></p>
				<p><a href="#">Mailing Lists</a></p>
				<p><a href="#">Source For This Site</a></p>
			</div>

		</div>
	</div>
</footer>


</html>
