folly::observer_detail::Core Class Reference

#include <Core.h>

Inheritance diagram for folly::observer_detail::Core:

Classes
struct	VersionedData

Public Types
using	Ptr = std::shared_ptr< Core >
using	WeakPtr = std::weak_ptr< Core >

Public Member Functions
VersionedData	getData ()
size_t	getVersion () const
size_t	getVersionLastChange ()
size_t	refresh (size_t version, bool force=false)
	~Core ()

Static Public Member Functions
static Ptr	create (folly::Function< std::shared_ptr< const void >()> creator)

Private Types
using	Dependents = std::vector< WeakPtr >
using	Dependencies = std::unordered_set< Ptr >

Private Member Functions
	Core (folly::Function< std::shared_ptr< const void >()> creator)
void	addDependent (Core::WeakPtr dependent)
void	removeStaleDependents ()

Private Attributes
folly::Synchronized< Dependents >	dependents_
folly::Synchronized< Dependencies >	dependencies_
std::atomic< size_t >	version_ {0}
std::atomic< size_t >	versionLastChange_ {0}
folly::Synchronized< VersionedData >	data_
folly::Function< std::shared_ptr< const void >)>	creator_
std::mutex	refreshMutex_

Detailed Description

Core stores the current version of the object held by Observer. It also keeps all dependencies and dependents of the Observer.

Definition at line 38 of file Core.h.

Member Typedef Documentation

using folly::observer_detail::Core::Dependencies = std::unordered_set<Ptr>

private

Definition at line 100 of file Core.h.

using folly::observer_detail::Core::Dependents = std::vector<WeakPtr>

private

Definition at line 99 of file Core.h.

using folly::observer_detail::Core::Ptr = std::shared_ptr<Core>

Definition at line 40 of file Core.h.

using folly::observer_detail::Core::WeakPtr = std::weak_ptr<Core>

Definition at line 41 of file Core.h.

Constructor & Destructor Documentation

folly::observer_detail::Core::~Core

(

)

Definition at line 150 of file Core.cpp.

References dependencies_.

Referenced by getVersionLastChange().

            {
  dependencies_.withWLock([](const Dependencies& dependencies) {
    for (const auto& dependecy : dependencies) {
      dependecy->removeStaleDependents();
    }
  });
}

folly::observer_detail::Core::Core ( folly::Function< std::shared_ptr< const void >()>  creator )

explicitprivate

Definition at line 147 of file Core.cpp.

Referenced by create(), and getVersionLastChange().

    : creator_(std::move(creator)) {}

Member Function Documentation

void folly::observer_detail::Core::addDependent ( Core::WeakPtr  dependent )

private

Definition at line 163 of file Core.cpp.

References dependents_, and folly::gen::move.

Referenced by getVersionLastChange().

                                             {
  dependents_.withWLock([&](Dependents& dependents) {
    dependents.push_back(std::move(dependent));
  });
}

Core::Ptr folly::observer_detail::Core::create ( folly::Function< std::shared_ptr< const void >()>  creator )

static

Blocks until creator is successfully run by ObserverManager

Definition at line 158 of file Core.cpp.

References Core(), and folly::gen::move.

Referenced by folly::observer::makeObserver().

                                                                       {
  auto core = Core::Ptr(new Core(std::move(creator)));
  return core;
}

Core::VersionedData folly::observer_detail::Core::getData

(

)

Gets current view of the observed object. This is safe to call from any thread. If this is called from other Observer functor then that Observer is marked as dependent on current Observer.

Definition at line 25 of file Core.cpp.

References data_, folly::observer_detail::ObserverManager::getVersion(), folly::observer_detail::ObserverManager::inManagerThread(), folly::observer_detail::ObserverManager::DependencyRecorder::markDependency(), refresh(), version, and version_.

                                {
  if (!ObserverManager::inManagerThread()) {
    return data_.copy();
  }

  ObserverManager::DependencyRecorder::markDependency(shared_from_this());

  auto version = ObserverManager::getVersion();

  if (version_ >= version) {
    return data_.copy();
  }

  refresh(version);

  DCHECK_GE(version_, version);
  return data_.copy();
}

size_t folly::observer_detail::Core::getVersion ( ) const

inline

Gets the version of the observed object.

Definition at line 71 of file Core.h.

References version_.

                            {
    return version_;
  }

size_t folly::observer_detail::Core::getVersionLastChange ( )

inline

Get the last version at which the observed object was actually changed.

Definition at line 78 of file Core.h.

References addDependent(), Core(), refresh(), removeStaleDependents(), folly::observer_detail::Core::VersionedData::version, versionLastChange_, and ~Core().

Referenced by folly::observer::Observer< T >::needRefresh().

                                {
    return versionLastChange_;
  }

size_t folly::observer_detail::Core::refresh	(	size_t	version,
		bool	force = false
	)

Check if the observed object needs to be re-computed. Returns the version of last change. If force is true, re-computes the observed object, even if dependencies didn't change.

This should be only called from ObserverManager thread.

Definition at line 44 of file Core.cpp.

