anonymous_namespace{threadpoolimpl.cc}::ThreadList Class Reference

Collaboration diagram for anonymous_namespace{threadpoolimpl.cc}::ThreadList:

Public Types
using	Ptr = boost::shared_ptr< ThreadList >

Public Member Functions
void	wait ()
void	add (const ThreadPool::ThreadPtr &t)
void	add (const boost::shared_ptr< void > &t, const std::string &s)

Static Public Member Functions
static Ptr	instance ()

Private Member Functions
void	dumpPointers ()

Private Attributes
boost::mutex	mut
std::list< ThreadPool::ThreadPtr >	threads
std::list< std::pair< boost::weak_ptr< void >, std::string > >	pointers

Detailed Description

List of threads to wait for (when terminating)

Member Typedef Documentation

Ptr

using anonymous_namespace{threadpoolimpl.cc}::ThreadList::Ptr = boost::shared_ptr<ThreadList>

Member Function Documentation

add() [1/2]

void anonymous_namespace{threadpoolimpl.cc}::ThreadList::add	(	const boost::shared_ptr< void > &	t,
		const std::string &	s
	)

  {
    boost::mutex::scoped_lock const lock(mut);
    pointers.push_back(std::make_pair<boost::weak_ptr<void>, std::string>(t, std::string(s)));
  }

add() [2/2]

void anonymous_namespace{threadpoolimpl.cc}::ThreadList::add

(

const ThreadPool::ThreadPtr &

t

)

  {
    boost::mutex::scoped_lock const lock(mut);
    threads.push_back(t);
  }

dumpPointers()

void anonymous_namespace{threadpoolimpl.cc}::ThreadList::dumpPointers ( )

private

  {
    auto cur = pointers.begin();
    while(cur != pointers.end())
    {
      const auto count = cur->first.use_count();
 
      if(count)
      {
        spdlog::info("{} references to {} remaining", count, cur->second);
        cur++;
      }
      else
      {
        cur = pointers.erase(cur);
      }
    }
  }

instance()

ThreadList::Ptr anonymous_namespace{threadpoolimpl.cc}::ThreadList::instance ( )

static

  {
    static Ptr const threadList = Ptr(new ThreadList());
    return threadList;
  }

wait()

void anonymous_namespace{threadpoolimpl.cc}::ThreadList::wait

(

)

  {
    const boost::posix_time::millisec short_timeout(1);
    const boost::posix_time::millisec timeout(250);
    decltype(threads.size())          count = 0;
 
    {
      boost::mutex::scoped_lock const lock(mut);
 
      auto cur = threads.begin();
      while(cur != threads.end())
      {
        if((*cur)->timed_join(short_timeout))
        {
          cur = threads.erase(cur);
        }
        else
        {
          cur++;
        }
      }
 
      count = threads.size();
    }
 
    int triesRemaining = 256;
    while(triesRemaining > 0 && count > 0)
    {
      boost::mutex::scoped_lock const lock(mut);
      dumpPointers();
      spdlog::info("Waiting for {} threads to terminate", count);
 
      auto cur = threads.begin();
      while(cur != threads.end())
      {
        if((*cur)->timed_join(timeout))
        {
          cur = threads.erase(cur);
        }
        else
        {
          cur++;
        }
      }
 
      count = threads.size();
      triesRemaining--;
    }
 
    if(!threads.empty())
    {
      abort();
    }
  }

Here is the call graph for this function:

Member Data Documentation

mut

boost::mutex anonymous_namespace{threadpoolimpl.cc}::ThreadList::mut

private

pointers

std::list<std::pair<boost::weak_ptr<void>, std::string> > anonymous_namespace{threadpoolimpl.cc}::ThreadList::pointers

private

threads

std::list<ThreadPool::ThreadPtr> anonymous_namespace{threadpoolimpl.cc}::ThreadList::threads

private

---

The documentation for this class was generated from the following file:

• libs/threadpool/src/threadpoolimpl.cc