Changeset 266388 in webkit

Timestamp:

Sep 1, 2020 1:55:06 AM (4 years ago)

Author:

Carlos Garcia Campos

Message:

[Linux] Web Inspector: show per thread cpu usage
​https://bugs.webkit.org/show_bug.cgi?id=215883

Reviewed by Adrian Perez de Castro.

Source/JavaScriptCore:

Remove platform specific getter machThread() and add thread() to return the Thread instead. The caller knows how
to get the machThread or id from a Thread.

• runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::reportTopBytecodes):
(JSC::SamplingProfiler::machThread): Deleted.

• runtime/SamplingProfiler.h:

(JSC::SamplingProfiler::thread):

Source/WebCore:

Get per thread CPU usage and information to fill ResourceUsageData in Linux.

• page/ResourceUsageThread.h:
• page/cocoa/ResourceUsageThreadCocoa.mm:

(WebCore::ResourceUsageThread::platformSaveStateBeforeStarting): Update to new API in SamplingProfiler.

• page/linux/ResourceUsageThreadLinux.cpp:

(WebCore::ResourceUsageThread::platformSaveStateBeforeStarting): Initialize m_samplingProfilerThreadID.
(WebCore::threadInfoMap):
(WebCore::threadCPUUsage):
(WebCore::collectCPUUsage):
(WebCore::ResourceUsageThread::platformCollectCPUData):
(WebCore::cpuUsage): Deleted.

Source/WTF:

Add API to get the thread ID in Linux platform.

• wtf/Threading.cpp:

(WTF::Thread::initializeInThread):

• wtf/Threading.h:

(WTF::Thread::id const):

• wtf/ThreadingPrimitives.h:
• wtf/posix/ThreadingPOSIX.cpp:

(WTF::Thread::currentID):

Location:

trunk/Source

Files:

• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/runtime/SamplingProfiler.cpp (modified) (1 diff)
• JavaScriptCore/runtime/SamplingProfiler.h (modified) (1 diff)
• WTF/ChangeLog (modified) (1 diff)
• WTF/wtf/Threading.cpp (modified) (1 diff)
• WTF/wtf/Threading.h (modified) (2 diffs)
• WTF/wtf/ThreadingPrimitives.h (modified) (1 diff)
• WTF/wtf/posix/ThreadingPOSIX.cpp (modified) (2 diffs)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/page/ResourceUsageThread.h (modified) (1 diff)
• WebCore/page/cocoa/ResourceUsageThreadCocoa.mm (modified) (1 diff)
• WebCore/page/linux/ResourceUsageThreadLinux.cpp (modified) (7 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2020-09-01  Carlos Garcia Campos  <cgarcia@igalia.com>
+
+        [Linux] Web Inspector: show per thread cpu usage
+        https://bugs.webkit.org/show_bug.cgi?id=215883
+
+        Reviewed by Adrian Perez de Castro.
+
+        Remove platform specific getter machThread() and add thread() to return the Thread instead. The caller knows how
+        to get the machThread or id from a Thread.
+
+        * runtime/SamplingProfiler.cpp:
+        (JSC::SamplingProfiler::reportTopBytecodes):
+        (JSC::SamplingProfiler::machThread): Deleted.
+        * runtime/SamplingProfiler.h:
+        (JSC::SamplingProfiler::thread):
+
 2020-08-31  Yusuke Suzuki  <ysuzuki@apple.com>
 

trunk/Source/JavaScriptCore/runtime/SamplingProfiler.cpp

@@ -1142 +1142 @@
 }
 
-#if OS(DARWIN)
-mach_port_t SamplingProfiler::machThread()
-{
-    if (!m_thread)
-        return MACH_PORT_NULL;
-
-    return m_thread->machThread();
-}
-#endif
+Thread* SamplingProfiler::thread() const
+{
+    return m_thread.get();
+}
 
 } // namespace JSC

trunk/Source/JavaScriptCore/runtime/SamplingProfiler.h

@@ -194 +194 @@
     JS_EXPORT_PRIVATE void reportTopBytecodes(PrintStream&);
 
