Type type,

int num_ports,

int block_size,

int data_latency)

:

name(name),

type(type),

block_size(block_size),

data_latency(data_latency),

num_ports(num_ports)

{

// Create 'num_ports' in vector of ports

ports.resize(num_ports);

// Block size

assert(!(block_size & (block_size - 1)) && block_size >= 4);

log_block_size = misc::LogBase2(block_size);

{

// Address bounds

if (range_type == RangeBounds)

return address >= range.bounds.low &&

address <= range.bounds.high;

// Interleaved addresses

if (range_type == RangeInterleaved)

return (address / range.interleaved.div) %

range.interleaved.mod ==

range.interleaved.eq;

// Invalid

throw misc::Panic("Invalid range type");

{

// There must be a free port

assert(num_locked_ports <= num_ports);

if (num_locked_ports == num_ports)

return false;

// If no MSHR is given, module can be accessed

if (!mshr_size)

return true;

// Module can be accessed if number of non-coalesced in-flight accesses

// is smaller than the MSHR size.

int num_non_coalesced_accesses = accesses.size() -

num_coalesced_accesses;

return num_non_coalesced_accesses < mshr_size;

unsigned address,

int *witness,

esim::Event *return_event)

{

// Create a new event frame

auto frame = misc::new_shared<Frame>(

Frame::getNewId(),

this,

address);

frame->witness = witness;

// Select initial event type

esim::Event *event;

switch (type)

{

case TypeCache:

case TypeMainMemory:

switch (access_type)

{

case AccessLoad:

event = System::event_load;

break;

case AccessStore:

event = System::event_store;

break;

case AccessNCStore:

event = System::event_nc_store;

break;

default:

throw misc::Panic("Invalid access type");

}

break;

case TypeLocalMemory:

switch (access_type)

{

case AccessLoad:

event = System::event_local_load;

break;

case AccessStore:

event = System::event_local_store;

break;

default:

throw misc::Panic("Invalid access type");

}

break;

default:

throw misc::Panic("Invalid module type");

}

// Schedule event

esim::Engine *esim_engine = esim::Engine::getInstance();

esim_engine->Call(event, frame, return_event);

// Return frame ID

return frame->getId();

{

// Record access type

frame->access_type = access_type;

// Insert in access list

frame->accesses_iterator = accesses.insert(accesses.end(),

frame);

// Insert in write access list

if (access_type == AccessStore)

frame->write_accesses_iterator = write_accesses.insert(

write_accesses.end(),

frame);

// Insert in hash table of block addresses

unsigned block_address = frame->getAddress() >> log_block_size;

in_flight_block_addresses.emplace(std::make_pair(block_address, frame));

// Insert in set of access identifiers

in_flight_access_ids.emplace(frame->getId());

{

// Remove from access list

accesses.erase(frame->accesses_iterator);

frame->accesses_iterator = accesses.end();

// Remove from write access list

assert(frame->access_type);

if (frame->access_type == Module::AccessStore)

{

write_accesses.erase(frame->write_accesses_iterator);

frame->write_accesses_iterator = write_accesses.end();

}

// Remove from hash table

unsigned block_address = frame->getAddress() >> log_block_size;

auto range = in_flight_block_addresses.equal_range(block_address);

bool found = false;

for (auto it = range.first; it != range.second; ++it)

{

Frame *other_frame = it->second;

if (frame == other_frame)

{

found = true;

in_flight_block_addresses.erase(it);

break;

}

}

// Must have been removed

if (!found)

throw misc::Panic("Frame not found");

// Remove from set of in-flight access identifiers

in_flight_access_ids.erase(frame->getId());

// If this was a coalesced access, update counter

if (frame->coalesced)

{

assert(num_coalesced_accesses > 0);

num_coalesced_accesses--;

}

// When a frame finishes its access, we need to check each of the frames

// in the access list and make sure that no remaining frames use the

// finished frame as a master frame. If they are, their master frame

// pointer is resest to null. This is to prevent a situation where the

// finishing frame makes a later access and adopts a master frame from

// a frame in the access list which points to itself.

for (auto it = accesses.begin(); it != accesses.end(); it++)

{

Frame *list_frame = *it;

if (list_frame->master_frame == frame)

list_frame->master_frame = nullptr;

}

// Wake up dependent accesses

frame->queue.WakeupAll();

{

unsigned block_address = address >> log_block_size;

auto it = in_flight_block_addresses.find(block_address);

return it != in_flight_block_addresses.end();

{

auto it = in_flight_access_ids.find(id);

return it != in_flight_access_ids.end();

{

// First we have to calculate the largest string that will be presented

// in the table, and create the size of elements of the table according

// to this string. Initial element size is the string "Module <name>"

unsigned element_size = name.length() + 7;

// Get the number of sets and ways

unsigned sets = cache->getNumSets();

unsigned ways = cache->getNumWays();

int sub_blocks = directory->getNumSubBlocks();

// Also we create a list with integers for the maximum number of

// sharers per set

std::vector<int> max_sharers;

max_sharers.resize(cache->getNumSets());

for (unsigned set = 0; set < sets; set++)

{

for (unsigned way = 0; way < ways; way++)

{

// Get the block

Cache::Block *block = cache->getBlock(set,way);

// If block state is invalid continue

if (!block->getState())

continue;

// Start the element size with the tag of the block

if (element_size < std::to_string(

block->getTag()).length())

element_size = std::to_string(

block->getTag()).length();

// Sharers field size

unsigned entry_text_size = 0;

// find modules that are sharers/owner of the

// directory entries.

for (int sub_block_id = 0;

sub_block_id < sub_blocks;

sub_block_id++)

{

// Number of sharers per sub_block

int sharers = 0;

// Add the name of the sharer + two spaces

for (auto &high_module : high_modules)

{

int index = getSharerIndex(high_module);

if (directory->isSharer((int) set, (int) way,

sub_block_id, index))

{

if (entry_text_size < high_module->

getName().length())

entry_text_size = high_module->

getName().

length();

sharers++;

}

}

// Increase the maximum number of sharers

// per set if it is required

if (max_sharers[set] < sharers)

max_sharers[set] = sharers;

}

// Check if this string is bigger than the previous

// maximum value

if (element_size < entry_text_size)

element_size = entry_text_size;

}

}

// Based on the element size construct the dump table

// No matter what, we would add extra space to the element size

element_size += 2;

// We start drawing the table based on the element size

// ******************************************

// * Module <name> *

// ******************************************

os << "(The Dump is best viewed when text "

"wrapping is disabled)\n";

os << std::string((ways * sub_blocks + 2)* element_size, '=') <<

"\n";

os << "| Module " << name.c_str() <<

std::string((ways * sub_blocks + 2) * element_size - 10 -

name.length(), ' ') << "|" << "\n";

os << std::string((ways * sub_blocks + 2)* element_size, '=') <<

"\n";

// Here we start printing

int pad_size = 0;

// The first line is the number of ways. The first two elements

// in this row are empty.

os << "|" << std::string(element_size * 2 - 2 , ' ') << "|";

for (unsigned i = 0; i < ways; i++)

{

// Print the way index

std::string way_id = "Way " + std::to_string(i);

// Empty space excluding | and the way index

pad_size = (sub_blocks * element_size) - 2 - way_id.length();

os << "|" <<

std::string(pad_size/2, ' ') <<

way_id.c_str() <<

std::string((sub_blocks * element_size) - 2

- way_id.length() - pad_size/2, ' ') <<

"|";

}

// Separating the first row

os <<"\n";

os << std::string((sub_blocks * ways + 2)* element_size, '=') <<

"\n";

for (unsigned set = 0; set < sets; set++)

{

// The row information

std::string set_id = "Set " + std::to_string(set);

// Print the set index

os << "| " <<

std::left <<

std::setw(element_size - 3) <<

std::setfill(' ') <<

set_id.c_str() <<

"|";

// The first row is the state (which is 5 letters)

pad_size = element_size - 2 - 5;

os << "|" <<

std::string(pad_size/2, ' ') <<

"State" <<

std::string(element_size - 7 -

pad_size/2, ' ') <<

"|";

// Printing the state of the block

for (unsigned way = 0; way < ways; way++)

{

// Get the block

Cache::Block *block = cache->getBlock(set, way);

// Print the state

pad_size = sub_blocks * element_size - 3;

os << "|" <<

std::string(pad_size/2, ' ') <<

Cache::BlockStateMap[block->getState()] <<

std::string(sub_blocks * element_size - 3 -

pad_size/2, ' ') <<

"|";

}

// Internal separator

os << "\n" << "|" << std::string(element_size - 1, ' ')

<< std::string(element_size *

(ways * sub_blocks + 1),'-') << "\n";

// The next row is the tag but the first column is empty

os << "|" << std::string(element_size - 2 , ' ') << "|";

// The second column prints Tag(which is 3 words)

pad_size = element_size - 2 - 3;

os << "|" <<

std::string(pad_size/2, ' ') <<

"Tag" <<

std::string(element_size - 5 -

pad_size/2, ' ') <<

"|";

// Printing the tag of the block

for (unsigned way = 0; way < ways; way++)

{

// Get the block

Cache::Block *block = cache->getBlock(set, way);

// If the block is invalid print empty

if (!block->getState())

{

os << "|" << std::string(sub_blocks * element_size - 2, ' ')

<< "|";

}

else

{

// Conduct the tag in Hex

std::stringstream stream;

stream << std::hex << block->getTag();

std::string tag = "0x" + stream.str();

// Print the tag

pad_size = sub_blocks * element_size -

2 - tag.length();

os << "|" <<

std::string(pad_size/2, ' ') <<

tag.c_str() <<

std::string(sub_blocks *

element_size - 2 -

tag.length() - pad_size/2,

' ') <<

"|";

}

}

// Internal separator

os << "\n" << "|" << std::string(element_size - 1, ' ')

<< std::string(element_size *

(sub_blocks * ways + 1),'-') << "\n";

// Start printing sharers of the sub-blocks one sharer

// per line

std::vector<int> printed_counter;

printed_counter.resize(cache->getNumWays() * directory->

getNumSubBlocks());

// Minimum number of rows for sharer is 1

int sharer_rows = 1;

if (sharer_rows < max_sharers[set])

sharer_rows = max_sharers[set];

for (int sharer_row = 0; sharer_row < sharer_rows;

sharer_row++)

{

// The next row is the sharers but the first column is empty

os << "|" << std::string(element_size - 2 , ' ') << "|";

// The second column prints Sharers(which is 7 words)

if (sharer_row == 0)

{

pad_size = element_size - 2 - 7;

os << "|" <<

std::string(pad_size/2, ' ') <<

"Sharers" <<

std::string(element_size - 9 -

pad_size/2, ' ') <<

"|";

}

else

{

os << "|" << std::string(element_size - 2, ' ')

<< "|";

}

// For each entry

for (unsigned way = 0; way < ways; way++)

{

for (int sub_block = 0; sub_block < sub_blocks;

sub_block++)

{

// If the sub_block doesn't have a sharer

// print empty and continue

if (!getNumSharers(set, way, sub_block))

{

os << "|" << std::string(

element_size - 2, ' ') << "|";

continue;

}

// Counting the modules that are

// sharers

int counting = 0;

for (auto &high_module : high_modules)

{

// Get the number of printed sharer

int printed = printed_counter[

way * directory->

getNumSubBlocks() +

sub_block];

// Find a sharer module

int index = getSharerIndex(high_module);

if (directory->isSharer((int) set, (int) way,

sub_block,

index))

{

// If the sharer module is

// already printed continue

// otherwise print and

// exit the loop for

// this sub-block

if (printed > counting)

{

counting++;

continue;

}

else

{

// Increase

// printed

// counter

printed_counter[

way * directory->

getNumSubBlocks() +

sub_block]++;

// Print

int length =

high_module->

getName().

length();

pad_size = element_size -

2 -

length;

os << "|" <<

std::string(pad_size/2, ' ') <<

high_module->getName() <<

std::string(element_size - 2 -

length - pad_size/2, ' ') <<

"|";

break;

}

}

}

}

}

// Internal separator

os << "\n";

}

// Internal separator

os << "|" << std::string(element_size - 1, ' ')

<< std::string(element_size *

(sub_blocks * ways + 1),'-') << "\n";

// The next row is the owner but the first column is empty

os << "|" << std::string(element_size - 2 , ' ') << "|";

// The second column prints Owner(which is 5 letters)

pad_size = element_size - 2 - 5;

os << "|" <<

std::string(pad_size/2, ' ') <<

"Owner" <<

std::string(element_size - 7 -

pad_size/2, ' ') <<

"|";

// For each entry

for (unsigned way = 0; way < ways; way++)

{

for (int sub_block = 0; sub_block < sub_blocks;

sub_block++)

{

// If the sub_block doesn't have a owner

// print empty

Module *owner = getOwner(set, way, sub_block);

if (!owner)

{

os << "|" << std::string(

element_size - 2, ' ') << "|";

}

else

{

// Print

int length = owner->getName().length();

pad_size = element_size - 2 - length;

os << "|" <<

std::string(pad_size/2,

' ') <<

owner->getName() <<

std::string(element_size -

2 - length -

pad_size/2, ' ') <<

"|";

}

}

}

// Set separator

os << "\n" << "|" << std::string((2 + ways * sub_blocks) *

element_size - 2, '=') << "|"

<< "\n";

}

{

// Dumping module's name

os << misc::fmt("[ %s ]\n\n", name.c_str());

// Dump the cache related information

if (type == TypeCache)

{

os << misc::fmt("Sets = %d\n", cache->getNumSets());

os << misc::fmt("Ways = %d\n", cache->getNumWays());

os << "ReplacementPolicy = " <<

cache->ReplacementPolicyMap.MapValue(

cache->getReplacementPolicy()) << "\n";

os << "WritePolicy = " << cache->WritePolicyMap.MapValue(

cache->getWritePolicy()) << "\n";

}

// Dump the module information

os << misc::fmt("BlockSize = %d\n", block_size);

os << misc::fmt("DataLatency = %d\n", data_latency);

os << misc::fmt("Ports = %d\n", num_ports);

os << "\n";

// Statistics - Accesses

os << misc::fmt("Accesses = %lld\n", num_accesses);

os << misc::fmt("CoalescedAccesses = %lld\n", num_coalesced_reads +

num_coalesced_writes + num_coalesced_nc_writes);

os << misc::fmt("RetriedAccesses = %lld\n", num_retry_accesses);

os << misc::fmt("Evictions = %lld\n", num_evictions);

// Statistics - Hits and misses

long long int num_hits = num_read_hits + num_write_hits

+ num_nc_write_hits;

os << misc::fmt("Hits = %lld\n", num_hits);

os << misc::fmt("Misses = %lld\n", num_accesses - num_hits);

os << misc::fmt("HitRatio = %.4g\n", num_accesses ?

(double) num_hits / num_accesses : 0.0);

os << "\n";

// Statistics breakdown - Reads

os << misc::fmt("Reads = %lld\n", num_reads);

os << misc::fmt("CoalescedReads = %lld\n", num_coalesced_reads);

os << misc::fmt("ReadHits = %lld\n", num_read_hits);

os << misc::fmt("ReadMisses = %lld\n", num_reads - num_read_hits);

os << misc::fmt("ReadRetries = %lld\n", num_retry_reads);

os << misc::fmt("ReadRetryHits = %lld\n", num_retry_read_hits);

os << misc::fmt("ReadRetryMisses = %lld\n", num_retry_read_misses);

os << misc::fmt("BlockingReads = %lld\n", num_blocking_reads);

os << misc::fmt("NonBlockingReads = %lld\n", num_non_blocking_reads);

os << "\n";

// Statistics breakdown - Writes

os << misc::fmt("Writes = %lld\n", num_writes);

os << misc::fmt("CoalescedWrites = %lld\n", num_coalesced_writes);

os << misc::fmt("WriteHits = %lld\n", num_write_hits);

os << misc::fmt("WriteMisses = %lld\n", num_writes - num_write_hits);

os << misc::fmt("WriteRetries = %lld\n", num_retry_writes);

os << misc::fmt("WriteRetryHits = %lld\n", num_retry_write_hits);

os << misc::fmt("WriteRetryMisses = %lld\n", num_retry_write_misses);

os << misc::fmt("BlockingWrites = %lld\n", num_blocking_writes);

os << misc::fmt("NonBlockingWrites = %lld\n", num_non_blocking_writes);

os << "\n";

// Statistics breakdown - Non-coherent Writes

os << misc::fmt("NCWrites = %lld\n", num_nc_writes);

os << misc::fmt("CoalescedNCWrites = %lld\n", num_coalesced_nc_writes);

os << misc::fmt("NCWriteHits = %lld\n", num_nc_write_hits);

os << misc::fmt("NCWriteMisses = %lld\n",

num_nc_writes - num_nc_write_hits);

os << misc::fmt("NCWriteRetries = %lld\n", num_retry_nc_writes);

os << misc::fmt("NCWriteRetryHits = %lld\n", num_retry_nc_write_hits);

os << misc::fmt("NCWriteRetryMisses = %lld\n",

num_retry_nc_write_misses);

os << misc::fmt("BlockingNCWrites = %lld\n", num_blocking_nc_writes);

os << misc::fmt("NonBlockingNCWrites = %lld\n",

num_non_blocking_nc_writes);

os << "\n";

// Statistics - Conflicts

os << misc::fmt("DirectoryEntryConflicts = %lld\n",

num_directory_entry_conflicts);

os << misc::fmt("RetryDirectoryEntryConflicts = %lld\n",

num_retry_directory_entry_conflicts);

if (type == TypeCache)

os << misc::fmt("ConflictInvalidation = %lld\n",

num_conflict_invalidations);

// Separating line between modules

os << "\n\n";

{

esim::Engine *engine = esim::Engine::getInstance();

os << misc::fmt("[%s] In-flight blocks in cycle %lld:\n",

name.c_str(), engine->getCycle());

for (auto &pair : in_flight_block_addresses)

{

unsigned block_address = pair.first;

Frame *frame = pair.second;

os << misc::fmt("\tkey (block_address) = 0x%x: "

"id = %lld, "

"address = 0x%x, "

"block_address = 0x%x\n",

block_address,

frame->getId(),

frame->getAddress(),

frame->getAddress() >> log_block_size);

frame->CheckMagic();

if (block_address != frame->getAddress() >> log_block_size)

throw misc::Panic("Invalid block address");

}