feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

QmlProfiler: Integrate TraceTime into ModelManager

Browse Source 
We never use it independently and only a subset of its interface needs
to be public.

Change-Id: I97bbc638270bcbb8fb1a4097fcfeacf37e96c048
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
This commit is contained in:
Ulf Hermann
2018-03-28 08:57:46 +02:00
parent 507c2d6b5b
commit 7ca958fa85
14 changed files with 107 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/qmlprofiler/debugmessagesmodel.cpp
View File

@@ -81,7 +81,7 @@ QVariantMap DebugMessagesModel::details(int index) const
QVariantMap result;
result.insert(QLatin1String("displayName"), messageType(type.detailType()));
result.insert(tr("Timestamp"), Timeline::formatTime(startTime(index),
manager->traceTime()->duration()));
manager->traceDuration()));
result.insert(tr("Message"), m_data[index].text);
result.insert(tr("Location"), type.displayName());
return result;

3
src/plugins/qmlprofiler/flamegraphmodel.cpp
View File

@@ -176,8 +176,7 @@ void FlameGraphModel::restrictToFeatures(quint64 visibleFeatures)
clear();
beginResetModel();
if (!m_modelManager->replayEvents(m_modelManager->traceTime()->startTime(),
m_modelManager->traceTime()->endTime(),
if (!m_modelManager->replayEvents(m_modelManager->traceStart(), m_modelManager->traceEnd(),
std::bind(&FlameGraphModel::loadEvent,
this, std::placeholders::_1,
std::placeholders::_2))) {

2
src/plugins/qmlprofiler/inputeventsmodel.cpp
View File

@@ -78,7 +78,7 @@ QVariantMap InputEventsModel::details(int index) const
{
QVariantMap result;
result.insert(tr("Timestamp"), Timeline::formatTime(startTime(index),
modelManager()->traceTime()->duration()));
modelManager()->traceDuration()));
QString type;
const InputEvent &event = m_data[index];
switch (event.type) {

10
src/plugins/qmlprofiler/memoryusagemodel.cpp
View File

@@ -234,12 +234,12 @@ void MemoryUsageModel::loadEvent(const QmlEvent &event, const QmlEventType &type
void MemoryUsageModel::finalize()
{
if (m_currentJSHeapIndex != -1)
insertEnd(m_currentJSHeapIndex, modelManager()->traceTime()->endTime() -
startTime(m_currentJSHeapIndex));
if (m_currentJSHeapIndex != -1) {
insertEnd(m_currentJSHeapIndex,
modelManager()->traceEnd() - startTime(m_currentJSHeapIndex));
}
if (m_currentUsageIndex != -1)
insertEnd(m_currentUsageIndex, modelManager()->traceTime()->endTime() -
startTime(m_currentUsageIndex));
insertEnd(m_currentUsageIndex, modelManager()->traceEnd() - startTime(m_currentUsageIndex));
computeNesting();

9
src/plugins/qmlprofiler/pixmapcachemodel.cpp
View File

@@ -331,7 +331,7 @@ void PixmapCacheModel::loadEvent(const QmlEvent &event, const QmlEventType &type
if (state.loadState == Initial) {
newEvent.pixmapEventType = PixmapLoadingStarted;
newEvent.typeId = event.typeIndex();
qint64 traceStart = modelManager()->traceTime()->startTime();
const qint64 traceStart = modelManager()->traceStart();
state.started = insert(traceStart, pixmapStartTime - traceStart,
newEvent.urlIndex + 1);
m_data.insert(state.started, newEvent);
@@ -382,8 +382,8 @@ void PixmapCacheModel::loadEvent(const QmlEvent &event, const QmlEventType &type
void PixmapCacheModel::finalize()
{
if (m_lastCacheSizeEvent != -1) {
insertEnd(m_lastCacheSizeEvent, modelManager()->traceTime()->endTime() -
startTime(m_lastCacheSizeEvent));
insertEnd(m_lastCacheSizeEvent,
modelManager()->traceEnd() - startTime(m_lastCacheSizeEvent));
}
resizeUnfinishedLoads();
@@ -446,8 +446,7 @@ void PixmapCacheModel::resizeUnfinishedLoads()
for (auto size = pixmap->sizes.begin(), sizesEnd = pixmap->sizes.end(); size != sizesEnd;
++size) {
if (size->loadState == Loading) {
insertEnd(size->started,
modelManager()->traceTime()->endTime() - startTime(size->started));
insertEnd(size->started, modelManager()->traceEnd() - startTime(size->started));
size->loadState = Error;
}
}

6
src/plugins/qmlprofiler/qmlprofilerclientmanager.cpp
View File

@@ -91,7 +91,7 @@ void QmlProfilerClientManager::createClients()
m_clientPlugin->setFlushInterval(m_flushInterval);
QObject::connect(m_clientPlugin.data(), &QmlProfilerTraceClient::traceFinished,
m_modelManager->traceTime(), &QmlProfilerTraceTime::increaseEndTime);
m_modelManager, &QmlProfilerModelManager::increaseTraceEnd);
QObject::connect(m_profilerState.data(), &QmlProfilerStateManager::requestedFeaturesChanged,
m_clientPlugin.data(), &QmlProfilerTraceClient::setRequestedFeatures);
@@ -101,11 +101,11 @@ void QmlProfilerClientManager::createClients()
QObject::connect(m_clientPlugin.data(), &QmlProfilerTraceClient::traceStarted,
this, [this](qint64 time) {
m_profilerState->setServerRecording(true);
m_modelManager->traceTime()->decreaseStartTime(time);
m_modelManager->decreaseTraceStart(time);
});
QObject::connect(m_clientPlugin, &QmlProfilerTraceClient::complete, this, [this](qint64 time) {
m_modelManager->traceTime()->increaseEndTime(time);
m_modelManager->increaseTraceEnd(time);
m_profilerState->setServerRecording(false);
});

162
src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
View File

@@ -62,85 +62,9 @@ static const char *ProfileFeatureNames[] = {
Q_STATIC_ASSERT(sizeof(ProfileFeatureNames) == sizeof(char *) * MaximumProfileFeature);
/////////////////////////////////////////////////////////////////////
QmlProfilerTraceTime::QmlProfilerTraceTime(QObject *parent) :
QObject(parent), m_startTime(-1), m_endTime(-1),
m_restrictedStartTime(-1), m_restrictedEndTime(-1)
{
}
qint64 QmlProfilerTraceTime::startTime() const
{
return m_restrictedStartTime != -1 ? m_restrictedStartTime : m_startTime;
}
qint64 QmlProfilerTraceTime::endTime() const
{
return m_restrictedEndTime != -1 ? m_restrictedEndTime : m_endTime;
}
qint64 QmlProfilerTraceTime::duration() const
{
return endTime() - startTime();
}
bool QmlProfilerTraceTime::isRestrictedToRange() const
{
return m_restrictedStartTime != -1 || m_restrictedEndTime != -1;
}
void QmlProfilerTraceTime::clear()
{
restrictToRange(-1, -1);
m_startTime = -1;
m_endTime = -1;
}
void QmlProfilerTraceTime::update(qint64 time)
{
QTC_ASSERT(time >= 0, return);
if (m_startTime > time || m_startTime == -1)
m_startTime = time;
if (m_endTime < time || m_endTime == -1)
m_endTime = time;
QTC_ASSERT(m_endTime >= m_startTime, m_startTime = m_endTime);
}
void QmlProfilerTraceTime::decreaseStartTime(qint64 time)
{
QTC_ASSERT(time >= 0, return);
if (m_startTime > time || m_startTime == -1) {
m_startTime = time;
if (m_endTime == -1)
m_endTime = m_startTime;
else
QTC_ASSERT(m_endTime >= m_startTime, m_endTime = m_startTime);
}
}
void QmlProfilerTraceTime::increaseEndTime(qint64 time)
{
QTC_ASSERT(time >= 0, return);
if (m_endTime < time || m_endTime == -1) {
m_endTime = time;
if (m_startTime == -1)
m_startTime = m_endTime;
else
QTC_ASSERT(m_endTime >= m_startTime, m_startTime = m_endTime);
}
}
void QmlProfilerTraceTime::restrictToRange(qint64 startTime, qint64 endTime)
{
QTC_ASSERT(endTime == -1 || startTime <= endTime, endTime = startTime);
m_restrictedStartTime = startTime;
m_restrictedEndTime = endTime;
}
} // namespace Internal
/////////////////////////////////////////////////////////////////////
using namespace Internal;
class QmlProfilerModelManager::QmlProfilerModelManagerPrivate
{
@@ -151,7 +75,6 @@ public:
QmlProfilerTextMarkModel *textMarkModel = nullptr;
QmlProfilerModelManager::State state = Empty;
QmlProfilerTraceTime *traceTime = nullptr;
int numRegisteredModels = 0;
int numFinishedFinalizers = 0;
@@ -171,16 +94,21 @@ public:
Utils::TemporaryFile file;
QDataStream eventStream;
qint64 traceStart = -1;
qint64 traceEnd = -1;
qint64 restrictedTraceStart = -1;
qint64 restrictedTraceEnd = -1;
void dispatch(const QmlEvent &event, const QmlEventType &type);
void rewriteType(int typeIndex);
int resolveStackTop();
void updateTraceTime(qint64 time);
void restrictTraceTimeToRange(qint64 start, qint64 end);
};
QmlProfilerModelManager::QmlProfilerModelManager(QObject *parent) :
QObject(parent), d(new QmlProfilerModelManagerPrivate)
{
d->traceTime = new QmlProfilerTraceTime(this);
d->notesModel = new QmlProfilerNotesModel(this);
d->textMarkModel = new QmlProfilerTextMarkModel(this);
@@ -201,9 +129,43 @@ QmlProfilerModelManager::~QmlProfilerModelManager()
delete d;
}
QmlProfilerTraceTime *QmlProfilerModelManager::traceTime() const
qint64 QmlProfilerModelManager::traceStart() const
{
return d->traceTime;
return d->restrictedTraceStart != -1 ? d->restrictedTraceStart : d->traceStart;
}
qint64 QmlProfilerModelManager::traceEnd() const
{
return d->restrictedTraceEnd != -1 ? d->restrictedTraceEnd : d->traceEnd;
}
qint64 QmlProfilerModelManager::traceDuration() const
{
return traceEnd() - traceStart();
}
void QmlProfilerModelManager::decreaseTraceStart(qint64 start)
{
QTC_ASSERT(start >= 0, return);
if (d->traceStart > start || d->traceStart == -1) {
d->traceStart = start;
if (d->traceEnd == -1)
d->traceEnd = d->traceStart;
else
QTC_ASSERT(d->traceEnd >= d->traceStart, d->traceEnd = d->traceStart);
}
}
void QmlProfilerModelManager::increaseTraceEnd(qint64 end)
{
QTC_ASSERT(end >= 0, return);
if (d->traceEnd < end || d->traceEnd == -1) {
d->traceEnd = end;
if (d->traceStart == -1)
d->traceStart = d->traceEnd;
else
QTC_ASSERT(d->traceEnd >= d->traceStart, d->traceStart = d->traceEnd);
}
}
QmlProfilerNotesModel *QmlProfilerModelManager::notesModel() const
@@ -250,7 +212,7 @@ void QmlProfilerModelManager::addEvents(const QVector<QmlEvent> &events)
{
for (const QmlEvent &event : events) {
d->eventStream << event;
d->traceTime->update(event.timestamp());
d->updateTraceTime(event.timestamp());
d->dispatch(event, d->eventTypes[event.typeIndex()]);
}
}
@@ -258,7 +220,7 @@ void QmlProfilerModelManager::addEvents(const QVector<QmlEvent> &events)
void QmlProfilerModelManager::addEvent(const QmlEvent &event)
{
d->eventStream << event;
d->traceTime->update(event.timestamp());
d->updateTraceTime(event.timestamp());
QTC_ASSERT(event.typeIndex() < d->eventTypes.size(),
d->eventTypes.resize(event.typeIndex() + 1));
d->dispatch(event, d->eventTypes.at(event.typeIndex()));
@@ -434,6 +396,23 @@ void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::rewriteType(int ty
detailsRewriter->requestDetailsForLocation(typeIndex, location);
}
void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::updateTraceTime(qint64 time)
{
QTC_ASSERT(time >= 0, return);
if (traceStart > time || traceStart == -1)
traceStart = time;
if (traceEnd < time || traceEnd == -1)
traceEnd = time;
QTC_ASSERT(traceEnd >= traceStart, traceStart = traceEnd);
}
void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::restrictTraceTimeToRange(qint64 start, qint64 end)
{
QTC_ASSERT(end == -1 || start <= end, end = start);
restrictedTraceStart = start;
restrictedTraceEnd = end;
}
void QmlProfilerModelManager::announceFeatures(quint64 features, EventLoader eventLoader,
Finalizer finalizer)
{
@@ -541,8 +520,7 @@ void QmlProfilerModelManager::save(const QString &filename)
d->notesModel->stash();
QmlProfilerFileWriter *writer = new QmlProfilerFileWriter(this);
writer->setTraceTime(traceTime()->startTime(), traceTime()->endTime(),
traceTime()->duration());
writer->setTraceTime(traceStart(), traceEnd(), traceDuration());
writer->setData(this);
writer->setNotes(d->notesModel->notes());
@@ -609,9 +587,9 @@ void QmlProfilerModelManager::load(const QString &filename)
connect(reader, &QmlProfilerFileReader::success, this, [this, reader]() {
if (reader->traceStart() >= 0)
d->traceTime->decreaseStartTime(reader->traceStart());
decreaseTraceStart(reader->traceStart());
if (reader->traceEnd() >= 0)
d->traceTime->increaseEndTime(reader->traceEnd());
increaseTraceEnd(reader->traceEnd());
setRecordedFeatures(reader->loadedFeatures());
delete reader;
finalize();
@@ -691,7 +669,9 @@ void QmlProfilerModelManager::doClearEvents()
d->eventStream.setDevice(&d->file);
else
emit error(tr("Cannot open temporary trace file to store events."));
d->traceTime->clear();
d->restrictTraceTimeToRange(-1, -1);
d->traceStart = -1;
d->traceEnd = -1;
d->notesModel->clear();
setVisibleFeatures(0);
setRecordedFeatures(0);
@@ -731,14 +711,14 @@ void QmlProfilerModelManager::restrictToRange(qint64 startTime, qint64 endTime)
clear();
} else {
d->notesModel->setNotes(notes);
d->traceTime->restrictToRange(startTime, endTime);
d->restrictTraceTimeToRange(startTime, endTime);
finalize();
}
}
bool QmlProfilerModelManager::isRestrictedToRange() const
{
return d->traceTime->isRestrictedToRange();
return d->restrictedTraceStart != -1 || d->restrictedTraceEnd != -1;
}
void QmlProfilerModelManager::startAcquiring()

42
src/plugins/qmlprofiler/qmlprofilermodelmanager.h
View File

@@ -43,38 +43,6 @@ namespace QmlProfiler {
class QmlProfilerModelManager;
class QmlProfilerNotesModel;
namespace Internal {
class QMLPROFILER_EXPORT QmlProfilerTraceTime : public QObject
{
Q_OBJECT
public:
explicit QmlProfilerTraceTime(QObject *parent);
qint64 startTime() const;
qint64 endTime() const;
qint64 duration() const;
bool isRestrictedToRange() const;
void clear();
void update(qint64 time);
void decreaseStartTime(qint64 time);
void increaseEndTime(qint64 time);
void restrictToRange(qint64 startTime, qint64 endTime);
private:
qint64 m_startTime;
qint64 m_endTime;
qint64 m_restrictedStartTime;
qint64 m_restrictedEndTime;
};
} // End internal namespace
using namespace Internal;
// Interface between the Data Model and the Engine/Tool
class QMLPROFILER_EXPORT QmlProfilerModelManager : public QObject
{
@@ -94,9 +62,15 @@ public:
~QmlProfilerModelManager();
State state() const;
QmlProfilerTraceTime *traceTime() const;
qint64 traceStart() const;
qint64 traceEnd() const;
qint64 traceDuration() const;
void decreaseTraceStart(qint64 start);
void increaseTraceEnd(qint64 end);
QmlProfilerNotesModel *notesModel() const;
QmlProfilerTextMarkModel *textMarkModel() const;
Internal::QmlProfilerTextMarkModel *textMarkModel() const;
bool isEmpty() const;
uint numLoadedEvents() const;

2
src/plugins/qmlprofiler/qmlprofilerrangemodel.cpp
View File

@@ -85,7 +85,7 @@ void QmlProfilerRangeModel::finalize()
{
if (!m_stack.isEmpty()) {
qWarning() << "End times for some events are missing.";
const qint64 endTime = modelManager()->traceTime()->endTime();
const qint64 endTime = modelManager()->traceEnd();
do {
int index = m_stack.pop();
insertEnd(index, endTime - startTime(index));

2
src/plugins/qmlprofiler/qmlprofilerstatewidget.cpp
View File

@@ -126,7 +126,7 @@ void QmlProfilerStateWidget::updateDisplay()
QmlProfilerModelManager::State state = d->m_modelManager->state();
if (state == QmlProfilerModelManager::Done || state == QmlProfilerModelManager::Empty) {
// After profiling, there is an empty trace
if (d->m_modelManager->traceTime()->duration() > 0 && d->m_modelManager->isEmpty()) {
if (d->m_modelManager->traceDuration() > 0 && d->m_modelManager->isEmpty()) {
showText(tr("No QML events recorded"));
return;
}

9
src/plugins/qmlprofiler/qmlprofilerstatisticsmodel.cpp
View File

@@ -104,11 +104,10 @@ void QmlProfilerStatisticsModel::restrictToFeatures(quint64 features)
clear();
beginResetModel();
if (!m_modelManager->replayEvents(m_modelManager->traceTime()->startTime(),
m_modelManager->traceTime()->endTime(),
std::bind(&QmlProfilerStatisticsModel::loadEvent,
this, std::placeholders::_1,
std::placeholders::_2))) {
if (!m_modelManager->replayEvents(m_modelManager->traceStart(), m_modelManager->traceEnd(),
std::bind(&QmlProfilerStatisticsModel::loadEvent,
this, std::placeholders::_1,
std::placeholders::_2))) {
endResetModel();
emit m_modelManager->error(tr("Could not re-read events from temporary trace file."));
clear();

2
src/plugins/qmlprofiler/qmlprofilertool.cpp
View File

@@ -486,7 +486,7 @@ void QmlProfilerTool::updateTimeDisplay()
case QmlProfilerStateManager::Idle:
if (d->m_profilerModelManager->state() != QmlProfilerModelManager::Empty &&
d->m_profilerModelManager->state() != QmlProfilerModelManager::ClearingData)
seconds = d->m_profilerModelManager->traceTime()->duration() / 1.0e9;
seconds = d->m_profilerModelManager->traceDuration() / 1.0e9;
break;
}
QString timeString = QString::number(seconds,'f',1);

4
src/plugins/qmlprofiler/qmlprofilertraceview.cpp
View File

@@ -99,8 +99,8 @@ QmlProfilerTraceView::QmlProfilerTraceView(QWidget *parent, QmlProfilerViewManag
connect(modelManager, &QmlProfilerModelManager::stateChanged, this, [modelManager, this]() {
switch (modelManager->state()) {
case QmlProfilerModelManager::Done: {
qint64 start = modelManager->traceTime()->startTime();
qint64 end = modelManager->traceTime()->endTime();
const qint64 start = modelManager->traceStart();
const qint64 end = modelManager->traceEnd();
d->m_zoomControl->setTrace(start, end);
d->m_zoomControl->setRange(start, start + (end - start) / 10);
Q_FALLTHROUGH();

8
src/plugins/qmlprofiler/tests/pixmapcachemodel_test.cpp
View File

@@ -38,8 +38,8 @@ PixmapCacheModelTest::PixmapCacheModelTest(QObject *parent) : QObject(parent),
void PixmapCacheModelTest::initTestCase()
{
manager.startAcquiring();
manager.traceTime()->decreaseStartTime(1);
manager.traceTime()->increaseEndTime(300);
manager.decreaseTraceStart(1);
manager.increaseTraceEnd(300);
for (int i = 0; i < MaximumPixmapEventType; ++i) {
eventTypeIndices[i] = manager.numLoadedEventTypes();
@@ -208,9 +208,9 @@ void PixmapCacheModelTest::testConsistency()
QVERIFY(model.startTime(i) >= currentTime);
currentTime = model.startTime(i);
QVERIFY(currentTime >= manager.traceTime()->startTime());
QVERIFY(currentTime >= manager.traceStart());
currentEnd = model.endTime(i);
QVERIFY(currentEnd <= manager.traceTime()->endTime());
QVERIFY(currentEnd <= manager.traceEnd());
const QVariantMap details = model.details(i);