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

Tracing: Move the type storage out of the trace manager

Browse Source 
When we replay events we want to keep this constant and pass it to the
event receivers as separate entity. This way we can move the replaying
to a separate thread.

When loading we will have a similar situation, but then the loading
thread will create a new type storage and later assign that to the trace
manager.

Change-Id: I11402ed1e0663da6da5b61b15bba40e1a62adc4b
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
Ulf Hermann
2018-05-04 17:19:08 +02:00
parent 447befac61
commit 6e0373adb3
14 changed files with 191 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -61,14 +61,25 @@ static const char *ProfileFeatureNames[] = {
Q_STATIC_ASSERT(sizeof(ProfileFeatureNames) == sizeof(char *) * MaximumProfileFeature);
class QmlProfilerEventTypeStorage : public Timeline::TraceEventTypeStorage
{
public:
const Timeline::TraceEventType &get(int typeId) const override;
void set(int typeId, Timeline::TraceEventType &&type) override;
int append(Timeline::TraceEventType &&type) override;
int size() const override;
void clear() override;
private:
std::vector<QmlEventType> m_types;
};
class QmlProfilerModelManager::QmlProfilerModelManagerPrivate
{
public:
QmlProfilerModelManagerPrivate() : file("qmlprofiler-data") {}
Internal::QmlProfilerTextMarkModel *textMarkModel = nullptr;
QVector<QmlEventType> eventTypes;
Internal::QmlProfilerDetailsRewriter *detailsRewriter = nullptr;
Timeline::TraceStashFile<QmlEvent> file;
@@ -79,12 +90,12 @@ public:
void addEventType(const QmlEventType &eventType);
void handleError(const QString &message);
void rewriteType(int typeIndex);
int resolveStackTop();
};
QmlProfilerModelManager::QmlProfilerModelManager(QObject *parent) :
Timeline::TimelineTraceManager(parent), d(new QmlProfilerModelManagerPrivate)
Timeline::TimelineTraceManager(std::make_unique<QmlProfilerEventTypeStorage>(), parent),
d(new QmlProfilerModelManagerPrivate)
{
setNotesModel(new QmlProfilerNotesModel(this));
d->textMarkModel = new Internal::QmlProfilerTextMarkModel(this);
@@ -133,17 +144,9 @@ void QmlProfilerModelManager::addEvents(const QVector<QmlEvent> &events)
addEvent(event);
}
void QmlProfilerModelManager::addEventTypes(const QVector<QmlEventType> &types)
{
for (const QmlEventType &type : types) {
d->addEventType(type);
TimelineTraceManager::addEventType(type);
}
}
const QmlEventType &QmlProfilerModelManager::eventType(int typeId) const
{
return d->eventTypes.at(typeId);
return static_cast<const QmlEventType &>(TimelineTraceManager::eventType(typeId));
}
void QmlProfilerModelManager::replayEvents(TraceEventLoader loader, Initializer initializer,
@@ -175,7 +178,7 @@ void QmlProfilerModelManager::replayQmlEvents(QmlEventLoader loader,
if (future.isCanceled())
return false;
loader(event, d->eventTypes[event.typeIndex()]);
loader(event, eventType(event.typeIndex()));
return true;
});
@@ -238,41 +241,12 @@ void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::writeToStream(cons
file.append(event);
}
void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::addEventType(const QmlEventType &type)
{
const int typeId = eventTypes.count();
eventTypes.append(type);
rewriteType(typeId);
const QmlEventLocation &location = type.location();
if (location.isValid()) {
textMarkModel->addTextMarkId(typeId, QmlEventLocation(
detailsRewriter->getLocalFile(location.filename()),
location.line(), location.column()));
}
}
void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::handleError(const QString &message)
{
// What to do here?
qWarning() << message;
}
void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::rewriteType(int typeIndex)
{
QmlEventType &type = eventTypes[typeIndex];
type.setDisplayName(getDisplayName(type));
type.setData(getInitialDetails(type));
const QmlEventLocation &location = type.location();
// There is no point in looking for invalid locations
if (!location.isValid())
return;
// Only bindings and signal handlers need rewriting
if (type.rangeType() == Binding || type.rangeType() == HandlingSignal)
detailsRewriter->requestDetailsForLocation(typeIndex, location);
}
const char *QmlProfilerModelManager::featureName(ProfileFeature feature)
{
return ProfileFeatureNames[feature];
@@ -302,8 +276,10 @@ QString QmlProfilerModelManager::findLocalFile(const QString &remoteFile)
void QmlProfilerModelManager::detailsChanged(int typeId, const QString &newString)
{
QTC_ASSERT(typeId < d->eventTypes.count(), return);
d->eventTypes[typeId].setData(newString);
QTC_ASSERT(typeId < numEventTypes(), return);
QmlEventType type = eventType(typeId);
type.setData(newString);
setEventType(typeId, std::move(type));
emit typeDetailsChanged(typeId);
}
@@ -323,11 +299,6 @@ void QmlProfilerModelManager::restrictByFilter(QmlProfilerModelManager::QmlEvent
});
}
const Timeline::TraceEventType &QmlProfilerModelManager::lookupType(int typeIndex) const
{
return eventType(typeIndex);
}
void QmlProfilerModelManager::clearEventStorage()
{
TimelineTraceManager::clearEventStorage();
@@ -336,18 +307,50 @@ void QmlProfilerModelManager::clearEventStorage()
emit error(tr("Failed to reset temporary trace file"));
}
void QmlProfilerModelManager::clearTypeStorage()
int QmlProfilerModelManager::appendEventType(QmlEventType &&type)
{
TimelineTraceManager::clearTypeStorage();
d->eventTypes.clear();
type.setDisplayName(getDisplayName(type));
type.setData(getInitialDetails(type));
const QmlEventLocation &location = type.location();
if (location.isValid()) {
const RangeType rangeType = type.rangeType();
const QmlEventLocation localLocation(d->detailsRewriter->getLocalFile(location.filename()),
location.line(), location.column());
// location and type are invalid after this
const int typeIndex = TimelineTraceManager::appendEventType(std::move(type));
// Only bindings and signal handlers need rewriting
if (rangeType == Binding || rangeType == HandlingSignal)
d->detailsRewriter->requestDetailsForLocation(typeIndex, location);
d->textMarkModel->addTextMarkId(typeIndex, localLocation);
return typeIndex;
} else {
// There is no point in looking for invalid locations; just add the type
return TimelineTraceManager::appendEventType(std::move(type));
}
}
void QmlProfilerModelManager::addEventType(const QmlEventType &type)
void QmlProfilerModelManager::setEventType(int typeIndex, QmlEventType &&type)
{
d->addEventType(type);
TimelineTraceManager::addEventType(type);
type.setDisplayName(getDisplayName(type));
type.setData(getInitialDetails(type));
const QmlEventLocation &location = type.location();
if (location.isValid()) {
// Only bindings and signal handlers need rewriting
if (type.rangeType() == Binding || type.rangeType() == HandlingSignal)
d->detailsRewriter->requestDetailsForLocation(typeIndex, location);
d->textMarkModel->addTextMarkId(typeIndex, QmlEventLocation(
d->detailsRewriter->getLocalFile(location.filename()),
location.line(), location.column()));
}
TimelineTraceManager::setEventType(typeIndex, std::move(type));
}
void QmlProfilerModelManager::addEvent(const QmlEvent &event)
{
d->writeToStream(event);
@@ -442,4 +445,39 @@ Timeline::TimelineTraceFile *QmlProfilerModelManager::createTraceFile()
return new Internal::QmlProfilerTraceFile(this);
}
const Timeline::TraceEventType &QmlProfilerEventTypeStorage::get(int typeId) const
{
Q_ASSERT(typeId >= 0);
return m_types.at(static_cast<size_t>(typeId));
}
void QmlProfilerEventTypeStorage::set(int typeId, Timeline::TraceEventType &&type)
{
Q_ASSERT(typeId >= 0);
const size_t index = static_cast<size_t>(typeId);
if (m_types.size() <= index)
m_types.resize(index + 1);
m_types[index] = std::move(static_cast<QmlEventType &&>(type));
}
int QmlProfilerEventTypeStorage::append(Timeline::TraceEventType &&type)
{
const size_t index = m_types.size();
m_types.push_back(std::move(static_cast<QmlEventType &&>(type)));
QTC_ASSERT(index <= std::numeric_limits<int>::max(), return std::numeric_limits<int>::max());
return static_cast<int>(index);
}
int QmlProfilerEventTypeStorage::size() const
{
const size_t size = m_types.size();
QTC_ASSERT(size <= std::numeric_limits<int>::max(), return std::numeric_limits<int>::max());
return static_cast<int>(size);
}
void QmlProfilerEventTypeStorage::clear()
{
m_types.clear();
}
} // namespace QmlProfiler

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

