| /* |
| * Copyright (c) 1999-2011 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. |
| */ |
| |
| #include "mem/ruby/system/RubySystem.hh" |
| |
| #include <fcntl.h> |
| #include <zlib.h> |
| |
| #include <cstdio> |
| #include <list> |
| |
| #include "base/intmath.hh" |
| #include "base/statistics.hh" |
| #include "debug/RubyCacheTrace.hh" |
| #include "debug/RubySystem.hh" |
| #include "mem/ruby/common/Address.hh" |
| #include "mem/ruby/network/Network.hh" |
| #include "mem/simple_mem.hh" |
| #include "sim/eventq.hh" |
| #include "sim/simulate.hh" |
| |
| using namespace std; |
| |
| bool RubySystem::m_randomization; |
| uint32_t RubySystem::m_block_size_bytes; |
| uint32_t RubySystem::m_block_size_bits; |
| uint32_t RubySystem::m_memory_size_bits; |
| bool RubySystem::m_warmup_enabled = false; |
| // To look forward to allowing multiple RubySystem instances, track the number |
| // of RubySystems that need to be warmed up on checkpoint restore. |
| unsigned RubySystem::m_systems_to_warmup = 0; |
| bool RubySystem::m_cooldown_enabled = false; |
| |
| RubySystem::RubySystem(const Params *p) |
| : ClockedObject(p), m_access_backing_store(p->access_backing_store), |
| m_cache_recorder(NULL) |
| { |
| m_randomization = p->randomization; |
| |
| m_block_size_bytes = p->block_size_bytes; |
| assert(isPowerOf2(m_block_size_bytes)); |
| m_block_size_bits = floorLog2(m_block_size_bytes); |
| m_memory_size_bits = p->memory_size_bits; |
| |
| // Resize to the size of different machine types |
| m_abstract_controls.resize(MachineType_NUM); |
| |
| // Collate the statistics before they are printed. |
| Stats::registerDumpCallback(new RubyStatsCallback(this)); |
| // Create the profiler |
| m_profiler = new Profiler(p, this); |
| m_phys_mem = p->phys_mem; |
| } |
| |
| void |
| RubySystem::registerNetwork(Network* network_ptr) |
| { |
| m_network = network_ptr; |
| } |
| |
| void |
| RubySystem::registerAbstractController(AbstractController* cntrl) |
| { |
| m_abs_cntrl_vec.push_back(cntrl); |
| |
| MachineID id = cntrl->getMachineID(); |
| m_abstract_controls[id.getType()][id.getNum()] = cntrl; |
| } |
| |
| RubySystem::~RubySystem() |
| { |
| delete m_network; |
| delete m_profiler; |
| } |
| |
| void |
| RubySystem::makeCacheRecorder(uint8_t *uncompressed_trace, |
| uint64_t cache_trace_size, |
| uint64_t block_size_bytes) |
| { |
| vector<Sequencer*> sequencer_map; |
| Sequencer* sequencer_ptr = NULL; |
| |
| for (int cntrl = 0; cntrl < m_abs_cntrl_vec.size(); cntrl++) { |
| sequencer_map.push_back(m_abs_cntrl_vec[cntrl]->getCPUSequencer()); |
| if (sequencer_ptr == NULL) { |
| sequencer_ptr = sequencer_map[cntrl]; |
| } |
| } |
| |
| assert(sequencer_ptr != NULL); |
| |
| for (int cntrl = 0; cntrl < m_abs_cntrl_vec.size(); cntrl++) { |
| if (sequencer_map[cntrl] == NULL) { |
| sequencer_map[cntrl] = sequencer_ptr; |
| } |
| } |
| |
| // Remove the old CacheRecorder if it's still hanging about. |
| if (m_cache_recorder != NULL) { |
| delete m_cache_recorder; |
| } |
| |
| // Create the CacheRecorder and record the cache trace |
| m_cache_recorder = new CacheRecorder(uncompressed_trace, cache_trace_size, |
| sequencer_map, block_size_bytes); |
| } |
| |
| void |
| RubySystem::memWriteback() |
| { |
| m_cooldown_enabled = true; |
| |
| // Make the trace so we know what to write back. |
| DPRINTF(RubyCacheTrace, "Recording Cache Trace\n"); |
| makeCacheRecorder(NULL, 0, getBlockSizeBytes()); |
| for (int cntrl = 0; cntrl < m_abs_cntrl_vec.size(); cntrl++) { |
| m_abs_cntrl_vec[cntrl]->recordCacheTrace(cntrl, m_cache_recorder); |
| } |
| DPRINTF(RubyCacheTrace, "Cache Trace Complete\n"); |
| |
| // save the current tick value |
| Tick curtick_original = curTick(); |
| DPRINTF(RubyCacheTrace, "Recording current tick %ld\n", curtick_original); |
| |
| // Deschedule all prior events on the event queue, but record the tick they |
| // were scheduled at so they can be restored correctly later. |
| list<pair<Event*, Tick> > original_events; |
| while (!eventq->empty()) { |
| Event *curr_head = eventq->getHead(); |
| if (curr_head->isAutoDelete()) { |
| DPRINTF(RubyCacheTrace, "Event %s auto-deletes when descheduled," |
| " not recording\n", curr_head->name()); |
| } else { |
| original_events.push_back(make_pair(curr_head, curr_head->when())); |
| } |
| eventq->deschedule(curr_head); |
| } |
| |
| // Schedule an event to start cache cooldown |
| DPRINTF(RubyCacheTrace, "Starting cache flush\n"); |
| enqueueRubyEvent(curTick()); |
| simulate(); |
| DPRINTF(RubyCacheTrace, "Cache flush complete\n"); |
| |
| // Deschedule any events left on the event queue. |
| while (!eventq->empty()) { |
| eventq->deschedule(eventq->getHead()); |
| } |
| |
| // Restore curTick |
| setCurTick(curtick_original); |
| |
| // Restore all events that were originally on the event queue. This is |
| // done after setting curTick back to its original value so that events do |
| // not seem to be scheduled in the past. |
| while (!original_events.empty()) { |
| pair<Event*, Tick> event = original_events.back(); |
| eventq->schedule(event.first, event.second); |
| original_events.pop_back(); |
| } |
| |
| // No longer flushing back to memory. |
| m_cooldown_enabled = false; |
| |
| // There are several issues with continuing simulation after calling |
| // memWriteback() at the moment, that stem from taking events off the |
| // queue, simulating again, and then putting them back on, whilst |
| // pretending that no time has passed. One is that some events will have |
| // been deleted, so can't be put back. Another is that any object |
| // recording the tick something happens may end up storing a tick in the |
| // future. A simple warning here alerts the user that things may not work |
| // as expected. |
| warn_once("Ruby memory writeback is experimental. Continuing simulation " |
| "afterwards may not always work as intended."); |
| |
| // Keep the cache recorder around so that we can dump the trace if a |
| // checkpoint is immediately taken. |
| } |
| |
| void |
| RubySystem::writeCompressedTrace(uint8_t *raw_data, string filename, |
| uint64_t uncompressed_trace_size) |
| { |
| // Create the checkpoint file for the memory |
| string thefile = CheckpointIn::dir() + "/" + filename.c_str(); |
| |
| int fd = creat(thefile.c_str(), 0664); |
| if (fd < 0) { |
| perror("creat"); |
| fatal("Can't open memory trace file '%s'\n", filename); |
| } |
| |
| gzFile compressedMemory = gzdopen(fd, "wb"); |
| if (compressedMemory == NULL) |
| fatal("Insufficient memory to allocate compression state for %s\n", |
| filename); |
| |
| if (gzwrite(compressedMemory, raw_data, uncompressed_trace_size) != |
| uncompressed_trace_size) { |
| fatal("Write failed on memory trace file '%s'\n", filename); |
| } |
| |
| if (gzclose(compressedMemory)) { |
| fatal("Close failed on memory trace file '%s'\n", filename); |
| } |
| delete[] raw_data; |
| } |
| |
| void |
| RubySystem::serialize(CheckpointOut &cp) const |
| { |
| // Store the cache-block size, so we are able to restore on systems with a |
| // different cache-block size. CacheRecorder depends on the correct |
| // cache-block size upon unserializing. |
| uint64_t block_size_bytes = getBlockSizeBytes(); |
| SERIALIZE_SCALAR(block_size_bytes); |
| |
| // Check that there's a valid trace to use. If not, then memory won't be |
| // up-to-date and the simulation will probably fail when restoring from the |
| // checkpoint. |
| if (m_cache_recorder == NULL) { |
| fatal("Call memWriteback() before serialize() to create ruby trace"); |
| } |
| |
| // Aggregate the trace entries together into a single array |
| uint8_t *raw_data = new uint8_t[4096]; |
| uint64_t cache_trace_size = m_cache_recorder->aggregateRecords(&raw_data, |
| 4096); |
| string cache_trace_file = name() + ".cache.gz"; |
| writeCompressedTrace(raw_data, cache_trace_file, cache_trace_size); |
| |
| SERIALIZE_SCALAR(cache_trace_file); |
| SERIALIZE_SCALAR(cache_trace_size); |
| } |
| |
| void |
| RubySystem::drainResume() |
| { |
| // Delete the cache recorder if it was created in memWriteback() |
| // to checkpoint the current cache state. |
| if (m_cache_recorder) { |
| delete m_cache_recorder; |
| m_cache_recorder = NULL; |
| } |
| } |
| |
| void |
| RubySystem::readCompressedTrace(string filename, uint8_t *&raw_data, |
| uint64_t &uncompressed_trace_size) |
| { |
| // Read the trace file |
| gzFile compressedTrace; |
| |
| // trace file |
| int fd = open(filename.c_str(), O_RDONLY); |
| if (fd < 0) { |
| perror("open"); |
| fatal("Unable to open trace file %s", filename); |
| } |
| |
| compressedTrace = gzdopen(fd, "rb"); |
| if (compressedTrace == NULL) { |
| fatal("Insufficient memory to allocate compression state for %s\n", |
| filename); |
| } |
| |
| raw_data = new uint8_t[uncompressed_trace_size]; |
| if (gzread(compressedTrace, raw_data, uncompressed_trace_size) < |
| uncompressed_trace_size) { |
| fatal("Unable to read complete trace from file %s\n", filename); |
| } |
| |
| if (gzclose(compressedTrace)) { |
| fatal("Failed to close cache trace file '%s'\n", filename); |
| } |
| } |
| |
| void |
| RubySystem::unserialize(CheckpointIn &cp) |
| { |
| uint8_t *uncompressed_trace = NULL; |
| |
| // This value should be set to the checkpoint-system's block-size. |
| // Optional, as checkpoints without it can be run if the |
| // checkpoint-system's block-size == current block-size. |
| uint64_t block_size_bytes = getBlockSizeBytes(); |
| UNSERIALIZE_OPT_SCALAR(block_size_bytes); |
| |
| string cache_trace_file; |
| uint64_t cache_trace_size = 0; |
| |
| UNSERIALIZE_SCALAR(cache_trace_file); |
| UNSERIALIZE_SCALAR(cache_trace_size); |
| cache_trace_file = cp.cptDir + "/" + cache_trace_file; |
| |
| readCompressedTrace(cache_trace_file, uncompressed_trace, |
| cache_trace_size); |
| m_warmup_enabled = true; |
| m_systems_to_warmup++; |
| |
| // Create the cache recorder that will hang around until startup. |
| makeCacheRecorder(uncompressed_trace, cache_trace_size, block_size_bytes); |
| } |
| |
| void |
| RubySystem::startup() |
| { |
| |
| // Ruby restores state from a checkpoint by resetting the clock to 0 and |
| // playing the requests that can possibly re-generate the cache state. |
| // The clock value is set to the actual checkpointed value once all the |
| // requests have been executed. |
| // |
| // This way of restoring state is pretty finicky. For example, if a |
| // Ruby component reads time before the state has been restored, it would |
| // cache this value and hence its clock would not be reset to 0, when |
| // Ruby resets the global clock. This can potentially result in a |
| // deadlock. |
| // |
| // The solution is that no Ruby component should read time before the |
| // simulation starts. And then one also needs to hope that the time |
| // Ruby finishes restoring the state is less than the time when the |
| // state was checkpointed. |
| |
| if (m_warmup_enabled) { |
| DPRINTF(RubyCacheTrace, "Starting ruby cache warmup\n"); |
| // save the current tick value |
| Tick curtick_original = curTick(); |
| // save the event queue head |
| Event* eventq_head = eventq->replaceHead(NULL); |
| // set curTick to 0 and reset Ruby System's clock |
| setCurTick(0); |
| resetClock(); |
| |
| // Schedule an event to start cache warmup |
| enqueueRubyEvent(curTick()); |
| simulate(); |
| |
| delete m_cache_recorder; |
| m_cache_recorder = NULL; |
| m_systems_to_warmup--; |
| if (m_systems_to_warmup == 0) { |
| m_warmup_enabled = false; |
| } |
| |
| // Restore eventq head |
| eventq->replaceHead(eventq_head); |
| // Restore curTick and Ruby System's clock |
| setCurTick(curtick_original); |
| resetClock(); |
| } |
| |
| resetStats(); |
| } |
| |
| void |
| RubySystem::processRubyEvent() |
| { |
| if (getWarmupEnabled()) { |
| m_cache_recorder->enqueueNextFetchRequest(); |
| } else if (getCooldownEnabled()) { |
| m_cache_recorder->enqueueNextFlushRequest(); |
| } |
| } |
| |
| void |
| RubySystem::resetStats() |
| { |
| m_start_cycle = curCycle(); |
| } |
| |
| bool |
| RubySystem::functionalRead(PacketPtr pkt) |
| { |
| Addr address(pkt->getAddr()); |
| Addr line_address = makeLineAddress(address); |
| |
| AccessPermission access_perm = AccessPermission_NotPresent; |
| int num_controllers = m_abs_cntrl_vec.size(); |
| |
| DPRINTF(RubySystem, "Functional Read request for %#x\n", address); |
| |
| unsigned int num_ro = 0; |
| unsigned int num_rw = 0; |
| unsigned int num_busy = 0; |
| unsigned int num_backing_store = 0; |
| unsigned int num_invalid = 0; |
| |
| // In this loop we count the number of controllers that have the given |
| // address in read only, read write and busy states. |
| for (unsigned int i = 0; i < num_controllers; ++i) { |
| access_perm = m_abs_cntrl_vec[i]-> getAccessPermission(line_address); |
| if (access_perm == AccessPermission_Read_Only) |
| num_ro++; |
| else if (access_perm == AccessPermission_Read_Write) |
| num_rw++; |
| else if (access_perm == AccessPermission_Busy) |
| num_busy++; |
| else if (access_perm == AccessPermission_Backing_Store) |
| // See RubySlicc_Exports.sm for details, but Backing_Store is meant |
| // to represent blocks in memory *for Broadcast/Snooping protocols*, |
| // where memory has no idea whether it has an exclusive copy of data |
| // or not. |
| num_backing_store++; |
| else if (access_perm == AccessPermission_Invalid || |
| access_perm == AccessPermission_NotPresent) |
| num_invalid++; |
| } |
| assert(num_rw <= 1); |
| |
| // This if case is meant to capture what happens in a Broadcast/Snoop |
| // protocol where the block does not exist in the cache hierarchy. You |
| // only want to read from the Backing_Store memory if there is no copy in |
| // the cache hierarchy, otherwise you want to try to read the RO or RW |
| // copies existing in the cache hierarchy (covered by the else statement). |
| // The reason is because the Backing_Store memory could easily be stale, if |
| // there are copies floating around the cache hierarchy, so you want to read |
| // it only if it's not in the cache hierarchy at all. |
| if (num_invalid == (num_controllers - 1) && num_backing_store == 1) { |
| DPRINTF(RubySystem, "only copy in Backing_Store memory, read from it\n"); |
| for (unsigned int i = 0; i < num_controllers; ++i) { |
| access_perm = m_abs_cntrl_vec[i]->getAccessPermission(line_address); |
| if (access_perm == AccessPermission_Backing_Store) { |
| m_abs_cntrl_vec[i]->functionalRead(line_address, pkt); |
| return true; |
| } |
| } |
| } else if (num_ro > 0 || num_rw == 1) { |
| // In Broadcast/Snoop protocols, this covers if you know the block |
| // exists somewhere in the caching hierarchy, then you want to read any |
| // valid RO or RW block. In directory protocols, same thing, you want |
| // to read any valid readable copy of the block. |
| DPRINTF(RubySystem, "num_busy = %d, num_ro = %d, num_rw = %d\n", |
| num_busy, num_ro, num_rw); |
| // In this loop, we try to figure which controller has a read only or |
| // a read write copy of the given address. Any valid copy would suffice |
| // for a functional read. |
| for (unsigned int i = 0;i < num_controllers;++i) { |
| access_perm = m_abs_cntrl_vec[i]->getAccessPermission(line_address); |
| if (access_perm == AccessPermission_Read_Only || |
| access_perm == AccessPermission_Read_Write) { |
| m_abs_cntrl_vec[i]->functionalRead(line_address, pkt); |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| // The function searches through all the buffers that exist in different |
| // cache, directory and memory controllers, and in the network components |
| // and writes the data portion of those that hold the address specified |
| // in the packet. |
| bool |
| RubySystem::functionalWrite(PacketPtr pkt) |
| { |
| Addr addr(pkt->getAddr()); |
| Addr line_addr = makeLineAddress(addr); |
| AccessPermission access_perm = AccessPermission_NotPresent; |
| int num_controllers = m_abs_cntrl_vec.size(); |
| |
| DPRINTF(RubySystem, "Functional Write request for %#x\n", addr); |
| |
| uint32_t M5_VAR_USED num_functional_writes = 0; |
| |
| for (unsigned int i = 0; i < num_controllers;++i) { |
| num_functional_writes += |
| m_abs_cntrl_vec[i]->functionalWriteBuffers(pkt); |
| |
| access_perm = m_abs_cntrl_vec[i]->getAccessPermission(line_addr); |
| if (access_perm != AccessPermission_Invalid && |
| access_perm != AccessPermission_NotPresent) { |
| num_functional_writes += |
| m_abs_cntrl_vec[i]->functionalWrite(line_addr, pkt); |
| } |
| } |
| |
| num_functional_writes += m_network->functionalWrite(pkt); |
| DPRINTF(RubySystem, "Messages written = %u\n", num_functional_writes); |
| |
| return true; |
| } |
| |
| RubySystem * |
| RubySystemParams::create() |
| { |
| return new RubySystem(this); |
| } |