iris/src/main.cpp

   1 #include <unistd.h>
   2
   3
   4 #include <cstdio>
   5 #include <chrono>
   6 #include <limits>
   7 #include <cmath>
   8
   9 #include <level_logger.h>
  10 #include <file_writer.h>
  11
  12 #include <map>
  13 #include <thread>
  14 #include <vector>
  15 /*
  16 using log_t = reckless::severity_log<
  17     reckless::indent<4>,       // 4 spaces of indent
  18     ' '                       // Field separator
  19     >;
  20 reckless::file_writer rwriter("log_reckless.txt");
  21 log_t r_log(&rwriter, 102400, 65534, 102400);
  22 */
  23
  24 iris::file_writer writer("./log.txt");
  25 iris::level_logger g_log(&writer, iris::INFO);
  26 int freq_map[50000000];
  27
  28 long long g_max_lat;
  29 long long g_min_lat;
  30 #define ITERATIONS 1e3
  31
  32 void worker_thread() {
  33     std::hash<std::thread::id> hasher;
  34     long long max_lat = std::numeric_limits<long long>::lowest(), min_lat = std::numeric_limits<long long>::max(), avg_lat = 0, sum = 0;
  35     size_t tid = hasher(std::this_thread::get_id());
  36     g_log.set_thread_queue_size(65534);
  37     g_log.set_thread_ringbuf_size(655340);
  38     auto start = std::chrono::high_resolution_clock::now();
  39     for (int i = 1; i <= ITERATIONS; ++i) {
  40         auto start = std::chrono::high_resolution_clock::now();
  41         g_log.info("hello %s, world %d, there %d, here %d, idx: %d", "dsads", 231, 0, 0, i);
  42         auto finish = std::chrono::high_resolution_clock::now();
  43         long long lat = std::chrono::duration_cast<std::chrono::nanoseconds>(finish-start).count();
  44         //sum += lat;
  45         max_lat = std::max(max_lat, lat);
  46         min_lat = std::min(min_lat, lat);
  47         g_max_lat = std::max(max_lat, g_max_lat);
  48         g_min_lat = std::min(min_lat, g_min_lat);
  49         //avg_lat = sum / i;
  50         if (lat < 50000000)
  51             freq_map[lat]++;
  52         //if (i % 10000 == 0)
  53         //    usleep(1000);
  54     }
  55     auto finish = std::chrono::high_resolution_clock::now();
  56     long long lat = std::chrono::duration_cast<std::chrono::nanoseconds>(finish-start).count();
  57     printf("thread_id: %lu max_lat: %lldns, min_lat: %lldns, avg_lat: %lldns, latency sum %lldns\n", tid, 0ll, min_lat, (long long)lat / (long long)ITERATIONS, lat);
  58 }
  59 int main(int argc, char const *argv[]) {
  60     g_max_lat = 0;
  61     g_min_lat = std::numeric_limits<int>::max();
  62     int n = 10;
  63     if (argc > 1) {
  64         n = std::stoi(argv[1]);
  65     }
  66     std::vector<std::thread> workers;
  67
  68     for (int i = 0; i < n; ++i) {
  69         workers.push_back(std::thread(worker_thread));
  70     }
  71     for (int i = 0; i < n; ++i) {
  72         workers[i].join();
  73     }
  74     printf("\nlatency,count\n");
  75     g_max_lat = std::min(50000000 - 1, (int)g_max_lat);
  76     for (int i = g_min_lat; i <= 400; ++i) {
  77         if (freq_map[i])
  78             printf("%d,%d\n", i, freq_map[i]);
  79     }
  80     //printf("\nno,latency\n");
  81     //for (size_t i = 0; i < lats.size(); ++i) {
  82     //    printf("%zu,%d\n", i + 1, lats[i]);
  83     //}
  84     //g_log.sync_and_close();
  85     return 0;
  86 }