130 lines
4.5 KiB
C++
130 lines
4.5 KiB
C++
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "TraceEvent.h"
|
|
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
namespace facebook::react::jsinspector_modern::tracing {
|
|
|
|
/// Opaque class to represent the original runtime profile returned by the
|
|
/// Runtime. RuntimeSamplingProfile class is designed to be agnostic to the
|
|
/// Runtime where sampling occurred.
|
|
class RawRuntimeProfile {
|
|
public:
|
|
virtual ~RawRuntimeProfile() = default;
|
|
};
|
|
|
|
/// Contains relevant information about the sampled runtime from start to
|
|
/// finish.
|
|
struct RuntimeSamplingProfile {
|
|
public:
|
|
/// Represents a single frame inside the captured sample stack.
|
|
struct SampleCallStackFrame {
|
|
public:
|
|
/// Represents type of frame inside of recorded call stack.
|
|
enum class Kind {
|
|
JSFunction, /// JavaScript function frame.
|
|
NativeFunction, /// Native built-in functions, like arrayPrototypeMap.
|
|
HostFunction, /// Native functions, defined by Host, a.k.a. Host
|
|
/// functions.
|
|
GarbageCollector, /// Garbage collection frame.
|
|
};
|
|
|
|
inline bool operator==(const SampleCallStackFrame &rhs) const noexcept = default;
|
|
|
|
/// type of the call stack frame
|
|
Kind kind;
|
|
/// id of the corresponding script in the VM.
|
|
uint32_t scriptId;
|
|
/// name of the function that represents call frame.
|
|
/// Storing a std::string_view should be considered safe here, beacause
|
|
/// the lifetime of the string contents are guaranteed as long as the raw
|
|
// Sampling Profiler object from Hermes is allocated.
|
|
std::string_view functionName;
|
|
/// source url of the corresponding script in the VM.
|
|
/// Storing a std::string_view should be considered safe here, beacause
|
|
/// the lifetime of the string contents are guaranteed as long as the raw
|
|
// Sampling Profiler object from Hermes is allocated.
|
|
std::optional<std::string_view> scriptURL = std::nullopt;
|
|
/// 0-based line number of the corresponding call frame.
|
|
std::optional<uint32_t> lineNumber = std::nullopt;
|
|
/// 0-based column number of the corresponding call frame.
|
|
std::optional<uint32_t> columnNumber = std::nullopt;
|
|
};
|
|
|
|
/// A pair of a timestamp and a snapshot of the call stack at this point in
|
|
/// time.
|
|
struct Sample {
|
|
public:
|
|
Sample(uint64_t timestamp, ThreadId threadId, std::vector<SampleCallStackFrame> callStack)
|
|
: timestamp(timestamp), threadId(threadId), callStack(std::move(callStack))
|
|
{
|
|
}
|
|
|
|
// Movable.
|
|
Sample &operator=(Sample &&) = default;
|
|
Sample(Sample &&) = default;
|
|
|
|
// Not copyable.
|
|
Sample(const Sample &) = delete;
|
|
Sample &operator=(const Sample &) = delete;
|
|
|
|
~Sample() = default;
|
|
|
|
/// When the call stack snapshot was taken (μs).
|
|
uint64_t timestamp;
|
|
/// Thread id where sample was recorded.
|
|
ThreadId threadId;
|
|
/// Snapshot of the call stack. The first element of the vector is
|
|
/// the lowest frame in the stack.
|
|
std::vector<SampleCallStackFrame> callStack;
|
|
};
|
|
|
|
RuntimeSamplingProfile(
|
|
std::string runtimeName,
|
|
ProcessId processId,
|
|
std::vector<Sample> samples,
|
|
std::unique_ptr<RawRuntimeProfile> rawRuntimeProfile)
|
|
: runtimeName(std::move(runtimeName)),
|
|
processId(processId),
|
|
samples(std::move(samples)),
|
|
rawRuntimeProfile(std::move(rawRuntimeProfile))
|
|
{
|
|
}
|
|
|
|
// Movable.
|
|
RuntimeSamplingProfile &operator=(RuntimeSamplingProfile &&) = default;
|
|
RuntimeSamplingProfile(RuntimeSamplingProfile &&) = default;
|
|
|
|
// Not copyable.
|
|
RuntimeSamplingProfile(const RuntimeSamplingProfile &) = delete;
|
|
RuntimeSamplingProfile &operator=(const RuntimeSamplingProfile &) = delete;
|
|
|
|
~RuntimeSamplingProfile() = default;
|
|
|
|
/// Name of the runtime, where sampling occurred: Hermes, V8, etc.
|
|
std::string runtimeName;
|
|
/// The ID of the OS-level process where the sampling occurred.
|
|
ProcessId processId;
|
|
/// List of recorded samples, should be chronologically sorted.
|
|
std::vector<Sample> samples;
|
|
/// A unique pointer to the original raw runtime profile, collected from the
|
|
/// runtime in RuntimeTargetDelegate. Keeping a pointer to the original
|
|
/// profile allows it to remain alive as long as RuntimeSamplingProfile is
|
|
/// alive, since it may be using the same std::string_view.
|
|
std::unique_ptr<RawRuntimeProfile> rawRuntimeProfile;
|
|
};
|
|
|
|
} // namespace facebook::react::jsinspector_modern::tracing
|