derek/DRAMSys
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup TLM recorder.

Browse Source
This commit is contained in:
Lukas Steiner
2020-11-26 13:57:07 +01:00
parent efdba2c9ee
commit ce50dee0e2
3 changed files with 112 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
DRAMSys/library/src/common/TlmRecorder.cpp
View File

@@ -54,11 +54,11 @@ TlmRecorder::TlmRecorder(std::string name, std::string dbname) :
setUpTransactionTerminatingPhases();
openDB(TlmRecorder::dbName.c_str());
char *sErrMsg;
sqlite3_exec(db, "PRAGMA main.page_size = 4096", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.cache_size=10000", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.locking_mode=EXCLUSIVE", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.synchronous=OFF", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = OFF", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.page_size = 4096", nullptr, nullptr, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.cache_size=10000", nullptr, nullptr, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.locking_mode=EXCLUSIVE", nullptr, nullptr, &sErrMsg);
sqlite3_exec(db, "PRAGMA main.synchronous=OFF", nullptr, nullptr, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = OFF", nullptr, nullptr, &sErrMsg);
executeInitialSqlCommand();
prepareSqlStatements();
@@ -96,7 +96,7 @@ void TlmRecorder::recordBufferDepth(double timeInSeconds, const std::vector<doub
for (size_t index = 0; index < averageBufferDepth.size(); index++)
{
sqlite3_bind_double(insertBufferDepthStatement, 1, timeInSeconds);
sqlite3_bind_int(insertBufferDepthStatement, 2, index);
sqlite3_bind_int(insertBufferDepthStatement, 2, static_cast<int>(index));
sqlite3_bind_double(insertBufferDepthStatement, 3, averageBufferDepth[index]);
executeSqlStatement(insertBufferDepthStatement);
}
@@ -157,25 +157,20 @@ void TlmRecorder::recordDebugMessage(std::string message, sc_time time)
void TlmRecorder::introduceTransactionSystem(tlm_generic_payload &trans)
{
unsigned int id = totalNumTransactions++;
uint64_t id = totalNumTransactions++;
currentTransactionsInSystem[&trans].id = id;
currentTransactionsInSystem[&trans].cmd = trans.get_command() ==
tlm::TLM_READ_COMMAND ? "R" : "W";
currentTransactionsInSystem[&trans].address = trans.get_address();
currentTransactionsInSystem[&trans].burstlength = trans.get_streaming_width();
currentTransactionsInSystem[&trans].dramExtension = DramExtension::getExtension(
trans);
if (DramExtension::getExtension(trans).getThread().ID() == UINT_MAX)
currentTransactionsInSystem[&trans].timeOfGeneration = SC_ZERO_TIME;
else
currentTransactionsInSystem[&trans].timeOfGeneration =
GenerationExtension::getTimeOfGeneration(trans);
currentTransactionsInSystem[&trans].dramExtension = DramExtension::getExtension(trans);
currentTransactionsInSystem[&trans].timeOfGeneration = GenerationExtension::getTimeOfGeneration(trans);
PRINTDEBUGMESSAGE(name, "New transaction #" + std::to_string(id) + " generation time " +
currentTransactionsInSystem[&trans].timeOfGeneration.to_string());
if (id % transactionCommitRate == 0) {
if (id % transactionCommitRate == 0)
{
PRINTDEBUGMESSAGE(name, "Committing transactions " +
std::to_string(id - transactionCommitRate + 1) + " - " + std::to_string(id));
commitRecordedDataToDB();
@@ -196,11 +191,13 @@ void TlmRecorder::removeTransactionFromSystem(tlm_generic_payload &trans)
void TlmRecorder::commitRecordedDataToDB()
{
sqlite3_exec(db, "BEGIN;", 0, 0, 0);
for (Transaction &recordingData : recordedData) {
sqlite3_exec(db, "BEGIN;", nullptr, nullptr, nullptr);
for (Transaction &recordingData : recordedData)
{
assert(recordingData.recordedPhases.size() > 0);
insertTransactionInDB(recordingData);
for (Transaction::Phase &phaseData : recordingData.recordedPhases) {
for (Transaction::Phase &phaseData : recordingData.recordedPhases)
{
insertPhaseInDB(phaseData.name, phaseData.interval.start,
phaseData.interval.end, recordingData.id);
}
@@ -214,7 +211,7 @@ void TlmRecorder::commitRecordedDataToDB()
insertRangeInDB(recordingData.id, rangeBegin, rangeEnd);
}
sqlite3_exec(db, "COMMIT;", 0, 0, 0);
sqlite3_exec(db, "COMMIT;", nullptr, nullptr, nullptr);
recordedData.clear();
}
@@ -229,12 +226,13 @@ void TlmRecorder::Transaction::setPhaseEnd(std::string name, sc_time end)
// Find the latest recorder phase for that transaction with a matching name and update it
// Note: Transactions might have the same phase multiple times (e.g. PRE->ACT->REF->ACT->RD)
// only update the latest one that has been recorded
for (int i = recordedPhases.size() - 1; i >= 0; i--) {
Phase &data = recordedPhases[i];
if (data.name == name) {
for (size_t i = recordedPhases.size(); i > 0; i--)
{
Phase &data = recordedPhases[i - 1];
if (data.name == name)
{
data.interval.end = end;
return;
}
}
SC_REPORT_FATAL("Recording Error",
@@ -244,13 +242,16 @@ void TlmRecorder::Transaction::setPhaseEnd(std::string name, sc_time end)
void TlmRecorder::openDB(std::string name)
{
std::ifstream f(name.c_str());
if (f.good()) {
if (remove(name.c_str()) != 0) {
if (f.good())
{
if (remove(name.c_str()) != 0)
{
SC_REPORT_FATAL("TlmRecorder", "Error deleting file" );
}
}
if (sqlite3_open(name.c_str(), &db) != SQLITE_OK) {
if (sqlite3_open(name.c_str(), &db) != SQLITE_OK)
{
SC_REPORT_FATAL("Error in TraceRecorder", "Error cannot open database");
sqlite3_close(db);
}
@@ -316,61 +317,61 @@ void TlmRecorder::prepareSqlStatements()
insertBufferDepthString = "INSERT INTO BufferDepth VALUES (:time,:bufferNumber,:averageBufferDepth)";
insertBandwidthString = "INSERT INTO Bandwidth VALUES (:time,:averageBandwidth)";
sqlite3_prepare_v2(db, insertTransactionString.c_str(), -1, &insertTransactionStatement, 0);
sqlite3_prepare_v2(db, insertRangeString.c_str(), -1, &insertRangeStatement, 0);
sqlite3_prepare_v2(db, updateRangeString.c_str(), -1, &updateRangeStatement, 0);
sqlite3_prepare_v2(db, insertPhaseString.c_str(), -1, &insertPhaseStatement, 0);
sqlite3_prepare_v2(db, updatePhaseString.c_str(), -1, &updatePhaseStatement, 0);
sqlite3_prepare_v2(db, updateDataStrobeString.c_str(), -1, &updateDataStrobeStatement, 0);
sqlite3_prepare_v2(db, insertGeneralInfoString.c_str(), -1, &insertGeneralInfoStatement, 0);
sqlite3_prepare_v2(db, insertCommandLengthsString.c_str(), -1, &insertCommandLengthsStatement, 0);
sqlite3_prepare_v2(db, insertDebugMessageString.c_str(), -1, &insertDebugMessageStatement, 0);
sqlite3_prepare_v2(db, insertPowerString.c_str(), -1, &insertPowerStatement, 0);
sqlite3_prepare_v2(db, insertBufferDepthString.c_str(), -1, &insertBufferDepthStatement, 0);
sqlite3_prepare_v2(db, insertBandwidthString.c_str(), -1, &insertBandwidthStatement, 0);
sqlite3_prepare_v2(db, insertTransactionString.c_str(), -1, &insertTransactionStatement, nullptr);
sqlite3_prepare_v2(db, insertRangeString.c_str(), -1, &insertRangeStatement, nullptr);
sqlite3_prepare_v2(db, updateRangeString.c_str(), -1, &updateRangeStatement, nullptr);
sqlite3_prepare_v2(db, insertPhaseString.c_str(), -1, &insertPhaseStatement, nullptr);
sqlite3_prepare_v2(db, updatePhaseString.c_str(), -1, &updatePhaseStatement, nullptr);
sqlite3_prepare_v2(db, updateDataStrobeString.c_str(), -1, &updateDataStrobeStatement, nullptr);
sqlite3_prepare_v2(db, insertGeneralInfoString.c_str(), -1, &insertGeneralInfoStatement, nullptr);
sqlite3_prepare_v2(db, insertCommandLengthsString.c_str(), -1, &insertCommandLengthsStatement, nullptr);
sqlite3_prepare_v2(db, insertDebugMessageString.c_str(), -1, &insertDebugMessageStatement, nullptr);
sqlite3_prepare_v2(db, insertPowerString.c_str(), -1, &insertPowerStatement, nullptr);
sqlite3_prepare_v2(db, insertBufferDepthString.c_str(), -1, &insertBufferDepthStatement, nullptr);
sqlite3_prepare_v2(db, insertBandwidthString.c_str(), -1, &insertBandwidthStatement, nullptr);
}
void TlmRecorder::insertDebugMessageInDB(std::string message, const sc_time &time)
{
sqlite3_bind_int64(insertDebugMessageStatement, 1, time.value());
sqlite3_bind_text(insertDebugMessageStatement, 2, message.c_str(), message.length(), 0);
sqlite3_bind_int64(insertDebugMessageStatement, 1, static_cast<int64_t>(time.value()));
sqlite3_bind_text(insertDebugMessageStatement, 2, message.c_str(), static_cast<int>(message.length()), nullptr);
executeSqlStatement(insertDebugMessageStatement);
}
void TlmRecorder::insertGeneralInfo()
{
sqlite3_bind_int64(insertGeneralInfoStatement, 1, totalNumTransactions - 1);
sqlite3_bind_int64(insertGeneralInfoStatement, 2, simulationTimeCoveredByRecording.value());
sqlite3_bind_int(insertGeneralInfoStatement, 3, Configuration::getInstance().memSpec->numberOfRanks);
sqlite3_bind_int(insertGeneralInfoStatement, 4, Configuration::getInstance().memSpec->numberOfBankGroups);
sqlite3_bind_int(insertGeneralInfoStatement, 5, Configuration::getInstance().memSpec->numberOfBanks);
sqlite3_bind_int(insertGeneralInfoStatement, 6, Configuration::getInstance().memSpec->tCK.value());
sqlite3_bind_text(insertGeneralInfoStatement, 7, "PS", 2, NULL);
sqlite3_bind_text(insertGeneralInfoStatement, 8, mcconfig.c_str(), mcconfig.length(), NULL);
sqlite3_bind_text(insertGeneralInfoStatement, 9, memspec.c_str(), memspec.length(), NULL);
sqlite3_bind_text(insertGeneralInfoStatement, 10, traces.c_str(), traces.length(), NULL);
sqlite3_bind_int64(insertGeneralInfoStatement, 1, static_cast<int64_t>(totalNumTransactions - 1));
sqlite3_bind_int64(insertGeneralInfoStatement, 2, static_cast<int64_t>(simulationTimeCoveredByRecording.value()));
sqlite3_bind_int(insertGeneralInfoStatement, 3, static_cast<int>(Configuration::getInstance().memSpec->numberOfRanks));
sqlite3_bind_int(insertGeneralInfoStatement, 4, static_cast<int>(Configuration::getInstance().memSpec->numberOfBankGroups));
sqlite3_bind_int(insertGeneralInfoStatement, 5, static_cast<int>(Configuration::getInstance().memSpec->numberOfBanks));
sqlite3_bind_int(insertGeneralInfoStatement, 6, static_cast<int>(Configuration::getInstance().memSpec->tCK.value()));
sqlite3_bind_text(insertGeneralInfoStatement, 7, "PS", 2, nullptr);
sqlite3_bind_text(insertGeneralInfoStatement, 8, mcconfig.c_str(), static_cast<int>(mcconfig.length()), nullptr);
sqlite3_bind_text(insertGeneralInfoStatement, 9, memspec.c_str(), static_cast<int>(memspec.length()), nullptr);
sqlite3_bind_text(insertGeneralInfoStatement, 10, traces.c_str(), static_cast<int>(traces.length()), nullptr);
if (!Configuration::getInstance().enableWindowing)
sqlite3_bind_int64(insertGeneralInfoStatement, 11, 0);
else
sqlite3_bind_int64(insertGeneralInfoStatement, 11,
(Configuration::getInstance().memSpec->tCK *
Configuration::getInstance().windowSize).value());
static_cast<int64_t>((Configuration::getInstance().memSpec->tCK *
Configuration::getInstance().windowSize).value()));
if ((Configuration::getInstance().refreshMaxPostponed > 0)
|| (Configuration::getInstance().refreshMaxPulledin > 0))
{
sqlite3_bind_int(insertGeneralInfoStatement, 12, 1);
sqlite3_bind_int(insertGeneralInfoStatement, 13,
std::max(Configuration::getInstance().refreshMaxPostponed,
Configuration::getInstance().refreshMaxPulledin));
static_cast<int>(std::max(Configuration::getInstance().refreshMaxPostponed,
Configuration::getInstance().refreshMaxPulledin)));
}
else
{
sqlite3_bind_int(insertGeneralInfoStatement, 12, 0);
sqlite3_bind_int(insertGeneralInfoStatement, 13, 0);
}
sqlite3_bind_int(insertGeneralInfoStatement, 14, UINT_MAX);
sqlite3_bind_int(insertGeneralInfoStatement, 15, Configuration::getInstance().requestBufferSize);
sqlite3_bind_int(insertGeneralInfoStatement, 14, static_cast<int>(UINT_MAX));
sqlite3_bind_int(insertGeneralInfoStatement, 15, static_cast<int>(Configuration::getInstance().requestBufferSize));
executeSqlStatement(insertGeneralInfoStatement);
}
@@ -378,77 +379,78 @@ void TlmRecorder::insertCommandLengths()
{
MemSpec *memSpec = Configuration::getInstance().memSpec;
sqlite3_bind_int(insertCommandLengthsStatement, 1, memSpec->getCommandLength(Command::NOP) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 2, memSpec->getCommandLength(Command::RD) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 3, memSpec->getCommandLength(Command::WR) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 4, memSpec->getCommandLength(Command::RDA) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 5, memSpec->getCommandLength(Command::WRA) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 6, memSpec->getCommandLength(Command::ACT) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 7, memSpec->getCommandLength(Command::PRE) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 8, memSpec->getCommandLength(Command::REFB) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 9, memSpec->getCommandLength(Command::PRESB) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 10, memSpec->getCommandLength(Command::REFSB) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 11, memSpec->getCommandLength(Command::PREA) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 12, memSpec->getCommandLength(Command::REFA) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 13, memSpec->getCommandLength(Command::PDEA) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 14, memSpec->getCommandLength(Command::PDXA) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 15, memSpec->getCommandLength(Command::PDEP) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 16, memSpec->getCommandLength(Command::PDXP) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 17, memSpec->getCommandLength(Command::SREFEN) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 18, memSpec->getCommandLength(Command::SREFEX) / memSpec->tCK);
sqlite3_bind_int(insertCommandLengthsStatement, 1, static_cast<int>(memSpec->getCommandLength(Command::NOP) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 2, static_cast<int>(memSpec->getCommandLength(Command::RD) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 3, static_cast<int>(memSpec->getCommandLength(Command::WR) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 4, static_cast<int>(memSpec->getCommandLength(Command::RDA) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 5, static_cast<int>(memSpec->getCommandLength(Command::WRA) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 6, static_cast<int>(memSpec->getCommandLength(Command::ACT) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 7, static_cast<int>(memSpec->getCommandLength(Command::PRE) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 8, static_cast<int>(memSpec->getCommandLength(Command::REFB) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 9, static_cast<int>(memSpec->getCommandLength(Command::PRESB) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 10, static_cast<int>(memSpec->getCommandLength(Command::REFSB) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 11, static_cast<int>(memSpec->getCommandLength(Command::PREA) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 12, static_cast<int>(memSpec->getCommandLength(Command::REFA) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 13, static_cast<int>(memSpec->getCommandLength(Command::PDEA) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 14, static_cast<int>(memSpec->getCommandLength(Command::PDXA) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 15, static_cast<int>(memSpec->getCommandLength(Command::PDEP) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 16, static_cast<int>(memSpec->getCommandLength(Command::PDXP) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 17, static_cast<int>(memSpec->getCommandLength(Command::SREFEN) / memSpec->tCK + 0.5));
sqlite3_bind_int(insertCommandLengthsStatement, 18, static_cast<int>(memSpec->getCommandLength(Command::SREFEX) / memSpec->tCK + 0.5));
executeSqlStatement(insertCommandLengthsStatement);
}
void TlmRecorder::insertTransactionInDB(Transaction &recordingData)
{
sqlite3_bind_int(insertTransactionStatement, 1, recordingData.id);
sqlite3_bind_int(insertTransactionStatement, 2, recordingData.id);
sqlite3_bind_int(insertTransactionStatement, 3, recordingData.address);
sqlite3_bind_int(insertTransactionStatement, 4, recordingData.burstlength);
sqlite3_bind_int(insertTransactionStatement, 1, static_cast<int>(recordingData.id));
sqlite3_bind_int(insertTransactionStatement, 2, static_cast<int>(recordingData.id));
sqlite3_bind_int64(insertTransactionStatement, 3, static_cast<int64_t>(recordingData.address));
sqlite3_bind_int(insertTransactionStatement, 4, static_cast<int>(recordingData.burstlength));
sqlite3_bind_int(insertTransactionStatement, 5,
recordingData.dramExtension.getThread().ID());
static_cast<int>(recordingData.dramExtension.getThread().ID()));
sqlite3_bind_int(insertTransactionStatement, 6,
recordingData.dramExtension.getChannel().ID());
static_cast<int>(recordingData.dramExtension.getChannel().ID()));
sqlite3_bind_int(insertTransactionStatement, 7,
recordingData.dramExtension.getRank().ID());
static_cast<int>(recordingData.dramExtension.getRank().ID()));
sqlite3_bind_int(insertTransactionStatement, 8,
recordingData.dramExtension.getBankGroup().ID());
static_cast<int>(recordingData.dramExtension.getBankGroup().ID()));
sqlite3_bind_int(insertTransactionStatement, 9,
recordingData.dramExtension.getBank().ID());
static_cast<int>(recordingData.dramExtension.getBank().ID()));
sqlite3_bind_int(insertTransactionStatement, 10,
recordingData.dramExtension.getRow().ID());
static_cast<int>(recordingData.dramExtension.getRow().ID()));
sqlite3_bind_int(insertTransactionStatement, 11,
recordingData.dramExtension.getColumn().ID());
static_cast<int>(recordingData.dramExtension.getColumn().ID()));
sqlite3_bind_int64(insertTransactionStatement, 12,
recordingData.timeOnDataStrobe.start.value());
static_cast<int64_t>(recordingData.timeOnDataStrobe.start.value()));
sqlite3_bind_int64(insertTransactionStatement, 13,
recordingData.timeOnDataStrobe.end.value());
static_cast<int64_t>(recordingData.timeOnDataStrobe.end.value()));
sqlite3_bind_int64(insertTransactionStatement, 14,
recordingData.timeOfGeneration.value());
static_cast<int64_t>(recordingData.timeOfGeneration.value()));
sqlite3_bind_text(insertTransactionStatement, 15,
recordingData.cmd.c_str(), recordingData.cmd.length(), NULL);
recordingData.cmd.c_str(), static_cast<int>(recordingData.cmd.length()), nullptr);
executeSqlStatement(insertTransactionStatement);
}
void TlmRecorder::insertRangeInDB(unsigned int id, const sc_time &begin,
void TlmRecorder::insertRangeInDB(uint64_t id, const sc_time &begin,
const sc_time &end)
{
sqlite3_bind_int(insertRangeStatement, 1, id);
sqlite3_bind_int64(insertRangeStatement, 2, begin.value());
sqlite3_bind_int64(insertRangeStatement, 3, end.value());
sqlite3_bind_int64(insertRangeStatement, 1, static_cast<int64_t>(id));
sqlite3_bind_int64(insertRangeStatement, 2, static_cast<int64_t>(begin.value()));
sqlite3_bind_int64(insertRangeStatement, 3, static_cast<int64_t>(end.value()));
executeSqlStatement(insertRangeStatement);
}
void TlmRecorder::insertPhaseInDB(std::string phaseName, const sc_time &begin,
const sc_time &end,
unsigned int transactionID)
uint64_t transactionID)
{
sqlite3_bind_text(insertPhaseStatement, 1, phaseName.c_str(),
phaseName.length(), 0);
sqlite3_bind_int64(insertPhaseStatement, 2, begin.value());
sqlite3_bind_int64(insertPhaseStatement, 3, end.value());
sqlite3_bind_int(insertPhaseStatement, 4, transactionID);
static_cast<int>(phaseName.length()), nullptr);
sqlite3_bind_int64(insertPhaseStatement, 2, static_cast<int64_t>(begin.value()));
sqlite3_bind_int64(insertPhaseStatement, 3, static_cast<int64_t>(end.value()));
sqlite3_bind_int64(insertPhaseStatement, 4, static_cast<int64_t>(transactionID));
executeSqlStatement(insertPhaseStatement);
}
@@ -467,8 +469,8 @@ void TlmRecorder::executeInitialSqlCommand()
{
PRINTDEBUGMESSAGE(name, "Creating database by running provided sql script");
char *errMsg = 0;
int rc = sqlite3_exec(db, initialCommand.c_str(), NULL, 0, &errMsg);
char *errMsg = nullptr;
int rc = sqlite3_exec(db, initialCommand.c_str(), nullptr, nullptr, &errMsg);
if (rc != SQLITE_OK) {
SC_REPORT_FATAL("SQLITE Error", errMsg);
sqlite3_free(errMsg);
@@ -486,6 +488,5 @@ void TlmRecorder::closeConnection()
+ std::to_string(totalNumTransactions - 1));
PRINTDEBUGMESSAGE(name, "tlmPhaseRecorder:\tEnd Recording");
sqlite3_close(db);
db = NULL;
db = nullptr;
}

14
DRAMSys/library/src/common/TlmRecorder.h
View File

@@ -88,10 +88,10 @@ private:
struct Transaction
{
Transaction() {}
Transaction(unsigned int id): id(id) {}
Transaction(uint64_t id) : id(id) {}
unsigned int id;
unsigned int address;
uint64_t id;
uint64_t address;
unsigned int burstlength;
std::string cmd;
DramExtension dramExtension;
@@ -128,20 +128,20 @@ private:
void insertGeneralInfo();
void insertCommandLengths();
void insertTransactionInDB(Transaction &recordingData);
void insertRangeInDB(unsigned int id, const sc_time &begin, const sc_time &end);
void insertRangeInDB(uint64_t id, const sc_time &begin, const sc_time &end);
void insertPhaseInDB(std::string phaseName, const sc_time &begin, const sc_time &end,
unsigned int transactionID);
uint64_t transactionID);
void insertDebugMessageInDB(std::string message, const sc_time &time);
static const int transactionCommitRate = 1000;
std::vector<Transaction> recordedData;
std::map<tlm::tlm_generic_payload *, Transaction> currentTransactionsInSystem;
unsigned int totalNumTransactions;
uint64_t totalNumTransactions;
sc_time simulationTimeCoveredByRecording;
std::vector<tlm::tlm_phase> transactionTerminatingPhases;
sqlite3 *db = NULL;
sqlite3 *db = nullptr;
sqlite3_stmt *insertTransactionStatement, *insertRangeStatement,
*updateRangeStatement, *insertPhaseStatement, *updatePhaseStatement,
*insertGeneralInfoStatement, *insertCommandLengthsStatement,

1
DRAMSys/library/src/common/utils.cpp
View File

@@ -150,4 +150,5 @@ void setUpDummy(tlm_generic_payload &payload, uint64_t channelPayloadID, Rank ra
payload.set_streaming_width(0);
payload.set_extension(new DramExtension(Thread(UINT_MAX), Channel(0), rank, bankgroup,
bank, Row(0), Column(0), 0, 0, channelPayloadID));
payload.set_extension(new GenerationExtension(SC_ZERO_TIME));
}