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

Make the lines of the TraceAnalyzer more dynamic

Browse Source 
This commit is a preparation for the upcoming feature that will make
dynamically rearranging the lines of the TracePlot possible. Most
importantly the y-values of the lines in the TraceDrawingProperties
class aren't statically defined any more and can already be rearranged
as wanted in the code.
This commit is contained in:
Derek Christ
2021-06-28 18:59:32 +02:00
parent 0141bde845
commit 6bbc348b8a
12 changed files with 358 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
DRAMSys/traceAnalyzer/businessObjects/phases/phase.cpp
View File

@@ -66,33 +66,29 @@ void Phase::draw(QPainter *painter, const QwtScaleMap &xMap,
if (!isCollapsed(drawingProperties))
{
if (getGranularity() == Granularity::Rankwise)
for (auto line : getTracePlotLines(drawingProperties))
{
for (int i = getYVal(drawingProperties); i < (int)(getYVal(drawingProperties) + drawingProperties.banksPerRank); i++)
drawPhaseSymbol(span.Begin(), span.End(), i, drawingProperties.drawText,
getPhaseSymbol(), painter, xMap, yMap);
}
else if (getGranularity() == Granularity::Groupwise)
{
for (int i = getYVal(drawingProperties); i < (int)(getYVal(drawingProperties) + drawingProperties.banksPerRank); i += drawingProperties.banksPerGroup)
drawPhaseSymbol(span.Begin(), span.End(), i, drawingProperties.drawText,
getPhaseSymbol(), painter, xMap, yMap);
}
else // if (getGranularity() == Granularity::Bankwise)
drawPhaseSymbol(span.Begin(), span.End(), getYVal(drawingProperties),
drawPhaseSymbol(span.Begin(), span.End(), line->getYVal(),
drawingProperties.drawText, getPhaseSymbol(), painter, xMap, yMap);
}
}
for (Timespan span : spansOnCommandBus)
{
drawPhaseSymbol(span.Begin(), span.End(), drawingProperties.yValCommandBus,
false, PhaseSymbol::Hexagon, painter, xMap, yMap);
for (auto commandBusLine : drawingProperties.getCommandBusLines())
{
drawPhaseSymbol(span.Begin(), span.End(), commandBusLine->getYVal(),
false, PhaseSymbol::Hexagon, painter, xMap, yMap);
}
}
if (spanOnDataBus)
{
drawPhaseSymbol(spanOnDataBus->Begin(), spanOnDataBus->End(), drawingProperties.yValDataBus,
false, PhaseSymbol::Hexagon, painter, xMap, yMap);
for (auto dataBusLine : drawingProperties.getDataBusLines())
{
drawPhaseSymbol(spanOnDataBus->Begin(), spanOnDataBus->End(), dataBusLine->getYVal(),
false, PhaseSymbol::Hexagon, painter, xMap, yMap);
}
}
}
@@ -137,16 +133,6 @@ QColor Phase::getColor(const TraceDrawingProperties &drawingProperties) const
}
}
int Phase::getYVal(const TraceDrawingProperties &drawingProperties) const
{
if (getGranularity() == Granularity::Bankwise)
return drawingProperties.getYValOfBank(transaction->bank);
else if (getGranularity() == Granularity::Groupwise)
return drawingProperties.getYValOfBankGroup(transaction->rank, transaction->bank);
else // if (getGranularity() == Granularity::Rankwise)
return drawingProperties.getYValOfRank(transaction->rank);
}
Qt::BrushStyle Phase::getBrushStyle() const
{
return Qt::SolidPattern;
@@ -160,36 +146,31 @@ bool Phase::isSelected(traceTime time, double yVal,
if (span.Begin() <= time && time <= (span.End() + offset))
{
if (getGranularity() == Granularity::Bankwise)
for (auto line : getTracePlotLines(drawingProperties))
{
if (fabs(yVal - getYVal(drawingProperties)) <= hexagonHeight)
if (fabs(yVal - line->getYVal()) <= hexagonHeight)
return true;
}
else if (getGranularity() == Granularity::Groupwise)
{
for (int offset = 0; offset < drawingProperties.banksPerRank; offset += drawingProperties.banksPerGroup)
{
if (fabs(yVal - (getYVal(drawingProperties) + offset)) <= hexagonHeight)
return true;
}
}
else // if (getGranularity() == Granularity::Rankwise)
{
for (int offset = 0; offset < drawingProperties.banksPerRank; offset++)
{
if (fabs(yVal - (getYVal(drawingProperties) + offset)) <= hexagonHeight)
return true;
}
}
}
if (spanOnDataBus && spanOnDataBus->contains(time) && fabs(yVal - drawingProperties.yValDataBus) <= hexagonHeight)
return true;
if (spanOnDataBus && spanOnDataBus->contains(time))
{
for (auto dataBusLine : drawingProperties.getDataBusLines())
{
if (fabs(yVal - dataBusLine->getYVal()) <= hexagonHeight)
return true;
}
}
for (Timespan span : spansOnCommandBus) {
if (span.contains(time)
&& fabs(yVal - drawingProperties.yValCommandBus) <= hexagonHeight)
return true;
if (span.contains(time))
{
for (auto commandBusLine : drawingProperties.getCommandBusLines())
{
if (fabs(yVal - commandBusLine->getYVal()) <= hexagonHeight)
return true;
}
}
}
return false;
@@ -200,6 +181,27 @@ Phase::PhaseSymbol Phase::getPhaseSymbol() const
return PhaseSymbol::Hexagon;
}
std::vector<std::shared_ptr<TracePlotLine>> Phase::getTracePlotLines(const TraceDrawingProperties &drawingProperties) const
{
if (getGranularity() == Granularity::Rankwise)
{
return drawingProperties.getBankLinesFromRank(transaction->rank);
}
else if (getGranularity() == Granularity::Groupwise)
{
return drawingProperties.getBankLinesFromGroup(transaction->rank,
transaction->bankgroup % drawingProperties.groupsPerRank);
}
else // if (getGranularity() == Granularity::Bankwise)
{
return drawingProperties.getBankLines(transaction->rank,
transaction->bankgroup % drawingProperties.groupsPerRank,
transaction->bank
% drawingProperties.banksPerRank
% drawingProperties.banksPerGroup);
}
}
bool Phase::isCollapsed(const TraceDrawingProperties &drawingProperties) const
{
// Never discard REQ and RESP phases

12
DRAMSys/traceAnalyzer/businessObjects/phases/phase.h
View File

@@ -90,12 +90,14 @@ protected:
virtual PhaseSymbol getPhaseSymbol() const;
virtual Qt::BrushStyle getBrushStyle() const;
virtual QColor getColor(const TraceDrawingProperties &drawingProperties) const;
virtual int getYVal(const TraceDrawingProperties &drawingProperties) const;
virtual QColor getPhaseColor() const = 0;
virtual void drawPhaseSymbol(traceTime begin, traceTime end, double y,
bool drawtext, PhaseSymbol symbol, QPainter *painter, const QwtScaleMap &xMap,
const QwtScaleMap &yMap) const;
virtual std::vector<std::shared_ptr<TracePlotLine>> getTracePlotLines(const TraceDrawingProperties &drawingProperties) const;
enum class Granularity {Bankwise, Groupwise, Rankwise};
virtual Granularity getGranularity() const
@@ -119,10 +121,10 @@ protected:
{
return "REQ";
}
virtual int getYVal(const TraceDrawingProperties &drawingProperties) const
virtual std::vector<std::shared_ptr<TracePlotLine>> getTracePlotLines(const TraceDrawingProperties &drawingProperties) const
override
{
return drawingProperties.yValRequest;
return drawingProperties.getRequestLines();
}
};
@@ -140,10 +142,10 @@ protected:
{
return "RESP";
}
virtual int getYVal(const TraceDrawingProperties &drawingProperties) const
virtual std::vector<std::shared_ptr<TracePlotLine>> getTracePlotLines(const TraceDrawingProperties &drawingProperties) const
override
{
return drawingProperties.yValResponse;
return drawingProperties.getResponseLines();
}
};

