util.h

#ifndef LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_UTIL_H
#define LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_UTIL_H
#include <atomic>
#include <future>
#include <memory>
#include <string>
#include <vector>
 
#include <molpro/mpi.h>
 
namespace molpro::linalg::array::util {
 
class LockMPI3 {
protected:
  MPI_Comm m_comm = MPI_COMM_NULL; 
  MPI_Win m_win = MPI_WIN_NULL;    
  bool m_locked = false;           
 
public:
  LockMPI3(MPI_Comm comm);
  ~LockMPI3();
 
  LockMPI3() = delete;
  LockMPI3(const LockMPI3 &) = delete;
  LockMPI3 &operator=(const LockMPI3 &) = delete;
 
  void lock();
 
  void unlock();
 
protected:
  struct Proxy {
    LockMPI3 &m_lock;
    explicit Proxy(LockMPI3 &);
    Proxy() = delete;
    ~Proxy();
 
    bool m_deleted = false; 
  };
 
  std::weak_ptr<Proxy> m_proxy;
 
public:
  std::shared_ptr<Proxy> scope();
};
 
class ScopeLock {
public:
  explicit ScopeLock(MPI_Comm comm) : lock{comm}, l{lock.scope()} {}
 
protected:
  LockMPI3 lock;
  decltype(std::declval<LockMPI3>().scope()) l;
};
 
template <typename Result = void>
class Task {
public:
  Task(std::future<Result> &&task) : m_task{std::move(task)} {};
  Task(Task &&other) = default;
 
  template <class Func, typename... Args>
  static Task create(Func &&f, Args &&...args) {
    return {std::async(std::launch::async, std::forward<Func>(f), std::forward<Args>(args)...)};
  }
 
  ~Task() { wait(); }
 
  bool test() { return m_task.wait_for(std::chrono::microseconds{1}) == std::future_status::ready; }
  Result wait() {
    if (!m_task.valid())
      throw std::future_error(std::future_errc::no_state);
    return m_task.get();
  }
 
protected:
  std::future<Result> m_task; 
};
 
} // namespace molpro::linalg::array::util
 
#endif // LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_UTIL_H