iris/tests/test_lfringbuffer.cpp

   1 #include <thread>
   2 #include <string>
   3 #include<cstring>
   4 #include <assert.h>
   5
   6 #include <lfringbuffer.h>
   7 #include <sslfqueue.h>
   8 #include <define.h>
   9
  10 #include <level_logger.h>
  11 #include <file_writer.h>
  12
  13 iris::file_writer writer("./log.txt");
  14 // this creates a logging thread
  15 iris::level_logger g_log(&writer, iris::TRACE);
  16
  17
  18 using namespace iris;
  19 #define ITERATIONS (int)1e7
  20 lfringbuffer rbuf(1024);
  21 struct buffer_t {
  22     char * b;
  23     int    size;
  24     int    alloc_size;
  25     int    data;
  26 };
  27 sslfqueue<buffer_t> q;
  28
  29 void recyle() {
  30     int i = 1;
  31     while (i <= ITERATIONS) {
  32         buffer_t b;
  33         while (!q.poll(b))
  34             std::this_thread::yield();
  35
  36         assert(std::stoi(std::string(b.b, b.b + b.size)) == b.data);
  37
  38         rbuf.release(b.alloc_size);
  39         ++i;
  40     }
  41 }
  42
  43 int main(int argc, char const *argv[]) {
  44
  45
  46     //configure thread level parameters, these should be done before any logging
  47     // queue size
  48     g_log.set_thread_queue_size(1024);
  49     // ring buffer size
  50     g_log.set_thread_ringbuf_size(20480);
  51
  52     g_log.info("Greetings from %s, bye %d\n", "iris", 0);
  53
  54     //this tells logging thread to persist the data into file and waits
  55     g_log.sync_and_close();
  56
  57     char *p1;
  58     char *p2;
  59     char *p3;
  60     assert(512 == rbuf.acquire(512, p1));
  61     assert(p1);
  62
  63     assert(256 == rbuf.acquire(256, p2));
  64     assert(p2);
  65
  66     assert(p2 - p1 == 512);
  67
  68     assert(0 == rbuf.acquire(512, p1));
  69
  70     assert(rbuf.freespace() == 256);
  71
  72     assert(0 == rbuf.acquire(512, p3));
  73
  74     rbuf.release(512);
  75
  76     assert(768 == rbuf.acquire(512, p3));
  77
  78     printf("rbuf.freespace(): %lu\n", rbuf.freespace());
  79     assert(rbuf.freespace() == 0);
  80
  81     rbuf.release(256);
  82     printf("rbuf.freespace(): %lu\n", rbuf.freespace());
  83     assert(256 == rbuf.freespace());
  84     rbuf.release(768);
  85     printf("rbuf.freespace(): %lu\n", rbuf.freespace());
  86     assert(1024 == rbuf.freespace());
  87
  88     std::thread recyler(recyle);
  89
  90     int i = 1;
  91     while (i <= ITERATIONS) {
  92         std::string s(std::to_string(i));
  93
  94         buffer_t b;
  95         char *ptr;
  96         int size;
  97         while (!(size = rbuf.acquire(s.size(), ptr)))
  98             std::this_thread::yield();
  99
 100         b.b = ptr;
 101         memcpy(b.b, s.c_str(), s.size());
 102         b.size = s.size();
 103         b.alloc_size = size;
 104         b.data = i;
 105
 106         while (!q.offer(b))
 107             std::this_thread::yield();
 108         ++i;
 109     }
 110
 111
 112
 113     recyler.join();
 114     printf("passed\n");
 115     return 0;
 116 }