always show all costs

lievenhey · lievenhey · commit 84d790472560 · 2024-01-15T13:43:21.000+01:00
since we now have one line per cost there is no need to hide some costs
diff --git a/src/models/data.cpp b/src/models/data.cpp
@@ -398,3 +398,15 @@ const Data::ThreadEvents* Data::EventResults::findThread(qint32 pid, qint32 tid)
 {
     return const_cast<Data::EventResults*>(this)->findThread(pid, tid);
 }
+
+const Data::ThreadEvents* Data::EventResults::findThread(qint32 pid, qint32 tid, qint32 costId) const
+{
+    for (int i = threads.size() - 1; i >= 0; --i) {
+        auto& thread = threads[i];
+        if (thread.pid == pid && thread.tid == tid && thread.events[0].type == costId) {
+            return &thread;
+        }
+    }
+
+    return nullptr;
+}
diff --git a/src/models/data.h b/src/models/data.h
@@ -855,6 +855,7 @@ struct EventResults
 
     ThreadEvents* findThread(qint32 pid, qint32 tid);
     const ThreadEvents* findThread(qint32 pid, qint32 tid) const;
+    const ThreadEvents* findThread(qint32 pid, qint32 tid, qint32 costId) const;
 
     bool operator==(const EventResults& rhs) const
     {
diff --git a/src/models/eventmodel.cpp b/src/models/eventmodel.cpp
@@ -210,13 +210,15 @@ QVariant EventModel::data(const QModelIndex& index, int role) const
             quint64 maxRuntime = 0;
             quint64 offCpuTime = 0;
             quint64 numEvents = 0;
-            for (const auto tid : process.threads) {
-                const auto thread = m_data.findThread(process.pid, tid);
-                Q_ASSERT(thread);
-                runtime += thread->time.delta();
-                maxRuntime = std::max(thread->time.delta(), maxRuntime);
-                offCpuTime += thread->offCpuTime;
-                numEvents += thread->events.size();
+            for (const auto tidCostId : process.threads) {
+                for (const auto& thread : m_data.threads) {
+                    if (thread.tid == tidCostId.tid) {
+                        runtime += thread.time.delta();
+                        maxRuntime = std::max(thread.time.delta(), maxRuntime);
+                        offCpuTime += thread.offCpuTime;
+                        numEvents += thread.events.size();
+                    }
+                }
             }
 
             const auto totalRuntime = m_time.delta();
@@ -249,8 +251,9 @@ QVariant EventModel::data(const QModelIndex& index, int role) const
         cpu = &m_data.cpus[index.row()];
     } else if (tag == Tag::Threads) {
         const auto process = m_processes.value(tagData(index.internalId()));
-        const auto tid = process.threads.value(index.row());
-        thread = m_data.findThread(process.pid, tid);
+        const auto tid = process.threads[index.row()].tid;
+        const auto costId = process.threads[index.row()].costId;
+        thread = m_data.findThread(process.pid, tid, costId);
         Q_ASSERT(thread);
     } else if (tag == Tag::Tracepoints) {
         tracepoint = &m_data.tracepoints[index.row()];
@@ -521,36 +524,68 @@ void EventModel::setData(const Data::EventResults& data)
     if (data.threads.isEmpty()) {
         m_time = {};
     } else {
+        const auto numCostTypes = m_data.totalCosts.size();
         m_time = data.threads.first().time;
+        m_data.threads.clear();
         for (const auto& thread : data.threads) {
             m_time.start = std::min(thread.time.start, m_time.start);
             m_time.end = std::max(thread.time.end, m_time.end);
             m_totalOffCpuTime += thread.offCpuTime;
             m_totalOnCpuTime += thread.time.delta() - thread.offCpuTime;
             m_totalEvents += thread.events.size();
             auto it = std::lower_bound(m_processes.begin(), m_processes.end(), thread.pid, orderProcessByPid);
-            if (it == m_processes.end() || it->pid != thread.pid) {
-                m_processes.insert(it, {thread.pid, {thread.tid}, thread.name});
-            } else {
-                it->threads.append(thread.tid);
-                // prefer process name, if we encountered a thread first
-                if (thread.pid == thread.tid)
-                    it->name = thread.name;
-            }
 
-            for (const auto& event : thread.events) {
-                if (event.type != 0) {
-                    // TODO: support multiple cost types somehow
-                    continue;
+            for (int eventType = 0; eventType < numCostTypes; eventType++) {
+                Data::ThreadEvents event {
+                    thread.pid,        thread.tid,  thread.time, {}, thread.name, thread.lastSwitchTime,
+                    thread.offCpuTime, thread.state};
+
+                std::copy_if(thread.events.cbegin(), thread.events.cend(), std::back_inserter(event.events),
+                             [eventType](const Data::Event& event) { return eventType == event.type; });
+
+                if (!event.events.isEmpty()) {
+                    m_data.threads.push_back(event);
+                    if (it == m_processes.end() || it->pid != thread.pid) {
+                        it = m_processes.insert(it, {thread.pid, {{thread.tid, eventType}}, thread.name});
+                    } else {
+                        it->threads.append({thread.tid, eventType});
+                        // prefer process name, if we encountered a thread first
+                        if (thread.pid == thread.tid)
+                            it->name = thread.name;
+                    }
                 }
-                m_maxCost = std::max(event.cost, m_maxCost);
+            }
+
+            // TODO: support multiple cost types somehow
+            if (!thread.events.isEmpty() && thread.events[0].type == 0) {
+                auto maxElement = std::max_element(thread.events.cbegin(), thread.events.cend(),
+                                                   [](const auto& a, const auto& b) { return a.cost < b.cost; });
+                m_maxCost = std::max(maxElement->cost, m_maxCost);
             }
         }
 
         // don't show timeline for CPU cores that did not receive any events
         auto it = std::remove_if(m_data.cpus.begin(), m_data.cpus.end(),
                                  [](const Data::CpuEvents& cpuEvents) { return cpuEvents.events.isEmpty(); });
         m_data.cpus.erase(it, m_data.cpus.end());
+
+        // split events to that each CpuEvents entry contains only one event type
+        QVector<Data::CpuEvents> cpuEventsExpanded;
+
+        for (const auto& cpu : std::as_const(m_data.cpus)) {
+            for (int eventType = 0; eventType < numCostTypes; eventType++) {
+                Data::CpuEvents event;
+                event.cpuId = cpu.cpuId;
+                std::copy_if(cpu.events.cbegin(), cpu.events.cend(), std::back_inserter(event.events),
+                             [eventType](const Data::Event& event) { return eventType == event.type; });
+
+                if (!event.events.isEmpty()) {
+                    cpuEventsExpanded.append(event);
+                }
+            }
+        }
+        // Keep the data somehow so that we can show all events if no source is selected
+        m_data.cpus = cpuEventsExpanded;
     }
 
     endResetModel();
diff --git a/src/models/eventmodel.h b/src/models/eventmodel.h
@@ -62,14 +62,20 @@ class EventModel : public QAbstractItemModel
 
     struct Process
     {
-        Process(qint32 pid = Data::INVALID_PID, const QVector<qint32>& threads = {}, const QString& name = {})
+        struct ThreadIdCostId
+        {
+            qint32 tid;
+            qint32 costId;
+        };
+
+        Process(qint32 pid = Data::INVALID_PID, const QVector<ThreadIdCostId>& threads = {}, const QString& name = {})
             : pid(pid)
             , threads(threads)
             , name(name)
         {
         }
         qint32 pid;
-        QVector<qint32> threads;
+        QVector<ThreadIdCostId> threads;
         QString name;
     };
 
diff --git a/src/models/timelinedelegate.cpp b/src/models/timelinedelegate.cpp
@@ -161,7 +161,6 @@ void TimeLineDelegate::paint(QPainter* painter, const QStyleOptionViewItem& opti
     const auto results = index.data(EventModel::EventResultsRole).value<Data::EventResults>();
     const auto offCpuCostId = results.offCpuTimeCostId;
     const auto lostEventCostId = results.lostEventCostId;
-    const auto tracepointEventCostId = results.tracepointEventCostId;
     const bool is_alternate = option.features & QStyleOptionViewItem::Alternate;
     const auto& palette = option.palette;
 
@@ -231,10 +230,6 @@ void TimeLineDelegate::paint(QPainter* painter, const QStyleOptionViewItem& opti
         // see also: https://www.spinics.net/lists/linux-perf-users/msg03486.html
         for (const auto& event : data.events) {
             const auto isLostEvent = event.type == lostEventCostId;
-            const auto isTracepointEvent = event.type == tracepointEventCostId;
-            if (event.type != m_eventType && !isLostEvent && !isTracepointEvent) {
-                continue;
-            }
 
             const auto x = data.mapTimeToX(event.time);
             if (x < TimeLineData::padding || x >= data.w) {
diff --git a/tests/modeltests/tst_models.cpp b/tests/modeltests/tst_models.cpp
@@ -478,7 +478,8 @@ private slots:
     {
         const auto events = createEventModelTestData();
         const int nonEmptyCpus = 2;
-        const int processes = 2;
+        // there are two in the data, but one does not contain any events, so the proxy filters it out
+        const int processes = 1;
 
         const quint64 endTime = 1000;
 
@@ -491,6 +492,8 @@ private slots:
 
         auto simplifiedEvents = events;
         simplifiedEvents.cpus.remove(1);
+        simplifiedEvents.threads.remove(2);
+        simplifiedEvents.threads.remove(2);
 
         auto verifyCommonData = [&](const QModelIndex& idx) {
             const auto eventResults = idx.data(EventModel::EventResultsRole).value<Data::EventResults>();
@@ -502,7 +505,7 @@ private slots:
             const auto numProcesses = idx.data(EventModel::NumProcessesRole).value<uint>();
             QCOMPARE(numProcesses, processes);
             const auto numThreads = idx.data(EventModel::NumThreadsRole).value<uint>();
-            QCOMPARE(numThreads, events.threads.size());
+            QCOMPARE(numThreads, simplifiedEvents.threads.size());
             const auto numCpus = idx.data(EventModel::NumCpusRole).value<uint>();
             QCOMPARE(numCpus, nonEmptyCpus);
             const auto maxCost = idx.data(EventModel::MaxCostRole).value<quint64>();
@@ -629,7 +632,7 @@ private slots:
             // favorites are still on top
             QVERIFY(proxy.index(0, 0, proxy.index(0, 0)).data(EventModel::IsFavoriteRole).toBool());
             // followed by processes
-            QCOMPARE(proxy.index(0, 0, proxy.index(1, 0)).data(EventModel::ProcessIdRole).value<quint32>(), 5678);
+            QCOMPARE(proxy.index(0, 0, proxy.index(1, 0)).data(EventModel::ProcessIdRole).value<quint32>(), 1234);
         }
 
         model.removeFromFavorites(model.index(0, 0, favoritesIndex));

Original file line number	Diff line number	Diff line change
`@@ -855,6 +855,7 @@ struct EventResults`
`855`	`855`
`856`	`856`	`ThreadEvents* findThread(qint32 pid, qint32 tid);`
`857`	`857`	`const ThreadEvents* findThread(qint32 pid, qint32 tid) const;`
	`858`	`+ const ThreadEvents* findThread(qint32 pid, qint32 tid, qint32 costId) const;`
`858`	`859`
`859`	`860`	`bool operator==(const EventResults& rhs) const`
`860`	`861`	`{`