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

Change database format 1.

Browse Source
This commit is contained in:
Lukas Steiner
2022-04-28 17:35:40 +02:00
parent 844eaa390a
commit f168782361
2 changed files with 86 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -124,12 +124,20 @@ void TlmRecorder::recordPhase(tlm_generic_payload &trans,
if (phase == END_REQ || phase == END_RESP || phase >= END_PDNA)
{
assert(getPhaseName(phase).substr(4) == currentTransactionsInSystem.at(&trans).recordedPhases.back().name);
// TODO: this assumes that the controller does not start with a transaction until END_REQ has been sent, which is not true any more for big transactions
currentTransactionsInSystem.at(&trans).recordedPhases.back().interval.end = time;
}
else if (phase == BEGIN_REQ || phase == BEGIN_RESP)
{
std::string phaseName = getPhaseName(phase).substr(6);
currentTransactionsInSystem.at(&trans).recordedPhases.emplace_back(phaseName, time);
}
else
{
std::string phaseName = getPhaseName(phase).substr(6); // remove "BEGIN_"
currentTransactionsInSystem.at(&trans).recordedPhases.emplace_back(phaseName, time);
const ControllerExtension& extension = ControllerExtension::getExtension(trans);
currentTransactionsInSystem.at(&trans).recordedPhases.emplace_back(phaseName, time, extension.getRank(),
extension.getBankGroup(), extension.getBank(), extension.getRow(), extension.getColumn());
}
if (currentTransactionsInSystem.at(&trans).cmd == 'X')
@@ -174,23 +182,24 @@ void TlmRecorder::recordDebugMessage(const std::string &message, const sc_time &
// ------------- internal -----------------------
void TlmRecorder::introduceTransactionSystem(tlm_generic_payload &trans)
void TlmRecorder::introduceTransactionSystem(tlm_generic_payload& trans)
{
totalNumTransactions++;
currentTransactionsInSystem.insert({&trans, Transaction(totalNumTransactions,
ArbiterExtension::getExtension(trans), ControllerExtension::getExtension(trans))});
currentTransactionsInSystem.at(&trans).id = totalNumTransactions;
char commandChar;
tlm_command command = trans.get_command();
if (command == TLM_READ_COMMAND)
currentTransactionsInSystem.at(&trans).cmd = 'R';
commandChar = 'R';
else if (command == TLM_WRITE_COMMAND)
currentTransactionsInSystem.at(&trans).cmd = 'W';
commandChar = 'W';
else
currentTransactionsInSystem.at(&trans).cmd = 'X';
currentTransactionsInSystem.at(&trans).address = trans.get_address();
currentTransactionsInSystem.at(&trans).burstLength = ControllerExtension::getBurstLength(trans);
currentTransactionsInSystem.at(&trans).controllerExtension = ControllerExtension::getExtension(trans);
currentTransactionsInSystem.at(&trans).timeOfGeneration = ArbiterExtension::getTimeOfGeneration(trans);
commandChar = 'X';
const ArbiterExtension& extension = ArbiterExtension::getExtension(trans);
currentTransactionsInSystem.insert({&trans, Transaction(totalNumTransactions, trans.get_address(),
trans.get_data_length(), commandChar, extension.getTimeOfGeneration(), extension.getThread(),
extension.getChannel())});
PRINTDEBUGMESSAGE(name, "New transaction #" + std::to_string(totalNumTransactions) + " generation time " +
currentTransactionsInSystem.at(&trans).timeOfGeneration.to_string());
@@ -247,23 +256,22 @@ void TlmRecorder::terminateRemainingTransactions()
void TlmRecorder::commitRecordedDataToDB()
{
sqlite3_exec(db, "BEGIN;", nullptr, nullptr, nullptr);
for (Transaction &recordingData : *storageDataBuffer)
for (const Transaction& transaction : *storageDataBuffer)
{
assert(!recordingData.recordedPhases.empty());
insertTransactionInDB(recordingData);
for (Transaction::Phase &phaseData : recordingData.recordedPhases)
assert(!transaction.recordedPhases.empty());
insertTransactionInDB(transaction);
for (const Transaction::Phase& phase : transaction.recordedPhases)
{
insertPhaseInDB(phaseData.name, phaseData.interval.start,
phaseData.interval.end, recordingData.id);
insertPhaseInDB(phase, transaction.id);
}
sc_time rangeBegin = recordingData.recordedPhases.front().interval.start;
sc_time rangeBegin = transaction.recordedPhases.front().interval.start;
sc_time rangeEnd = rangeBegin;
for (auto &it : recordingData.recordedPhases)
for (const Transaction::Phase& phase : transaction.recordedPhases)
{
rangeEnd = std::max(rangeEnd, it.interval.end);
rangeEnd = std::max(rangeEnd, phase.interval.end);
}
insertRangeInDB(recordingData.id, rangeBegin, rangeEnd);
insertRangeInDB(transaction.id, rangeBegin, rangeEnd);
}
sqlite3_exec(db, "COMMIT;", nullptr, nullptr, nullptr);
@@ -290,8 +298,8 @@ void TlmRecorder::openDB(const std::string &dbName)
void TlmRecorder::prepareSqlStatements()
{
insertTransactionString =
"INSERT INTO Transactions VALUES (:id,:rangeID,:address,:burstlength,:thread,:channel,:rank,"
":bankgroup,:bank,:row,:column,:dataStrobeBegin,:dataStrobeEnd, :timeOfGeneration,:command)";
"INSERT INTO Transactions VALUES (:id,:rangeID,:address,:dataLength,:thread,:channel,"
":dataStrobeBegin,:dataStrobeEnd,:timeOfGeneration,:command)";
insertRangeString = "INSERT INTO Ranges VALUES (:id,:begin,:end)";
@@ -301,7 +309,8 @@ void TlmRecorder::prepareSqlStatements()
"UPDATE Transactions SET DataStrobeBegin = :begin, DataStrobeEnd = :end WHERE ID = :id";
insertPhaseString =
"INSERT INTO Phases (PhaseName,PhaseBegin,PhaseEnd,Transact) VALUES (:name,:begin,:end,:transaction)";
"INSERT INTO Phases (PhaseName,PhaseBegin,PhaseEnd,Rank,BankGroup,Bank,Row,Column,BurstLength,Transact) "
"VALUES (:name,:begin,:end,:rank,:bankGroup,:bank,:row,:column,:burstLength,:transaction)";
updatePhaseString =
"UPDATE Phases SET PhaseEnd = :end WHERE Transact = :trans AND PhaseName = :name";
@@ -408,33 +417,23 @@ void TlmRecorder::insertCommandLengths()
insertCommandLength(static_cast<Command::Type>(command));
}
void TlmRecorder::insertTransactionInDB(Transaction &recordingData)
void TlmRecorder::insertTransactionInDB(const Transaction &recordingData)
{
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, 4, static_cast<int>(recordingData.dataLength));
sqlite3_bind_int(insertTransactionStatement, 5,
static_cast<int>(recordingData.arbiterExtension.getThread().ID()));
static_cast<int>(recordingData.thread.ID()));
sqlite3_bind_int(insertTransactionStatement, 6,
static_cast<int>(recordingData.arbiterExtension.getChannel().ID()));
sqlite3_bind_int(insertTransactionStatement, 7,
static_cast<int>(recordingData.controllerExtension.getRank().ID()));
sqlite3_bind_int(insertTransactionStatement, 8,
static_cast<int>(recordingData.controllerExtension.getBankGroup().ID()));
sqlite3_bind_int(insertTransactionStatement, 9,
static_cast<int>(recordingData.controllerExtension.getBank().ID()));
sqlite3_bind_int(insertTransactionStatement, 10,
static_cast<int>(recordingData.controllerExtension.getRow().ID()));
sqlite3_bind_int(insertTransactionStatement, 11,
static_cast<int>(recordingData.controllerExtension.getColumn().ID()));
sqlite3_bind_int64(insertTransactionStatement, 12,
static_cast<int>(recordingData.channel.ID()));
sqlite3_bind_int64(insertTransactionStatement, 7,
static_cast<int64_t>(recordingData.timeOnDataStrobe.start.value()));
sqlite3_bind_int64(insertTransactionStatement, 13,
sqlite3_bind_int64(insertTransactionStatement, 8,
static_cast<int64_t>(recordingData.timeOnDataStrobe.end.value()));
sqlite3_bind_int64(insertTransactionStatement, 14,
sqlite3_bind_int64(insertTransactionStatement, 9,
static_cast<int64_t>(recordingData.timeOfGeneration.value()));
sqlite3_bind_text(insertTransactionStatement, 15,
sqlite3_bind_text(insertTransactionStatement, 10,
&recordingData.cmd, 1, nullptr);
executeSqlStatement(insertTransactionStatement);
@@ -449,15 +448,18 @@ void TlmRecorder::insertRangeInDB(uint64_t id, const sc_time &begin,
executeSqlStatement(insertRangeStatement);
}
void TlmRecorder::insertPhaseInDB(const std::string &phaseName, const sc_time &begin,
const sc_time &end,
uint64_t transactionID)
void TlmRecorder::insertPhaseInDB(const Transaction::Phase& phase, uint64_t transactionID)
{
sqlite3_bind_text(insertPhaseStatement, 1, phaseName.c_str(),
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));
sqlite3_bind_text(insertPhaseStatement, 1, phase.name.c_str(), static_cast<int>(phase.name.length()), nullptr);
sqlite3_bind_int64(insertPhaseStatement, 2, static_cast<int64_t>(phase.interval.start.value()));
sqlite3_bind_int64(insertPhaseStatement, 3, static_cast<int64_t>(phase.interval.end.value()));
sqlite3_bind_int(insertPhaseStatement, 4, static_cast<int>(phase.rank.ID()));
sqlite3_bind_int(insertPhaseStatement, 5, static_cast<int>(phase.bankGroup.ID()));
sqlite3_bind_int(insertPhaseStatement, 6, static_cast<int>(phase.bank.ID()));
sqlite3_bind_int(insertPhaseStatement, 7, static_cast<int>(phase.row.ID()));
sqlite3_bind_int(insertPhaseStatement, 8, static_cast<int>(phase.column.ID()));
sqlite3_bind_int(insertPhaseStatement, 9, static_cast<int>(phase.burstLength));
sqlite3_bind_int64(insertPhaseStatement, 10, static_cast<int64_t>(transactionID));
executeSqlStatement(insertPhaseStatement);
}

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

@@ -91,25 +91,39 @@ private:
struct Transaction
{
//Transaction() = default;
Transaction(uint64_t id, ArbiterExtension arbiterExtension, ControllerExtension controllerExtension) :
id(id), arbiterExtension(std::move(arbiterExtension)),
controllerExtension(std::move(controllerExtension)) {}
Transaction(uint64_t id, uint64_t address, unsigned int dataLength, char cmd,
const sc_core::sc_time& timeOfGeneration, Thread thread, Channel channel) :
id(id), address(address), dataLength(dataLength), cmd(cmd), timeOfGeneration(timeOfGeneration),
thread(thread), channel(channel) {}
uint64_t id = 0;
uint64_t address = 0;
unsigned int burstLength = 0;
unsigned int dataLength = 0;
//unsigned int burstLength = 0; // TODO: move to phase
char cmd = 'X';
ArbiterExtension arbiterExtension;
ControllerExtension controllerExtension;
//ArbiterExtension arbiterExtension; // TODO: remove
//ControllerExtension controllerExtension; // TODO: move to phase
sc_core::sc_time timeOfGeneration;
TimeInterval timeOnDataStrobe;
TimeInterval timeOnDataStrobe; // TODO: move to phase
Thread thread;
Channel channel;
struct Phase
{
Phase(std::string name, const sc_core::sc_time& begin): name(std::move(name)),
Phase(std::string name, const sc_core::sc_time& begin) : name(std::move(name)),
interval(begin, sc_core::SC_ZERO_TIME) {}
Phase(std::string name, const sc_core::sc_time& begin, Rank rank, BankGroup bankGroup, Bank bank,
Row row, Column column) : name(std::move(name)), interval(begin, sc_core::SC_ZERO_TIME),
rank(rank), bankGroup(bankGroup), bank(bank), row(row), column(column) {}
std::string name;
TimeInterval interval;
//TimeInterval intervalOnDataStrobe;
Rank rank = Rank(0);
BankGroup bankGroup = BankGroup(0);
Bank bank = Bank(0);
Row row = Row(0);
Column column = Column(0);
unsigned int burstLength = 0;
};
std::vector<Phase> recordedPhases;
};
@@ -132,10 +146,9 @@ private:
void commitRecordedDataToDB();
void insertGeneralInfo();
void insertCommandLengths();
void insertTransactionInDB(Transaction &recordingData);
void insertTransactionInDB(const Transaction& recordingData);
void insertRangeInDB(uint64_t id, const sc_core::sc_time &begin, const sc_core::sc_time &end);
void insertPhaseInDB(const std::string &phaseName, const sc_core::sc_time &begin, const sc_core::sc_time &end,
uint64_t transactionID);
void insertPhaseInDB(const Transaction::Phase& phase, uint64_t transactionID);
void insertDebugMessageInDB(const std::string &message, const sc_core::sc_time &time);
static constexpr unsigned transactionCommitRate = 8192;
@@ -177,6 +190,12 @@ private:
" PhaseName TEXT, \n"
" PhaseBegin INTEGER, \n"
" PhaseEnd INTEGER, \n"
" Rank INTEGER, \n"
" BankGroup INTEGER, \n"
" Bank INTEGER, \n"
" Row INTEGER, \n"
" Column INTEGER, \n"
" BurstLength INTEGER, \n"
" Transact INTEGER \n"
"); \n"
" \n"
@@ -242,14 +261,9 @@ private:
" ID INTEGER, \n"
" Range INTEGER, \n"
" Address INTEGER, \n"
" Burstlength INTEGER, \n"
" TThread INTEGER, \n"
" TChannel INTEGER, \n"
" TRank INTEGER, \n"
" TBankgroup INTEGER, \n"
" TBank INTEGER, \n"
" TRow INTEGER, \n"
" TColumn INTEGER, \n"
" DataLength INTEGER, \n"
" Thread INTEGER, \n"
" Channel INTEGER, \n"
" DataStrobeBegin INTEGER, \n"
" DataStrobeEnd INTEGER, \n"
" TimeOfGeneration INTEGER, \n"