130 lines
4.0 KiB
C++
130 lines
4.0 KiB
C++
/*
|
|
* Copyright (C) 2020 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// This example demonstrates system-wide tracing with Perfetto.
|
|
//
|
|
// 1). To use it, first build the `tracebox` and this file. The tracebox will
|
|
// internally build tracing service (traced, which is long running
|
|
// process / daemon ) and perfetto consumer client, and many other perfetto
|
|
// tracing related tools.
|
|
// `ninja -C out/default/ tracebox example_system_wide`
|
|
//
|
|
// 2). Run traced (long running process), and open another terminal tab.
|
|
// `./out/default/tracebox traced`
|
|
//
|
|
// 3). Run this file. This is main application to trace.
|
|
// `./out/default/example_system_wide`
|
|
//
|
|
// 4). Use perfetto client to start a session and record trace in a file.
|
|
// `./out/default/tracebox perfetto -c /tmp/trace_config.txt --txt
|
|
// -o /tmp/trace_output`
|
|
//
|
|
// but before running that command, put following trace config (protobuf config)
|
|
// in a file named `/tmp/trace_config.txt`
|
|
// This can also be copied from: https://pastebin.com/embed_iframe/ufmtBBuq
|
|
// ---------------------
|
|
// buffers: {
|
|
// size_kb: 63488
|
|
// }
|
|
// data_sources: {
|
|
// config {
|
|
// name: "track_event"
|
|
// }
|
|
// }
|
|
// duration_ms: 10000
|
|
// ---------------------
|
|
// After running the command above, trace will be saved in `/tmp/trace_output`
|
|
// file. It is a binary content. We can read it by running:
|
|
// `./tools/traceconv text /tmp/trace_output`
|
|
// Or we can use "Open Trace File" option in the perfetto UI
|
|
// (https://ui.perfetto.dev)
|
|
//
|
|
// Learn More:
|
|
// https://perfetto.dev/docs/quickstart/linux-tracing#capturing-a-trace
|
|
|
|
#include "trace_categories.h"
|
|
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <fstream>
|
|
#include <thread>
|
|
|
|
namespace {
|
|
|
|
class Observer : public perfetto::TrackEventSessionObserver {
|
|
public:
|
|
Observer() { perfetto::TrackEvent::AddSessionObserver(this); }
|
|
~Observer() override { perfetto::TrackEvent::RemoveSessionObserver(this); }
|
|
|
|
void OnStart(const perfetto::DataSourceBase::StartArgs&) override {
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
cv.notify_one();
|
|
}
|
|
|
|
void WaitForTracingStart() {
|
|
PERFETTO_LOG("Waiting for tracing to start...");
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
cv.wait(lock, [] { return perfetto::TrackEvent::IsEnabled(); });
|
|
PERFETTO_LOG("Tracing started");
|
|
}
|
|
|
|
std::mutex mutex;
|
|
std::condition_variable cv;
|
|
};
|
|
|
|
void InitializePerfetto() {
|
|
perfetto::TracingInitArgs args;
|
|
// The backends determine where trace events are recorded. For this example we
|
|
// are going to use the system-wide tracing service, so that we can see our
|
|
// app's events in context with system profiling information.
|
|
args.backends = perfetto::kSystemBackend;
|
|
|
|
perfetto::Tracing::Initialize(args);
|
|
perfetto::TrackEvent::Register();
|
|
}
|
|
|
|
void DrawPlayer(int player_number) {
|
|
TRACE_EVENT("rendering", "DrawPlayer", "player_number", player_number);
|
|
// Sleep to simulate a long computation.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
}
|
|
|
|
void DrawGame() {
|
|
TRACE_EVENT("rendering", "DrawGame");
|
|
DrawPlayer(1);
|
|
DrawPlayer(2);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int, const char**) {
|
|
InitializePerfetto();
|
|
|
|
Observer observer;
|
|
observer.WaitForTracingStart();
|
|
|
|
// Simulate some work that emits trace events.
|
|
// Note that we don't start and stop tracing here; for system-wide tracing
|
|
// this needs to be done through the "perfetto" command line tool or the
|
|
// Perfetto UI (https://ui.perfetto.dev).
|
|
DrawGame();
|
|
|
|
// Make sure the last event is closed for this example.
|
|
perfetto::TrackEvent::Flush();
|
|
|
|
return 0;
|
|
}
|