future.h

Go to the documentation of this file.

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
 
#pragma once
 
#include <functional>
#include <vector>
 
#include <dispenso/detail/future_impl.h>
#include <dispenso/detail/result_of.h>
#include <dispenso/schedulable.h>
 
namespace dispenso {
 
// See https://en.cppreference.com/w/cpp/experimental/future for details on the API.
 
// TODO(bbudge): Implement when_any(), ?unwrapping constructor? functionality.
 
constexpr std::launch kNotAsync = static_cast<std::launch>(0);
constexpr std::launch kNotDeferred = static_cast<std::launch>(0);
 
template <typename Result>
class Future : detail::FutureBase<Result> {
  using Base = detail::FutureBase<Result>;
 
 public:
  Future() noexcept : Base() {}
 
  Future(Future&& f) noexcept : Base(std::move(f)) {}
  Future(Base&& f) noexcept : Base(std::move(f)) {}
 
  Future(const Future& f) noexcept : Base(f) {}
  Future(const Base& f) noexcept : Base(f) {}
 
  template <typename F, typename Schedulable>
  Future(
      F&& f,
      Schedulable& schedulable,
      std::launch asyncPolicy = kNotAsync,
      std::launch deferredPolicy = std::launch::deferred)
      : Base(std::forward<F>(f), schedulable, asyncPolicy, deferredPolicy) {}
 
  Future& operator=(Future&& f) noexcept {
    Base::move(reinterpret_cast<Base&&>(f));
    return *this;
  }
  Future& operator=(const Future& f) {
    Base::copy(f);
    return *this;
  }
 
  ~Future() = default;
 
  bool valid() const noexcept {
    return Base::valid();
  }
 
  bool is_ready() const {
    return Base::is_ready();
  }
 
  void wait() const {
    Base::wait();
  }
 
  template <class Rep, class Period>
  std::future_status wait_for(const std::chrono::duration<Rep, Period>& timeoutDuration) const {
    return Base::wait_for(timeoutDuration);
  }
 
  template <class Clock, class Duration>
  std::future_status wait_until(const std::chrono::time_point<Clock, Duration>& timeoutTime) const {
    return Base::wait_until(timeoutTime);
  }
 
  Future share() {
    return std::move(*this);
  }
 
  const Result& get() const {
    wait();
    return this->impl_->result();
  }
 
  template <typename F, typename Schedulable>
  Future<detail::ResultOf<F, Future<Result>&&>> then(
      F&& f,
      Schedulable& sched,
      std::launch asyncPolicy = kNotAsync,
      std::launch deferredPolicy = std::launch::deferred) {
    Future<detail::ResultOf<F, Future<Result>&&>> retFuture;
    retFuture.impl_ = this->template thenImpl<detail::ResultOf<F, Future<Result>&&>>(
        std::forward<F>(f), sched, asyncPolicy, deferredPolicy);
    return retFuture;
  }
  template <typename F>
  Future<detail::ResultOf<F, Future<Result>&&>> then(F&& f) {
    return then(std::forward<F>(f), globalThreadPool(), kNotAsync, std::launch::deferred);
  }
 
 private:
  template <typename T>
  Future(T&& t, detail::ReadyTag) {
    this->impl_ = detail::createValueFutureImplReady<Result>(std::forward<T>(t));
  }
 
  template <typename T>
  friend Future<std::decay_t<T>> make_ready_future(T&& t);
 
  template <typename R>
  friend class Future;
};
 
template <typename Result>
class Future<Result&> : detail::FutureBase<Result&> {
  using Base = detail::FutureBase<Result&>;
 
