From 2f30950143cc70bc42a3c8a4111d7cf8198ec881 Mon Sep 17 00:00:00 2001 From: Nathan Binkert Date: Mon, 11 May 2009 10:38:43 -0700 Subject: ruby: Import ruby and slicc from GEMS We eventually plan to replace the m5 cache hierarchy with the GEMS hierarchy, but for now we will make both live alongside eachother. --- src/mem/ruby/profiler/StoreTrace.cc | 158 ++++++++++++++++++++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 src/mem/ruby/profiler/StoreTrace.cc (limited to 'src/mem/ruby/profiler/StoreTrace.cc') diff --git a/src/mem/ruby/profiler/StoreTrace.cc b/src/mem/ruby/profiler/StoreTrace.cc new file mode 100644 index 000000000..c53f590ac --- /dev/null +++ b/src/mem/ruby/profiler/StoreTrace.cc @@ -0,0 +1,158 @@ + +/* + * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * $Id$ + * + */ + +#include "StoreTrace.hh" +#include "EventQueue.hh" + +bool StoreTrace::s_init = false; // Total number of store lifetimes of all lines +int64 StoreTrace::s_total_samples = 0; // Total number of store lifetimes of all lines +Histogram* StoreTrace::s_store_count_ptr = NULL; +Histogram* StoreTrace::s_store_first_to_stolen_ptr = NULL; +Histogram* StoreTrace::s_store_last_to_stolen_ptr = NULL; +Histogram* StoreTrace::s_store_first_to_last_ptr = NULL; + +StoreTrace::StoreTrace(const Address& addr) : + m_store_count(-1), m_store_first_to_stolen(-1), m_store_last_to_stolen(-1), m_store_first_to_last(-1) +{ + StoreTrace::initSummary(); + m_addr = addr; + m_total_samples = 0; + m_last_writer = -1; // Really -1 isn't valid, so this will trigger the initilization code + m_stores_this_interval = 0; +} + +StoreTrace::~StoreTrace() +{ +} + +void StoreTrace::print(ostream& out) const +{ + out << m_addr; + out << " total_samples: " << m_total_samples << endl; + out << "store_count: " << m_store_count << endl; + out << "store_first_to_stolen: " << m_store_first_to_stolen << endl; + out << "store_last_to_stolen: " << m_store_last_to_stolen << endl; + out << "store_first_to_last: " << m_store_first_to_last << endl; +} + +// Class method +void StoreTrace::initSummary() +{ + if (!s_init) { + s_total_samples = 0; + s_store_count_ptr = new Histogram(-1); + s_store_first_to_stolen_ptr = new Histogram(-1); + s_store_last_to_stolen_ptr = new Histogram(-1); + s_store_first_to_last_ptr = new Histogram(-1); + } + s_init = true; +} + +// Class method +void StoreTrace::printSummary(ostream& out) +{ + out << "total_samples: " << s_total_samples << endl; + out << "store_count: " << (*s_store_count_ptr) << endl; + out << "store_first_to_stolen: " << (*s_store_first_to_stolen_ptr) << endl; + out << "store_last_to_stolen: " << (*s_store_last_to_stolen_ptr) << endl; + out << "store_first_to_last: " << (*s_store_first_to_last_ptr) << endl; +} + +// Class method +void StoreTrace::clearSummary() +{ + StoreTrace::initSummary(); + s_total_samples = 0; + s_store_count_ptr->clear(); + s_store_first_to_stolen_ptr->clear(); + s_store_last_to_stolen_ptr->clear(); + s_store_first_to_last_ptr->clear(); +} + +void StoreTrace::store(NodeID node) +{ + Time current = g_eventQueue_ptr->getTime(); + + assert((m_last_writer == -1) || (m_last_writer == node)); + + m_last_writer = node; + if (m_last_writer == -1) { + assert(m_stores_this_interval == 0); + } + + if (m_stores_this_interval == 0) { + // A new proessor just wrote the line, so reset the stats + m_first_store = current; + } + + m_last_store = current; + m_stores_this_interval++; +} + +void StoreTrace::downgrade(NodeID node) +{ + if (node == m_last_writer) { + Time current = g_eventQueue_ptr->getTime(); + assert(m_stores_this_interval != 0); + assert(m_last_store != 0); + assert(m_first_store != 0); + assert(m_last_writer != -1); + + // Per line stats + m_store_first_to_stolen.add(current - m_first_store); + m_store_count.add(m_stores_this_interval); + m_store_last_to_stolen.add(current - m_last_store); + m_store_first_to_last.add(m_last_store - m_first_store); + m_total_samples++; + + // Global stats + assert(s_store_first_to_stolen_ptr != NULL); + s_store_first_to_stolen_ptr->add(current - m_first_store); + s_store_count_ptr->add(m_stores_this_interval); + s_store_last_to_stolen_ptr->add(current - m_last_store); + s_store_first_to_last_ptr->add(m_last_store - m_first_store); + s_total_samples++; + + // Initilize for next go round + m_stores_this_interval = 0; + m_last_store = 0; + m_first_store = 0; + m_last_writer = -1; + } +} + +bool node_less_then_eq(const StoreTrace* n1, const StoreTrace* n2) +{ + return (n1->getTotal() > n2->getTotal()); +} -- cgit v1.2.3