bdf3e7e5b8
I'm adding two new classes that can be used to measure the duration of long tasks as process and thread level, e.g. decoding, fetching data from lldb-server, etc. In this first patch, I'm using it to measure the time it takes to decode each thread, which is printed out with the `dump info` command. In a later patch I'll start adding process-level tasks and I might move these classes to the upper Trace level, instead of having them in the intel-pt plugin. I might need to do that anyway in the future when we have to measure HTR. For now, I want to keep the impact of this change minimal. With it, I was able to generate the following info of a very big trace: ``` (lldb) thread trace dump info Trace technology: intel-pt thread #1: tid = 616081 Total number of instructions: 9729366 Memory usage: Raw trace size: 1024 KiB Total approximate memory usage (excluding raw trace): 123517.34 KiB Average memory usage per instruction (excluding raw trace): 13.00 bytes Timing: Decoding instructions: 1.62s Errors: Number of TSC decoding errors: 0 ``` As seen above, it took 1.62 seconds to decode 9.7M instructions. This is great news, as we don't need to do any optimization work in this area. Differential Revision: https://reviews.llvm.org/D123357
76 lines
2.4 KiB
C++
76 lines
2.4 KiB
C++
//===-- TaskTimer.h ---------------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TASKTIMER_H
|
|
#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TASKTIMER_H
|
|
|
|
#include "lldb/lldb-types.h"
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
#include <chrono>
|
|
#include <functional>
|
|
#include <unordered_map>
|
|
|
|
namespace lldb_private {
|
|
namespace trace_intel_pt {
|
|
|
|
/// Class used to track the duration of long running tasks related to a single
|
|
/// thread for reporting.
|
|
class ThreadTaskTimer {
|
|
public:
|
|
/// Execute the given \p task and record its duration.
|
|
///
|
|
/// \param[in] name
|
|
/// The name used to identify this task for reporting.
|
|
///
|
|
/// \param[in] task
|
|
/// The task function.
|
|
///
|
|
/// \return
|
|
/// The return value of the task.
|
|
template <class R> R TimeTask(llvm::StringRef name, std::function<R()> task) {
|
|
auto start = std::chrono::steady_clock::now();
|
|
R result = task();
|
|
auto end = std::chrono::steady_clock::now();
|
|
std::chrono::milliseconds duration =
|
|
std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
m_timed_tasks.insert({name.str(), duration});
|
|
return result;
|
|
}
|
|
|
|
/// Executive the given \p callback on each recorded task.
|
|
///
|
|
/// \param[in] callback
|
|
/// The first parameter of the callback is the name of the recorded task,
|
|
/// and the second parameter is the duration of that task.
|
|
void ForEachTimedTask(std::function<void(const std::string &name,
|
|
std::chrono::milliseconds duration)>
|
|
callback);
|
|
|
|
private:
|
|
std::unordered_map<std::string, std::chrono::milliseconds> m_timed_tasks;
|
|
};
|
|
|
|
/// Class used to track the duration of long running tasks for reporting.
|
|
class TaskTimer {
|
|
public:
|
|
/// \return
|
|
/// The timer object for the given thread.
|
|
ThreadTaskTimer &ForThread(lldb::tid_t tid);
|
|
|
|
private:
|
|
llvm::DenseMap<lldb::tid_t, ThreadTaskTimer> m_thread_timers;
|
|
};
|
|
|
|
} // namespace trace_intel_pt
|
|
} // namespace lldb_private
|
|
|
|
#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TASKTIMER_H
|