References folly::Synchronized< T, Mutex >::copy(), creator_, data_, dependencies_, dependents_, folly::exceptionStr(), folly::observer_detail::ObserverManager::inManagerThread(), folly::observer_detail::ObserverManager::DependencyRecorder::markRefreshDependency(), folly::gen::move, refreshMutex_, folly::observer_detail::ObserverManager::DependencyRecorder::release(), folly::observer_detail::ObserverManager::scheduleRefresh(), SCOPE_EXIT, folly::observer_detail::ObserverManager::DependencyRecorder::unmarkRefreshDependency(), version, version_, and versionLastChange_.

Referenced by getData(), and getVersionLastChange().

                                               {
  CHECK(ObserverManager::inManagerThread());

  ObserverManager::DependencyRecorder::markRefreshDependency(*this);
  SCOPE_EXIT {
    ObserverManager::DependencyRecorder::unmarkRefreshDependency(*this);
  };

  if (version_ >= version) {
    return versionLastChange_;
  }

  {
    std::lock_guard<std::mutex> lgRefresh(refreshMutex_);

    // Recheck in case this code was already refreshed
    if (version_ >= version) {
      return versionLastChange_;
    }

    bool needRefresh = force || version_ == 0;

    ObserverManager::DependencyRecorder dependencyRecorder(*this);

    // This can be run in parallel, but we expect most updates to propagate
    // bottom to top.
    dependencies_.withRLock([&](const Dependencies& dependencies) {
      for (const auto& dependency : dependencies) {
        try {
          if (dependency->refresh(version) > version_) {
            needRefresh = true;
            break;
          }
        } catch (...) {
          LOG(ERROR) << "Exception while checking dependencies for updates: "
                     << exceptionStr(std::current_exception());

          needRefresh = true;
          break;
        }
      }
    });

    if (!needRefresh) {
      version_ = version;
      return versionLastChange_;
    }

    try {
      {
        VersionedData newData{creator_(), version};
        if (!newData.data) {
          throw std::logic_error("Observer creator returned nullptr.");
        }
        data_.swap(newData);
      }

      versionLastChange_ = version;
    } catch (...) {
      LOG(ERROR) << "Exception while refreshing Observer: "
                 << exceptionStr(std::current_exception());

      if (version_ == 0) {
        // Re-throw exception if this is the first time we run creator
        throw;
      }
    }

    version_ = version;

    if (versionLastChange_ != version) {
      return versionLastChange_;
    }

    auto newDependencies = dependencyRecorder.release();
    dependencies_.withWLock([&](Dependencies& dependencies) {
      for (const auto& dependency : newDependencies) {
        if (!dependencies.count(dependency)) {
          dependency->addDependent(this->shared_from_this());
        }
      }

      for (const auto& dependency : dependencies) {
        if (!newDependencies.count(dependency)) {
          dependency->removeStaleDependents();
        }
      }

      dependencies = std::move(newDependencies);
    });
  }

  auto dependents = dependents_.copy();

  for (const auto& dependentWeak : dependents) {
    if (auto dependent = dependentWeak.lock()) {
      ObserverManager::scheduleRefresh(std::move(dependent), version);
    }
  }

  return versionLastChange_;
}

void folly::observer_detail::Core::removeStaleDependents ( )

private

Definition at line 169 of file Core.cpp.

References dependents_, i, and folly::f14::swap().

Referenced by getVersionLastChange().

                                 {
  // This is inefficient, the assumption is that we won't have many dependents
  dependents_.withWLock([](Dependents& dependents) {
    for (size_t i = 0; i < dependents.size(); ++i) {
      if (dependents[i].expired()) {
        std::swap(dependents[i], dependents.back());
        dependents.pop_back();
        --i;
      }
    }
  });
}

Member Data Documentation

folly::Function<std::shared_ptr<const void>)> folly::observer_detail::Core::creator_

private

Definition at line 110 of file Core.h.

Referenced by refresh().

folly::Synchronized<VersionedData> folly::observer_detail::Core::data_

private

Definition at line 108 of file Core.h.

Referenced by getData(), and refresh().

folly::Synchronized<Dependencies> folly::observer_detail::Core::dependencies_

private

Definition at line 103 of file Core.h.

Referenced by refresh(), and ~Core().

folly::Synchronized<Dependents> folly::observer_detail::Core::dependents_

private

Definition at line 102 of file Core.h.

Referenced by addDependent(), refresh(), and removeStaleDependents().

std::mutex folly::observer_detail::Core::refreshMutex_

private

Definition at line 112 of file Core.h.

Referenced by refresh().

std::atomic<size_t> folly::observer_detail::Core::version_ {0}

private

Definition at line 105 of file Core.h.

Referenced by getData(), getVersion(), and refresh().

std::atomic<size_t> folly::observer_detail::Core::versionLastChange_ {0}

private

Definition at line 106 of file Core.h.

Referenced by getVersionLastChange(), and refresh().

---

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

• proxygen/folly/folly/experimental/observer/detail/Core.h
• proxygen/folly/folly/experimental/observer/detail/Core.cpp