#include <SonicDispatcherPseudoAsync.h>

Inheritance diagram for SonicDispatcherPseudoAsync:

Public Member Functions
void	dispatch (edm::WaitingTaskWithArenaHolder holder) override

	SonicDispatcherPseudoAsync (SonicClientBase *client)

	~SonicDispatcherPseudoAsync () override

Public Member Functions inherited from SonicDispatcher
virtual void	dispatch ()

	SonicDispatcher (SonicClientBase *client)

virtual	~SonicDispatcher ()=default

Private Member Functions
void	waitForNext ()

Private Attributes
std::condition_variable	cond_

bool	hasCall_

std::mutex	mutex_

std::atomic< bool >	stop_

std::unique_ptr< std::thread >	thread_

Additional Inherited Members
Protected Attributes inherited from SonicDispatcher
SonicClientBase *	client_

Detailed Description

Definition at line 16 of file SonicDispatcherPseudoAsync.h.

Constructor & Destructor Documentation

◆ SonicDispatcherPseudoAsync()

SonicDispatcherPseudoAsync::SonicDispatcherPseudoAsync ( SonicClientBase * client )

Definition at line 5 of file SonicDispatcherPseudoAsync.cc.

     : SonicDispatcher(client), hasCall_(false), stop_(false) {
   thread_ = std::make_unique<std::thread>([this]() { waitForNext(); });
 }

References thread_, and waitForNext().

◆ ~SonicDispatcherPseudoAsync()

SonicDispatcherPseudoAsync::~SonicDispatcherPseudoAsync ( )

override

Definition at line 10 of file SonicDispatcherPseudoAsync.cc.

                                                         {
   stop_ = true;
   cond_.notify_one();
   if (thread_) {
     // avoid throwing in destructor
     CMS_SA_ALLOW try {
       thread_->join();
       thread_.reset();
     } catch (...) {
     }
   }
 }

References CMS_SA_ALLOW, cond_, stop_, and thread_.

Member Function Documentation

◆ dispatch()

void SonicDispatcherPseudoAsync::dispatch ( edm::WaitingTaskWithArenaHolder holder )

overridevirtual

Reimplemented from SonicDispatcher.

Definition at line 23 of file SonicDispatcherPseudoAsync.cc.

                                                                               {
   //do all read/writes inside lock to ensure cache synchronization
   {
     std::lock_guard<std::mutex> guard(mutex_);
     client_->start(std::move(holder));
  
     //activate thread to wait for response, and return
     hasCall_ = true;
   }
   cond_.notify_one();
 }

References SonicDispatcher::client_, cond_, hasCall_, eostools::move(), mutex_, and SonicClientBase::start().

◆ waitForNext()

void SonicDispatcherPseudoAsync::waitForNext ( )

private

Definition at line 35 of file SonicDispatcherPseudoAsync.cc.

                                              {
   while (true) {
     //wait for condition
     {
       std::unique_lock<std::mutex> lk(mutex_);
       cond_.wait(lk, [this]() { return (hasCall_ or stop_); });
       if (stop_)
         break;
  
       //do everything inside lock
       client_->evaluate();
  
       //reset condition
       hasCall_ = false;
     }
   }
 }