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