worker_progress_thread.h

#pragma once
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
 
#include <ucxx/delayed_submission.h>
 
namespace ucxx {

typedef std::function<void(void)> SignalWorkerFunction;

typedef std::function<void(void*)> ProgressThreadStartCallback;

typedef void* ProgressThreadStartCallbackArg;

class WorkerProgressThread {
 public:
  struct StopConfig {
    uint64_t callbackTimeoutNs;  
    uint64_t signalIntervalNs;   

    explicit StopConfig(uint64_t callbackTimeoutNs = 3000000000,
                        uint64_t signalIntervalNs  = 100000000)
      : callbackTimeoutNs(callbackTimeoutNs), signalIntervalNs(signalIntervalNs)
    {
    }
  };
 
 private:
  std::thread _thread{};  
  std::shared_ptr<std::atomic<bool>> _stop{
    std::make_shared<std::atomic<bool>>(false)};  
  bool _pollingMode{false};  
  SignalWorkerFunction _signalWorkerFunction{
    nullptr};  
  ProgressThreadStartCallback _startCallback{
    nullptr};  
  ProgressThreadStartCallbackArg _startCallbackArg{
    nullptr};  
  std::shared_ptr<DelayedSubmissionCollection> _delayedSubmissionCollection{
    nullptr};  

  static void progressUntilSync(
    std::function<bool(void)> progressFunction,
    std::shared_ptr<std::atomic<bool>> stop,
    std::function<void(void)> setThreadId,
    ProgressThreadStartCallback startCallback,
    ProgressThreadStartCallbackArg startCallbackArg,
    std::shared_ptr<DelayedSubmissionCollection> delayedSubmissionCollection);
 
 public:
  WorkerProgressThread()                                       = default;
  WorkerProgressThread(const WorkerProgressThread&)            = delete;
  WorkerProgressThread& operator=(WorkerProgressThread const&) = delete;

  WorkerProgressThread(WorkerProgressThread&& o) = default;

  WorkerProgressThread& operator=(WorkerProgressThread&& o) = default;

  WorkerProgressThread(const bool pollingMode,
                       std::function<bool(void)> progressFunction,
                       std::function<void(void)> signalWorkerFunction,
                       std::function<void(void)> setThreadId,
                       ProgressThreadStartCallback startCallback,
                       ProgressThreadStartCallbackArg startCallbackArg,
                       std::shared_ptr<DelayedSubmissionCollection> delayedSubmissionCollection);

  ~WorkerProgressThread();

  [[nodiscard]] bool pollingMode() const;

  [[nodiscard]] std::thread::id getId() const;

  [[nodiscard]] bool isRunning() const;

  void stop(StopConfig stopConfig = StopConfig{});
};
 
}  // namespace ucxx