GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/tracing/agent.cc Lines: 133 133 100.0 %
Date: 2019-02-13 22:28:58 Branches: 43 50 86.0 %

Line Branch Exec Source
1
#include "tracing/agent.h"
2
3
#include <string>
4
#include "trace_event.h"
5
#include "tracing/node_trace_buffer.h"
6
#include "debug_utils.h"
7
#include "env-inl.h"
8
9
namespace node {
10
namespace tracing {
11
12
class Agent::ScopedSuspendTracing {
13
 public:
14
156
  ScopedSuspendTracing(TracingController* controller, Agent* agent,
15
                       bool do_suspend = true)
16
156
    : controller_(controller), agent_(do_suspend ? agent : nullptr) {
17
156
    if (do_suspend) {
18
141
      CHECK(agent_->started_);
19
141
      controller->StopTracing();
20
    }
21
156
  }
22
23
156
  ~ScopedSuspendTracing() {
24
171
    if (agent_ == nullptr) return;
25
141
    TraceConfig* config = agent_->CreateTraceConfig();
26
141
    if (config != nullptr) {
27
139
      controller_->StartTracing(config);
28
    }
29
297
  }
30
31
 private:
32
  TracingController* controller_;
33
  Agent* agent_;
34
};
35
36
namespace {
37
38
151
std::set<std::string> flatten(
39
    const std::unordered_map<int, std::multiset<std::string>>& map) {
40
151
  std::set<std::string> result;
41
376
  for (const auto& id_value : map)
42
225
    result.insert(id_value.second.begin(), id_value.second.end());
43
151
  return result;
44
}
45
46
}  // namespace
47
48
using v8::platform::tracing::TraceConfig;
49
using v8::platform::tracing::TraceWriter;
50
using std::string;
51
52
4269
Agent::Agent() : tracing_controller_(new TracingController()) {
53
4269
  tracing_controller_->Initialize(nullptr);
54
55
4269
  CHECK_EQ(uv_loop_init(&tracing_loop_), 0);
56
8674
  CHECK_EQ(uv_async_init(&tracing_loop_,
57
                         &initialize_writer_async_,
58
                         [](uv_async_t* async) {
59
    Agent* agent = ContainerOf(&Agent::initialize_writer_async_, async);
60
    agent->InitializeWritersOnThread();
61
  }), 0);
62
4269
  uv_unref(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_));
63
4269
}
64
65
68
void Agent::InitializeWritersOnThread() {
66
68
  Mutex::ScopedLock lock(initialize_writer_mutex_);
67
204
  while (!to_be_initialized_.empty()) {
68
68
    AsyncTraceWriter* head = *to_be_initialized_.begin();
69
68
    head->InitializeOnThread(&tracing_loop_);
70
68
    to_be_initialized_.erase(head);
71
  }
72
68
  initialize_writer_condvar_.Broadcast(lock);
73
68
}
74
75
8538
Agent::~Agent() {
76
4269
  categories_.clear();
77
4269
  writers_.clear();
78
79
4269
  StopTracing();
80
81
4269
  uv_close(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_), nullptr);
82
4269
  uv_run(&tracing_loop_, UV_RUN_ONCE);
83
4269
  CheckedUvLoopClose(&tracing_loop_);
84
4269
}
85
86
68
void Agent::Start() {
87
68
  if (started_)
88
68
    return;
89
90
  NodeTraceBuffer* trace_buffer_ = new NodeTraceBuffer(
91
68
      NodeTraceBuffer::kBufferChunks, this, &tracing_loop_);
92
68
  tracing_controller_->Initialize(trace_buffer_);
93
94
  // This thread should be created *after* async handles are created
95
  // (within NodeTraceWriter and NodeTraceBuffer constructors).
96
  // Otherwise the thread could shut down prematurely.
97
272
  CHECK_EQ(0, uv_thread_create(&thread_, [](void* arg) {
98
    Agent* agent = static_cast<Agent*>(arg);
99
    uv_run(&agent->tracing_loop_, UV_RUN_DEFAULT);
100
  }, this));
101
68
  started_ = true;
102
}
103
104
68
AgentWriterHandle Agent::AddClient(
105
    const std::set<std::string>& categories,
106
    std::unique_ptr<AsyncTraceWriter> writer,
107
    enum UseDefaultCategoryMode mode) {
108
68
  Start();
109
110
68
  const std::set<std::string>* use_categories = &categories;
111
112
68
  std::set<std::string> categories_with_default;
113
68
  if (mode == kUseDefaultCategories) {
114
66
    categories_with_default.insert(categories.begin(), categories.end());
115
132
    categories_with_default.insert(categories_[kDefaultHandleId].begin(),
116
198
                                   categories_[kDefaultHandleId].end());
117
66
    use_categories = &categories_with_default;
118
  }
119
120
136
  ScopedSuspendTracing suspend(tracing_controller_.get(), this);
121
68
  int id = next_writer_id_++;
122
68
  AsyncTraceWriter* raw = writer.get();
123
68
  writers_[id] = std::move(writer);
124
68
  categories_[id] = { use_categories->begin(), use_categories->end() };
125
126
  {
127
68
    Mutex::ScopedLock lock(initialize_writer_mutex_);
128
68
    to_be_initialized_.insert(raw);
129
68
    uv_async_send(&initialize_writer_async_);
130
204
    while (to_be_initialized_.count(raw) > 0)
131
136
      initialize_writer_condvar_.Wait(lock);
132
  }
133
134
136
  return AgentWriterHandle(this, id);
135
}
136
137
4203
AgentWriterHandle Agent::DefaultHandle() {
138
4203
  return AgentWriterHandle(this, kDefaultHandleId);
139
}
140
141
4269
void Agent::StopTracing() {
142
4269
  if (!started_)
143
8470
    return;
144
  // Perform final Flush on TraceBuffer. We don't want the tracing controller
145
  // to flush the buffer again on destruction of the V8::Platform.
146
68
  tracing_controller_->StopTracing();
147
68
  tracing_controller_->Initialize(nullptr);
148
68
  started_ = false;
149
150
  // Thread should finish when the tracing loop is stopped.
151
68
  uv_thread_join(&thread_);
152
}
153
154
4271
void Agent::Disconnect(int client) {
155
8542
  if (client == kDefaultHandleId) return;
156
  {
157
68
    Mutex::ScopedLock lock(initialize_writer_mutex_);
158
68
    to_be_initialized_.erase(writers_[client].get());
159
  }
160
68
  ScopedSuspendTracing suspend(tracing_controller_.get(), this);
161
68
  writers_.erase(client);
162
68
  categories_.erase(client);
163
}
164
165
16
void Agent::Enable(int id, const std::set<std::string>& categories) {
166
16
  if (categories.empty())
167
16
    return;
168
169
  ScopedSuspendTracing suspend(tracing_controller_.get(), this,
170
16
                               id != kDefaultHandleId);
171
16
  categories_[id].insert(categories.begin(), categories.end());
172
}
173
174
4
void Agent::Disable(int id, const std::set<std::string>& categories) {
175
  ScopedSuspendTracing suspend(tracing_controller_.get(), this,
176
4
                               id != kDefaultHandleId);
177
4
  std::multiset<std::string>& writer_categories = categories_[id];
178
8
  for (const std::string& category : categories) {
179
4
    auto it = writer_categories.find(category);
180
4
    if (it != writer_categories.end())
181
4
      writer_categories.erase(it);
182
4
  }
183
4
}
184
185
141
TraceConfig* Agent::CreateTraceConfig() const {
186
141
  if (categories_.empty())
187
2
    return nullptr;
188
139
  TraceConfig* trace_config = new TraceConfig();
189
222
  for (const auto& category : flatten(categories_)) {
190
83
    trace_config->AddIncludedCategory(category.c_str());
191
139
  }
192
139
  return trace_config;
193
}
194
195
12
std::string Agent::GetEnabledCategories() const {
196
12
  std::string categories;
197
22
  for (const std::string& category : flatten(categories_)) {
198
10
    if (!categories.empty())
199
1
      categories += ',';
200
10
    categories += category;
201
12
  }
202
12
  return categories;
203
}
204
205
5303
void Agent::AppendTraceEvent(TraceObject* trace_event) {
206
9416
  for (const auto& id_writer : writers_)
207
4113
    id_writer.second->AppendTraceEvent(trace_event);
208
5303
}
209
210
601
void Agent::AddMetadataEvent(std::unique_ptr<TraceObject> event) {
211
601
  Mutex::ScopedLock lock(metadata_events_mutex_);
212
603
  metadata_events_.push_back(std::move(event));
213
603
}
214
215
278
void Agent::Flush(bool blocking) {
216
  {
217
278
    Mutex::ScopedLock lock(metadata_events_mutex_);
218
2764
    for (const auto& event : metadata_events_)
219
2764
      AppendTraceEvent(event.get());
220
  }
221
222
424
  for (const auto& id_writer : writers_)
223
146
    id_writer.second->Flush(blocking);
224
278
}
225
226
598
void TracingController::AddMetadataEvent(
227
    const unsigned char* category_group_enabled,
228
    const char* name,
229
    int num_args,
230
    const char** arg_names,
231
    const unsigned char* arg_types,
232
    const uint64_t* arg_values,
233
    std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,
234
    unsigned int flags) {
235
598
  std::unique_ptr<TraceObject> trace_event(new TraceObject);
236
  trace_event->Initialize(
237
      TRACE_EVENT_PHASE_METADATA, category_group_enabled, name,
238
      node::tracing::kGlobalScope,  // scope
239
      node::tracing::kNoId,         // id
240
      node::tracing::kNoId,         // bind_id
241
      num_args, arg_names, arg_types, arg_values, convertable_values,
242
      TRACE_EVENT_FLAG_NONE,
243
601
      CurrentTimestampMicroseconds(),
244
1204
      CurrentCpuTimestampMicroseconds());
245
  node::tracing::TraceEventHelper::GetAgent()->AddMetadataEvent(
246
601
      std::move(trace_event));
247
603
}
248
249
}  // namespace tracing
250
}  // namespace node