tlbmc/hal/shared_mem/demo/shared_mem_metrics_server.cc

#include <chrono>      // NOLINT
#include <filesystem>  // NOLINT
#include <iostream>
#include <string>

#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "tlbmc/hal/shared_mem/client.h"
#include "tlbmc/hal/shared_mem/segment_manager.h"
#include "tlbmc/hal/shared_mem/server.h"
#include "bmcweb_authorizer_singleton.h"
#include "server.h"

ABSL_FLAG(int, iterations, 1000'000,
          "Number of iterations to update metrics. If -1, run forever.");
ABSL_FLAG(bool, unit_test, false, "Use shared memory for unit test.");

int main(int argc, char** argv) {
  absl::ParseCommandLine(argc, argv);
  boost::interprocess::shared_memory_object::remove("TlbmcSharedMemory");
  std::filesystem::remove(std::string{milotic_tlbmc::kShareMemInitializedFile});
  if (absl::GetFlag(FLAGS_unit_test)) {
    milotic_tlbmc::SharedMemoryServer::SetUpInstanceForUnitTest();
    milotic_tlbmc::SharedMemoryClient::SetUpInstanceForUnitTest();
  }
  std::cout << "SharedMemoryServer starts \n";
  milotic_tlbmc::SharedMemoryServer::Initialize();
  milotic::RedfishServiceConfig config;
  milotic::authz::BmcWebAuthorizerSingleton::Initialize(
      {
          .configuration_path = config.authz_config_path,
          .platform_configuration_path = config.authz_platform_config_path,
          .base_privileges_folder = config.rofs_base_privileges_folder,
          .pattern_entity_overrides_path =
              config.pattern_to_entity_overrides_path,
          .offline_node_entities_path = config.offline_node_entity_path,
          .google_machine_identity_path = config.gmi_file_path,
      },
      /*oauth_key_path=*/config.oauth_key_path);

  std::chrono::high_resolution_clock::time_point start =
      std::chrono::high_resolution_clock::now();
  const int iterations = absl::GetFlag(FLAGS_iterations);
  if (iterations == -1) {
    while (true) {
      milotic_tlbmc::SharedMemoryServer::GetInstance()
          .UpdateMetricsRequestCount(true);
      absl::SleepFor(absl::Seconds(1));
    }
    return 0;
  }
  for (int i = 0; i < iterations; ++i) {
    milotic_tlbmc::SharedMemoryServer::GetInstance().UpdateMetricsRequestCount(
        true);
  }
  std::chrono::high_resolution_clock::time_point end =
      std::chrono::high_resolution_clock::now();
  std::cout << "latency ns of one UpdateMetricsRequestCount :"
            << static_cast<double>(
                   std::chrono::duration_cast<std::chrono::nanoseconds>(end -
                                                                        start)
                       .count()) /
                   iterations
            << "\n";
  start = std::chrono::high_resolution_clock::now();
  for (int i = 0; i < iterations; ++i) {
    milotic_tlbmc::SharedMemoryServer::GetInstance().UpdateMetricsResponse(
        absl::Milliseconds(i), 200, "test_resource_url");
  }
  end = std::chrono::high_resolution_clock::now();
  std::cout << "latency ns of one UpdateMetricsResponse :"
            << static_cast<double>(
                   std::chrono::duration_cast<std::chrono::nanoseconds>(end -
                                                                        start)
                       .count()) /
                   iterations
            << "\n";
  std::cout << "Metrics is "
            << milotic_tlbmc::SharedMemoryClient::GetInstance()
                   .GetMetrics()
                   ->ToJson()
                   .dump(2)
            << "\n";
  return 0;
}