semaphore.hpp

#pragma once
 
#include <mutex>
 
#include "declarations.hpp"
#include "../utility/small_vector.hpp"

 
namespace tf {
 
// ----------------------------------------------------------------------------
// Semaphore
// ----------------------------------------------------------------------------

class Semaphore {
 
  friend class Node;
  friend class Executor;
 
  public:

    Semaphore() = default;

    explicit Semaphore(size_t max_value);

    size_t value() const;

    size_t max_value() const;

    void reset();
    
    void reset(size_t new_max_value);
 
  private:
 
    mutable std::mutex _mtx;
    
    size_t _max_value{0};
    size_t _cur_value{0};
 
    SmallVector<Node*> _waiters;
 
    bool _try_acquire_or_wait(Node*);
 
    void _release(SmallVector<Node*>&);
};
 
inline Semaphore::Semaphore(size_t max_value) :
  _max_value(max_value),
  _cur_value(max_value) {
}
 
inline bool Semaphore::_try_acquire_or_wait(Node* me) {
  std::lock_guard<std::mutex> lock(_mtx);
  if(_cur_value > 0) {
    --_cur_value;
    return true;
  }
  else {
    _waiters.push_back(me);
    return false;
  }
}
 
inline void Semaphore::_release(SmallVector<Node*>& dst) {
 
  std::lock_guard<std::mutex> lock(_mtx);
 
  if(_cur_value >= _max_value) {
    TF_THROW("can't release the semaphore more than its maximum value: ", _max_value);
  }
 
  ++_cur_value;
  
  if(dst.empty()) {
    dst.swap(_waiters);
  }
  else {
    dst.reserve(dst.size() + _waiters.size());
    dst.insert(dst.end(), _waiters.begin(), _waiters.end());
    _waiters.clear();
  }
}
 
inline size_t Semaphore::max_value() const {
  return _max_value; 
}
 
inline size_t Semaphore::value() const {
  std::lock_guard<std::mutex> lock(_mtx);
  return _cur_value;
}
 
inline void Semaphore::reset() {
  std::lock_guard<std::mutex> lock(_mtx);
  _cur_value = _max_value;
  _waiters.clear();
}
 
inline void Semaphore::reset(size_t new_max_value) {
  std::lock_guard<std::mutex> lock(_mtx);
  _cur_value = (_max_value = new_max_value);
  _waiters.clear();
}
 
}  // end of namespace tf. ---------------------------------------------------