@@ -62,7 +62,6 @@ public:
Clearer clearer = nullptr);
void addEvents(const QVector<QmlEvent> &events);
void addEventTypes(const QVector<QmlEventType> &types);
const QmlEventType &eventType(int typeId) const;
void replayQmlEvents(QmlEventLoader loader, Initializer initializer, Finalizer finalizer,
@@ -75,7 +74,8 @@ public:
static const char *featureName(ProfileFeature feature);
void addEventType(const QmlEventType &type);
int appendEventType(QmlEventType &&type);
void setEventType(int typeId, QmlEventType &&type);
void addEvent(const QmlEvent &event);
void restrictToRange(qint64 start, qint64 end);
@@ -92,9 +92,7 @@ private:
void restrictByFilter(QmlEventFilter filter);
void clearEventStorage() override;
void clearTypeStorage() override;
const Timeline::TraceEventType &lookupType(int typeId) const override;
Timeline::TimelineTraceFile *createTraceFile() override;
void replayEvents(TraceEventLoader loader, Initializer initializer, Finalizer finalizer,
ErrorHandler errorHandler, QFutureInterface<void> &future) const override;

8
src/plugins/qmlprofiler/qmlprofilertraceclient.cpp
View File

@@ -109,8 +109,9 @@ int QmlProfilerTraceClientPrivate::resolveType(const QmlTypedEvent &event)
if (it != serverTypeIds.constEnd()) {
typeIndex = it.value();
} else {
typeIndex = modelManager->numEventTypes();
modelManager->addEventType(event.type);
// We can potentially move the type away here, as we don't need to access it anymore,
// but that requires some more refactoring.
typeIndex = modelManager->appendEventType(QmlEventType(event.type));
serverTypeIds[event.serverTypeId] = typeIndex;
}
} else {
@@ -119,8 +120,7 @@ int QmlProfilerTraceClientPrivate::resolveType(const QmlTypedEvent &event)
if (it != eventTypeIds.constEnd()) {
typeIndex = it.value();
} else {
typeIndex = modelManager->numEventTypes();
modelManager->addEventType(event.type);
typeIndex = modelManager->appendEventType(QmlEventType(event.type));
eventTypeIds[event.type] = typeIndex;
}
}

