CacheRecorder.cc revision 11039:fe230bcf3f38
1/* 2 * Copyright (c) 1999-2012 Mark D. Hill and David A. Wood 3 * Copyright (c) 2010 Advanced Micro Devices, Inc. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer; 10 * redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution; 13 * neither the name of the copyright holders nor the names of its 14 * contributors may be used to endorse or promote products derived from 15 * this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30#include "debug/RubyCacheTrace.hh" 31#include "mem/ruby/system/CacheRecorder.hh" 32#include "mem/ruby/system/Sequencer.hh" 33#include "mem/ruby/system/System.hh" 34 35using namespace std; 36 37void 38TraceRecord::print(ostream& out) const 39{ 40 out << "[TraceRecord: Node, " << m_cntrl_id << ", " 41 << m_data_address << ", " << m_pc_address << ", " 42 << m_type << ", Time: " << m_time << "]"; 43} 44 45CacheRecorder::CacheRecorder() 46 : m_uncompressed_trace(NULL), 47 m_uncompressed_trace_size(0), 48 m_block_size_bytes(RubySystem::getBlockSizeBytes()) 49{ 50} 51 52CacheRecorder::CacheRecorder(uint8_t* uncompressed_trace, 53 uint64_t uncompressed_trace_size, 54 std::vector<Sequencer*>& seq_map, 55 uint64_t block_size_bytes) 56 : m_uncompressed_trace(uncompressed_trace), 57 m_uncompressed_trace_size(uncompressed_trace_size), 58 m_seq_map(seq_map), m_bytes_read(0), m_records_read(0), 59 m_records_flushed(0), m_block_size_bytes(block_size_bytes) 60{ 61} 62 63CacheRecorder::~CacheRecorder() 64{ 65 if (m_uncompressed_trace != NULL) { 66 delete [] m_uncompressed_trace; 67 m_uncompressed_trace = NULL; 68 } 69 m_seq_map.clear(); 70} 71 72void 73CacheRecorder::enqueueNextFlushRequest() 74{ 75 if (m_records_flushed < m_records.size()) { 76 TraceRecord* rec = m_records[m_records_flushed]; 77 m_records_flushed++; 78 Request* req = new Request(rec->m_data_address, 79 m_block_size_bytes, 0, 80 Request::funcMasterId); 81 MemCmd::Command requestType = MemCmd::FlushReq; 82 Packet *pkt = new Packet(req, requestType); 83 84 Sequencer* m_sequencer_ptr = m_seq_map[rec->m_cntrl_id]; 85 assert(m_sequencer_ptr != NULL); 86 m_sequencer_ptr->makeRequest(pkt); 87 88 DPRINTF(RubyCacheTrace, "Flushing %s\n", *rec); 89 } else { 90 DPRINTF(RubyCacheTrace, "Flushed all %d records\n", m_records_flushed); 91 } 92} 93 94void 95CacheRecorder::enqueueNextFetchRequest() 96{ 97 if (m_bytes_read < m_uncompressed_trace_size) { 98 TraceRecord* traceRecord = (TraceRecord*) (m_uncompressed_trace + 99 m_bytes_read); 100 101 DPRINTF(RubyCacheTrace, "Issuing %s\n", *traceRecord); 102 103 for (int rec_bytes_read = 0; rec_bytes_read < m_block_size_bytes; 104 rec_bytes_read += RubySystem::getBlockSizeBytes()) { 105 Request* req = nullptr; 106 MemCmd::Command requestType; 107 108 if (traceRecord->m_type == RubyRequestType_LD) { 109 requestType = MemCmd::ReadReq; 110 req = new Request(traceRecord->m_data_address + rec_bytes_read, 111 RubySystem::getBlockSizeBytes(), 0, Request::funcMasterId); 112 } else if (traceRecord->m_type == RubyRequestType_IFETCH) { 113 requestType = MemCmd::ReadReq; 114 req = new Request(traceRecord->m_data_address + rec_bytes_read, 115 RubySystem::getBlockSizeBytes(), 116 Request::INST_FETCH, Request::funcMasterId); 117 } else { 118 requestType = MemCmd::WriteReq; 119 req = new Request(traceRecord->m_data_address + rec_bytes_read, 120 RubySystem::getBlockSizeBytes(), 0, Request::funcMasterId); 121 } 122 123 Packet *pkt = new Packet(req, requestType); 124 pkt->dataStatic(traceRecord->m_data + rec_bytes_read); 125 126 Sequencer* m_sequencer_ptr = m_seq_map[traceRecord->m_cntrl_id]; 127 assert(m_sequencer_ptr != NULL); 128 m_sequencer_ptr->makeRequest(pkt); 129 } 130 131 m_bytes_read += (sizeof(TraceRecord) + m_block_size_bytes); 132 m_records_read++; 133 } else { 134 DPRINTF(RubyCacheTrace, "Fetched all %d records\n", m_records_read); 135 } 136} 137 138void 139CacheRecorder::addRecord(int cntrl, Addr data_addr, Addr pc_addr, 140 RubyRequestType type, Tick time, DataBlock& data) 141{ 142 TraceRecord* rec = (TraceRecord*)malloc(sizeof(TraceRecord) + 143 m_block_size_bytes); 144 rec->m_cntrl_id = cntrl; 145 rec->m_time = time; 146 rec->m_data_address = data_addr; 147 rec->m_pc_address = pc_addr; 148 rec->m_type = type; 149 memcpy(rec->m_data, data.getData(0, m_block_size_bytes), 150 m_block_size_bytes); 151 152 m_records.push_back(rec); 153} 154 155uint64_t 156CacheRecorder::aggregateRecords(uint8_t **buf, uint64_t total_size) 157{ 158 std::sort(m_records.begin(), m_records.end(), compareTraceRecords); 159 160 int size = m_records.size(); 161 uint64_t current_size = 0; 162 int record_size = sizeof(TraceRecord) + m_block_size_bytes; 163 164 for (int i = 0; i < size; ++i) { 165 // Determine if we need to expand the buffer size 166 if (current_size + record_size > total_size) { 167 uint8_t* new_buf = new (nothrow) uint8_t[total_size * 2]; 168 if (new_buf == NULL) { 169 fatal("Unable to allocate buffer of size %s\n", 170 total_size * 2); 171 } 172 total_size = total_size * 2; 173 uint8_t* old_buf = *buf; 174 memcpy(new_buf, old_buf, current_size); 175 *buf = new_buf; 176 delete [] old_buf; 177 } 178 179 // Copy the current record into the buffer 180 memcpy(&((*buf)[current_size]), m_records[i], record_size); 181 current_size += record_size; 182 183 free(m_records[i]); 184 m_records[i] = NULL; 185 } 186 187 m_records.clear(); 188 return current_size; 189} 190