-#if OS(DARWIN)
-    JS_EXPORT_PRIVATE mach_port_t machThread();
-#endif
+    JS_EXPORT_PRIVATE Thread* thread() const;
 
 private:

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2020-09-01  Carlos Garcia Campos  <cgarcia@igalia.com>
+
+        [Linux] Web Inspector: show per thread cpu usage
+        https://bugs.webkit.org/show_bug.cgi?id=215883
+
+        Reviewed by Adrian Perez de Castro.
+
+        Add API to get the thread ID in Linux platform.
+
+        * wtf/Threading.cpp:
+        (WTF::Thread::initializeInThread):
+        * wtf/Threading.h:
+        (WTF::Thread::id const):
+        * wtf/ThreadingPrimitives.h:
+        * wtf/posix/ThreadingPOSIX.cpp:
+        (WTF::Thread::currentID):
+
 2020-08-31  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WTF/wtf/Threading.cpp

@@ -147 +147 @@
     }
 #endif
+
+#if OS(LINUX)
+    m_id = currentID();
+#endif
 }
 

trunk/Source/WTF/wtf/Threading.h

@@ -158 +158 @@
 
 #if USE(PTHREADS)
+#if OS(LINUX)
+    WTF_EXPORT_PRIVATE static ThreadIdentifier currentID();
+    ThreadIdentifier id() const { return m_id; }
+#endif
     WTF_EXPORT_PRIVATE bool signal(int signalNumber);
 #endif
@@ -330 +334 @@
     mach_port_t m_platformThread { MACH_PORT_NULL };
 #elif USE(PTHREADS)
+#if OS(LINUX)
+    ThreadIdentifier m_id { 0 };
+#endif
     PlatformRegisters* m_platformRegisters { nullptr };
     unsigned m_suspendCount { 0 };

trunk/Source/WTF/wtf/ThreadingPrimitives.h

@@ -58 +58 @@
 using PlatformCondition = pthread_cond_t;
 using ThreadSpecificKey = pthread_key_t;
+#if OS(LINUX)
+using ThreadIdentifier = pid_t;
+#endif
 #elif OS(WINDOWS)
 using ThreadIdentifier = uint32_t;

trunk/Source/WTF/wtf/posix/ThreadingPOSIX.cpp

@@ -69 +69 @@
 #endif
 
+#if OS(LINUX)
+#include <sys/syscall.h>
+#endif
+
 namespace WTF {
 
@@ -187 +191 @@
 #endif
 }
+
+#if OS(LINUX)
+ThreadIdentifier Thread::currentID()
+{
+    return static_cast<ThreadIdentifier>(syscall(SYS_gettid));
+}
+#endif
 
 void Thread::initializeCurrentThreadEvenIfNonWTFCreated()

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-09-01  Carlos Garcia Campos  <cgarcia@igalia.com>
+
+        [Linux] Web Inspector: show per thread cpu usage
+        https://bugs.webkit.org/show_bug.cgi?id=215883
+
+        Reviewed by Adrian Perez de Castro.
+
+        Get per thread CPU usage and information to fill ResourceUsageData in Linux.
+
+        * page/ResourceUsageThread.h:
+        * page/cocoa/ResourceUsageThreadCocoa.mm:
+        (WebCore::ResourceUsageThread::platformSaveStateBeforeStarting): Update to new API in SamplingProfiler.
+        * page/linux/ResourceUsageThreadLinux.cpp:
+        (WebCore::ResourceUsageThread::platformSaveStateBeforeStarting): Initialize m_samplingProfilerThreadID.
+        (WebCore::threadInfoMap):
+        (WebCore::threadCPUUsage):
+        (WebCore::collectCPUUsage):
+        (WebCore::ResourceUsageThread::platformCollectCPUData):
+        (WebCore::cpuUsage): Deleted.
+
 2020-08-31  Myles C. Maxfield  <mmaxfield@apple.com>
 

trunk/Source/WebCore/page/ResourceUsageThread.h

@@ -89 +89 @@
     JSC::VM* m_vm { nullptr };
 
-#if ENABLE(SAMPLING_PROFILER) && OS(DARWIN)
+#if ENABLE(SAMPLING_PROFILER)
+#if OS(DARWIN)
     mach_port_t m_samplingProfilerMachThread { MACH_PORT_NULL };
+#elif OS(LINUX)
+    pid_t m_samplingProfilerThreadID { 0 };
+#endif
 #endif
 

trunk/Source/WebCore/page/cocoa/ResourceUsageThreadCocoa.mm

