folly::EventBaseManager Class Reference

#include <EventBaseManager.h>

Classes
struct	EventBaseInfo

Public Member Functions
	EventBaseManager ()
	~EventBaseManager ()
	EventBaseManager (const std::shared_ptr< EventBaseObserver > &observer)
EventBase *	getEventBase () const
EventBase *	getExistingEventBase () const
void	setEventBase (EventBase *eventBase, bool takeOwnership)
void	clearEventBase ()
template<typename FunctionType >
void	withEventBaseSet (const FunctionType &runnable)

Static Public Member Functions
static EventBaseManager *	get ()

Private Member Functions
	EventBaseManager (EventBaseManager const &)
EventBaseManager &	operator= (EventBaseManager const &)
void	trackEventBase (EventBase *evb)
void	untrackEventBase (EventBase *evb)

Private Attributes
folly::ThreadLocalPtr< EventBaseInfo >	localStore_
std::set< EventBase * >	eventBaseSet_
std::mutex	eventBaseSetMutex_
std::shared_ptr< folly::EventBaseObserver >	observer_

Detailed Description

Manager for per-thread EventBase objects. This class will find or create a EventBase for the current thread, associated with thread-specific storage for that thread. Although a typical application will generally only have one EventBaseManager, there is no restriction on multiple instances; the EventBases belong to one instance are isolated from those of another.

Definition at line 36 of file EventBaseManager.h.

Constructor & Destructor Documentation

folly::EventBaseManager::EventBaseManager ( )

inline

Definition at line 40 of file EventBaseManager.h.

Referenced by get(), and folly::EventBaseManager::EventBaseInfo::~EventBaseInfo().

{}

folly::EventBaseManager::~EventBaseManager ( )

inline

Definition at line 42 of file EventBaseManager.h.

{}

folly::EventBaseManager::EventBaseManager ( const std::shared_ptr< EventBaseObserver > &  observer )

inlineexplicit

Definition at line 44 of file EventBaseManager.h.

References getEventBase().

      : observer_(observer) {}

folly::EventBaseManager::EventBaseManager ( EventBaseManager const &  )

private

Member Function Documentation

void folly::EventBaseManager::clearEventBase

(

)

Clear the EventBase for this thread.

This can be used if the code driving the EventBase loop() has finished the loop and new events should no longer be added to the EventBase.

Definition at line 56 of file EventBaseManager.cpp.

References folly::EventBaseManager::EventBaseInfo::eventBase, deadlock::info(), localStore_, and untrackEventBase().

Referenced by proxygen::WorkerThread::cleanup(), getExistingEventBase(), folly::run(), HTTPDownstreamTest< SPDY3_1CodecPair >::SetUp(), and folly::IOThreadPoolExecutor::threadRun().

                                      {
  EventBaseInfo* info = localStore_.get();
  if (info != nullptr) {
    this->untrackEventBase(info->eventBase);
    this->localStore_.reset(nullptr);
  }
}

EventBaseManager * folly::EventBaseManager::get ( )

static

Get the global EventBaseManager for this program. Ideally all users of EventBaseManager go through this interface and do not construct EventBaseManager directly.

Definition at line 23 of file EventBaseManager.cpp.

References EventBaseManager(), and folly::globalManager().

Referenced by wangle::ServerBootstrap< DefaultPipeline >::bind(), wangle::ClientBootstrap< DefaultPipeline >::connect(), TestClientPipelineFactory::newPipeline(), wangle::AsyncServerSocketFactory::newSocket(), wangle::AsyncUDPServerSocketFactory::newSocket(), StaticService::StaticHandler::onEgressResumed(), StaticService::StaticHandler::onRequest(), ProxyService::ProxyHandler::onRequest(), HTTPDownstreamTest< SPDY3_1CodecPair >::SetUp(), TEST(), wangle::TEST(), TEST_F(), and proxygen::WheelTimerInstance::WheelTimerInstance().

                                        {
  EventBaseManager* mgr = globalManager;
  if (mgr) {
    return mgr;
  }

  EventBaseManager* new_mgr = new EventBaseManager;
  bool exchanged = globalManager.compare_exchange_strong(mgr, new_mgr);
  if (!exchanged) {
    delete new_mgr;
    return mgr;
  } else {
    return new_mgr;
  }
}

EventBase * folly::EventBaseManager::getEventBase

(

)

const

Get the EventBase for this thread, or create one if none exists yet.

If no EventBase exists for this thread yet, a new one will be created and returned. May throw std::bad_alloc if allocation fails.

Definition at line 65 of file EventBaseManager.cpp.

References deadlock::info(), localStore_, and observer_.

