coroutine_context_base.h

Go to the documentation of this file.

// Copyright 2023 owent
 
#pragma once
 
#include <libcopp/utils/config/libcopp_build_features.h>
 
#include <libcopp/stack/stack_context.h>
#include <libcopp/utils/atomic_int_type.h>
#include <libcopp/utils/features.h>
#include <libcopp/utils/memory/intrusive_ptr.h>
#include <libcopp/fcontext/all.hpp>
 
// clang-format off
#include <libcopp/utils/config/stl_include_prefix.h>  // NOLINT(build/include_order)
// clang-format on
#include <cstddef>
#include <functional>
#include <memory>
#if defined(LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR) && LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR
#  include <exception>
#endif
// clang-format off
#include <libcopp/utils/config/stl_include_suffix.h>  // NOLINT(build/include_order)
// clang-format on
 
LIBCOPP_COPP_NAMESPACE_BEGIN
 
namespace details {
template <size_t N1, size_t N2, bool BIGGER_THAN_16>
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper_inner;
 
template <size_t N1, size_t N2>
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper_inner<N1, N2, true> {
  static constexpr const size_t value = N1;
};
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper_inner<N1, N2, true> {…};
 
template <size_t N1, size_t N2>
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper_inner<N1, N2, false> {
  static constexpr const size_t value = N2;
};
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper_inner<N1, N2, false> {…};
 
template <size_t N, size_t COMPARE_TO>
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper {
  static constexpr const size_t value = align_helper_inner<N, COMPARE_TO, N >= COMPARE_TO>::value;
};
struct LIBCOPP_COPP_API_HEAD_ONLY align_helper {…};
 
// We should align to at least 16 bytes, @see https://wiki.osdev.org/System_V_ABI for more details
#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
    (defined(_MSC_VER) && _MSC_VER >= 1900)
#  define COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE \
    LIBCOPP_COPP_NAMESPACE_ID::details::align_helper<sizeof(max_align_t), 16>::value
#else
#  define COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE \
    LIBCOPP_COPP_NAMESPACE_ID::details::align_helper<2 * sizeof(size_t), 16>::value
#  define COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE \ …
#endif
 
// Some architecture may require stack to be aligned to 64
// @see "3.2.2 The Stack Frame" of https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf
// More documents about x86/x86_64 canbe found at https://stackoverflow.com/tags/x86/info
#define COROUTINE_CONTEXT_STACK_ALIGN_UNIT_SIZE \
  LIBCOPP_COPP_NAMESPACE_ID::details::align_helper<COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE, 64>::value
#define COROUTINE_CONTEXT_STACK_ALIGN_UNIT_SIZE \ …
 
static_assert(COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE >= 16 && 0 == COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE % 16,
              "COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE");
static_assert(COROUTINE_CONTEXT_STACK_ALIGN_UNIT_SIZE >= 16 && 0 == COROUTINE_CONTEXT_STACK_ALIGN_UNIT_SIZE % 16,
              "COROUTINE_CONTEXT_STACK_ALIGN_UNIT_SIZE");
}  // namespace details
namespace details {…}
 
class coroutine_context_base {
 public:
  using callback_type = std::function<int(void *)>;
 
  struct LIBCOPP_COPP_API status_type {
    enum type {
      EN_CRS_INVALID = 0,  
      EN_CRS_READY,        
      EN_CRS_RUNNING,      
      EN_CRS_FINISHED,     
      EN_CRS_EXITED,       
    };
    enum type {…};
  };
  struct LIBCOPP_COPP_API status_type {…};
 
  struct LIBCOPP_COPP_API flag_type {
    enum type {
      EN_CFT_UNKNOWN = 0,
      EN_CFT_FINISHED = 0x01,
      EN_CFT_IS_FIBER = 0x02,
      EN_CFT_MASK = 0xFF,
    };
    enum type {…};
  };
  struct LIBCOPP_COPP_API flag_type {…};
 
  // Compability with libcopp-1.x
  using callback_t = callback_type;
  using status_t = status_type;
  using flag_t = flag_type;
 
 protected:
  int runner_ret_code_;  
  int flags_;            
  callback_type runner_; 
  void *priv_data_;
  size_t private_buffer_size_;
 
#if LIBCOPP_MACRO_ENABLE_MULTI_THREAD
  LIBCOPP_COPP_NAMESPACE_ID::util::lock::atomic_int_type<int> status_; 
#else
  LIBCOPP_COPP_NAMESPACE_ID::util::lock::atomic_int_type<LIBCOPP_COPP_NAMESPACE_ID::util::lock::unsafe_int_type<int> >
      status_; 
#endif
 
#if defined(LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR) && LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR
  std::exception_ptr unhandle_exception_;
#endif
 
