once_function.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 <cstring>
#include <utility>
 
#include <dispenso/detail/once_callable_impl.h>
#include <dispenso/platform.h>
 
namespace dispenso {
 
#if DISPENSO_HAS_CONCEPTS
template <typename F>
concept OnceCallableFunc = std::invocable<F>;
#endif // DISPENSO_HAS_CONCEPTS
 
namespace detail {
template <typename Result>
class FutureBase;
template <typename Result>
class FutureImplBase;
} // namespace detail
 
class OnceFunction {
 public:
  OnceFunction() : ops_(detail::emptyOps()) {}
 
  template <typename F>
  DISPENSO_REQUIRES(OnceCallableFunc<F>)
  OnceFunction(F&& f) : ops_(detail::createOnceCallable(std::forward<F>(f), buf_)) {}
 
  OnceFunction(const OnceFunction& other) = delete;
 
  OnceFunction(OnceFunction&& other) noexcept {
    moveFrom(other);
  }
 
  OnceFunction& operator=(OnceFunction&& other) noexcept {
    if (this != &other) {
#if defined DISPENSO_DEBUG
      assert(
          ops_->invoke == nullptr &&
          "OnceFunction must be invoked or cleanupNotRun() before reassignment");
#endif // DISPENSO_DEBUG
      moveFrom(other);
    }
    return *this;
  }
 
  void cleanupNotRun() {
#if defined DISPENSO_DEBUG
    assert(ops_->invoke != nullptr && "Must not cleanup an invalid OnceFunction!");
#endif
    consumeOps()->invoke(buf_, false);
  }
 
  void operator()() const {
#if defined DISPENSO_DEBUG
    assert(ops_->invoke != nullptr && "Must not use OnceFunction more than once!");
#endif // DISPENSO_DEBUG
    consumeOps()->invoke(buf_, true);
  }
 
 private:
  // 64 bytes total (one cache line): 56 bytes inline storage + 8 bytes operations ptr.
  // Inline: buf_ holds the functor directly.
  // Spill: buf_[0..7] holds a void* to pool-allocated storage.
  // Moves are a 64-byte memcpy, except for inline functors that are not trivially copyable, which
  // the operations' relocate entry move-constructs into place.
  void moveFrom(OnceFunction& other) noexcept {
    if (DISPENSO_EXPECT(other.ops_->relocate == nullptr, true)) {
      std::memcpy(static_cast<void*>(this), &other, sizeof(OnceFunction));
    } else {
      ops_ = other.ops_;
      ops_->relocate(other.buf_, buf_);
    }
    other.ops_ = detail::emptyOps();
  }
 
  // Marks this object consumed before the call, because the invoked functor may free the memory
  // holding this OnceFunction.  Leaves no stale relocate entry for a later move to act on.
  const detail::OnceCallableOps* consumeOps() const {
    const detail::OnceCallableOps* ops = ops_;
    ops_ = detail::emptyOps();
    return ops;
  }
 
  alignas(64) mutable char buf_[detail::kOnceFunctionInlineSize];
  mutable const detail::OnceCallableOps* ops_;
 
  template <typename Result>
  friend class detail::FutureBase;
  template <typename Result>
  friend class detail::FutureImplBase;
};
 
} // namespace dispenso