@@ -137 +137 @@
 {
 #if ENABLE(SAMPLING_PROFILER)
-    m_samplingProfilerMachThread = m_vm->samplingProfiler() ? m_vm->samplingProfiler()->machThread() : MACH_PORT_NULL;
+    m_samplingProfilerMachThread = MACH_PORT_NULL;
+
+    if (auto* profiler = m_vm->samplingProfiler()) {
+        if (auto* thread = profiler->thread())
+            m_samplingProfilerMachThread = thread->machThread();
+    }
 #endif
 }

trunk/Source/WebCore/page/linux/ResourceUsageThreadLinux.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2017 Igalia S.L.
+ * Copyright (C) 2017, 2020 Igalia S.L.
  * Copyright (C) 2018 Apple Inc. All rights reserved.
  *
@@ -30 +30 @@
 #if ENABLE(RESOURCE_USAGE) && OS(LINUX)
 
+#include "WorkerThread.h"
 #include <JavaScriptCore/GCActivityCallback.h>
+#include <JavaScriptCore/SamplingProfiler.h>
 #include <JavaScriptCore/VM.h>
 #include <errno.h>
@@ -39 +41 @@
 #include <sys/types.h>
 #include <unistd.h>
+#include <wtf/Threading.h>
 #include <wtf/linux/CurrentProcessMemoryStatus.h>
 
@@ -91 +94 @@
 }
 
