void PrintResult()

in e2e-examples/gcs/benchmark/print_result.cc [96:173]

• 64 lines of code
• 7 McCabe index (conditional complexity)

void PrintResult(const RunnerWatcher& watcher) {
  auto operations = watcher.GetNonWarmupsOperations();
  if (operations.empty()) {
    return;
  }

  auto elapsed_time = absl::ToDoubleSeconds(watcher.GetNonWarmupsDuration());

  // Total throughput

  int64_t total_bytes = 0;
  for (auto& op : operations) {
    total_bytes += op.bytes;
  }
  std::cout
      << absl::StrFormat(
             "Elapsed: %.1fs Count: %d Bytes: %.1fMB Throughput: %.2fMB/s",
             elapsed_time, operations.size(), total_bytes / kMB,
             total_bytes / kMB / elapsed_time)
      << std::endl;

  // Resource usage

  struct rusage ru;
  if (getrusage(RUSAGE_SELF, &ru) == 0) {
    std::cout << "Resource [ ";
    std::cout << absl::StrFormat(
        "utime: %.1fs ",
        absl::ToDoubleSeconds(absl::DurationFromTimeval(ru.ru_utime)));
    std::cout << absl::StrFormat(
        "stime: %.1fs ",
        absl::ToDoubleSeconds(absl::DurationFromTimeval(ru.ru_stime)));
    std::cout << absl::StrFormat("maxrss: %.2fMB ", ru.ru_maxrss / 1024.0);
    std::cout << "]" << std::endl;
  }

  // Percentile for each file

  std::cout << std::endl << "Operation percentiles" << std::endl;
  std::vector<size_t> indexes = GetSortedOperationIndex(operations);
  for (auto p : kSevenPercentiles) {
    size_t index = indexes[size_t(p * indexes.size())];
    auto op = operations[index];
    auto sec = absl::ToDoubleSeconds(op.elapsed_time);
    std::cout << absl::StrFormat(
                     " [p%04.1f] Throughput: %.2fMB/s Time: %.1fs, Chunks: %d "
                     "Peer: %s",
                     p * 100, op.bytes / sec / kMB, sec, op.chunks.size(),
                     op.peer)
              << std::endl;
  }

  // Percentile for each peer

  std::cout << std::endl << "Peer percentiles" << std::endl;
  std::vector<PeerValue> peers = GetSortedPeers(operations);
  for (auto p : kSevenPercentiles) {
    const PeerValue& peer = peers[size_t(p * peers.size())];
    auto indexes = peer.indexes;
    // Sorted by throughput in an ascending order
    std::sort(indexes.begin(), indexes.end(),
              [&operations](size_t a, size_t b) {
                return operations[a].elapsed_time > operations[b].elapsed_time;
              });
    std::vector<double> subt;
    for (auto p2 : kSevenPercentiles) {
      size_t index = indexes[indexes.size() * p2];
      auto op = operations[index];
      subt.push_back(op.bytes / absl::ToDoubleSeconds(op.elapsed_time));
    }
    std::cout << absl::StrFormat(
                     " [p%04.1f] Throughput: %.2fMB/s (p01:%.1f p50:%.1f "
                     "p99:%.1f) Count: %d Peer: %s",
                     p * 100, peer.throughput / kMB, subt[0] / kMB,
                     subt[2] / kMB, subt[4] / kMB, peer.total_count, peer.peer)
              << std::endl;
  }
}