 public:
  Future() noexcept : Base() {}
  Future(Future&& f) noexcept : Base(std::move(f)) {}
  Future(Base&& f) noexcept : Base(std::move(f)) {}
  Future(const Future& f) noexcept : Base(f) {}
  Future(const Base& f) noexcept : Base(f) {}
  template <typename F, typename Schedulable>
  Future(
      F&& f,
      Schedulable& schedulable,
      std::launch asyncPolicy = kNotAsync,
      std::launch deferredPolicy = std::launch::deferred)
      : Base(std::forward<F>(f), schedulable, asyncPolicy, deferredPolicy) {}
  Future& operator=(Future&& f) noexcept {
    Base::move(reinterpret_cast<Base&&>(f));
    return *this;
  }
  Future& operator=(const Future& f) {
    Base::copy(f);
    return *this;
  }
  ~Future() = default;
  using Base::is_ready;
  using Base::valid;
  using Base::wait;
  using Base::wait_for;
  using Base::wait_until;
 
  Future share() {
    return std::move(*this);
  }
 
  Result& get() const {
    wait();
    return this->impl_->result();
  }
 
  template <typename F, typename Schedulable>
  Future<detail::ResultOf<F, Future<Result&>&&>> then(
      F&& f,
      Schedulable& sched,
      std::launch asyncPolicy = kNotAsync,
      std::launch deferredPolicy = std::launch::deferred) {
    Future<detail::ResultOf<F, Future<Result&>&&>> retFuture;
    retFuture.impl_ = this->template thenImpl<detail::ResultOf<F, Future<Result&>&&>>(
        std::forward<F>(f), sched, asyncPolicy, deferredPolicy);
    return retFuture;
  }
  template <typename F>
  Future<detail::ResultOf<F, Future<Result&>&&>> then(F&& f) {
    return then(std::forward<F>(f), globalThreadPool(), kNotAsync, std::launch::deferred);
  }
 
 private:
  template <typename T>
  Future(std::reference_wrapper<T> t, detail::ReadyTag) {
    this->impl_ = detail::createRefFutureImplReady<Result>(t);
  }
 
  template <typename X>
  friend Future<X&> make_ready_future(std::reference_wrapper<X> x);
 
  template <typename R>
  friend class Future;
};
 
template <>
class Future<void> : detail::FutureBase<void> {
  using Base = detail::FutureBase<void>;
 
 public:
  Future() noexcept : Base() {}
  Future(Future&& f) noexcept : Base(std::move(f)) {}
  Future(Base&& f) noexcept : Base(std::move(f)) {}
  Future(const Future& f) noexcept : Base(f) {}
  Future(const Base& f) noexcept : Base(f) {}
  template <typename F, typename Schedulable>
  Future(
      F&& f,
      Schedulable& schedulable,
      std::launch asyncPolicy = kNotAsync,
      std::launch deferredPolicy = std::launch::deferred)
      : Base(std::forward<F>(f), schedulable, asyncPolicy, deferredPolicy) {}
  Future& operator=(Future&& f) noexcept {
    Base::move(reinterpret_cast<Base&&>(f));
    return *this;
  }
  Future& operator=(const Future& f) {
    Base::copy(f);
    return *this;
  }
  ~Future() = default;
  using Base::is_ready;
  using Base::valid;
  using Base::wait;
  using Base::wait_for;
  using Base::wait_until;
 
  Future share() {
    return std::move(*this);
  }
 
  void get() const {
    wait();
    this->impl_->result();
  }
 
  template <typename F, typename Schedulable>
  Future<detail::ResultOf<F, Future<void>&&>> then(
      F&& f,
      Schedulable& sched,
      std::launch asyncPolicy = kNotAsync,
      std::launch deferredPolicy = std::launch::deferred) {
    Future<detail::ResultOf<F, Future<void>&&>> retFuture;
    retFuture.impl_ = this->template thenImpl<detail::ResultOf<F, Future<void>&&>>(
        std::forward<F>(f), sched, asyncPolicy, deferredPolicy);
    return retFuture;
  }
  template <typename F>
  Future<detail::ResultOf<F, Future<void>&&>> then(F&& f) {
    return then(std::forward<F>(f), globalThreadPool(), kNotAsync, std::launch::deferred);
  }
 