-static float cpuUsage()
-{
-    float period = cpuPeriod();
-    if (!period)
-        return -1;
-
-    int fd = open("/proc/self/stat", O_RDONLY);
+void ResourceUsageThread::platformSaveStateBeforeStarting()
+{
+#if ENABLE(SAMPLING_PROFILER)
+    m_samplingProfilerThreadID = 0;
+
+    if (auto* profiler = m_vm->samplingProfiler()) {
+        if (auto* thread = profiler->thread())
+            m_samplingProfilerThreadID = thread->id();
+    }
+#endif
+}
+
+struct ThreadInfo {
+    Optional<String> name;
+    Optional<float> cpuUsage;
+    unsigned long long previousUtime { 0 };
+    unsigned long long previousStime { 0 };
+};
+
+static HashMap<pid_t, ThreadInfo>& threadInfoMap()
+{
+    static LazyNeverDestroyed<HashMap<pid_t, ThreadInfo>> map;
+    static std::once_flag flag;
+    std::call_once(flag, [&] {
+        map.construct();
+    });
+    return map;
+}
+
+static bool threadCPUUsage(pid_t id, float period, ThreadInfo& info)
+{
+    String path = makeString("/proc/self/task/", id, "/stat");
+    int fd = open(path.utf8().data(), O_RDONLY);
     if (fd < 0)
-        return -1;
+        return false;
 
     static const ssize_t maxBufferLength = BUFSIZ - 1;
@@ -111 +140 @@
             if (errno != EINTR) {
                 close(fd);
-                return -1;
+                return false;
             }
             continue;
@@ -124 +153 @@
     buffer[totalBytesRead] = '\0';
 
-    // Skip pid and process name.
-    char* position = strrchr(buffer, ')');
+    // Skip tid and name.
+    char* position = strchr(buffer, ')');
     if (!position)
-        return -1;
+        return false;
+
+    if (!info.name) {
+        char* name = strchr(buffer, '(');
+        if (!name)
+            return false;
+        name++;
+        info.name = String::fromUTF8(name, position - name);
+    }
 
     // Move after state.
@@ -140 +177 @@
     }
 
-    static unsigned long long previousUtime = 0;
-    static unsigned long long previousStime = 0;
     unsigned long long utime = strtoull(position, &position, 10);
     unsigned long long stime = strtoull(position, &position, 10);
-    float usage = (utime + stime - (previousUtime + previousStime)) / period * 100.0;
-    previousUtime = utime;
-    previousStime = stime;
-
-    return clampTo<float>(usage, 0, 100);
-}
-
-void ResourceUsageThread::platformSaveStateBeforeStarting()
-{
+    float usage = (utime + stime - (info.previousUtime + info.previousStime)) / period * 100.0;
+    info.previousUtime = utime;
+    info.previousStime = stime;
+
+    info.cpuUsage = clampTo<float>(usage, 0, 100);
+    return true;
+}
+
+static void collectCPUUsage(float period)
+{
+    DIR* dir = opendir("/proc/self/task");
+    if (!dir) {
+        threadInfoMap().clear();
+        return;
+    }
+
+    HashSet<pid_t> previousTasks;
+    for (const auto& key : threadInfoMap().keys())
+        previousTasks.add(key);
+
+    struct dirent* dp;
+    while ((dp = readdir(dir))) {
+        String name = String::fromUTF8(dp->d_name);
+        if (name == "." || name == "..")
+            continue;
+
+        bool ok;
+        pid_t id = name.toIntStrict(&ok);
+        if (!ok)
+            continue;
+
+        auto& info = threadInfoMap().add(id, ThreadInfo()).iterator->value;
+        if (!threadCPUUsage(id, period, info))
+            threadInfoMap().remove(id);
+
+        previousTasks.remove(id);
+    }
+    closedir(dir);
+
+    threadInfoMap().removeIf([&](auto& entry)  {
+        return previousTasks.contains(entry.key);
+    });
 }
 
 void ResourceUsageThread::platformCollectCPUData(JSC::VM*, ResourceUsageData& data)
 {
-    data.cpu = cpuUsage();
-
-    // FIXME: Exclude the ResourceUsage thread.
-    // FIXME: Exclude the SamplingProfiler thread.
-    // FIXME: Classify usage per thread.
-    data.cpuExcludingDebuggerThreads = data.cpu;
+    float period = cpuPeriod();
+    if (!period) {
+        data.cpu = 0;
+        data.cpuExcludingDebuggerThreads = 0;
+        return;
+    }
+
+    collectCPUUsage(period);
+
+    pid_t resourceUsageThreadID = Thread::currentID();
+
+    HashSet<pid_t> knownWebKitThreads;
+    {
+        auto locker = holdLock(Thread::allThreadsMutex());
+        for (auto* thread : Thread::allThreads(locker)) {
+            if (auto id = thread->id())
+                knownWebKitThreads.add(id);
+        }
+    }
+
+    HashMap<pid_t, String> knownWorkerThreads;
+    {
+        LockHolder lock(WorkerThread::workerThreadsMutex());
+        for (auto* thread : WorkerThread::workerThreads(lock)) {
+            // Ignore worker threads that have not been fully started yet.
+            if (!thread->thread())
+                continue;
+
+            if (auto id = thread->thread()->id())
+                knownWorkerThreads.set(id, thread->identifier().isolatedCopy());
+        }
+    }
+
+    auto isDebuggerThread = [&](pid_t id) -> bool {
+        if (id == resourceUsageThreadID)
+            return true;
+#if ENABLE(SAMPLING_PROFILER)
+        if (id == m_samplingProfilerThreadID)
+            return true;
+#endif
+        return false;
+    };
+
+    auto isWebKitThread = [&](pid_t id, const String& name) -> bool {
+        if (knownWebKitThreads.contains(id))
+            return true;
+
+        // The bmalloc scavenger thread is below WTF. Detect it by its name.
+        if (name == "BMScavenger")
+            return true;
+
+        return false;
+    };
+
+    for (const auto& it : threadInfoMap()) {
+        if (!it.value.cpuUsage)
+            continue;
+
+        float cpuUsage = it.value.cpuUsage.value();
+        pid_t id = it.key;
+        data.cpu += cpuUsage;
+        if (isDebuggerThread(id))
+            continue;
+
+        data.cpuExcludingDebuggerThreads += cpuUsage;
+
+        if (getpid() == id)
+            data.cpuThreads.append(ThreadCPUInfo { "Main Thread"_s, { }, cpuUsage, ThreadCPUInfo::Type::Main});
+        else {
+            String threadIdentifier = knownWorkerThreads.get(id);
+            bool isWorkerThread = !threadIdentifier.isEmpty();
+            String name = it.value.name.valueOr(emptyString());
+            ThreadCPUInfo::Type type = (isWorkerThread || isWebKitThread(id, name)) ? ThreadCPUInfo::Type::WebKit : ThreadCPUInfo::Type::Unknown;
+            data.cpuThreads.append(ThreadCPUInfo { name, threadIdentifier, cpuUsage, type });
+        }
+    }
 }