26
src/plugins/qmlprofiler/qmlprofilertracefile.cpp
View File

@@ -229,25 +229,24 @@ void QmlProfilerTraceFile::loadQzt(QIODevice *device)
QByteArray data;
setDeviceProgress(device);
QmlProfilerModelManager *manager = modelManager();
if (!isCanceled()) {
stream >> data;
buffer.setData(qUncompress(data));
buffer.open(QIODevice::ReadOnly);
QVector<QmlEventType> eventTypes;
quint32 numEventTypes;
bufferStream >> numEventTypes;
if (numEventTypes > quint32(std::numeric_limits<int>::max())) {
emit error(tr("Excessive number of event types: %1").arg(numEventTypes));
return;
}
eventTypes.reserve(static_cast<int>(numEventTypes));
QmlEventType type;
for (int typeId = 0; typeId < static_cast<int>(numEventTypes); ++typeId) {
QmlEventType type;
bufferStream >> type;
eventTypes.append(type);
manager->setEventType(typeId, std::move(type));
}
buffer.close();
modelManager()->addEventTypes(eventTypes);
setDeviceProgress(device);
}
@@ -275,7 +274,7 @@ void QmlProfilerTraceFile::loadQzt(QIODevice *device)
emit error(tr("Invalid type index %1").arg(event.typeIndex()));
return;
}
addFeature(modelManager()->eventType(event.typeIndex()).feature());
addFeature(manager->eventType(event.typeIndex()).feature());
if (event.timestamp() < 0)
event.setTimestamp(0);
} else if (bufferStream.status() == QDataStream::ReadPastEnd) {
@@ -288,7 +287,7 @@ void QmlProfilerTraceFile::loadQzt(QIODevice *device)
}
eventBuffer.append(event);
}
modelManager()->addEvents(eventBuffer);
manager->addEvents(eventBuffer);
eventBuffer.clear();
buffer.close();
setDeviceProgress(device);
@@ -297,7 +296,7 @@ void QmlProfilerTraceFile::loadQzt(QIODevice *device)
if (isCanceled()) {
emit canceled();
} else {
modelManager()->addEvents(eventBuffer);
manager->addEvents(eventBuffer);
emit success();
}
}
@@ -316,7 +315,6 @@ void QmlProfilerTraceFile::addStageProgress(QmlProfilerTraceFile::ProgressValues
void QmlProfilerTraceFile::loadEventTypes(QXmlStreamReader &stream)
{
QTC_ASSERT(stream.name() == _("eventData"), return);
QVector<QmlEventType> eventTypes;
int typeIndex = -1;
@@ -421,12 +419,11 @@ void QmlProfilerTraceFile::loadEventTypes(QXmlStreamReader &stream)
case QXmlStreamReader::EndElement: {
if (elementName == _("event")) {
if (typeIndex >= 0) {
if (typeIndex >= eventTypes.length())
eventTypes.resize(typeIndex + 1);
QmlEventType type(messageAndRange.first, messageAndRange.second, detailType,
QmlEventLocation(filename, line, column), data, displayName);
eventTypes[typeIndex] = type;
QmlEventType type(messageAndRange.first, messageAndRange.second,
detailType, QmlEventLocation(filename, line, column),
data, displayName);
const quint8 feature = type.feature();
modelManager()->setEventType(typeIndex, std::move(type));
if (feature != MaximumProfileFeature)
addFeature(feature);
}
@@ -435,7 +432,6 @@ void QmlProfilerTraceFile::loadEventTypes(QXmlStreamReader &stream)
if (elementName == _("eventData")) {
// done reading eventData
modelManager()->addEventTypes(eventTypes);
return;
}
break;

2
src/plugins/qmlprofiler/tests/debugmessagesmodel_test.cpp
View File

@@ -49,7 +49,7 @@ void DebugMessagesModelTest::initTestCase()
QmlEventType type(DebugMessage, MaximumRangeType, i % (QtMsgType::QtInfoMsg + 1),
QmlEventLocation("somefile.js", i, 10 - i));
event.setTypeIndex(manager.numEventTypes());
manager.addEventType(type);
manager.appendEventType(std::move(type));
manager.addEvent(event);
}
manager.finalize();

10
src/plugins/qmlprofiler/tests/flamegraphmodel_test.cpp
View File

@@ -55,11 +55,11 @@ int FlameGraphModelTest::generateData(QmlProfilerModelManager *manager,
while (i < 10) {
int typeIndex = -1;
if (i < 5) {
QmlEventType type(MaximumMessage,
static_cast<RangeType>(static_cast<int>(Javascript) - i),
-1, QmlEventLocation("somefile.js", i, 20 - i), QString("funcfunc"));
typeIndex = manager->numEventTypes();
manager->addEventType(type);
typeIndex = manager->appendEventType(
QmlEventType(MaximumMessage,
static_cast<RangeType>(static_cast<int>(Javascript) - i), -1,
QmlEventLocation("somefile.js", i, 20 - i),
QString("funcfunc")));
} else {
typeIndex = typeIndices[i - 5];
}

6
src/plugins/qmlprofiler/tests/inputeventsmodel_test.cpp
View File

@@ -41,10 +41,8 @@ static InputEventType inputType(int i)
InputEventsModelTest::InputEventsModelTest(QObject *parent) :
QObject(parent), model(&manager, &aggregator)
{
keyTypeId = manager.numEventTypes();
manager.addEventType(QmlEventType(Event, MaximumRangeType, Key));
mouseTypeId = manager.numEventTypes();
manager.addEventType(QmlEventType(Event, MaximumRangeType, Mouse));
keyTypeId = manager.appendEventType(QmlEventType(Event, MaximumRangeType, Key));
mouseTypeId = manager.appendEventType(QmlEventType(Event, MaximumRangeType, Mouse));
}
void InputEventsModelTest::initTestCase()

12
src/plugins/qmlprofiler/tests/memoryusagemodel_test.cpp
View File

@@ -41,11 +41,11 @@ void MemoryUsageModelTest::initTestCase()
heapPageTypeId = manager.numEventTypes();
manager.addEventType(QmlEventType(MemoryAllocation, MaximumRangeType, HeapPage));
manager.appendEventType(QmlEventType(MemoryAllocation, MaximumRangeType, HeapPage));
smallItemTypeId = manager.numEventTypes();
manager.addEventType(QmlEventType(MemoryAllocation, MaximumRangeType, SmallItem));
manager.appendEventType(QmlEventType(MemoryAllocation, MaximumRangeType, SmallItem));
largeItemTypeId = manager.numEventTypes();
manager.addEventType(QmlEventType(MemoryAllocation, MaximumRangeType, LargeItem));
manager.appendEventType(QmlEventType(MemoryAllocation, MaximumRangeType, LargeItem));
auto addMemoryEvents = [&]() {
QmlEvent event;
@@ -74,9 +74,9 @@ void MemoryUsageModelTest::initTestCase()
addMemoryEvents();
rangeTypeId = manager.numEventTypes();
manager.addEventType(QmlEventType(MaximumMessage, Javascript, -1,
QmlEventLocation(QString("somefile.js"), 10, 20),
QString("funcfunc")));
manager.appendEventType(QmlEventType(MaximumMessage, Javascript, -1,
QmlEventLocation(QString("somefile.js"), 10, 20),
QString("funcfunc")));
QmlEvent event;
event.setRangeStage(RangeStart);

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

@@ -43,8 +43,8 @@ void PixmapCacheModelTest::initTestCase()
for (int i = 0; i < MaximumPixmapEventType; ++i) {
eventTypeIndices[i] = manager.numEventTypes();
manager.addEventType(QmlEventType(PixmapCacheEvent, MaximumRangeType, i,
QmlEventLocation("dings.png", 0, 0)));
manager.appendEventType(QmlEventType(PixmapCacheEvent, MaximumRangeType, i,
QmlEventLocation("dings.png", 0, 0)));
}
// random data, should still result in consistent model.
@@ -58,8 +58,8 @@ void PixmapCacheModelTest::initTestCase()
for (int i = 0; i < MaximumPixmapEventType; ++i) {
eventTypeIndices[i + MaximumPixmapEventType] = manager.numEventTypes();
manager.addEventType(QmlEventType(PixmapCacheEvent, MaximumRangeType, i,
QmlEventLocation("blah.png", 0, 0)));
manager.appendEventType(QmlEventType(PixmapCacheEvent, MaximumRangeType, i,
QmlEventLocation("blah.png", 0, 0)));
}

5
src/plugins/qmlprofiler/tests/qmlprofileranimationsmodel_test.cpp
View File

@@ -44,10 +44,9 @@ void QmlProfilerAnimationsModelTest::initTestCase()
{
manager.initialize();
QmlEventType type(Event, MaximumRangeType, AnimationFrame);
QmlEvent event;
event.setTypeIndex(manager.numEventTypes());
manager.addEventType(type);
event.setTypeIndex(manager.appendEventType(
QmlEventType(Event, MaximumRangeType, AnimationFrame)));
for (int i = 0; i < 10; ++i) {
event.setTimestamp(i);

7
src/plugins/qmlprofiler/tests/qmlprofilerbindingloopsrenderpass_test.cpp
View File

@@ -50,16 +50,17 @@ DummyModel::DummyModel(QmlProfilerModelManager *manager,
void DummyModel::loadData()
{
QmlEventType type(MaximumMessage, Binding);
modelManager()->addEventType(type);
const int typeIndex = modelManager()->appendEventType(QmlEventType(type));
QCOMPARE(typeIndex, 0);
for (int i = 0; i < 10; ++i) {
QmlEvent event(i, 0, {});
QmlEvent event(i, typeIndex, {});
event.setRangeStage(RangeStart);
loadEvent(event, type);
}
for (int i = 10; i < 20; ++i) {
QmlEvent event(i, 0, {});
QmlEvent event(i, typeIndex, {});
event.setRangeStage(RangeEnd);
loadEvent(event, type);
}

7
src/plugins/qmlprofiler/tests/qmlprofilertool_test.cpp
View File

@@ -100,8 +100,9 @@ void QmlProfilerToolTest::testClearEvents()
stateManager->setServerRecording(true);
QCOMPARE(modelManager->numEventTypes(), 0);
QCOMPARE(modelManager->numEvents(), 0);
modelManager->addEventType(QmlEventType());
modelManager->addEvent(QmlEvent(0, 0, ""));
const int typeIndex = modelManager->appendEventType(QmlEventType());
QCOMPARE(typeIndex, 0);
modelManager->addEvent(QmlEvent(0, typeIndex, ""));
QCOMPARE(modelManager->numEventTypes(), 1);
QCOMPARE(modelManager->numEvents(), 1);
stateManager->setServerRecording(false);
@@ -110,7 +111,7 @@ void QmlProfilerToolTest::testClearEvents()
stateManager->setServerRecording(true); // clears previous events, but not types
QCOMPARE(modelManager->numEventTypes(), 1);
QCOMPARE(modelManager->numEvents(), 0);
modelManager->addEvent(QmlEvent(0, 0, ""));
modelManager->addEvent(QmlEvent(0, typeIndex, ""));
QCOMPARE(modelManager->numEventTypes(), 1);
QCOMPARE(modelManager->numEvents(), 1);
}