threadpool-tests.cc File Reference

#include <scroom/threadpool.hh>
#include <memory>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread.hpp>
#include <boost/thread/future.hpp>
#include <gtest/gtest.h>
#include <scroom/function-additor.hh>
#include <scroom/semaphore.hh>
#include "helpers.hh"

Include dependency graph for threadpool-tests.cc:

Classes
class	A
class	B< R >

Functions
const millisec	short_timeout (250)
const millisec	long_timeout (2000)
template<typename R >
R	no_op (Semaphore *s, R result)
bool	has_at_least_n_threads (ThreadPool *pool, int count_)
bool	has_exactly_n_threads (ThreadPool *pool, int count)
pool	schedule (clear(&s))
	EXPECT_FALSE (s.P(long_timeout))
pool	add ()
	EXPECT_TRUE (s.P(long_timeout))
pool	schedule (clear(&low), PRIO_NORMAL)
pool	schedule (pass(&low)+clear(&high), PRIO_HIGH)
	EXPECT_FALSE (high.P(short_timeout))
	EXPECT_TRUE (high.P(long_timeout))
	EXPECT_TRUE (has_exactly_n_threads(&pool, 0))
pool	schedule (A::create(&a))
	EXPECT_TRUE (a.P(long_timeout))
boost::unique_future< int >	result (pool.schedule< int >([pa=&a] { return no_op(pa, 42);}))
	EXPECT_FALSE (a.P(short_timeout))
	EXPECT_FALSE (result.is_ready())
	EXPECT_EQ (42, result.get())
boost::unique_future< bool >	result (pool.schedule< bool, B< bool > >(B< bool >::create(&a, false)))
	EXPECT_EQ (false, result.get())
	EXPECT_TRUE (has_exactly_n_threads(t.get(), expected))
	EXPECT_TRUE (has_exactly_n_threads(t.get(), 1))

Variables
ThreadPool	pool (0)
Semaphore	low (0)
const int	expected = 2
Semaphore	a (0)

Function Documentation

add()

pool add

(

)

EXPECT_EQ() [1/2]

EXPECT_EQ	(	42	,
		result.	get()
	)

EXPECT_EQ() [2/2]

EXPECT_EQ	(	false	,
		result.	get()
	)

EXPECT_FALSE() [1/4]

EXPECT_FALSE

(

a.

Pshort_timeout

)

EXPECT_FALSE() [2/4]

EXPECT_FALSE

(

high.

Pshort_timeout

)

EXPECT_FALSE() [3/4]

EXPECT_FALSE

(

result.

is_ready()

)

EXPECT_FALSE() [4/4]

EXPECT_FALSE

(

s.

Plong_timeout

)

EXPECT_TRUE() [1/6]

EXPECT_TRUE

(

a.

Plong_timeout

)

EXPECT_TRUE() [2/6]

EXPECT_TRUE

(

has_exactly_n_threads &,

0pool

)

Initial value:

{
  ThreadPool pool(1)

EXPECT_TRUE() [3/6]

EXPECT_TRUE

(

has_exactly_n_threads(t.get(), 1)

)

EXPECT_TRUE() [4/6]

EXPECT_TRUE

(

has_exactly_n_threads(t.get(), expected)

)

EXPECT_TRUE() [5/6]

EXPECT_TRUE

(

high.

Plong_timeout

)

EXPECT_TRUE() [6/6]

EXPECT_TRUE

(

s.

Plong_timeout

)

has_at_least_n_threads()

bool has_at_least_n_threads	(	ThreadPool *	pool,
		int	count_
	)

{
  if(count_ <= 0)
  {
    return true;
  }
 
  std::vector<Semaphore*> semaphores(count_);
  for(int i = 0; i < count_; i++)
  {
    semaphores[i] = new Semaphore(0);
  }
 
  for(int i = 0; i < count_ - 1; i++)
  {
    pool->schedule(pass(semaphores[i + 1]) + clear(semaphores[i]));
  }
 
  // All tasks are blocked on semaphores[count-1]
 
  pool->schedule(clear(semaphores[count_ - 1]));
  // If jobs of the same priority are scheduled in order, and if
  // there are at least count_ threads, then this final job will get
  // scheduled on the last available thread, thus freeing all
  // others.
  bool const result = semaphores[0]->P(long_timeout);
 
  if(!result)
  {
    // If there are too few threads, then all threads are still
    // blocked. This will ultimately block the ThreadPool destructor,
    // so we have to unblock them manually here.
    for(int i = 1; i < count_; i++)
    {
      semaphores[i]->V();
    }
  }
  return result;
}

Referenced by has_exactly_n_threads().

Here is the call graph for this function:

Here is the caller graph for this function:

has_exactly_n_threads()

bool has_exactly_n_threads	(	ThreadPool *	pool,
		int	count
	)

{
  return has_at_least_n_threads(pool, count) && !has_at_least_n_threads(pool, count + 1);
}

Here is the call graph for this function:

long_timeout()

const millisec long_timeout

(

2000

)

Referenced by has_at_least_n_threads().

Here is the caller graph for this function:

no_op()

template<typename R >

R no_op	(	Semaphore *	s,
		R	result
	)

{
  s->V();
  return result;
}

result() [1/2]

boost::unique_future< bool > result

(

pool.schedule< bool, B< bool > >

B< bool >::create(&a, false)

)

result() [2/2]

boost::unique_future< int > result

(

pool.schedule< int >

[pa=&a] { return no_op(pa, 42);}

)

schedule() [1/4]

pool schedule

(

A::create &

a

)

schedule() [2/4]

pool schedule	(	clear &	low,
		PRIO_NORMAL
	)

schedule() [3/4]

pool schedule

(

clear &

s

)

schedule() [4/4]

pool schedule	(	pass &low+clear &	high,
		PRIO_HIGH
	)

short_timeout()

const millisec short_timeout

(

250

)

Variable Documentation

a

Semaphore a(0)

(

0

)

Initial value:

{
  ThreadPool pool(1)

expected

expected = 2

low

Semaphore low(0)

(

0

)

Initial value:

{
  Semaphore high(0)

pool

ThreadPool pool(0)

(

0

)

Initial value:

{
  Semaphore s(0)

Referenced by has_at_least_n_threads(), and has_exactly_n_threads().