287 lines
9.6 KiB
Python
Executable File
287 lines
9.6 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
# Copyright (c) 2021, 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:
|
|
# Derek Christ
|
|
|
|
|
|
import sqlite3
|
|
import io
|
|
import sys
|
|
import enum
|
|
import datetime
|
|
from abc import ABC, abstractmethod
|
|
from memUtil import *
|
|
from vcd import VCDWriter
|
|
|
|
class Signal(ABC):
|
|
def __init__(self, name):
|
|
self.name = name
|
|
|
|
@abstractmethod
|
|
def getNeutralValue(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def getSignalType(self):
|
|
pass
|
|
|
|
class NumericSignal(Signal):
|
|
def getNeutralValue(self):
|
|
return "z"
|
|
|
|
def getSignalType(self):
|
|
return "integer"
|
|
|
|
class StringSignal(Signal):
|
|
def getNeutralValue(self):
|
|
return ""
|
|
|
|
def getSignalType(self):
|
|
return "string"
|
|
|
|
class Event():
|
|
def __init__(self, signal, value):
|
|
self.signal = signal
|
|
self.value = value
|
|
|
|
class Transaction():
|
|
def __init__(self, rank, bankgroup, bank, dataStrobeBegin, dataStrobeEnd):
|
|
self.rank = rank
|
|
self.bankgroup = bankgroup
|
|
self.bank = bank
|
|
self.dataStrobeBegin = dataStrobeBegin
|
|
self.dataStrobeEnd = dataStrobeEnd
|
|
|
|
class Granularity(enum.Enum):
|
|
Bankwise = 0
|
|
Groupwise = 1
|
|
Rankwise = 2
|
|
|
|
def getGranularity(phase):
|
|
if phase == "PRESB" or phase == "REFSB":
|
|
return Granularity.Groupwise
|
|
elif phase == "PREA" or phase == "REFA" or phase=="RFMAB" or phase == "PDNA" or phase == "PDNP" or phase == "SREF":
|
|
return Granularity.Rankwise
|
|
else:
|
|
return Granularity.Bankwise
|
|
|
|
def getAmountOfCommandBusSpans(phase):
|
|
if phase == "PDNA" or phase == "PDNAB" or phase == "PDNP" or phase == "PDNPB" or phase == "SREF" or phase == "SREFB":
|
|
return 2
|
|
else:
|
|
return 1
|
|
|
|
def getRanksBankgroupsBanks(connection):
|
|
ranks = getNumberOfRanks(connection)
|
|
bankgroups = int(getNumberOfBankGroups(connection) / ranks)
|
|
banks = int(getNumberOfBanks(connection) / (bankgroups * ranks))
|
|
|
|
return (ranks, bankgroups, banks)
|
|
|
|
def getBankName(rank, bankgroup, bank):
|
|
return "RA" + str(rank) + "_BG" + str(bankgroup) + "_BA" + str(bank)
|
|
|
|
def getBankNames(ranks, bankgroups, banks):
|
|
names = []
|
|
for rank in range(ranks):
|
|
for bankgroup in range(bankgroups):
|
|
for bank in range(banks):
|
|
names.append(getBankName(rank, bankgroup, bank))
|
|
|
|
return names
|
|
|
|
def getOccurringSignals(connection):
|
|
setOfPhases = set()
|
|
|
|
setOfPhases.add(NumericSignal("REQ"))
|
|
setOfPhases.add(NumericSignal("RESP"))
|
|
|
|
(ranks, bankgroups, banks) = getRanksBankgroupsBanks(connection)
|
|
|
|
for name in getBankNames(ranks, bankgroups, banks):
|
|
setOfPhases.add(NumericSignal(name))
|
|
|
|
setOfPhases.add(StringSignal("Command_Bus"))
|
|
setOfPhases.add(NumericSignal("Data_Bus"))
|
|
|
|
return setOfPhases
|
|
|
|
def getDataBusEvents(connection, eventDict):
|
|
cursor = connection.cursor()
|
|
cursor.execute("SELECT ID, DataStrobeBegin, DataStrobeEnd FROM Transactions")
|
|
|
|
transactions = getNumberOfTransactions(connection)
|
|
|
|
for transactionId, begin, end in cursor.fetchall():
|
|
if eventDict.get(begin) == None:
|
|
eventDict[begin] = []
|
|
|
|
if eventDict.get(end) == None:
|
|
eventDict[end] = []
|
|
|
|
eventDict[begin].append(Event("Data_Bus", transactionId))
|
|
eventDict[end].append(Event("Data_Bus", "z"))
|
|
|
|
def getCommandBusEvents(connection, eventDict, transactionDict):
|
|
cursor = connection.cursor()
|
|
cursor.execute("SELECT PhaseName, PhaseBegin, PhaseEnd, Transact FROM Phases")
|
|
|
|
for phase, phaseBegin, phaseEnd, transactionId in cursor.fetchall():
|
|
if phase == "REQ" or phase == "RESP":
|
|
continue
|
|
|
|
timespans = []
|
|
commandLengthTime = getCommandLengthForPhase(connection, "RD") * getClock(connection)[0]
|
|
|
|
if getAmountOfCommandBusSpans(phase) == 1:
|
|
timespans.append((phaseBegin, phaseBegin + commandLengthTime))
|
|
else:
|
|
timespans.append((phaseBegin, phaseBegin + commandLengthTime))
|
|
timespans.append((phaseEnd - commandLengthTime, phaseEnd))
|
|
|
|
for begin, end in timespans:
|
|
if eventDict.get(begin) == None:
|
|
eventDict[begin] = []
|
|
|
|
if eventDict.get(end) == None:
|
|
eventDict[end] = []
|
|
|
|
eventDict[begin].append(Event("Command_Bus", phase))
|
|
eventDict[end].append(Event("Command_Bus", ""))
|
|
|
|
currentTransaction = transactionDict[transactionId]
|
|
rank = currentTransaction.rank
|
|
bankgroup = currentTransaction.bankgroup
|
|
bank = currentTransaction.bank
|
|
|
|
(ranks, bankgroups, banks) = getRanksBankgroupsBanks(connection)
|
|
|
|
currentBanks = []
|
|
|
|
if getGranularity(phase) == Granularity.Rankwise:
|
|
rank = currentTransaction.rank
|
|
for _bankgroup in range(bankgroups):
|
|
for _bank in range(banks):
|
|
currentBanks.append((rank, _bankgroup, _bank))
|
|
|
|
elif getGranularity(phase) == Granularity.Groupwise:
|
|
for _bankgroup in range(bankgroups):
|
|
currentBanks.append((rank, _bankgroup, bank))
|
|
|
|
else:
|
|
currentBanks.append((rank, bankgroup, bank))
|
|
|
|
for _rank, _bankgroup, _bank in currentBanks:
|
|
currentBankName = getBankName(_rank, _bankgroup, _bank)
|
|
|
|
eventDict[begin].append(Event(currentBankName, transactionId))
|
|
eventDict[end].append(Event(currentBankName, "z"))
|
|
|
|
def getReqAndRespPhases(connection, eventDict):
|
|
cursor = connection.cursor()
|
|
cursor.execute("SELECT PhaseName, PhaseBegin, PhaseEnd, Transact FROM Phases")
|
|
|
|
for phase, begin, end, transactionId in cursor.fetchall():
|
|
if phase != "REQ" and phase != "RESP":
|
|
continue
|
|
|
|
if eventDict.get(begin) == None:
|
|
eventDict[begin] = []
|
|
|
|
if eventDict.get(end) == None:
|
|
eventDict[end] = []
|
|
|
|
eventDict[begin].append(Event(phase, transactionId))
|
|
eventDict[end].append(Event(phase, "z"))
|
|
|
|
def getTransactions(connection, transactionDict):
|
|
cursor = connection.cursor()
|
|
cursor.execute("SELECT ID, TRank, TBankgroup, TBank, DataStrobeBegin, DataStrobeEnd FROM Transactions")
|
|
|
|
(ranks, bankgroups, banks) = getRanksBankgroupsBanks(connection)
|
|
|
|
for transactionId, rank, bankgroup, bank, dataStrobeBegin, dataStrobeEnd in cursor.fetchall():
|
|
rank = rank % ranks
|
|
bankgroup = bankgroup % bankgroups
|
|
bank = bank % banks
|
|
|
|
currentTransaction = Transaction(rank, bankgroup, bank, dataStrobeBegin, dataStrobeEnd)
|
|
|
|
transactionDict[transactionId] = currentTransaction
|
|
|
|
def dumpVcd(pathToTrace):
|
|
connection = sqlite3.connect(pathToTrace)
|
|
|
|
eventDict = {}
|
|
transactionDict = {}
|
|
|
|
getTransactions(connection, transactionDict)
|
|
signalList = getOccurringSignals(connection)
|
|
getReqAndRespPhases(connection, eventDict)
|
|
getDataBusEvents(connection, eventDict)
|
|
getCommandBusEvents(connection, eventDict, transactionDict)
|
|
|
|
# Sort the eventDict so that VCDWriter can work with it.
|
|
eventDict = sorted(eventDict.items(), key=lambda x: x[0])
|
|
|
|
with io.StringIO() as f:
|
|
currentDate = datetime.date.today().strftime("%B %d, %Y")
|
|
with VCDWriter(f, timescale='1 ps', date=currentDate) as writer:
|
|
variableDict = {}
|
|
|
|
for signal in signalList:
|
|
neutralValue = signal.getNeutralValue()
|
|
signalType = signal.getSignalType()
|
|
variableDict[signal.name] = writer.register_var("DRAMSys", signal.name, signalType, init=neutralValue)
|
|
|
|
for timestamp, eventList in eventDict:
|
|
for event in eventList:
|
|
value_to_change = variableDict.get(event.signal)
|
|
if value_to_change != None:
|
|
writer.change(value_to_change, timestamp, event.value)
|
|
|
|
|
|
f.seek(0)
|
|
return f.read()
|
|
|
|
if __name__ == "__main__":
|
|
if len(sys.argv) == 2:
|
|
dump = dumpVcd(sys.argv[1])
|
|
print(dump)
|
|
elif len(sys.argv) == 3:
|
|
dump = dumpVcd(sys.argv[1])
|
|
with open(sys.argv[2], 'x') as outputFile:
|
|
outputFile.write(dump)
|
|
else:
|
|
print("Usage: ", sys.argv[0], "<trace_file> [output_file_name]")
|