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: 130 137 94.9 %
Date: 2019-02-13 22:28:58 Branches: 33 60 55.0 %

Line Branch Exec Source
1
#include "tracing/node_trace_writer.h"
2
3
#include <string.h>
4
#include <fcntl.h>
5
6
#include "util-inl.h"
7
8
namespace node {
9
namespace tracing {
10
11
66
NodeTraceWriter::NodeTraceWriter(const std::string& log_file_pattern)
12
66
    : log_file_pattern_(log_file_pattern) {}
13
14
66
void NodeTraceWriter::InitializeOnThread(uv_loop_t* loop) {
15
66
  CHECK_NULL(tracing_loop_);
16
66
  tracing_loop_ = loop;
17
18
66
  flush_signal_.data = this;
19
  int err = uv_async_init(tracing_loop_, &flush_signal_,
20
482
                          [](uv_async_t* signal) {
21
    NodeTraceWriter* trace_writer =
22
208
        ContainerOf(&NodeTraceWriter::flush_signal_, signal);
23
208
    trace_writer->FlushPrivate();
24
548
  });
25
66
  CHECK_EQ(err, 0);
26
27
66
  exit_signal_.data = this;
28
66
  err = uv_async_init(tracing_loop_, &exit_signal_, ExitSignalCb);
29
66
  CHECK_EQ(err, 0);
30
66
}
31
32
66
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
66
  bool should_flush = false;
37
  {
38
66
    Mutex::ScopedLock scoped_lock(stream_mutex_);
39
66
    if (total_traces_ > 0) {
40
66
      total_traces_ = kTracesPerFile;  // Act as if we reached the file limit.
41
66
      should_flush = true;
42
66
    }
43
  }
44
66
  if (should_flush) {
45
66
    Flush(true);
46
  }
47
66
}
48
49
198
NodeTraceWriter::~NodeTraceWriter() {
50
66
  WriteSuffix();
51
  uv_fs_t req;
52
66
  if (fd_ != -1) {
53
66
    CHECK_EQ(0, uv_fs_close(nullptr, &req, fd_, nullptr));
54
66
    uv_fs_req_cleanup(&req);
55
  }
56
66
  uv_async_send(&exit_signal_);
57
66
  Mutex::ScopedLock scoped_lock(request_mutex_);
58
179
  while (!exited_) {
59
47
    exit_cond_.Wait(scoped_lock);
60
66
  }
61
132
}
62
63
132
void replace_substring(std::string* target,
64
                       const std::string& search,
65
                       const std::string& insert) {
66
132
  size_t pos = target->find(search);
67
201
  for (; pos != std::string::npos; pos = target->find(search, pos)) {
68
69
    target->replace(pos, search.size(), insert);
69
69
    pos += insert.size();
70
  }
71
132
}
72
73
66
void NodeTraceWriter::OpenNewFileForStreaming() {
74
66
  ++file_num_;
75
  uv_fs_t req;
76
77
  // Evaluate a JS-style template string, it accepts the values ${pid} and
78
  // ${rotation}
79
66
  std::string filepath(log_file_pattern_);
80
66
  replace_substring(&filepath, "${pid}", std::to_string(uv_os_getpid()));
81
66
  replace_substring(&filepath, "${rotation}", std::to_string(file_num_));
82
83
66
  if (fd_ != -1) {
84
    CHECK_EQ(uv_fs_close(nullptr, &req, fd_, nullptr), 0);
85
    uv_fs_req_cleanup(&req);
86
  }
87
88
  fd_ = uv_fs_open(nullptr, &req, filepath.c_str(),
89
66
      O_CREAT | O_WRONLY | O_TRUNC, 0644, nullptr);
90
66
  uv_fs_req_cleanup(&req);
91
66
  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
66
  }
97
66
}
98
99
3916
void NodeTraceWriter::AppendTraceEvent(TraceObject* trace_event) {
100
3916
  Mutex::ScopedLock scoped_lock(stream_mutex_);
101
  // If this is the first trace event, open a new file for streaming.
102
3916
  if (total_traces_ == 0) {
103
66
    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
66
    json_trace_writer_.reset(TraceWriter::CreateJSONTraceWriter(stream_));
111
  }
112
3916
  ++total_traces_;
113
3916
  json_trace_writer_->AppendTraceEvent(trace_event);
114
3916
}
115
116
208
void NodeTraceWriter::FlushPrivate() {
117
208
  std::string str;
118
  int highest_request_id;
119
  {
120
208
    Mutex::ScopedLock stream_scoped_lock(stream_mutex_);
121
208
    if (total_traces_ >= kTracesPerFile) {
122
66
      total_traces_ = 0;
123
      // Destroying the member JSONTraceWriter object appends "]}" to
124
      // stream_ - in other words, ending a JSON file.
125
66
      json_trace_writer_.reset();
126
    }
127
    // str() makes a copy of the contents of the stream.
128
208
    str = stream_.str();
129
208
    stream_.str("");
130
208
    stream_.clear();
131
  }
132
  {
133
208
    Mutex::ScopedLock request_scoped_lock(request_mutex_);
134
208
    highest_request_id = num_write_requests_;
135
  }
136
208
  WriteToFile(std::move(str), highest_request_id);
137
208
}
138
139
208
void NodeTraceWriter::Flush(bool blocking) {
140
208
  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
208
    Mutex::ScopedLock stream_mutex_lock(stream_mutex_);
146
208
    if (!json_trace_writer_)
147
208
      return;
148
  }
149
208
  int request_id = ++num_write_requests_;
150
208
  int err = uv_async_send(&flush_signal_);
151
208
  CHECK_EQ(err, 0);
152
208
  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

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

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

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