h2load: Avoid ev_now

src/h2load.cc

@@ -344,11 +344,13 @@ void rps_cb(struct ev_loop *loop, ev_timer *w, int revents) {
     return;
   }
 
-  auto now = ev_now(loop);
+  auto now = std::chrono::steady_clock::now();
   auto d = now - client->rps_duration_started;
-  auto n = static_cast<size_t>(round(d * config.rps));
+  auto n = static_cast<size_t>(
+      round(std::chrono::duration<double>(d).count() * config.rps));
   client->rps_req_pending += n;
-  client->rps_duration_started = now - d + static_cast<double>(n) / config.rps;
+  client->rps_duration_started +=
+      util::duration_from(static_cast<double>(n) / config.rps);
 
   if (client->rps_req_pending == 0) {
     return;
@@ -425,10 +427,10 @@ void client_request_timeout_cb(struct ev_loop *loop, ev_timer *w, int revents) {
     return;
   }
 
-  ev_tstamp duration =
+  auto duration =
       config.timings[client->reqidx] - config.timings[client->reqidx - 1];
 
-  while (duration < 1e-9) {
+  while (duration < std::chrono::duration<double>(1e-9)) {
     if (client->submit_request() != 0) {
       ev_timer_stop(client->worker->loop, w);
       client->process_request_failure();
@@ -443,7 +445,7 @@ void client_request_timeout_cb(struct ev_loop *loop, ev_timer *w, int revents) {
         config.timings[client->reqidx] - config.timings[client->reqidx - 1];
   }
 
-  client->request_timeout_watcher.repeat = duration;
+  client->request_timeout_watcher.repeat = util::ev_tstamp_from(duration);
   ev_timer_again(client->worker->loop, &client->request_timeout_watcher);
 }
 } // namespace
@@ -470,7 +472,6 @@ Client::Client(uint32_t id, Worker *worker, size_t req_todo)
       local_addr{},
       new_connection_requested(false),
       final(false),
-      rps_duration_started(0),
       rps_req_pending(0),
       rps_req_inflight(0) {
   if (req_todo == 0) { // this means infinite number of requests are to be made
@@ -1178,7 +1179,7 @@ int Client::connection_made() {
   if (config.rps_enabled()) {
     rps_watcher.repeat = std::max(0.01, 1. / config.rps);
     ev_timer_again(worker->loop, &rps_watcher);
-    rps_duration_started = ev_now(worker->loop);
+    rps_duration_started = std::chrono::steady_clock::now();
   }
 
   if (config.rps_enabled()) {
@@ -1202,9 +1203,9 @@ int Client::connection_made() {
     }
   } else {
 
-    ev_tstamp duration = config.timings[reqidx];
+    auto duration = config.timings[reqidx];
 
-    while (duration < 1e-9) {
+    while (duration < std::chrono::duration<double>(1e-9)) {
       if (submit_request() != 0) {
         process_request_failure();
         break;
@@ -1217,10 +1218,10 @@ int Client::connection_made() {
       }
     }
 
-    if (duration >= 1e-9) {
+    if (duration >= std::chrono::duration<double>(1e-9)) {
       // double check since we may have break due to reqidx wraps
       // around back to 0
-      request_timeout_watcher.repeat = duration;
+      request_timeout_watcher.repeat = util::ev_tstamp_from(duration);
       ev_timer_again(worker->loop, &request_timeout_watcher);
     }
   }
@@ -1971,9 +1972,10 @@ std::vector<std::string> read_uri_from_file(std::istream &infile) {
 } // namespace
 
 namespace {
-void read_script_from_file(std::istream &infile,
+void read_script_from_file(
-                           std::vector<ev_tstamp> &timings,
+    std::istream &infile,
-                           std::vector<std::string> &uris) {
+    std::vector<std::chrono::steady_clock::duration> &timings,
+    std::vector<std::string> &uris) {
   std::string script_line;
   int line_count = 0;
   while (std::getline(infile, script_line)) {
@@ -2006,7 +2008,9 @@ void read_script_from_file(std::istream &infile,
       exit(EXIT_FAILURE);
     }
 
-    timings.push_back(v / 1000.0);
+    timings.emplace_back(
+        std::chrono::duration_cast<std::chrono::steady_clock::duration>(
+            std::chrono::duration<double, std::milli>(v)));
     uris.push_back(script_line.substr(pos + 1, script_line.size()));
   }
 }

src/h2load.h

@@ -73,7 +73,7 @@ struct Worker;
 struct Config {
   std::vector<std::vector<nghttp2_nv>> nva;
   std::vector<std::string> h1reqs;
-  std::vector<ev_tstamp> timings;
+  std::vector<std::chrono::steady_clock::duration> timings;
   nghttp2::Headers custom_headers;
   std::string scheme;
   std::string host;
@@ -396,7 +396,7 @@ struct Client {
   ev_timer rps_watcher;
   // The timestamp that starts the period which contributes to the
   // next request generation.
-  ev_tstamp rps_duration_started;
+  std::chrono::steady_clock::time_point rps_duration_started;
   // The number of requests allowed by rps, but limited by stream
   // concurrency.
   size_t rps_req_pending;

src/util.h

@@ -47,6 +47,8 @@
 #include <map>
 #include <random>
 
+#include <ev.h>
+
 #include "url-parser/url_parser.h"
 
 #include "template.h"
@@ -695,6 +697,15 @@ template <typename Clock, typename Rep> Rep clock_precision() {
   return duration.count();
 }
 
+template <typename Duration = std::chrono::steady_clock::duration>
+Duration duration_from(ev_tstamp d) {
+  return std::chrono::duration_cast<Duration>(std::chrono::duration<double>(d));
+}
+
+template <typename Duration> ev_tstamp ev_tstamp_from(const Duration &d) {
+  return std::chrono::duration<double>(d).count();
+}
+
 int make_socket_closeonexec(int fd);
 int make_socket_nonblocking(int fd);
 int make_socket_nodelay(int fd);