async_task.hpp

#pragma once
 
#include "graph.hpp"

 
namespace tf {
 
// ----------------------------------------------------------------------------
// AsyncTask
// ----------------------------------------------------------------------------

class AsyncTask {
  
  friend class Executor;
  
  public:
    
    AsyncTask() = default;
    
    ~AsyncTask();
    
    AsyncTask(const AsyncTask& rhs);

    AsyncTask(AsyncTask&& rhs);
    
    AsyncTask& operator = (const AsyncTask& rhs);

    AsyncTask& operator = (AsyncTask&& rhs);
    
    bool empty() const;

    void reset();
    
    size_t hash_value() const;

    size_t use_count() const;

    bool is_done() const; 
    
    std::exception_ptr exception_ptr() const;
    
    bool has_exception_ptr() const;
 
  private:
 
    explicit AsyncTask(Node*);
 
    Node* _node {nullptr};
 
    void _incref();
    void _decref();
};
 
// Constructor
inline AsyncTask::AsyncTask(Node* ptr) : _node{ptr} {
  _incref();
}
 
// Function: _incref
inline void AsyncTask::_incref() {
  if(_node) {
    // increment the refcount packed in the lower 24 bits of _estate —
    // no std::get_if needed since we know this node is DependentAsync
    _node->_estate.fetch_add(ESTATE::REFCOUNT_ONE, std::memory_order_relaxed);
  }
}
 
// Function: _decref
inline void AsyncTask::_decref() {
  if(_node) {
    // decrement the refcount packed in the lower 24 bits of _estate.
    // mask out the state bits before comparing so we only check the refcount.
    // if it reaches zero, no owners remain and we recycle the node.
    if((_node->_estate.fetch_sub(ESTATE::REFCOUNT_ONE, std::memory_order_acq_rel)
        & ESTATE::REFCOUNT_MASK) == ESTATE::REFCOUNT_ONE) {
      recycle(_node);
    }
  }
}
 
// Copy Constructor
inline AsyncTask::AsyncTask(const AsyncTask& rhs) : 
  _node{rhs._node} {
  _incref();
}
 
// Move Constructor
inline AsyncTask::AsyncTask(AsyncTask&& rhs) :
  _node {rhs._node} {
  rhs._node = nullptr;
}
 
// Destructor
inline AsyncTask::~AsyncTask() {
  _decref();
}
 
// Copy assignment
inline AsyncTask& AsyncTask::operator = (const AsyncTask& rhs) {
  _decref();
  _node = rhs._node;
  _incref();
  return *this;
}
 
// Move assignment
inline AsyncTask& AsyncTask::operator = (AsyncTask&& rhs) {
  _decref();
  _node = rhs._node;
  rhs._node = nullptr;
  return *this;
}
 
// Function: exception
inline std::exception_ptr AsyncTask::exception_ptr() const {
  return _node ? _node->_exception_ptr : nullptr;
}
 
// Function: has_exception
inline bool AsyncTask::has_exception_ptr() const {
  return _node ? (_node->_exception_ptr != nullptr) : false;
}
 
// Function: empty
inline bool AsyncTask::empty() const {
  return _node == nullptr;
}
 
// Function: reset
inline void AsyncTask::reset() {
  _decref();
  _node = nullptr;
}
 
// Function: hash_value
inline size_t AsyncTask::hash_value() const {
  return std::hash<Node*>{}(_node);
}
 
// Function: use_count
inline size_t AsyncTask::use_count() const {
  return _node == nullptr ? size_t{0} :
    static_cast<size_t>(
      _node->_estate.load(std::memory_order_relaxed) & ESTATE::REFCOUNT_MASK
    );
}
 
// Function: is_done
inline bool AsyncTask::is_done() const {
  return _node == nullptr ? true: (_node->_estate.load(std::memory_order_acquire) & ESTATE::FINISHED);
}
 
}  // end of namespace tf ----------------------------------------------------