288 lines
12 KiB
C++
288 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2017, Technische Universität Kaiserslautern
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. 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.
|
|
*
|
|
* 3. Neither the name of the copyright holder 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 HOLDER
|
|
* 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.
|
|
*
|
|
* Authors:
|
|
* Matthias Jung
|
|
* Luiza Correa
|
|
* Derek Christ
|
|
*/
|
|
|
|
#include <iomanip>
|
|
#include "TraceSetup.h"
|
|
#include "StlPlayer.h"
|
|
#include "TrafficGenerator.h"
|
|
|
|
using namespace sc_core;
|
|
using namespace tlm;
|
|
|
|
TraceSetup::TraceSetup(const std::string &uri,
|
|
const std::string &pathToResources,
|
|
std::vector<std::unique_ptr<TrafficInitiator>> &players)
|
|
{
|
|
// Load Simulation:
|
|
nlohmann::json simulationdoc = parseJSON(uri);
|
|
|
|
if (simulationdoc["simulation"].empty())
|
|
SC_REPORT_FATAL("TraceSetup",
|
|
"Cannot load simulation: simulation node expected");
|
|
|
|
// Load TrafficInitiators:
|
|
if (simulationdoc["simulation"]["tracesetup"].empty())
|
|
SC_REPORT_FATAL("TraceSetup", "tracesetup is empty");
|
|
for (auto &it : simulationdoc["simulation"]["tracesetup"].items())
|
|
{
|
|
nlohmann::json value = it.value();
|
|
if (!value.empty())
|
|
{
|
|
sc_time playerClk;
|
|
if (!value["clkMhz"].is_number() || value["clkMhz"] <= 0)
|
|
SC_REPORT_FATAL("TraceSetup", "Frequency is not a positive number.");
|
|
|
|
double frequencyMHz = value["clkMhz"];
|
|
playerClk = sc_time(1.0 / frequencyMHz, SC_US);
|
|
|
|
if (!value["name"].is_string())
|
|
SC_REPORT_FATAL("TraceSetup", "No trace name defined.");
|
|
|
|
std::string name = value["name"];
|
|
|
|
unsigned int maxPendingReadRequests = 0;
|
|
unsigned int maxPendingWriteRequests = 0;
|
|
|
|
if (value["maxPendingReadRequests"].is_number_unsigned())
|
|
maxPendingReadRequests = value["maxPendingReadRequests"];
|
|
|
|
if (value["maxPendingWriteRequests"].is_number_unsigned())
|
|
maxPendingWriteRequests = value["maxPendingWriteRequests"];
|
|
|
|
bool needsLengthConverter = false;
|
|
|
|
if (value["needsLengthConverter"].is_boolean())
|
|
needsLengthConverter = value["needsLengthConverter"];
|
|
|
|
std::string type;
|
|
|
|
// Defaulting to type "player" when not specified
|
|
if (!value["type"].is_string())
|
|
type = "player";
|
|
else
|
|
type = value["type"];
|
|
|
|
if (type == "player")
|
|
{
|
|
size_t pos = name.rfind('.');
|
|
if (pos == std::string::npos)
|
|
throw std::runtime_error("Name of the trace file does not contain a valid extension.");
|
|
|
|
// Get the extension and make it lower case
|
|
std::string ext = name.substr(pos + 1);
|
|
std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
|
|
|
|
std::stringstream stlFileStream;
|
|
stlFileStream << pathToResources << "traces/" << name;
|
|
std::string stlFile = stlFileStream.str();
|
|
std::string moduleName = name;
|
|
|
|
// replace all '.' to '_'
|
|
std::replace(moduleName.begin(), moduleName.end(), '.', '_');
|
|
|
|
StlPlayer *player;
|
|
if (ext == "stl")
|
|
player = new StlPlayer(moduleName.c_str(), stlFile, playerClk,
|
|
maxPendingReadRequests, maxPendingWriteRequests, needsLengthConverter,
|
|
this, false);
|
|
else if (ext == "rstl")
|
|
player = new StlPlayer(moduleName.c_str(), stlFile, playerClk,
|
|
maxPendingReadRequests, maxPendingWriteRequests, needsLengthConverter,
|
|
this, true);
|
|
else
|
|
throw std::runtime_error("Unsupported file extension in " + name);
|
|
|
|
totalTransactions += player->getNumberOfLines();
|
|
players.push_back(std::unique_ptr<TrafficInitiator>(player));
|
|
}
|
|
else if (type == "generator")
|
|
{
|
|
if (!value["numRequests"].is_number_unsigned())
|
|
SC_REPORT_FATAL("TraceSetup", "Number of requests is not a number.");
|
|
|
|
uint64_t numRequests = value["numRequests"];
|
|
|
|
if (!value["rwRatio"].is_number() || value["rwRatio"] < 0 || value["rwRatio"] > 1)
|
|
SC_REPORT_FATAL("TraceSetup", "Read/Write ratio is not a number between 0 and 1.");
|
|
|
|
float rwRatio = value["rwRatio"];
|
|
|
|
if (!value["addressDistribution"].is_string())
|
|
SC_REPORT_FATAL("TraceSetup", "Address distribution not defined.");
|
|
|
|
std::string addressDistribution = value["addressDistribution"];
|
|
if (addressDistribution != "sequential" && addressDistribution != "random")
|
|
SC_REPORT_FATAL("TraceSetup", "Address distribution must either be sequential or random.");
|
|
|
|
unsigned int seed = 0;
|
|
if (!value["seed"].empty())
|
|
{
|
|
if (value["seed"].is_number_unsigned())
|
|
seed = value["seed"];
|
|
else
|
|
SC_REPORT_FATAL("TraceSetup", "Seed is not an unsigned number.");
|
|
}
|
|
|
|
uint64_t minAddress = 0;
|
|
if (!value["minAddress"].empty())
|
|
{
|
|
if (value["minAddress"].is_number_unsigned())
|
|
{
|
|
minAddress = value["minAddress"];
|
|
if (minAddress > Configuration::getInstance().memSpec->getSimMemSizeInBytes() - 1)
|
|
SC_REPORT_FATAL("TraceSetup", "minAddress is out of range.");
|
|
}
|
|
else
|
|
SC_REPORT_FATAL("TraceSetup", "minAddress is not an unsigned number.");
|
|
}
|
|
|
|
uint64_t maxAddress = Configuration::getInstance().memSpec->getSimMemSizeInBytes() - 1;
|
|
if (!value["maxAddress"].empty())
|
|
{
|
|
if (value["maxAddress"].is_number_unsigned())
|
|
{
|
|
maxAddress = value["maxAddress"];
|
|
if (maxAddress > Configuration::getInstance().memSpec->getSimMemSizeInBytes() - 1)
|
|
SC_REPORT_FATAL("TraceSetup", "maxAddress is out of range.");
|
|
}
|
|
else
|
|
SC_REPORT_FATAL("TraceSetup", "maxAddress is not an unsigned number.");
|
|
}
|
|
|
|
if (maxAddress < minAddress)
|
|
SC_REPORT_FATAL("TraceSetup", "maxAddress is smaller than minAddress.");
|
|
|
|
if (addressDistribution == "sequential")
|
|
{
|
|
uint64_t addressIncrement = 0x0;
|
|
if (!value["addressIncrement"].is_number_unsigned())
|
|
SC_REPORT_FATAL("TraceSetup", "Address increment is not an unsigned number.");
|
|
else
|
|
addressIncrement = value["addressIncrement"];
|
|
|
|
players.push_back(std::unique_ptr<TrafficInitiator>(new TrafficGeneratorSequential(name.c_str(),
|
|
playerClk, numRequests, maxPendingReadRequests, maxPendingWriteRequests,
|
|
needsLengthConverter, minAddress, maxAddress, rwRatio, addressIncrement, seed, this)));
|
|
}
|
|
else
|
|
{
|
|
players.push_back(std::unique_ptr<TrafficInitiator>(new TrafficGeneratorRandom(name.c_str(),
|
|
playerClk, numRequests, maxPendingReadRequests, maxPendingWriteRequests,
|
|
needsLengthConverter, minAddress, maxAddress, rwRatio, seed, this)));
|
|
}
|
|
|
|
totalTransactions += numRequests;
|
|
}
|
|
else if (type == "hammer")
|
|
{
|
|
if (!value["numRequests"].is_number_unsigned())
|
|
SC_REPORT_FATAL("TraceSetup", "Number of requests is not a number.");
|
|
uint64_t numRequests = value["numRequests"];
|
|
|
|
if (!value["rowIncrement"].is_number_unsigned())
|
|
SC_REPORT_FATAL("TraceSetup", "Row increment is not a number.");
|
|
uint64_t rowIncrement = value["rowIncrement"];
|
|
|
|
players.push_back(std::unique_ptr<TrafficInitiator>(new TrafficGeneratorHammer(name.c_str(), playerClk,
|
|
numRequests, rowIncrement, this)));
|
|
}
|
|
}
|
|
else
|
|
SC_REPORT_FATAL("TraceSetup", "Empty trace setup item.");
|
|
}
|
|
|
|
remainingTransactions = totalTransactions;
|
|
numberOfTrafficInitiators = players.size();
|
|
}
|
|
|
|
void TraceSetup::trafficInitiatorTerminates()
|
|
{
|
|
finishedTrafficInitiators++;
|
|
|
|
if (finishedTrafficInitiators == numberOfTrafficInitiators)
|
|
sc_stop();
|
|
}
|
|
|
|
void TraceSetup::transactionFinished()
|
|
{
|
|
remainingTransactions--;
|
|
|
|
loadBar(totalTransactions - remainingTransactions, totalTransactions);
|
|
|
|
if (remainingTransactions == 0)
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
tlm_generic_payload *TraceSetup::allocatePayload()
|
|
{
|
|
return memoryManager.allocate();
|
|
}
|
|
|
|
void TraceSetup::loadBar(uint64_t x, uint64_t n, unsigned int w, unsigned int granularity)
|
|
{
|
|
if ((n < 100) || ((x != n) && (x % (n / 100 * granularity) != 0)))
|
|
return;
|
|
|
|
float ratio = x / (float) n;
|
|
unsigned int c = (ratio * w);
|
|
float rest = (ratio * w) - c;
|
|
std::cout << std::setw(3) << round(ratio * 100) << "% |";
|
|
for (unsigned int x = 0; x < c; x++)
|
|
std::cout << "█";
|
|
|
|
if (rest >= 0 && rest < 0.125f && c != w)
|
|
std::cout << " ";
|
|
if (rest >= 0.125f && rest < 2 * 0.125f)
|
|
std::cout << "▏";
|
|
if (rest >= 2 * 0.125f && rest < 3 * 0.125f)
|
|
std::cout << "▎";
|
|
if (rest >= 3 * 0.125f && rest < 4 * 0.125f)
|
|
std::cout << "▍";
|
|
if (rest >= 4 * 0.125f && rest < 5 * 0.125f)
|
|
std::cout << "▌";
|
|
if (rest >= 5 * 0.125f && rest < 6 * 0.125f)
|
|
std::cout << "▋";
|
|
if (rest >= 6 * 0.125f && rest < 7 * 0.125f)
|
|
std::cout << "▊";
|
|
if (rest >= 7 * 0.125f && rest < 8 * 0.125f)
|
|
std::cout << "▉";
|
|
|
|
for (unsigned int x = c; x < (w - 1); x++)
|
|
std::cout << " ";
|
|
std::cout << "|\r" << std::flush;
|
|
}
|