diff --git a/DRAMSys/library/src/common/TlmRecorder.cpp b/DRAMSys/library/src/common/TlmRecorder.cpp index 51e941de..ab7af256 100644 --- a/DRAMSys/library/src/common/TlmRecorder.cpp +++ b/DRAMSys/library/src/common/TlmRecorder.cpp @@ -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(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(time.value())); + sqlite3_bind_text(insertDebugMessageStatement, 2, message.c_str(), static_cast(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(totalNumTransactions - 1)); + sqlite3_bind_int64(insertGeneralInfoStatement, 2, static_cast(simulationTimeCoveredByRecording.value())); + sqlite3_bind_int(insertGeneralInfoStatement, 3, static_cast(Configuration::getInstance().memSpec->numberOfRanks)); + sqlite3_bind_int(insertGeneralInfoStatement, 4, static_cast(Configuration::getInstance().memSpec->numberOfBankGroups)); + sqlite3_bind_int(insertGeneralInfoStatement, 5, static_cast(Configuration::getInstance().memSpec->numberOfBanks)); + sqlite3_bind_int(insertGeneralInfoStatement, 6, static_cast(Configuration::getInstance().memSpec->tCK.value())); + sqlite3_bind_text(insertGeneralInfoStatement, 7, "PS", 2, nullptr); + sqlite3_bind_text(insertGeneralInfoStatement, 8, mcconfig.c_str(), static_cast(mcconfig.length()), nullptr); + sqlite3_bind_text(insertGeneralInfoStatement, 9, memspec.c_str(), static_cast(memspec.length()), nullptr); + sqlite3_bind_text(insertGeneralInfoStatement, 10, traces.c_str(), static_cast(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((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(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(UINT_MAX)); + sqlite3_bind_int(insertGeneralInfoStatement, 15, static_cast(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(memSpec->getCommandLength(Command::NOP) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 2, static_cast(memSpec->getCommandLength(Command::RD) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 3, static_cast(memSpec->getCommandLength(Command::WR) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 4, static_cast(memSpec->getCommandLength(Command::RDA) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 5, static_cast(memSpec->getCommandLength(Command::WRA) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 6, static_cast(memSpec->getCommandLength(Command::ACT) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 7, static_cast(memSpec->getCommandLength(Command::PRE) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 8, static_cast(memSpec->getCommandLength(Command::REFB) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 9, static_cast(memSpec->getCommandLength(Command::PRESB) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 10, static_cast(memSpec->getCommandLength(Command::REFSB) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 11, static_cast(memSpec->getCommandLength(Command::PREA) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 12, static_cast(memSpec->getCommandLength(Command::REFA) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 13, static_cast(memSpec->getCommandLength(Command::PDEA) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 14, static_cast(memSpec->getCommandLength(Command::PDXA) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 15, static_cast(memSpec->getCommandLength(Command::PDEP) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 16, static_cast(memSpec->getCommandLength(Command::PDXP) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 17, static_cast(memSpec->getCommandLength(Command::SREFEN) / memSpec->tCK + 0.5)); + sqlite3_bind_int(insertCommandLengthsStatement, 18, static_cast(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(recordingData.id)); + sqlite3_bind_int(insertTransactionStatement, 2, static_cast(recordingData.id)); + sqlite3_bind_int64(insertTransactionStatement, 3, static_cast(recordingData.address)); + sqlite3_bind_int(insertTransactionStatement, 4, static_cast(recordingData.burstlength)); sqlite3_bind_int(insertTransactionStatement, 5, - recordingData.dramExtension.getThread().ID()); + static_cast(recordingData.dramExtension.getThread().ID())); sqlite3_bind_int(insertTransactionStatement, 6, - recordingData.dramExtension.getChannel().ID()); + static_cast(recordingData.dramExtension.getChannel().ID())); sqlite3_bind_int(insertTransactionStatement, 7, - recordingData.dramExtension.getRank().ID()); + static_cast(recordingData.dramExtension.getRank().ID())); sqlite3_bind_int(insertTransactionStatement, 8, - recordingData.dramExtension.getBankGroup().ID()); + static_cast(recordingData.dramExtension.getBankGroup().ID())); sqlite3_bind_int(insertTransactionStatement, 9, - recordingData.dramExtension.getBank().ID()); + static_cast(recordingData.dramExtension.getBank().ID())); sqlite3_bind_int(insertTransactionStatement, 10, - recordingData.dramExtension.getRow().ID()); + static_cast(recordingData.dramExtension.getRow().ID())); sqlite3_bind_int(insertTransactionStatement, 11, - recordingData.dramExtension.getColumn().ID()); + static_cast(recordingData.dramExtension.getColumn().ID())); sqlite3_bind_int64(insertTransactionStatement, 12, - recordingData.timeOnDataStrobe.start.value()); + static_cast(recordingData.timeOnDataStrobe.start.value())); sqlite3_bind_int64(insertTransactionStatement, 13, - recordingData.timeOnDataStrobe.end.value()); + static_cast(recordingData.timeOnDataStrobe.end.value())); sqlite3_bind_int64(insertTransactionStatement, 14, - recordingData.timeOfGeneration.value()); + static_cast(recordingData.timeOfGeneration.value())); sqlite3_bind_text(insertTransactionStatement, 15, - recordingData.cmd.c_str(), recordingData.cmd.length(), NULL); + recordingData.cmd.c_str(), static_cast(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(id)); + sqlite3_bind_int64(insertRangeStatement, 2, static_cast(begin.value())); + sqlite3_bind_int64(insertRangeStatement, 3, static_cast(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(phaseName.length()), nullptr); + sqlite3_bind_int64(insertPhaseStatement, 2, static_cast(begin.value())); + sqlite3_bind_int64(insertPhaseStatement, 3, static_cast(end.value())); + sqlite3_bind_int64(insertPhaseStatement, 4, static_cast(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; } - diff --git a/DRAMSys/library/src/common/TlmRecorder.h b/DRAMSys/library/src/common/TlmRecorder.h index 8480b966..5e647eb5 100644 --- a/DRAMSys/library/src/common/TlmRecorder.h +++ b/DRAMSys/library/src/common/TlmRecorder.h @@ -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 recordedData; std::map currentTransactionsInSystem; - unsigned int totalNumTransactions; + uint64_t totalNumTransactions; sc_time simulationTimeCoveredByRecording; std::vector transactionTerminatingPhases; - sqlite3 *db = NULL; + sqlite3 *db = nullptr; sqlite3_stmt *insertTransactionStatement, *insertRangeStatement, *updateRangeStatement, *insertPhaseStatement, *updatePhaseStatement, *insertGeneralInfoStatement, *insertCommandLengthsStatement, diff --git a/DRAMSys/library/src/common/utils.cpp b/DRAMSys/library/src/common/utils.cpp index 75ceda79..e0230736 100644 --- a/DRAMSys/library/src/common/utils.cpp +++ b/DRAMSys/library/src/common/utils.cpp @@ -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)); }