CacheRecorder.cc revision 11049:dfb0aa3f0649
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 if (m_uncompressed_trace != NULL) { 62 if (m_block_size_bytes < RubySystem::getBlockSizeBytes()) { 63 // Block sizes larger than when the trace was recorded are not 64 // supported, as we cannot reliably turn accesses to smaller blocks 65 // into larger ones. 66 panic("Recorded cache block size (%d) < current block size (%d) !!", 67 m_block_size_bytes, RubySystem::getBlockSizeBytes()); 68 } 69 } 70} 71 72CacheRecorder::~CacheRecorder() 73{ 74 if (m_uncompressed_trace != NULL) { 75 delete [] m_uncompressed_trace; 76 m_uncompressed_trace = NULL; 77 } 78 m_seq_map.clear(); 79} 80 81void 82CacheRecorder::enqueueNextFlushRequest() 83{ 84 if (m_records_flushed < m_records.size()) { 85 TraceRecord* rec = m_records[m_records_flushed]; 86 m_records_flushed++; 87 Request* req = new Request(rec->m_data_address, 88 m_block_size_bytes, 0, 89 Request::funcMasterId); 90 MemCmd::Command requestType = MemCmd::FlushReq; 91 Packet *pkt = new Packet(req, requestType); 92 93 Sequencer* m_sequencer_ptr = m_seq_map[rec->m_cntrl_id]; 94 assert(m_sequencer_ptr != NULL); 95 m_sequencer_ptr->makeRequest(pkt); 96 97 DPRINTF(RubyCacheTrace, "Flushing %s\n", *rec); 98 } else { 99 DPRINTF(RubyCacheTrace, "Flushed all %d records\n", m_records_flushed); 100 } 101} 102 103void 104CacheRecorder::enqueueNextFetchRequest() 105{ 106 if (m_bytes_read < m_uncompressed_trace_size) { 107 TraceRecord* traceRecord = (TraceRecord*) (m_uncompressed_trace + 108 m_bytes_read); 109 110 DPRINTF(RubyCacheTrace, "Issuing %s\n", *traceRecord); 111 112 for (int rec_bytes_read = 0; rec_bytes_read < m_block_size_bytes; 113 rec_bytes_read += RubySystem::getBlockSizeBytes()) { 114 Request* req = nullptr; 115 MemCmd::Command requestType; 116 117 if (traceRecord->m_type == RubyRequestType_LD) { 118 requestType = MemCmd::ReadReq; 119 req = new Request(traceRecord->m_data_address + rec_bytes_read, 120 RubySystem::getBlockSizeBytes(), 0, Request::funcMasterId); 121 } else if (traceRecord->m_type == RubyRequestType_IFETCH) { 122 requestType = MemCmd::ReadReq; 123 req = new Request(traceRecord->m_data_address + rec_bytes_read, 124 RubySystem::getBlockSizeBytes(), 125 Request::INST_FETCH, Request::funcMasterId); 126 } else { 127 requestType = MemCmd::WriteReq; 128 req = new Request(traceRecord->m_data_address + rec_bytes_read, 129 RubySystem::getBlockSizeBytes(), 0, Request::funcMasterId); 130 } 131 132 Packet *pkt = new Packet(req, requestType); 133 pkt->dataStatic(traceRecord->m_data + rec_bytes_read); 134 135 Sequencer* m_sequencer_ptr = m_seq_map[traceRecord->m_cntrl_id]; 136 assert(m_sequencer_ptr != NULL); 137 m_sequencer_ptr->makeRequest(pkt); 138 } 139 140 m_bytes_read += (sizeof(TraceRecord) + m_block_size_bytes); 141 m_records_read++; 142 } else { 143 DPRINTF(RubyCacheTrace, "Fetched all %d records\n", m_records_read); 144 } 145} 146 147void 148CacheRecorder::addRecord(int cntrl, Addr data_addr, Addr pc_addr, 149 RubyRequestType type, Tick time, DataBlock& data) 150{ 151 TraceRecord* rec = (TraceRecord*)malloc(sizeof(TraceRecord) + 152 m_block_size_bytes); 153 rec->m_cntrl_id = cntrl; 154 rec->m_time = time; 155 rec->m_data_address = data_addr; 156 rec->m_pc_address = pc_addr; 157 rec->m_type = type; 158 memcpy(rec->m_data, data.getData(0, m_block_size_bytes), 159 m_block_size_bytes); 160 161 m_records.push_back(rec); 162} 163 164uint64 165CacheRecorder::aggregateRecords(uint8_t** buf, uint64 total_size) 166{ 167 std::sort(m_records.begin(), m_records.end(), compareTraceRecords); 168 169 int size = m_records.size(); 170 uint64 current_size = 0; 171 int record_size = sizeof(TraceRecord) + m_block_size_bytes; 172 173 for (int i = 0; i < size; ++i) { 174 // Determine if we need to expand the buffer size 175 if (current_size + record_size > total_size) { 176 uint8_t* new_buf = new (nothrow) uint8_t[total_size * 2]; 177 if (new_buf == NULL) { 178 fatal("Unable to allocate buffer of size %s\n", 179 total_size * 2); 180 } 181 total_size = total_size * 2; 182 uint8_t* old_buf = *buf; 183 memcpy(new_buf, old_buf, current_size); 184 *buf = new_buf; 185 delete [] old_buf; 186 } 187 188 // Copy the current record into the buffer 189 memcpy(&((*buf)[current_size]), m_records[i], record_size); 190 current_size += record_size; 191 192 free(m_records[i]); 193 m_records[i] = NULL; 194 } 195 196 m_records.clear(); 197 return current_size; 198} 199