threads_eventcount.cpp File Reference

#include "main.h"
#include <Eigen/ThreadPool>

Classes
struct	TestQueue

Macros
#define	EIGEN_USE_THREADS

Functions
int	rand_reentrant (unsigned int *s)
static void	test_basic_eventcount ()
static void	test_stress_eventcount ()
	EIGEN_DECLARE_TEST (cxx11_eventcount)

Macro Definition Documentation

EIGEN_USE_THREADS

#define EIGEN_USE_THREADS

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

cxx11_eventcount

)

                                     {
  CALL_SUBTEST(test_basic_eventcount());
  CALL_SUBTEST(test_stress_eventcount());
}

References CALL_SUBTEST, test_basic_eventcount(), and test_stress_eventcount().

rand_reentrant()

int rand_reentrant

(

unsigned int *

s

)

                                    {
#if EIGEN_COMP_MSVC_STRICT
  EIGEN_UNUSED_VARIABLE(s);
  return rand();
#else
  return rand_r(s);
#endif
}

References EIGEN_UNUSED_VARIABLE, and s.

Referenced by test_stress_eventcount().

test_basic_eventcount()

static void test_basic_eventcount ( )

static

                                    {
  MaxSizeVector<EventCount::Waiter> waiters(1);
  waiters.resize(1);
  EventCount ec(waiters);
  EventCount::Waiter& w = waiters[0];
  ec.Notify(false);
  ec.Prewait();
  ec.Notify(true);
  ec.CommitWait(&w);
  ec.Prewait();
  ec.CancelWait();
}

References Eigen::EventCount::CancelWait(), Eigen::EventCount::CommitWait(), Eigen::EventCount::Notify(), Eigen::EventCount::Prewait(), Eigen::MaxSizeVector< T >::resize(), and w.

Referenced by EIGEN_DECLARE_TEST().

test_stress_eventcount()

static void test_stress_eventcount ( )

static

                                     {
  const int kThreads = std::thread::hardware_concurrency();
  static const int kEvents = 1 << 16;
  static const int kQueues = 10;
 
  MaxSizeVector<EventCount::Waiter> waiters(kThreads);
  waiters.resize(kThreads);
  EventCount ec(waiters);
  TestQueue queues[kQueues];
 
  std::vector<std::unique_ptr<std::thread>> producers;
  for (int i = 0; i < kThreads; i++) {
    producers.emplace_back(new std::thread([&ec, &queues]() {
      unsigned int rnd = static_cast<unsigned int>(std::hash<std::thread::id>()(std::this_thread::get_id()));
      for (int j = 0; j < kEvents; j++) {
        unsigned idx = rand_reentrant(&rnd) % kQueues;
        if (queues[idx].Push()) {
          ec.Notify(false);
          continue;
        }
        EIGEN_THREAD_YIELD();
        j--;
      }
    }));
  }
 
  std::vector<std::unique_ptr<std::thread>> consumers;
  for (int i = 0; i < kThreads; i++) {
    consumers.emplace_back(new std::thread([&ec, &queues, &waiters, i]() {
      EventCount::Waiter& w = waiters[i];
      unsigned int rnd = static_cast<unsigned int>(std::hash<std::thread::id>()(std::this_thread::get_id()));
      for (int j = 0; j < kEvents; j++) {
        unsigned idx = rand_reentrant(&rnd) % kQueues;
        if (queues[idx].Pop()) continue;
        j--;
        ec.Prewait();
        bool empty = true;
        for (int q = 0; q < kQueues; q++) {
          if (!queues[q].Empty()) {
            empty = false;
            break;
          }
        }
        if (!empty) {
          ec.CancelWait();
          continue;
        }
        ec.CommitWait(&w);
      }
    }));
  }
 
  for (int i = 0; i < kThreads; i++) {
    producers[i]->join();
    consumers[i]->join();
  }
}

References Eigen::EventCount::CancelWait(), Eigen::EventCount::CommitWait(), EIGEN_THREAD_YIELD, internal::Colamd::Empty, i, j, Eigen::EventCount::Notify(), Eigen::EventCount::Prewait(), Eigen::numext::q, rand_reentrant(), Eigen::MaxSizeVector< T >::resize(), and w.

Referenced by EIGEN_DECLARE_TEST().