GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage/nodes/benchmark/out/../src/tracing/agent.cc Lines: 128 128 100.0 %
Date: 2019-01-07 12:15:22 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
154
  ScopedSuspendTracing(TracingController* controller, Agent* agent,
15
                       bool do_suspend = true)
16
154
    : controller_(controller), agent_(do_suspend ? agent : nullptr) {
17
154
    if (do_suspend) {
18
139
      CHECK(agent_->started_);
19
139
      controller->StopTracing();
20
    }
21
154
  }
22
23
154
  ~ScopedSuspendTracing() {
24
169
    if (agent_ == nullptr) return;
25
139
    TraceConfig* config = agent_->CreateTraceConfig();
26
139
    if (config != nullptr) {
27
137
      controller_->StartTracing(config);
28
    }
29
293
  }
30
31
 private:
32
  TracingController* controller_;
33
  Agent* agent_;
34
};
35
36
namespace {
37
38
149
std::set<std::string> flatten(
39
    const std::unordered_map<int, std::multiset<std::string>>& map) {
40
149
  std::set<std::string> result;
41
371
  for (const auto& id_value : map)
42
222
    result.insert(id_value.second.begin(), id_value.second.end());
43
149
  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
3562
Agent::Agent() : tracing_controller_(new TracingController()) {
53
3562
  tracing_controller_->Initialize(nullptr);
54
55
3562
  CHECK_EQ(uv_loop_init(&tracing_loop_), 0);
56
7258
  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
3562
  uv_unref(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_));
63
3562
}
64
65
67
void Agent::InitializeWritersOnThread() {
66
67
  Mutex::ScopedLock lock(initialize_writer_mutex_);
67
201
  while (!to_be_initialized_.empty()) {
68
67
    AsyncTraceWriter* head = *to_be_initialized_.begin();
69
67
    head->InitializeOnThread(&tracing_loop_);
70
67
    to_be_initialized_.erase(head);
71
  }
72
67
  initialize_writer_condvar_.Broadcast(lock);
73
67
}
74
75
7122
Agent::~Agent() {
76
3561
  categories_.clear();
77
3561
  writers_.clear();
78
79
3561
  StopTracing();
80
81
3561
  uv_close(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_), nullptr);
82
3561
  uv_run(&tracing_loop_, UV_RUN_ONCE);
83
3561
  CheckedUvLoopClose(&tracing_loop_);
84
3561
}
85
86
67
void Agent::Start() {
87
67
  if (started_)
88
67
    return;
89
90
  NodeTraceBuffer* trace_buffer_ = new NodeTraceBuffer(
91
67
      NodeTraceBuffer::kBufferChunks, this, &tracing_loop_);
92
67
  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
268
  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
67
  started_ = true;
102
}
103
104
67
AgentWriterHandle Agent::AddClient(
105
    const std::set<std::string>& categories,
106
    std::unique_ptr<AsyncTraceWriter> writer,
107
    enum UseDefaultCategoryMode mode) {
108
67
  Start();
109
110
67
  const std::set<std::string>* use_categories = &categories;
111
112
67
  std::set<std::string> categories_with_default;
113
67
  if (mode == kUseDefaultCategories) {
114
65
    categories_with_default.insert(categories.begin(), categories.end());
115
130
    categories_with_default.insert(categories_[kDefaultHandleId].begin(),
116
195
                                   categories_[kDefaultHandleId].end());
117
65
    use_categories = &categories_with_default;
118
  }
119
120
134
  ScopedSuspendTracing suspend(tracing_controller_.get(), this);
121
67
  int id = next_writer_id_++;
122
67
  AsyncTraceWriter* raw = writer.get();
123
67
  writers_[id] = std::move(writer);
124
67
  categories_[id] = { use_categories->begin(), use_categories->end() };
125
126
  {
127
67
    Mutex::ScopedLock lock(initialize_writer_mutex_);
128
67
    to_be_initialized_.insert(raw);
129
67
    uv_async_send(&initialize_writer_async_);
130
201
    while (to_be_initialized_.count(raw) > 0)
131
134
      initialize_writer_condvar_.Wait(lock);
132
  }
133
134
134
  return AgentWriterHandle(this, id);
135
}
136
137
3493
AgentWriterHandle Agent::DefaultHandle() {
138
3493
  return AgentWriterHandle(this, kDefaultHandleId);
139
}
140
141
3561
void Agent::StopTracing() {
142
3561
  if (!started_)
143
7055
    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
67
  tracing_controller_->StopTracing();
147
67
  tracing_controller_->Initialize(nullptr);
148
67
  started_ = false;
149
150
  // Thread should finish when the tracing loop is stopped.
151
67
  uv_thread_join(&thread_);
152
}
153
154
3560
void Agent::Disconnect(int client) {
155
7120
  if (client == kDefaultHandleId) return;
156
  {
157
67
    Mutex::ScopedLock lock(initialize_writer_mutex_);
158
67
    to_be_initialized_.erase(writers_[client].get());
159
  }
160
67
  ScopedSuspendTracing suspend(tracing_controller_.get(), this);
161
67
  writers_.erase(client);
162
67
  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
139
TraceConfig* Agent::CreateTraceConfig() const {
186
139
  if (categories_.empty())
187
2
    return nullptr;
188
137
  TraceConfig* trace_config = new TraceConfig();
189
219
  for (const auto& category : flatten(categories_)) {
190
82
    trace_config->AddIncludedCategory(category.c_str());
191
137
  }
192
137
  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
4700
void Agent::AppendTraceEvent(TraceObject* trace_event) {
206
8242
  for (const auto& id_writer : writers_)
207
3542
    id_writer.second->AppendTraceEvent(trace_event);
208
4700
}
209
210
274
void Agent::Flush(bool blocking) {
211
2696
  for (const auto& event : metadata_events_)
212
2422
    AppendTraceEvent(event.get());
213
214
418
  for (const auto& id_writer : writers_)
215
144
    id_writer.second->Flush(blocking);
216
274
}
217
218
592
void TracingController::AddMetadataEvent(
219
    const unsigned char* category_group_enabled,
220
    const char* name,
221
    int num_args,
222
    const char** arg_names,
223
    const unsigned char* arg_types,
224
    const uint64_t* arg_values,
225
    std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,
226
    unsigned int flags) {
227
592
  std::unique_ptr<TraceObject> trace_event(new TraceObject);
228
  trace_event->Initialize(
229
      TRACE_EVENT_PHASE_METADATA, category_group_enabled, name,
230
      node::tracing::kGlobalScope,  // scope
231
      node::tracing::kNoId,         // id
232
      node::tracing::kNoId,         // bind_id
233
      num_args, arg_names, arg_types, arg_values, convertable_values,
234
      TRACE_EVENT_FLAG_NONE,
235
593
      CurrentTimestampMicroseconds(),
236
1187
      CurrentCpuTimestampMicroseconds());
237
  node::tracing::TraceEventHelper::GetAgent()->AddMetadataEvent(
238
592
      std::move(trace_event));
239
594
}
240
241
}  // namespace tracing
242
}  // namespace node