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: 95 113 84.1 %
Date: 2021-04-26 04:12:24 Branches: 24 50 48.0 %

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
112
InternalTraceBuffer::InternalTraceBuffer(size_t max_chunks, uint32_t id,
10
112
                                         Agent* agent)
11
    : flushing_(false), max_chunks_(max_chunks),
12
112
      agent_(agent), id_(id) {
13
112
  chunks_.resize(max_chunks);
14
112
}
15
16
1799
TraceObject* InternalTraceBuffer::AddTraceEvent(uint64_t* handle) {
17
3598
  Mutex::ScopedLock scoped_lock(mutex_);
18
  // Create new chunk if last chunk is full or there is no chunk.
19

1799
  if (total_chunks_ == 0 || chunks_[total_chunks_ - 1]->IsFull()) {
20
68
    auto& chunk = chunks_[total_chunks_++];
21
68
    if (chunk) {
22
      chunk->Reset(current_chunk_seq_++);
23
    } else {
24
68
      chunk = std::make_unique<TraceBufferChunk>(current_chunk_seq_++);
25
    }
26
  }
27
1799
  auto& chunk = chunks_[total_chunks_ - 1];
28
  size_t event_index;
29
1799
  TraceObject* trace_object = chunk->AddTraceEvent(&event_index);
30
1799
  *handle = MakeHandle(total_chunks_ - 1, chunk->seq(), event_index);
31
3598
  return trace_object;
32
}
33
34
61
TraceObject* InternalTraceBuffer::GetEventByHandle(uint64_t handle) {
35
122
  Mutex::ScopedLock scoped_lock(mutex_);
36
61
  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
61
  ExtractHandle(handle, &buffer_id, &chunk_index, &chunk_seq, &event_index);
43

61
  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
61
  auto& chunk = chunks_[chunk_index];
50
61
  if (chunk->seq() != chunk_seq) {
51
    // Chunk is no longer in memory.
52
    return nullptr;
53
  }
54
61
  return chunk->GetEventAt(event_index);
55
}
56
57
272
void InternalTraceBuffer::Flush(bool blocking) {
58
  {
59
544
    Mutex::ScopedLock scoped_lock(mutex_);
60
272
    if (total_chunks_ > 0) {
61
50
      flushing_ = true;
62
118
      for (size_t i = 0; i < total_chunks_; ++i) {
63
68
        auto& chunk = chunks_[i];
64
1867
        for (size_t j = 0; j < chunk->size(); ++j) {
65
1799
          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
1799
          if (trace_event->name()) {
70
1799
            agent_->AppendTraceEvent(trace_event);
71
          }
72
        }
73
      }
74
50
      total_chunks_ = 0;
75
50
      flushing_ = false;
76
    }
77
  }
78
272
  agent_->Flush(blocking);
79
272
}
80
81
1799
uint64_t InternalTraceBuffer::MakeHandle(
82
    size_t chunk_index, uint32_t chunk_seq, size_t event_index) const {
83
3598
  return ((static_cast<uint64_t>(chunk_seq) * Capacity() +
84
3598
          chunk_index * TraceBufferChunk::kChunkSize + event_index) << 1) + id_;
85
}
86
87
61
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
61
  *buffer_id = static_cast<uint32_t>(handle & 0x1);
91
61
  handle >>= 1;
92
61
  *chunk_seq = static_cast<uint32_t>(handle / Capacity());
93
61
  size_t indices = handle % Capacity();
94
61
  *chunk_index = indices / TraceBufferChunk::kChunkSize;
95
61
  *event_index = indices % TraceBufferChunk::kChunkSize;
96
61
}
97
98
56
NodeTraceBuffer::NodeTraceBuffer(size_t max_chunks,
99
56
    Agent* agent, uv_loop_t* tracing_loop)
100
    : tracing_loop_(tracing_loop),
101
      buffer1_(max_chunks, 0, agent),
102
56
      buffer2_(max_chunks, 1, agent) {
103
56
  current_buf_.store(&buffer1_);
104
105
56
  flush_signal_.data = this;
106
56
  int err = uv_async_init(tracing_loop_, &flush_signal_,
107
56
                          NonBlockingFlushSignalCb);
108
56
  CHECK_EQ(err, 0);
109
110
56
  exit_signal_.data = this;
111
56
  err = uv_async_init(tracing_loop_, &exit_signal_, ExitSignalCb);
112
56
  CHECK_EQ(err, 0);
113
56
}
114
115
168
NodeTraceBuffer::~NodeTraceBuffer() {
116
56
  uv_async_send(&exit_signal_);
117
112
  Mutex::ScopedLock scoped_lock(exit_mutex_);
118
168
  while (!exited_) {
119
56
    exit_cond_.Wait(scoped_lock);
120
  }
121
112
}
122
123
1799
TraceObject* NodeTraceBuffer::AddTraceEvent(uint64_t* handle) {
124
  // If the buffer is full, attempt to perform a flush.
125
1799
  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
1799
  return current_buf_.load()->AddTraceEvent(handle);
133
}
134
135
61
TraceObject* NodeTraceBuffer::GetEventByHandle(uint64_t handle) {
136
61
  return current_buf_.load()->GetEventByHandle(handle);
137
}
138
139
136
bool NodeTraceBuffer::Flush() {
140
136
  buffer1_.Flush(true);
141
136
  buffer2_.Flush(true);
142
136
  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
1799
bool NodeTraceBuffer::TryLoadAvailableBuffer() {
149
1799
  InternalTraceBuffer* prev_buf = current_buf_.load();
150
1799
  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
1799
  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
56
void NodeTraceBuffer::ExitSignalCb(uv_async_t* signal) {
176
  NodeTraceBuffer* buffer =
177
56
      ContainerOf(&NodeTraceBuffer::exit_signal_, signal);
178
179
  // Close both flush_signal_ and exit_signal_.
180
112
  uv_close(reinterpret_cast<uv_handle_t*>(&buffer->flush_signal_),
181
168
           [](uv_handle_t* signal) {
182
    NodeTraceBuffer* buffer =
183
112
        ContainerOf(&NodeTraceBuffer::flush_signal_,
184
56
                    reinterpret_cast<uv_async_t*>(signal));
185
186
112
    uv_close(reinterpret_cast<uv_handle_t*>(&buffer->exit_signal_),
187
168
             [](uv_handle_t* signal) {
188
      NodeTraceBuffer* buffer =
189
112
          ContainerOf(&NodeTraceBuffer::exit_signal_,
190
56
                      reinterpret_cast<uv_async_t*>(signal));
191
112
        Mutex::ScopedLock scoped_lock(buffer->exit_mutex_);
192
56
        buffer->exited_ = true;
193
56
        buffer->exit_cond_.Signal(scoped_lock);
194
224
    });
195
224
  });
196
56
}
197
198
}  // namespace tracing
199
}  // namespace node