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{
| 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 }
|
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
| 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
|
155uint64_t 156CacheRecorder::aggregateRecords(uint8_t **buf, uint64_t total_size)
| 164uint64 165CacheRecorder::aggregateRecords(uint8_t** buf, uint64 total_size)
|
157{ 158 std::sort(m_records.begin(), m_records.end(), compareTraceRecords); 159 160 int size = m_records.size();
| 166{ 167 std::sort(m_records.begin(), m_records.end(), compareTraceRecords); 168 169 int size = m_records.size();
|
161 uint64_t current_size = 0;
| 170 uint64 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}
| 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}
|