 protected:
  LIBCOPP_COPP_API coroutine_context_base() LIBCOPP_MACRO_NOEXCEPT;
 
 public:
  LIBCOPP_COPP_API ~coroutine_context_base();
 
 private:
  coroutine_context_base(const coroutine_context_base &) = delete;
  coroutine_context_base &operator=(const coroutine_context_base &) = delete;
 
  coroutine_context_base(const coroutine_context_base &&) = delete;
  coroutine_context_base &operator=(const coroutine_context_base &&) = delete;
 
 public:
  LIBCOPP_COPP_API bool set_flags(int flags) LIBCOPP_MACRO_NOEXCEPT;
 
  LIBCOPP_COPP_API bool unset_flags(int flags) LIBCOPP_MACRO_NOEXCEPT;
 
  LIBCOPP_COPP_API bool check_flags(int flags) const LIBCOPP_MACRO_NOEXCEPT;
 
 protected:
  LIBCOPP_UTIL_FORCEINLINE void run_and_recv_retcode(void *priv_data) {
    if (!runner_) return;
 
    runner_ret_code_ = runner_(priv_data);
  }
  LIBCOPP_UTIL_FORCEINLINE void run_and_recv_retcode(void *priv_data) {…}
 
 public:
  LIBCOPP_COPP_API int set_runner(callback_type &&runner);
 
  LIBCOPP_UTIL_FORCEINLINE const std::function<int(void *)> &get_runner() const LIBCOPP_MACRO_NOEXCEPT {
    return runner_;
  }
  LIBCOPP_UTIL_FORCEINLINE const std::function<int(void *)> &get_runner() const LIBCOPP_MACRO_NOEXCEPT {…}
 
  LIBCOPP_UTIL_FORCEINLINE int get_ret_code() const LIBCOPP_MACRO_NOEXCEPT { return runner_ret_code_; }
 
  LIBCOPP_COPP_API bool is_finished() const LIBCOPP_MACRO_NOEXCEPT;
 
  LIBCOPP_UTIL_FORCEINLINE void *get_private_buffer() const LIBCOPP_MACRO_NOEXCEPT { return priv_data_; }
 
  LIBCOPP_UTIL_FORCEINLINE size_t get_private_buffer_size() const LIBCOPP_MACRO_NOEXCEPT {
    return private_buffer_size_;
  }
  LIBCOPP_UTIL_FORCEINLINE size_t get_private_buffer_size() const LIBCOPP_MACRO_NOEXCEPT {…}
 
 public:
  LIBCOPP_UTIL_FORCEINLINE static size_t align_private_data_size(size_t sz) {
    // static size_t random_index = 0;
    // constexpr const size_t random_mask = 63;
    constexpr const size_t align_mask = COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE - 1;
 
    // align
    sz += align_mask;
    sz &= ~align_mask;
 
    // random
    // ++random_index;
    // random_index &= random_mask;
    // sz += random_index * (align_mask + 1);
    return sz;
  }
  LIBCOPP_UTIL_FORCEINLINE static size_t align_private_data_size(size_t sz) {…}
 
  static inline size_t align_address_size(size_t sz) {
    constexpr const size_t align_mask = COROUTINE_CONTEXT_BASE_ALIGN_UNIT_SIZE - 1;
 
    sz += align_mask;
    sz &= ~align_mask;
    return sz;
  }
  static inline size_t align_address_size(size_t sz) {…}
 
  static inline size_t align_stack_size(size_t sz) {
    constexpr const size_t align_mask = COROUTINE_CONTEXT_STACK_ALIGN_UNIT_SIZE - 1;
 
    sz += align_mask;
    sz &= ~align_mask;
    return sz;
  }
  static inline size_t align_stack_size(size_t sz) {…}
 
#if defined(LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR) && LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR
  static inline void maybe_rethrow(std::exception_ptr &inout) {
    if LIBCOPP_UTIL_UNLIKELY_CONDITION (inout) {
      std::exception_ptr eptr;
      std::swap(eptr, inout);
      std::rethrow_exception(eptr);
    }
  }
 
  LIBCOPP_UTIL_FORCEINLINE void maybe_rethrow() { maybe_rethrow(unhandle_exception_); }
#endif
 
  static LIBCOPP_COPP_API coroutine_context_base *get_this_coroutine_base() LIBCOPP_MACRO_NOEXCEPT;
 
  static LIBCOPP_COPP_API void set_this_coroutine_base(coroutine_context_base *ctx) LIBCOPP_MACRO_NOEXCEPT;
};
class coroutine_context_base {…};
LIBCOPP_COPP_NAMESPACE_END