GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/tracing/node_trace_buffer.cc Lines: 90 108 83.3 %
Date: 2019-07-27 22:37:30 Branches: 25 52 48.1 %

Line Branch Exec Source
1
#include "tracing/node_trace_buffer.h"
2
3
#include <memory>
4
#include "util-inl.h"
5
6
namespace node {
7
namespace tracing {
8
9
144
InternalTraceBuffer::InternalTraceBuffer(size_t max_chunks, uint32_t id,
10
                                         Agent* agent)
11
    : flushing_(false), max_chunks_(max_chunks),
12
144
      agent_(agent), id_(id) {
13
144
  chunks_.resize(max_chunks);
14
144
}
15
16
2005
TraceObject* InternalTraceBuffer::AddTraceEvent(uint64_t* handle) {
17
2005
  Mutex::ScopedLock scoped_lock(mutex_);
18
  // Create new chunk if last chunk is full or there is no chunk.
19

2005
  if (total_chunks_ == 0 || chunks_[total_chunks_ - 1]->IsFull()) {
20
86
    auto& chunk = chunks_[total_chunks_++];
21
86
    if (chunk) {
22
      chunk->Reset(current_chunk_seq_++);
23
    } else {
24
86
      chunk = std::make_unique<TraceBufferChunk>(current_chunk_seq_++);
25
    }
26
  }
27
2005
  auto& chunk = chunks_[total_chunks_ - 1];
28
  size_t event_index;
29
2005
  TraceObject* trace_object = chunk->AddTraceEvent(&event_index);
30
2005
  *handle = MakeHandle(total_chunks_ - 1, chunk->seq(), event_index);
31
2005
  return trace_object;
32
}
33
34
154
TraceObject* InternalTraceBuffer::GetEventByHandle(uint64_t handle) {
35
154
  Mutex::ScopedLock scoped_lock(mutex_);
36
154
  if (handle == 0) {
37
    // A handle value of zero never has a trace event associated with it.
38
    return nullptr;
39
  }
40
  size_t chunk_index, event_index;
41
  uint32_t buffer_id, chunk_seq;
42
154
  ExtractHandle(handle, &buffer_id, &chunk_index, &chunk_seq, &event_index);
43

154
  if (buffer_id != id_ || chunk_index >= total_chunks_) {
44
    // Either the chunk belongs to the other buffer, or is outside the current
45
    // range of chunks loaded in memory (the latter being true suggests that
46
    // the chunk has already been flushed and is no longer in memory.)
47
    return nullptr;
48
  }
49
154
  auto& chunk = chunks_[chunk_index];
50
154
  if (chunk->seq() != chunk_seq) {
51
    // Chunk is no longer in memory.
52
    return nullptr;
53
  }
54
154
  return chunk->GetEventAt(event_index);
55
}
56
57
336
void InternalTraceBuffer::Flush(bool blocking) {
58
  {
59
336
    Mutex::ScopedLock scoped_lock(mutex_);
60
336
    if (total_chunks_ > 0) {
61
66
      flushing_ = true;
62
152
      for (size_t i = 0; i < total_chunks_; ++i) {
63
86
        auto& chunk = chunks_[i];
64
2091
        for (size_t j = 0; j < chunk->size(); ++j) {
65
2005
          TraceObject* trace_event = chunk->GetEventAt(j);
66
          // Another thread may have added a trace that is yet to be
67
          // initialized. Skip such traces.
68
          // https://github.com/nodejs/node/issues/21038.
69
2005
          if (trace_event->name()) {
70
2005
            agent_->AppendTraceEvent(trace_event);
71
          }
72
        }
73
      }
74
66
      total_chunks_ = 0;
75
66
      flushing_ = false;
76
336
    }
77
  }
78
336
  agent_->Flush(blocking);
79
336
}
80
81
2005
uint64_t InternalTraceBuffer::MakeHandle(
82
    size_t chunk_index, uint32_t chunk_seq, size_t event_index) const {
83
4010
  return ((static_cast<uint64_t>(chunk_seq) * Capacity() +
84
4010
          chunk_index * TraceBufferChunk::kChunkSize + event_index) << 1) + id_;
85
}
86
87
154
void InternalTraceBuffer::ExtractHandle(
88
    uint64_t handle, uint32_t* buffer_id, size_t* chunk_index,
89
    uint32_t* chunk_seq, size_t* event_index) const {
90
154
  *buffer_id = static_cast<uint32_t>(handle & 0x1);
91
154
  handle >>= 1;
92
154
  *chunk_seq = static_cast<uint32_t>(handle / Capacity());
93
154
  size_t indices = handle % Capacity();
94
154
  *chunk_index = indices / TraceBufferChunk::kChunkSize;
95
154
  *event_index = indices % TraceBufferChunk::kChunkSize;
96
154
}
97
98
72
NodeTraceBuffer::NodeTraceBuffer(size_t max_chunks,
99
    Agent* agent, uv_loop_t* tracing_loop)
100
    : tracing_loop_(tracing_loop),
101
      buffer1_(max_chunks, 0, agent),
102
72
      buffer2_(max_chunks, 1, agent) {
103
72
  current_buf_.store(&buffer1_);
104
105
72
  flush_signal_.data = this;
106
  int err = uv_async_init(tracing_loop_, &flush_signal_,
107
72
                          NonBlockingFlushSignalCb);
108
72
  CHECK_EQ(err, 0);
109
110
72
  exit_signal_.data = this;
111
72
  err = uv_async_init(tracing_loop_, &exit_signal_, ExitSignalCb);
112
72
  CHECK_EQ(err, 0);
113
72
}
114
115
216
NodeTraceBuffer::~NodeTraceBuffer() {
116
72
  uv_async_send(&exit_signal_);
117
72
  Mutex::ScopedLock scoped_lock(exit_mutex_);
118
216
  while (!exited_) {
119
72
    exit_cond_.Wait(scoped_lock);
120
72
  }
121
144
}
122
123
2005
TraceObject* NodeTraceBuffer::AddTraceEvent(uint64_t* handle) {
124
  // If the buffer is full, attempt to perform a flush.
125
2005
  if (!TryLoadAvailableBuffer()) {
126
    // Assign a value of zero as the trace event handle.
127
    // This is equivalent to calling InternalTraceBuffer::MakeHandle(0, 0, 0),
128
    // and will cause GetEventByHandle to return NULL if passed as an argument.
129
    *handle = 0;
130
    return nullptr;
131
  }
132
2005
  return current_buf_.load()->AddTraceEvent(handle);
133
}
134
135
154
TraceObject* NodeTraceBuffer::GetEventByHandle(uint64_t handle) {
136
154
  return current_buf_.load()->GetEventByHandle(handle);
137
}
138
139
168
bool NodeTraceBuffer::Flush() {
140
168
  buffer1_.Flush(true);
141
168
  buffer2_.Flush(true);
142
168
  return true;
143
}
144
145
// Attempts to set current_buf_ such that it references a buffer that can
146
// write at least one trace event. If both buffers are unavailable this
147
// method returns false; otherwise it returns true.
148
2005
bool NodeTraceBuffer::TryLoadAvailableBuffer() {
149
2005
  InternalTraceBuffer* prev_buf = current_buf_.load();
150
2005
  if (prev_buf->IsFull()) {
151
    uv_async_send(&flush_signal_);  // trigger flush on a separate thread
152
    InternalTraceBuffer* other_buf = prev_buf == &buffer1_ ?
153
      &buffer2_ : &buffer1_;
154
    if (!other_buf->IsFull()) {
155
      current_buf_.store(other_buf);
156
    } else {
157
      return false;
158
    }
159
  }
160
2005
  return true;
161
}
162
163
// static
164
void NodeTraceBuffer::NonBlockingFlushSignalCb(uv_async_t* signal) {
165
  NodeTraceBuffer* buffer = static_cast<NodeTraceBuffer*>(signal->data);
166
  if (buffer->buffer1_.IsFull() && !buffer->buffer1_.IsFlushing()) {
167
    buffer->buffer1_.Flush(false);
168
  }
169
  if (buffer->buffer2_.IsFull() && !buffer->buffer2_.IsFlushing()) {
170
    buffer->buffer2_.Flush(false);
171
  }
172
}
173
174
// static
175
72
void NodeTraceBuffer::ExitSignalCb(uv_async_t* signal) {
176
  NodeTraceBuffer* buffer =
177
72
      ContainerOf(&NodeTraceBuffer::exit_signal_, signal);
178
179
  // Close both flush_signal_ and exit_signal_.
180
  uv_close(reinterpret_cast<uv_handle_t*>(&buffer->flush_signal_),
181
216
           [](uv_handle_t* signal) {
182
    NodeTraceBuffer* buffer =
183
        ContainerOf(&NodeTraceBuffer::flush_signal_,
184
72
                    reinterpret_cast<uv_async_t*>(signal));
185
186
    uv_close(reinterpret_cast<uv_handle_t*>(&buffer->exit_signal_),
187
216
             [](uv_handle_t* signal) {
188
      NodeTraceBuffer* buffer =
189
          ContainerOf(&NodeTraceBuffer::exit_signal_,
190
72
                      reinterpret_cast<uv_async_t*>(signal));
191
72
        Mutex::ScopedLock scoped_lock(buffer->exit_mutex_);
192
72
        buffer->exited_ = true;
193
72
        buffer->exit_cond_.Signal(scoped_lock);
194
288
    });
195
288
  });
196
72
}
197
198
}  // namespace tracing
199
}  // namespace node