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_writer.cc Lines: 131 140 93.6 %
Date: 2020-05-27 22:15:15 Branches: 32 58 55.2 %

Line Branch Exec Source
1
#include "tracing/node_trace_writer.h"
2
3
#include "util-inl.h"
4
5
#include <fcntl.h>
6
#include <cstring>
7
8
namespace node {
9
namespace tracing {
10
11
55
NodeTraceWriter::NodeTraceWriter(const std::string& log_file_pattern)
12
55
    : log_file_pattern_(log_file_pattern) {}
13
14
55
void NodeTraceWriter::InitializeOnThread(uv_loop_t* loop) {
15
55
  CHECK_NULL(tracing_loop_);
16
55
  tracing_loop_ = loop;
17
18
55
  flush_signal_.data = this;
19
110
  int err = uv_async_init(tracing_loop_, &flush_signal_,
20
489
                          [](uv_async_t* signal) {
21
    NodeTraceWriter* trace_writer =
22
217
        ContainerOf(&NodeTraceWriter::flush_signal_, signal);
23
217
    trace_writer->FlushPrivate();
24
544
  });
25
55
  CHECK_EQ(err, 0);
26
27
55
  exit_signal_.data = this;
28
55
  err = uv_async_init(tracing_loop_, &exit_signal_, ExitSignalCb);
29
55
  CHECK_EQ(err, 0);
30
55
}
31
32
55
void NodeTraceWriter::WriteSuffix() {
33
  // If our final log file has traces, then end the file appropriately.
34
  // This means that if no trace events are recorded, then no trace file is
35
  // produced.
36
55
  bool should_flush = false;
37
  {
38
110
    Mutex::ScopedLock scoped_lock(stream_mutex_);
39
55
    if (total_traces_ > 0) {
40
55
      total_traces_ = kTracesPerFile;  // Act as if we reached the file limit.
41
55
      should_flush = true;
42
    }
43
  }
44
55
  if (should_flush) {
45
55
    Flush(true);
46
  }
47
55
}
48
49
165
NodeTraceWriter::~NodeTraceWriter() {
50
55
  WriteSuffix();
51
  uv_fs_t req;
52
55
  if (fd_ != -1) {
53
55
    CHECK_EQ(0, uv_fs_close(nullptr, &req, fd_, nullptr));
54
55
    uv_fs_req_cleanup(&req);
55
  }
56
55
  uv_async_send(&exit_signal_);
57
110
  Mutex::ScopedLock scoped_lock(request_mutex_);
58
165
  while (!exited_) {
59
55
    exit_cond_.Wait(scoped_lock);
60
  }
61
110
}
62
63
110
void replace_substring(std::string* target,
64
                       const std::string& search,
65
                       const std::string& insert) {
66
110
  size_t pos = target->find(search);
67
226
  for (; pos != std::string::npos; pos = target->find(search, pos)) {
68
58
    target->replace(pos, search.size(), insert);
69
58
    pos += insert.size();
70
  }
71
110
}
72
73
55
void NodeTraceWriter::OpenNewFileForStreaming() {
74
55
  ++file_num_;
75
  uv_fs_t req;
76
77
  // Evaluate a JS-style template string, it accepts the values ${pid} and
78
  // ${rotation}
79
110
  std::string filepath(log_file_pattern_);
80
55
  replace_substring(&filepath, "${pid}", std::to_string(uv_os_getpid()));
81
55
  replace_substring(&filepath, "${rotation}", std::to_string(file_num_));
82
83
55
  if (fd_ != -1) {
84
    CHECK_EQ(uv_fs_close(nullptr, &req, fd_, nullptr), 0);
85
    uv_fs_req_cleanup(&req);
86
  }
87
88
55
  fd_ = uv_fs_open(nullptr, &req, filepath.c_str(),
89
      O_CREAT | O_WRONLY | O_TRUNC, 0644, nullptr);
90
55
  uv_fs_req_cleanup(&req);
91
55
  if (fd_ < 0) {
92
    fprintf(stderr, "Could not open trace file %s: %s\n",
93
                    filepath.c_str(),
94
                    uv_strerror(fd_));
95
    fd_ = -1;
96
  }
97
55
}
98
99
3878
void NodeTraceWriter::AppendTraceEvent(TraceObject* trace_event) {
100
7756
  Mutex::ScopedLock scoped_lock(stream_mutex_);
101
  // If this is the first trace event, open a new file for streaming.
102
3878
  if (total_traces_ == 0) {
103
55
    OpenNewFileForStreaming();
104
    // Constructing a new JSONTraceWriter object appends "{\"traceEvents\":["
105
    // to stream_.
106
    // In other words, the constructor initializes the serialization stream
107
    // to a state where we can start writing trace events to it.
108
    // Repeatedly constructing and destroying json_trace_writer_ allows
109
    // us to use V8's JSON writer instead of implementing our own.
110
55
    json_trace_writer_.reset(TraceWriter::CreateJSONTraceWriter(stream_));
111
  }
112
3878
  ++total_traces_;
113
3878
  json_trace_writer_->AppendTraceEvent(trace_event);
114
3878
}
115
116
217
void NodeTraceWriter::FlushPrivate() {
117
434
  std::string str;
118
  int highest_request_id;
119
  {
120
434
    Mutex::ScopedLock stream_scoped_lock(stream_mutex_);
121
217
    if (total_traces_ >= kTracesPerFile) {
122
55
      total_traces_ = 0;
123
      // Destroying the member JSONTraceWriter object appends "]}" to
124
      // stream_ - in other words, ending a JSON file.
125
55
      json_trace_writer_.reset();
126
    }
127
    // str() makes a copy of the contents of the stream.
128
217
    str = stream_.str();
129
217
    stream_.str("");
130
217
    stream_.clear();
131
  }
132
  {
133
434
    Mutex::ScopedLock request_scoped_lock(request_mutex_);
134
217
    highest_request_id = num_write_requests_;
135
  }
136
217
  WriteToFile(std::move(str), highest_request_id);
137
217
}
138
139
217
void NodeTraceWriter::Flush(bool blocking) {
140
434
  Mutex::ScopedLock scoped_lock(request_mutex_);
141
  {
142
    // We need to lock the mutexes here in a nested fashion; stream_mutex_
143
    // protects json_trace_writer_, and without request_mutex_ there might be
144
    // a time window in which the stream state changes?
145
434
    Mutex::ScopedLock stream_mutex_lock(stream_mutex_);
146
217
    if (!json_trace_writer_)
147
      return;
148
  }
149
217
  int request_id = ++num_write_requests_;
150
217
  int err = uv_async_send(&flush_signal_);
151
217
  CHECK_EQ(err, 0);
152
217
  if (blocking) {
153
    // Wait until data associated with this request id has been written to disk.
154
    // This guarantees that data from all earlier requests have also been
155
    // written.
156

651
    while (request_id > highest_request_id_completed_) {
157
217
      request_cond_.Wait(scoped_lock);
158
    }
159
  }
160
}
161
162
217
void NodeTraceWriter::WriteToFile(std::string&& str, int highest_request_id) {
163
217
  if (fd_ == -1) return;
164
165
217
  uv_buf_t buf = uv_buf_init(nullptr, 0);
166
  {
167
434
    Mutex::ScopedLock lock(request_mutex_);
168
434
    write_req_queue_.emplace(WriteRequest {
169
217
      std::move(str), highest_request_id
170
217
    });
171
217
    if (write_req_queue_.size() == 1) {
172
      buf = uv_buf_init(
173
217
          const_cast<char*>(write_req_queue_.front().str.c_str()),
174
434
          write_req_queue_.front().str.length());
175
    }
176
  }
177
  // Only one write request for the same file descriptor should be active at
178
  // a time.
179

217
  if (buf.base != nullptr && fd_ != -1) {
180
217
    StartWrite(buf);
181
  }
182
}
183
184
217
void NodeTraceWriter::StartWrite(uv_buf_t buf) {
185
434
  int err = uv_fs_write(
186
      tracing_loop_, &write_req_, fd_, &buf, 1, -1,
187
651
      [](uv_fs_t* req) {
188
        NodeTraceWriter* writer =
189
217
            ContainerOf(&NodeTraceWriter::write_req_, req);
190
217
        writer->AfterWrite();
191
868
      });
192
217
  CHECK_EQ(err, 0);
193
217
}
194
195
217
void NodeTraceWriter::AfterWrite() {
196
217
  CHECK_GE(write_req_.result, 0);
197
217
  uv_fs_req_cleanup(&write_req_);
198
199
217
  uv_buf_t buf = uv_buf_init(nullptr, 0);
200
  {
201
434
    Mutex::ScopedLock scoped_lock(request_mutex_);
202
217
    int highest_request_id = write_req_queue_.front().highest_request_id;
203
217
    write_req_queue_.pop();
204
217
    highest_request_id_completed_ = highest_request_id;
205
217
    request_cond_.Broadcast(scoped_lock);
206
217
    if (!write_req_queue_.empty()) {
207
      buf = uv_buf_init(
208
          const_cast<char*>(write_req_queue_.front().str.c_str()),
209
          write_req_queue_.front().str.length());
210
    }
211
  }
212

217
  if (buf.base != nullptr && fd_ != -1) {
213
    StartWrite(buf);
214
  }
215
217
}
216
217
// static
218
55
void NodeTraceWriter::ExitSignalCb(uv_async_t* signal) {
219
  NodeTraceWriter* trace_writer =
220
55
      ContainerOf(&NodeTraceWriter::exit_signal_, signal);
221
  // Close both flush_signal_ and exit_signal_.
222
110
  uv_close(reinterpret_cast<uv_handle_t*>(&trace_writer->flush_signal_),
223
165
           [](uv_handle_t* signal) {
224
             NodeTraceWriter* trace_writer =
225
110
                 ContainerOf(&NodeTraceWriter::flush_signal_,
226
55
                             reinterpret_cast<uv_async_t*>(signal));
227
110
             uv_close(
228
55
                 reinterpret_cast<uv_handle_t*>(&trace_writer->exit_signal_),
229
165
                 [](uv_handle_t* signal) {
230
                   NodeTraceWriter* trace_writer =
231
110
                       ContainerOf(&NodeTraceWriter::exit_signal_,
232
55
                                   reinterpret_cast<uv_async_t*>(signal));
233
110
                   Mutex::ScopedLock scoped_lock(trace_writer->request_mutex_);
234
55
                   trace_writer->exited_ = true;
235
55
                   trace_writer->exit_cond_.Signal(scoped_lock);
236
220
                 });
237
220
           });
238
55
}
239
}  // namespace tracing
240
}  // namespace node