Referenced by wangle::ClientBootstrap< DefaultPipeline >::connect(), EventBaseManager(), TestClientPipelineFactory::newPipeline(), wangle::AsyncServerSocketFactory::newSocket(), wangle::AsyncUDPServerSocketFactory::newSocket(), ProxyService::ProxyHandler::onRequest(), TEST(), wangle::TEST(), TEST_F(), folly::IOThreadPoolExecutor::threadRun(), and proxygen::WheelTimerInstance::WheelTimerInstance().

                                                {
  // have one?
  auto* info = localStore_.get();
  if (!info) {
    info = new EventBaseInfo();
    localStore_.reset(info);

    if (observer_) {
      info->eventBase->setObserver(observer_);
    }

    // start tracking the event base
    // XXX
    // note: ugly cast because this does something mutable
    // even though this method is defined as "const".
    // Simply removing the const causes trouble all over fbcode;
    // lots of services build a const EventBaseManager and errors
    // abound when we make this non-const.
    (const_cast<EventBaseManager*>(this))->trackEventBase(info->eventBase);
  }

  return info->eventBase;
}

EventBase* folly::EventBaseManager::getExistingEventBase ( ) const

inline

Get the EventBase for this thread.

Returns nullptr if no EventBase has been created for this thread yet.

Definition at line 67 of file EventBaseManager.h.

References clearEventBase(), folly::EventBaseManager::EventBaseInfo::eventBase, deadlock::info(), localStore_, and setEventBase().

                                          {
    EventBaseInfo* info = localStore_.get();
    if (info == nullptr) {
      return nullptr;
    }
    return info->eventBase;
  }

EventBaseManager& folly::EventBaseManager::operator= ( EventBaseManager const &  )

private

Referenced by folly::EventBaseManager::EventBaseInfo::~EventBaseInfo().

void folly::EventBaseManager::setEventBase	(	EventBase *	eventBase,
		bool	takeOwnership
	)

Set the EventBase to be used by this thread.

This may only be called if no EventBase has been defined for this thread yet. If a EventBase is already defined for this thread, a std::runtime_error is thrown. std::bad_alloc may also be thrown if allocation fails while setting the EventBase.

This should typically be invoked by the code that will call loop() on the EventBase, to make sure the EventBaseManager points to the correct EventBase that is actually running in this thread.

Definition at line 43 of file EventBaseManager.cpp.

References deadlock::info(), localStore_, and trackEventBase().

Referenced by getExistingEventBase(), folly::run(), proxygen::WorkerThread::setup(), and TEST_F().

                                                                            {
  EventBaseInfo* info = localStore_.get();
  if (info != nullptr) {
    throw std::runtime_error(
        "EventBaseManager: cannot set a new EventBase "
        "for this thread when one already exists");
  }

  info = new EventBaseInfo(eventBase, takeOwnership);
  localStore_.reset(info);
  this->trackEventBase(eventBase);
}

void folly::EventBaseManager::trackEventBase ( EventBase *  evb )

inlineprivate

Definition at line 130 of file EventBaseManager.h.

References eventBaseSet_, eventBaseSetMutex_, and g().

Referenced by setEventBase().

                                      {
    std::lock_guard<std::mutex> g(*&eventBaseSetMutex_);
    eventBaseSet_.insert(evb);
  }

void folly::EventBaseManager::untrackEventBase ( EventBase *  evb )

inlineprivate

Definition at line 135 of file EventBaseManager.h.

References eventBaseSet_, eventBaseSetMutex_, and g().

Referenced by clearEventBase().

                                        {
    std::lock_guard<std::mutex> g(*&eventBaseSetMutex_);
    eventBaseSet_.erase(evb);
  }

template<typename FunctionType >

void folly::EventBaseManager::withEventBaseSet ( const FunctionType &  runnable )

inline

Gives the caller all references to all assigned EventBase instances at this moment in time. Locks a mutex so that these EventBase set cannot be changed, and also the caller can rely on no instances being destructed.

Definition at line 103 of file EventBaseManager.h.

References eventBaseSet_, eventBaseSetMutex_, and g().

                                                      {
    // grab the mutex for the caller
    std::lock_guard<std::mutex> g(*&eventBaseSetMutex_);
    // give them only a const set to work with
    const std::set<EventBase*>& constSet = eventBaseSet_;
    runnable(constSet);
  }

Member Data Documentation

std::set<EventBase*> folly::EventBaseManager::eventBaseSet_

mutableprivate

Definition at line 145 of file EventBaseManager.h.

Referenced by trackEventBase(), untrackEventBase(), and withEventBaseSet().

std::mutex folly::EventBaseManager::eventBaseSetMutex_

private

Definition at line 148 of file EventBaseManager.h.

Referenced by trackEventBase(), untrackEventBase(), and withEventBaseSet().

folly::ThreadLocalPtr<EventBaseInfo> folly::EventBaseManager::localStore_

mutableprivate

Definition at line 140 of file EventBaseManager.h.

Referenced by clearEventBase(), getEventBase(), getExistingEventBase(), and setEventBase().

std::shared_ptr<folly::EventBaseObserver> folly::EventBaseManager::observer_

private

Definition at line 150 of file EventBaseManager.h.

Referenced by getEventBase().

---

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

• proxygen/folly/folly/io/async/EventBaseManager.h
• proxygen/folly/folly/io/async/EventBaseManager.cpp