folly::python Namespace Reference

Namespaces
	test

Classes
class	AsyncioExecutor
class	GILAwareManualExecutor

Functions
folly::fibers::FiberManager *	getFiberManager (const folly::fibers::FiberManager::Options &opts)
template<typename T >
void	bridgeFibers (folly::Function< T()> &&function, folly::Function< void(folly::Try< T > &&, PyObject *)> callback, PyObject *userData)
folly::Executor *	getExecutor ()
template<typename T >
void	bridgeFuture (folly::Executor *executor, folly::Future< T > &&futureFrom, folly::Function< void(folly::Try< T > &&, PyObject *)> callback, PyObject *userData)
template<typename T >
void	bridgeFuture (folly::Future< T > &&futureFrom, folly::Function< void(folly::Try< T > &&, PyObject *)> callback, PyObject *userData)

Function Documentation

template<typename T >

void folly::python::bridgeFibers	(	folly::Function< T()> &&	function,
		folly::Function< void(folly::Try< T > &&, PyObject *)>	callback,
		PyObject *	userData
	)

Helper function with similar callback/userData parameters as bridgeFuture. This can be convenient in code that calls both (notably our tests), but most callsites should directly use getFiberManager().

Definition at line 39 of file fibers.h.

References getFiberManager(), folly::gen::guard(), folly::makeGuard(), folly::makeTryWith(), and folly::gen::move.

                        {
  auto* fiberManager = getFiberManager();
  // We are handing over a pointer to a python object to c++ and need
  // to make sure it isn't removed by python in that time.
  Py_INCREF(userData);
  auto guard = folly::makeGuard([=] { Py_DECREF(userData); });
  fiberManager->addTask([function = std::move(function),
                         callback = std::move(callback),
                         userData,
                         guard = std::move(guard)]() mutable {
    // This will run from inside the gil, called by the asyncio add_reader
    auto res = folly::makeTryWith([&] { return function(); });
    callback(std::move(res), userData);
    // guard goes out of scope here, and its stored function is called
  });
}

template<typename T >

void folly::python::bridgeFuture	(	folly::Executor *	executor,
		folly::Future< T > &&	futureFrom,
		folly::Function< void(folly::Try< T > &&, PyObject *)>	callback,
		PyObject *	userData
	)

Definition at line 38 of file futures.h.

References folly::gen::guard(), folly::makeGuard(), and folly::gen::move.

Referenced by bridgeFuture().

                        {
  // We are handing over a pointer to a python object to c++ and need
  // to make sure it isn't removed by python in that time.
  Py_INCREF(userData);
  auto guard = folly::makeGuard([=] { Py_DECREF(userData); });
  // Handle the lambdas for cython
  // run callback from our Q
  futureFrom.via(executor).then(
      [callback = std::move(callback), userData, guard = std::move(guard)](
          folly::Try<T>&& res) mutable {
        // This will run from inside the gil, called by the asyncio add_reader
        callback(std::move(res), userData);
        // guard goes out of scope here, and its stored function is called
      });
}

template<typename T >

void folly::python::bridgeFuture	(	folly::Future< T > &&	futureFrom,
		folly::Function< void(folly::Try< T > &&, PyObject *)>	callback,
		PyObject *	userData
	)

Definition at line 59 of file futures.h.

References bridgeFuture(), getExecutor(), and folly::gen::move.

                        {
  bridgeFuture(
      getExecutor(), std::move(futureFrom), std::move(callback), userData);
}

folly::Executor* folly::python::getExecutor ( )

inline

Definition at line 32 of file futures.h.

Referenced by bridgeFuture(), folly::Future< folly::folly::Unit >::then(), and folly::Future< folly::folly::Unit >::thenMultiWithExecutor().

                                    {
  import_folly__executor();
  return get_executor();
}

folly::fibers::FiberManager * folly::python::getFiberManager

(

const folly::fibers::FiberManager::Options &

opts

)

Definition at line 24 of file fibers.cpp.

References folly::call_once(), flag, and folly::fibers::runInMainContext().

Referenced by bridgeFibers().

                                                {
  static folly::fibers::once_flag flag;
  // Use call_once because Python performance is really poor,
  // just to check if a module was already imported
  folly::call_once(flag, [&]() {
    // Use main context, because import can load arbitrary number of files,
    // which is incompatible with fiber stack size restrictions
    folly::fibers::runInMainContext([&]() {
      import_folly__fiber_manager();
      if (PyErr_Occurred() != nullptr) {
        throw std::logic_error("Fail to import cython fiber_manager");
      }
    });
  });
  return get_fiber_manager(opts);
}