 private:
  Future(detail::ReadyTag) {
    impl_ = detail::createVoidFutureImplReady();
  }
 
  friend Future<void> make_ready_future();
 
  template <typename R>
  friend class Future;
};
 
// TODO(bbudge): Determine if we should
// a. Expand launch policies, and logically inherit from std::launch and
// b. Whether async should truly mean on a new thread.
// For now we will treat std::launch::async such that we pass ForceQueuingTag
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>> async(std::launch policy, F&& f, Args&&... args) {
  return Future<detail::ResultOf<F, Args...>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...), globalThreadPool(), policy);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>> async(F&& f, Args&&... args) {
  return ::dispenso::async(std::launch::deferred, std::forward<F>(f), std::forward<Args>(args)...);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>>
async(ThreadPool& pool, std::launch policy, F&& f, Args&&... args) {
  return Future<detail::ResultOf<F, Args...>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...), pool, policy);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>> async(ThreadPool& pool, F&& f, Args&&... args) {
  return ::dispenso::async(
      pool, std::launch::deferred, std::forward<F>(f), std::forward<Args>(args)...);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>>
async(TaskSet& tasks, std::launch policy, F&& f, Args&&... args) {
  return Future<detail::ResultOf<F, Args...>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...), tasks, policy);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>> async(TaskSet& tasks, F&& f, Args&&... args) {
  return ::dispenso::async(
      tasks, std::launch::deferred, std::forward<F>(f), std::forward<Args>(args)...);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>>
async(ConcurrentTaskSet& tasks, std::launch policy, F&& f, Args&&... args) {
  return Future<detail::ResultOf<F, Args...>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...), tasks, policy);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>> async(ConcurrentTaskSet& tasks, F&& f, Args&&... args) {
  return ::dispenso::async(
      tasks, std::launch::deferred, std::forward<F>(f), std::forward<Args>(args)...);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>>
async(NewThreadInvoker sched, std::launch policy, F&& f, Args&&... args) {
  return Future<detail::ResultOf<F, Args...>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...), sched, policy);
}
 
template <class F, class... Args>
inline Future<detail::ResultOf<F, Args...>> async(NewThreadInvoker sched, F&& f, Args&&... args) {
  return ::dispenso::async(
      sched, std::launch::deferred, std::forward<F>(f), std::forward<Args>(args)...);
}
 
template <typename T>
inline Future<std::decay_t<T>> make_ready_future(T&& t) {
  return Future<std::decay_t<T>>(std::forward<T>(t), detail::ReadyTag());
}
 
template <typename X>
inline Future<X&> make_ready_future(std::reference_wrapper<X> x) {
  return Future<X&>(x, detail::ReadyTag());
}
 
inline Future<void> make_ready_future() {
  return Future<void>(detail::ReadyTag());
}
 
template <class InputIt>
Future<std::vector<typename std::iterator_traits<InputIt>::value_type>> when_all(
    InputIt first,
    InputIt last);
 
template <class... Futures>
auto when_all(Futures&&... futures) -> Future<std::tuple<std::decay_t<Futures>...>>;
 
template <class InputIt>
Future<std::vector<typename std::iterator_traits<InputIt>::value_type>>
when_all(TaskSet& taskSet, InputIt first, InputIt last);
template <class InputIt>
Future<std::vector<typename std::iterator_traits<InputIt>::value_type>>
when_all(ConcurrentTaskSet& taskSet, InputIt first, InputIt last);
 
template <class... Futures>
auto when_all(TaskSet& taskSet, Futures&&... futures)
    -> Future<std::tuple<std::decay_t<Futures>...>>;
 
template <class... Futures>
auto when_all(ConcurrentTaskSet& taskSet, Futures&&... futures)
    -> Future<std::tuple<std::decay_t<Futures>...>>;
} // namespace dispenso
 
#include <dispenso/detail/future_impl2.h>