253
DRAMSys/traceAnalyzer/presentation/tracedrawingproperties.cpp
View File

@@ -35,25 +35,25 @@
#include "tracedrawingproperties.h"
TraceDrawingProperties::TraceDrawingProperties() :
drawText(true),
drawBorder(true),
colorGrouping(ColorGrouping::PhaseType)
TraceDrawingProperties::TraceDrawingProperties(bool drawText, bool drawBorder,
ColorGrouping colorGrouping) :
drawText(drawText),
drawBorder(drawBorder),
colorGrouping(colorGrouping)
{
}
TraceDrawingProperties::TraceDrawingProperties(bool drawText, bool drawBorder,
ColorGrouping colorGrouping) :
drawText(drawText),
drawBorder(drawBorder),
colorGrouping(colorGrouping)
void TraceDrawingProperties::init(std::shared_ptr<TracePlotLineVector> tracePlotLines,
std::shared_ptr<QHash<int, bool>> collapsedRanks)
{
this->tracePlotLines = tracePlotLines;
this->collapsedRanks = collapsedRanks;
}
void TraceDrawingProperties::setUpTracePlotLines()
{
tracePlotLines.push_back(std::make_shared<TracePlotRequestLine>("REQ", collapsedRanks));
tracePlotLines.push_back(std::make_shared<TracePlotResponseLine>("RESP", collapsedRanks));
tracePlotLines->push_back(std::make_shared<TracePlotRequestLine>("REQ", collapsedRanks));
tracePlotLines->push_back(std::make_shared<TracePlotResponseLine>("RESP", collapsedRanks));
for (unsigned int rank = numberOfRanks; rank--;)
{
@@ -61,26 +61,20 @@ void TraceDrawingProperties::setUpTracePlotLines()
{
for (unsigned int bank = banksPerGroup; bank--;)
{
QString rankLabel = QString("RA") + QString::number(rank);
QString bankGroupLabel = QString("BG") + QString::number(group);
QString bankLabel = QString("BA") + QString::number(bank);
QString label = rankLabel + QString(" ") + bankGroupLabel + QString(" ") + bankLabel;
std::shared_ptr<TracePlotLine> line;
if (bank == banksPerGroup - 1 && group == groupsPerRank - 1)
line = std::make_shared<TracePlotFirstRankLine>(label, rankLabel, rank, collapsedRanks);
line = std::make_shared<TracePlotFirstRankLine>(rank, group, bank, collapsedRanks);
else
line = std::make_shared<TracePlotBankLine>(label, rank, collapsedRanks);
line = std::make_shared<TracePlotBankLine>(rank, group, bank, collapsedRanks);
tracePlotLines.push_back(line);
tracePlotLines->push_back(line);
}
}
}
tracePlotLines.push_back(std::make_shared<TracePlotCommandBusLine>("Command Bus", collapsedRanks));
tracePlotLines.push_back(std::make_shared<TracePlotDataBusLine>("Data Bus", collapsedRanks));
tracePlotLines->push_back(std::make_shared<TracePlotCommandBusLine>("Command Bus", collapsedRanks));
tracePlotLines->push_back(std::make_shared<TracePlotDataBusLine>("Data Bus", collapsedRanks));
// Collapse all ranks except the first one by default.
for (int i = 0; i < numberOfRanks; i++)
@@ -95,10 +89,10 @@ void TraceDrawingProperties::updateLabels()
// Clear hash table, because otherwise not all old values will be overwritten.
labels->clear();
// The data bus is defined to start at -4.
int i = -4;
// The lowest line starts at the y value of 0.
int i = 0;
for (auto it = tracePlotLines.rbegin(); it != tracePlotLines.rend(); it++)
for (auto it = tracePlotLines->rbegin(); it != tracePlotLines->rend(); it++)
{
// Don't add collapsed ranks, but always add the first rank line.
auto bankLine = std::dynamic_pointer_cast<TracePlotBankLine>(*it);
@@ -110,18 +104,7 @@ void TraceDrawingProperties::updateLabels()
(*it)->setYVal(i);
if (std::dynamic_pointer_cast<TracePlotRequestLine>(*it))
yValRequest = i;
if (std::dynamic_pointer_cast<TracePlotResponseLine>(*it))
yValResponse = i;
if (std::dynamic_pointer_cast<TracePlotDataBusLine>(*it))
yValDataBus = i;
if (std::dynamic_pointer_cast<TracePlotCommandBusLine>(*it)) {
yValCommandBus = i;
// Add two spaces.
i += 2;
}
@@ -135,26 +118,9 @@ const std::shared_ptr<QHash<int, QString>> TraceDrawingProperties::getLabels() c
return labels;
}
const std::vector<std::shared_ptr<TracePlotLine>> & TraceDrawingProperties::getTracePlotLines() const
const TracePlotLineVector &TraceDrawingProperties::getTracePlotLines() const
{
return tracePlotLines;
}
const std::shared_ptr<TracePlotFirstRankLine> TraceDrawingProperties::getFirstRankLine(unsigned int rank) const
{
// TODO: Maybe cache results?
Q_ASSERT(rank <= numberOfRanks - 1);
std::shared_ptr<TracePlotFirstRankLine> firstRankLine;
for (auto &line : tracePlotLines)
{
firstRankLine = std::dynamic_pointer_cast<TracePlotFirstRankLine>(line);
if (firstRankLine && firstRankLine->rank == rank)
break;
}
return firstRankLine;
return *tracePlotLines;
}
void TraceDrawingProperties::setRankCollapsedState(unsigned int rank, bool collapse)
@@ -173,30 +139,179 @@ bool TraceDrawingProperties::getRankCollapsedState(unsigned int rank) const
unsigned int TraceDrawingProperties::getNumberOfDisplayedLines() const
{
return yValRequest + 6;
unsigned int max = 0;
for (auto line : *tracePlotLines)
{
if (!line->isCollapsed() && max < line->getYVal())
max = line->getYVal();
}
return max;
}
unsigned int TraceDrawingProperties::getYValOfBank(unsigned int bank) const
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getCommandBusLines() const
{
unsigned int rank = bank / banksPerRank;
if (commandBusLinesCache.size() != 0)
return commandBusLinesCache;
return getYValOfRank(rank) + bank % banksPerRank;
std::vector<std::shared_ptr<TracePlotLine>> commandBusLines;
for (auto line : *tracePlotLines)
{
auto commandBusLine = std::dynamic_pointer_cast<TracePlotCommandBusLine>(line);
if (commandBusLine)
commandBusLines.push_back(commandBusLine);
}
commandBusLinesCache = commandBusLines;
return commandBusLines;
}
unsigned int TraceDrawingProperties::getYValOfBankGroup(unsigned int rank, unsigned int bank) const
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getDataBusLines() const
{
return getYValOfRank(rank) + bank % banksPerGroup;
if (dataBusLinesCache.size() != 0)
return dataBusLinesCache;
std::vector<std::shared_ptr<TracePlotLine>> dataBusLines;
for (auto line : *tracePlotLines)
{
auto dataBusLine = std::dynamic_pointer_cast<TracePlotDataBusLine>(line);
if (dataBusLine)
dataBusLines.push_back(dataBusLine);
}
dataBusLinesCache = dataBusLines;
return dataBusLines;
}
unsigned int TraceDrawingProperties::getYValOfRank(unsigned int rank) const
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getRequestLines() const
{
unsigned int i = 0;
if (requestLinesCache.size() != 0)
return requestLinesCache;
for (unsigned int j = 0; j < rank; j++)
if ((*collapsedRanks)[j])
i += 1;
else
i += banksPerRank;
std::vector<std::shared_ptr<TracePlotLine>> requestLines;
for (auto line : *tracePlotLines)
{
auto requestLine = std::dynamic_pointer_cast<TracePlotRequestLine>(line);
if (requestLine)
requestLines.push_back(requestLine);
}
return i;
requestLinesCache = requestLines;
return requestLines;
}
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getResponseLines() const
{
if (responseLinesCache.size() != 0)
return responseLinesCache;
std::vector<std::shared_ptr<TracePlotLine>> responseLines;
for (auto line : *tracePlotLines)
{
auto responseLine = std::dynamic_pointer_cast<TracePlotResponseLine>(line);
if (responseLine)
responseLines.push_back(responseLine);
}
responseLinesCache = responseLines;
return responseLines;
}
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getFirstRankLines(unsigned int rank) const
{
Q_ASSERT(rank <= numberOfRanks - 1);
if (firstRankLinesCache.find(rank) != firstRankLinesCache.end())
return firstRankLinesCache[rank];
std::vector<std::shared_ptr<TracePlotLine>> firstRankLines;
for (auto line : *tracePlotLines)
{
auto firstRankLine = std::dynamic_pointer_cast<TracePlotFirstRankLine>(line);
if (firstRankLine && firstRankLine->rank == rank)
firstRankLines.push_back(firstRankLine);
}
firstRankLinesCache[rank] = firstRankLines;
return firstRankLines;
}
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getBankLinesFromRank(unsigned int rank) const
{
Q_ASSERT(rank <= numberOfRanks - 1);
if (bankLinesFromRankCache.find(rank) != bankLinesFromRankCache.end())
return bankLinesFromRankCache[rank];
std::vector<std::shared_ptr<TracePlotLine>> bankLines;
for (auto line : *tracePlotLines)
{
auto bankLine = std::dynamic_pointer_cast<TracePlotBankLine>(line);
if (bankLine && bankLine->rank == rank)
bankLines.push_back(bankLine);
}
bankLinesFromRankCache[rank] = bankLines;
return bankLines;
}
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getBankLinesFromGroup(unsigned int rank, unsigned int group) const
{
Q_ASSERT(rank <= numberOfRanks - 1);
Q_ASSERT(group <= groupsPerRank - 1);
std::tuple<int, int> bankLinesTuple {rank, group};
if (bankLinesFromGroupCache.find(bankLinesTuple) != bankLinesFromGroupCache.end())
return bankLinesFromGroupCache[bankLinesTuple];
std::vector<std::shared_ptr<TracePlotLine>> bankLines;
for (auto line : *tracePlotLines)
{
auto bankLine = std::dynamic_pointer_cast<TracePlotBankLine>(line);
if (bankLine && bankLine->rank == rank && bankLine->group == group)
bankLines.push_back(bankLine);
}
bankLinesFromGroupCache[bankLinesTuple] = bankLines;
return bankLines;
}
std::vector<std::shared_ptr<TracePlotLine>> TraceDrawingProperties::getBankLines(unsigned int rank, unsigned int group,
unsigned int bank) const
{
Q_ASSERT(rank <= numberOfRanks - 1);
Q_ASSERT(group <= groupsPerRank - 1);
Q_ASSERT(bank <= banksPerGroup - 1);
std::tuple<int, int, int> bankLinesTuple {rank, group, bank};
if (bankLinesCache.find(bankLinesTuple) != bankLinesCache.end())
return bankLinesCache[bankLinesTuple];
std::vector<std::shared_ptr<TracePlotLine>> bankLines;
for (auto line : *tracePlotLines)
{
auto bankLine = std::dynamic_pointer_cast<TracePlotBankLine>(line);
if (bankLine && bankLine->rank == rank && bankLine->group == group && bankLine->bank == bank)
bankLines.push_back(bankLine);
}
bankLinesCache[bankLinesTuple] = bankLines;
return bankLines;
}

46
DRAMSys/traceAnalyzer/presentation/tracedrawingproperties.h
View File

@@ -43,19 +43,19 @@
#include <QColor>
#include <map>
#include <QHash>
#include <tuple>
#include "tracedrawing.h"
#include "traceplotline.h"
enum class ColorGrouping {PhaseType, Transaction, Thread};
using TracePlotLineVector = std::vector<std::shared_ptr<TracePlotLine>>;
struct TraceDrawingProperties {
bool drawText;
bool drawBorder;
ColorGrouping colorGrouping;
int yValResponse;
int yValRequest;
int yValCommandBus;
int yValDataBus;
unsigned int numberOfRanks;
unsigned int numberOfBankgroups;
unsigned int numberOfBanks;
@@ -63,8 +63,12 @@ struct TraceDrawingProperties {
unsigned int groupsPerRank;
unsigned int banksPerGroup;
TraceDrawingProperties();
TraceDrawingProperties(bool drawText, bool drawBorder, ColorGrouping colorGrouping);
TraceDrawingProperties(bool drawText = true,
bool drawBorder = true,
ColorGrouping colorGrouping = ColorGrouping::PhaseType);
void init(std::shared_ptr<TracePlotLineVector> tracePlotLines, std::shared_ptr<QHash<int, bool>> collapsedRanks);
void setUpTracePlotLines();
void setRankCollapsedState(unsigned int rank, bool collapse);
@@ -72,21 +76,35 @@ struct TraceDrawingProperties {
unsigned int getNumberOfDisplayedLines() const;
unsigned int getYValOfBank(unsigned int bank) const;
unsigned int getYValOfBankGroup(unsigned int rank, unsigned int bank) const;
unsigned int getYValOfRank(unsigned int rank) const;
std::vector<std::shared_ptr<TracePlotLine>> getRequestLines() const;
std::vector<std::shared_ptr<TracePlotLine>> getResponseLines() const;
std::vector<std::shared_ptr<TracePlotLine>> getCommandBusLines() const;
std::vector<std::shared_ptr<TracePlotLine>> getDataBusLines() const;
std::vector<std::shared_ptr<TracePlotLine>> getFirstRankLines(unsigned int rank) const;
std::vector<std::shared_ptr<TracePlotLine>> getBankLines(unsigned int rank, unsigned int group, unsigned int bank) const;
std::vector<std::shared_ptr<TracePlotLine>> getBankLinesFromGroup(unsigned int rank, unsigned int group) const;
std::vector<std::shared_ptr<TracePlotLine>> getBankLinesFromRank(unsigned int rank) const;
const std::vector<std::shared_ptr<TracePlotLine>> & getTracePlotLines() const;
const std::shared_ptr<TracePlotFirstRankLine> getFirstRankLine(unsigned int rank) const;
const TracePlotLineVector &getTracePlotLines() const;
void updateLabels();
const std::shared_ptr<QHash<int, QString>> getLabels() const;
private:
std::shared_ptr<QHash<int, QString>> labels = std::make_shared<QHash<int, QString>>();
std::shared_ptr<QHash<int, bool>> collapsedRanks = std::make_shared<QHash<int, bool>>();
std::vector<std::shared_ptr<TracePlotLine>> tracePlotLines;
std::shared_ptr<QHash<int, bool>> collapsedRanks;
std::shared_ptr<TracePlotLineVector> tracePlotLines;
// Caches
mutable std::map<std::tuple<int, int, int>, std::vector<std::shared_ptr<TracePlotLine>>> bankLinesCache;
mutable std::map<std::tuple<int, int>, std::vector<std::shared_ptr<TracePlotLine>>> bankLinesFromGroupCache;
mutable std::map<int, std::vector<std::shared_ptr<TracePlotLine>>> bankLinesFromRankCache;
mutable std::map<int, std::vector<std::shared_ptr<TracePlotLine>>> firstRankLinesCache;
mutable std::vector<std::shared_ptr<TracePlotLine>> requestLinesCache;
mutable std::vector<std::shared_ptr<TracePlotLine>> responseLinesCache;
mutable std::vector<std::shared_ptr<TracePlotLine>> commandBusLinesCache;
mutable std::vector<std::shared_ptr<TracePlotLine>> dataBusLinesCache;
};
#endif // TRACECOLLECTIONDRAWINGPROPERTIES_H

10
DRAMSys/traceAnalyzer/presentation/tracenavigator.cpp
View File

@@ -317,3 +317,13 @@ Timespan TraceNavigator::getSpanCoveredBySelectedTransaction()
return Timespan(begin, end);
}
std::shared_ptr<QHash<int, bool>> TraceNavigator::getCollapsedRanks()
{
return collapsedRanks;
}
std::shared_ptr<TracePlotLineVector> TraceNavigator::getTracePlotLines()
{
return tracePlotLines;
}

5
DRAMSys/traceAnalyzer/presentation/tracenavigator.h
View File

@@ -117,6 +117,9 @@ public:
void commitChangesToDB();
void refreshData();
std::shared_ptr<QHash<int, bool>> getCollapsedRanks();
std::shared_ptr<TracePlotLineVector> getTracePlotLines();
Q_SIGNALS:
void currentTraceTimeChanged();
void selectedTransactionsChanged();
@@ -133,6 +136,8 @@ private:
void getCommentsFromDB();
bool changesToCommitExist;
std::shared_ptr<QHash<int, bool>> collapsedRanks = std::make_shared<QHash<int, bool>>();
std::shared_ptr<TracePlotLineVector> tracePlotLines = std::make_shared<TracePlotLineVector>();
};
#endif // TRACENAVIGATOR_H

30
DRAMSys/traceAnalyzer/presentation/traceplot.cpp
View File

@@ -209,6 +209,8 @@ void TracePlot::connectNavigatorQ_SIGNALS()
void TracePlot::setUpDrawingProperties()
{
drawingProperties.init(navigator->getTracePlotLines(), navigator->getCollapsedRanks());
drawingProperties.numberOfRanks = navigator->GeneralTraceInfo().numberOfRanks;
drawingProperties.numberOfBankgroups = navigator->GeneralTraceInfo().numberOfBankgroups;
drawingProperties.numberOfBanks = navigator->GeneralTraceInfo().numberOfBanks;
@@ -257,13 +259,14 @@ void TracePlot::setUpZoom()
void TracePlot::updateScrollbar()
{
const unsigned int pageStep = scrollBar->pageStep();
// The maximum number of displayed lines determined by the pageStep of the scroll bar.
const unsigned int maxDisplayedLines = scrollBar->pageStep();
const int maximum = drawingProperties.getNumberOfDisplayedLines() - pageStep;
const int maximum = drawingProperties.getNumberOfDisplayedLines() - maxDisplayedLines;
if (maximum >= 0)
{
scrollBar->setMaximum(drawingProperties.getNumberOfDisplayedLines() - pageStep);
scrollBar->setMaximum(maximum);
scrollBar->show();
}
else
@@ -272,18 +275,15 @@ void TracePlot::updateScrollbar()
void TracePlot::verticalScrollbarChanged(int value)
{
const int yValRequest = drawingProperties.yValRequest;
const int yMax = drawingProperties.getNumberOfDisplayedLines();
// The maximum number of displayed lines determined by the pageStep of the scroll bar.
const int maxDisplayedLines = scrollBar->pageStep();
if (drawingProperties.getNumberOfDisplayedLines() <= maxDisplayedLines)
if (scrollBar->isHidden())
{
setAxisScale(yLeft, -5, yValRequest + 1, 1.0);
setAxisScale(yLeft, -1, yMax + 1, 1.0);
}
else
{
setAxisScale(yLeft, yValRequest - maxDisplayedLines + 1 - value, yValRequest + 1 - value, 1.0);
setAxisScale(yLeft, scrollBar->maximum() - 1 - value, yMax + 1 - value, 1.0);
}
replot();
@@ -302,8 +302,11 @@ void TracePlot::setUpAxis()
QObject::connect(customLabelScaleDraw, &CustomLabelScaleDraw::scaleRedraw, this, [=]() {
for (auto rankButton : rankCollapseButtons)
{
auto firstRankLine = drawingProperties.getFirstRankLine(rankButton->rank);
positionButton(*firstRankLine, *rankButton);
for (auto line : drawingProperties.getFirstRankLines(rankButton->rank))
{
auto firstRankLine = static_pointer_cast<TracePlotFirstRankLine>(line);
positionButton(*firstRankLine, *rankButton);
}
}
});
@@ -338,7 +341,8 @@ void TracePlot::setUpAxis()
updateScrollbar();
emit scrollBar->valueChanged(scrollBar->value());
Q_EMIT scrollBar->valueChanged(scrollBar->value());
Q_EMIT tracePlotLinesChanged();
});
rankCollapseButtons.push_back(button);

1
DRAMSys/traceAnalyzer/presentation/traceplot.h
View File

@@ -96,6 +96,7 @@ public Q_SLOTS:
Q_SIGNALS:
void tracePlotZoomChanged();
void tracePlotLinesChanged();
void colorGroupingChanged(ColorGrouping colorgrouping);
private Q_SLOTS:

31
DRAMSys/traceAnalyzer/presentation/traceplotline.cpp
View File

@@ -42,6 +42,11 @@ TracePlotLine::TracePlotLine(const QString &label, const std::shared_ptr<QHash<i
{
}
TracePlotLine::TracePlotLine(const std::shared_ptr<QHash<int, bool>> collapsedRanks) :
collapsedRanks(collapsedRanks)
{
}
TracePlotLine::~TracePlotLine() {}
const QString & TracePlotLine::getLabel() const
@@ -66,11 +71,16 @@ int TracePlotLine::getYVal() const
}
TracePlotBankLine::TracePlotBankLine(const QString &label, unsigned int rank,
TracePlotBankLine::TracePlotBankLine(unsigned int rank, unsigned int group, unsigned int bank,
const std::shared_ptr<QHash<int, bool>> collapsedRanks) :
TracePlotLine(label, collapsedRanks),
rank(rank)
TracePlotLine(collapsedRanks),
rank(rank), group(group), bank(bank)
{
QString rankLabel = QString("RA") + QString::number(rank);
QString bankGroupLabel = QString("BG") + QString::number(group);
QString bankLabel = QString("BA") + QString::number(bank);
label = rankLabel + QString(" ") + bankGroupLabel + QString(" ") + bankLabel;
}
bool TracePlotBankLine::isCollapsed() const
@@ -79,16 +89,21 @@ bool TracePlotBankLine::isCollapsed() const
}
TracePlotFirstRankLine::TracePlotFirstRankLine(const QString &label, const QString &collapsedLabel,
unsigned int rank, const std::shared_ptr<QHash<int, bool>> collapsedRanks) :
TracePlotBankLine(label, rank, collapsedRanks),
collapsedLabel(collapsedLabel)
TracePlotFirstRankLine::TracePlotFirstRankLine(unsigned int rank, unsigned int group, unsigned int bank,
const std::shared_ptr<QHash<int, bool>> collapsedRanks) :
TracePlotBankLine(rank, group, bank, collapsedRanks)
{
collapsedLabel = QString("RA") + QString::number(rank);
}
bool TracePlotFirstRankLine::isCollapsed() const
{
return false;
}
const QString & TracePlotFirstRankLine::getLabel() const
{
if (isCollapsed())
if (TracePlotBankLine::isCollapsed())
return collapsedLabel;
else
return TracePlotLine::getLabel();

15
DRAMSys/traceAnalyzer/presentation/traceplotline.h
View File

@@ -53,6 +53,8 @@ public:
int getYVal() const;
protected:
TracePlotLine(const std::shared_ptr<QHash<int, bool>> collapsedRanks);
QString label;
int yVal;
const std::shared_ptr<QHash<int, bool>> collapsedRanks;
@@ -62,23 +64,28 @@ protected:
class TracePlotBankLine : public TracePlotLine
{
public:
TracePlotBankLine(const QString &label, unsigned int rank, const std::shared_ptr<QHash<int, bool>> collapsedRanks);
TracePlotBankLine(unsigned int rank, unsigned int group, unsigned int bank,
const std::shared_ptr<QHash<int, bool>> collapsedRanks);
~TracePlotBankLine() = default;
void setCollapsed(bool value);
bool isCollapsed() const override;
virtual bool isCollapsed() const override;
const unsigned int rank;
const unsigned int group;
const unsigned int bank;
};
class TracePlotFirstRankLine final : public TracePlotBankLine
{
public:
TracePlotFirstRankLine(const QString &label, const QString &collapsedLabel,
unsigned int rank, const std::shared_ptr<QHash<int, bool>> collapsedRanks);
TracePlotFirstRankLine(unsigned int rank, unsigned int group, unsigned int bank,
const std::shared_ptr<QHash<int, bool>> collapsedRanks);
~TracePlotFirstRankLine() = default;
bool isCollapsed() const override;
const QString & getLabel() const override;
private:

19
DRAMSys/traceAnalyzer/presentation/tracescroller.cpp
View File

@@ -61,8 +61,9 @@ void TraceScroller::init(TraceNavigator *navigator, TracePlot *tracePlot)
this -> navigator = navigator;
connectNavigatorQ_SIGNALS();
setUpAxis();
setUpDrawingProperties();
// setUpDrawingProperties() must be called before setUpAxis().
setUpAxis();
setUpTracePlotItem();
getAndDrawComments();
@@ -73,6 +74,8 @@ void TraceScroller::init(TraceNavigator *navigator, TracePlot *tracePlot)
QObject::connect(tracePlot, SIGNAL(colorGroupingChanged(ColorGrouping)), this,
SLOT(colorGroupingChanged(ColorGrouping)));
QObject::connect(tracePlot, SIGNAL(tracePlotLinesChanged()), this, SLOT(updateAxis()));
}
@@ -86,26 +89,30 @@ void TraceScroller::setUpTracePlotItem()
void TraceScroller::setUpDrawingProperties()
{
drawingProperties.init(navigator->getTracePlotLines(), navigator->getCollapsedRanks());
drawingProperties.numberOfRanks = navigator->GeneralTraceInfo().numberOfRanks;
drawingProperties.numberOfBankgroups = navigator->GeneralTraceInfo().numberOfBankgroups;
drawingProperties.numberOfBanks = navigator->GeneralTraceInfo().numberOfBanks;
drawingProperties.banksPerRank = drawingProperties.numberOfBanks / drawingProperties.numberOfRanks;
drawingProperties.groupsPerRank = drawingProperties.numberOfBankgroups / drawingProperties.numberOfRanks;
drawingProperties.banksPerGroup = drawingProperties.numberOfBanks / drawingProperties.numberOfBankgroups;
drawingProperties.yValResponse = drawingProperties.numberOfBanks;
drawingProperties.yValRequest = drawingProperties.numberOfBanks + 1;
drawingProperties.yValCommandBus = -3;
drawingProperties.yValDataBus = -4;
}
void TraceScroller::setUpAxis()
{
setAxisScale(yLeft, -1, navigator->GeneralTraceInfo().numberOfBanks + 2, 1.0);
updateAxis();
axisScaleDraw(yLeft)->enableComponent(QwtAbstractScaleDraw::Labels, false );
axisScaleDraw(yLeft)->enableComponent(QwtAbstractScaleDraw::Ticks, false );
}
void TraceScroller::updateAxis()
{
setAxisScale(yLeft, -1, drawingProperties.getNumberOfDisplayedLines() + 1, 1.0);
replot();
}
void TraceScroller::connectNavigatorQ_SIGNALS()
{
QObject::connect(navigator, SIGNAL(currentTraceTimeChanged()), this,

3
DRAMSys/traceAnalyzer/presentation/tracescroller.h
View File

@@ -78,6 +78,9 @@ public Q_SLOTS:
void selectedTransactionsChanged();
void colorGroupingChanged(ColorGrouping colorgrouping);
private Q_SLOTS:
void updateAxis();
};
#endif // TraceScroller_H