void WriteReport()

in e2e-examples/gcs/benchmark/print_result.cc [180:275]


void WriteReport(const RunnerWatcher& watcher, std::string report_file,
                 std::string tag) {
  auto operations = watcher.GetNonWarmupsOperations();
  if (operations.empty()) {
    return;
  }

  bool column_need = !FileExists(report_file);

  std::ofstream f;
  f.open(report_file, std::ios::out | std::ios::app);

  if (column_need) {
    //
    std::vector<std::string> c = {"Time",         "Tag",
                                  "Elapsed",      "Bytes",
                                  "Throughput",   "Success",
                                  "Failure",      "ChannelCount",
                                  "PeerCount",    "MaxChannelPerPeer",
                                  "File-P00.1-T", "File-P01-T",
                                  "File-P10-T",   "File-P50-T",
                                  "File-P90-T",   "File-P99-T",
                                  "File-P99.9-T", "Peer-P00.1-T",
                                  "Peer-P00.1-C", "Peer-P00.1-IP",
                                  "Peer-P01-T",   "Peer-P01-C",
                                  "Peer-P01-IP",  "Peer-P10-T",
                                  "Peer-P10-C",   "Peer-P10-IP",
                                  "Peer-P50-T",   "Peer-P50-C",
                                  "Peer-P50-IP",  "Peer-P90-T",
                                  "Peer-P90-C",   "Peer-P90-IP",
                                  "Peer-P99-T",   "Peer-P99-C",
                                  "Peer-P99-IP",  "Peer-P99.9-T",
                                  "Peer-P99.9-C", "Peer-P99.9-IP"};
    f << absl::StrJoin(c, "\t") << std::endl;
  }

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

  // Calculates stats

  int64_t total_bytes = 0;
  int32_t success_count = 0;
  int32_t failure_count = 0;
  std::unordered_set<int32_t> channel_id_set;
  std::unordered_map<std::string, std::unordered_set<int32_t>>
      peer_channel_ids_map;
  for (const auto& op : operations) {
    total_bytes += op.bytes;
    if (op.status.ok()) {
      success_count += 1;
    } else {
      failure_count += 1;
    }
    channel_id_set.insert(op.channel_id);
    peer_channel_ids_map[op.peer].insert(op.channel_id);
  }

  int32_t max_channel_per_peer = 0;
  for (const auto& i : peer_channel_ids_map) {
    max_channel_per_peer =
        std::max(max_channel_per_peer, (int32_t)i.second.size());
  }

  std::vector<std::string> v;
  v.push_back(FullFormatTime(watcher.GetStartTime()));
  v.push_back(tag);
  v.push_back(std::to_string(elapsed_time));
  v.push_back(std::to_string(total_bytes));
  v.push_back(std::to_string(total_bytes / elapsed_time));
  v.push_back(std::to_string(success_count));
  v.push_back(std::to_string(failure_count));
  v.push_back(std::to_string(channel_id_set.size()));
  v.push_back(std::to_string(peer_channel_ids_map.size()));
  v.push_back(std::to_string(max_channel_per_peer));

  // Percentile for each file
  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);
    v.push_back(std::to_string(op.bytes / sec));
  }

  // Percentile for each peer
  std::vector<PeerValue> peers = GetSortedPeers(operations);
  for (auto p : kSevenPercentiles) {
    const PeerValue& peer = peers[size_t(p * peers.size())];
    auto sec = absl::ToDoubleSeconds(peer.total_time);
    v.push_back(std::to_string(peer.total_size / sec));
    v.push_back(std::to_string(peer.total_count));
    v.push_back(peer.peer);
  }

  f << absl::StrJoin(v, "\t") << std::endl;
}