Function TEST

test/concurrent/test_bounded_queue_press_mpmc.cpp:11–83

using ::babylon::ConcurrentBoundedQueue;

TEST(concurrent_bounded_queue, press_blocking_mpmc) {
  size_t batch_size = 10;
  size_t batch_concurrent = 32;
  size_t single_concurrent = 32;
  size_t times = 10;
  ConcurrentBoundedQueue<size_t> queue {batch_concurrent + single_concurrent};

  ::std::vector<::std::future<size_t>> push_futures;
  push_futures.reserve(batch_concurrent + single_concurrent);
  for (size_t i = 0; i < batch_concurrent; ++i) {
    push_futures.emplace_back(::std::async(::std::launch::async, [&] {
      ::std::mt19937 gen(::std::random_device {}());
      size_t sum = 0;
      size_t vec[batch_size];
      for (size_t j = 0; j < times; ++j) {
        size_t value = gen();
        ::std::fill_n(vec, batch_size, value);
        queue.push_n(vec, vec + batch_size);
        sum += value * batch_size;
      }
      return sum;
    }));
  }
  for (size_t i = 0; i < single_concurrent; ++i) {
    push_futures.emplace_back(::std::async(::std::launch::async, [&] {
      ::std::mt19937 gen(::std::random_device {}());
      size_t sum = 0;
      for (size_t j = 0; j < times; ++j) {
        size_t value = gen();
        queue.push(value);
        sum += value;
      }
      return sum;
    }));
  }

  ::std::vector<::std::future<size_t>> pop_futures;
  pop_futures.reserve(batch_concurrent + single_concurrent);
  for (size_t i = 0; i < batch_concurrent; ++i) {
    pop_futures.emplace_back(::std::async(::std::launch::async, [&] {
      size_t sum = 0;
      size_t vec[batch_size];
      for (size_t j = 0; j < times; ++j) {
        queue.pop_n(vec, vec + batch_size);
        for (size_t k = 0; k < batch_size; ++k) {
          sum += vec[k];
        }
      }
      return sum;
    }));
  }
  for (size_t i = 0; i < single_concurrent; ++i) {
    pop_futures.emplace_back(::std::async(::std::launch::async, [&] {
      size_t sum = 0;
      for (size_t j = 0; j < times; ++j) {
        size_t v = 0;
        queue.pop(v);
        sum += v;