thread.hxx

// dawn/include/dawn/common/thread.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <pthread.h>
#include <utility>
 
#include "dawn/porting/config.hxx"
 
namespace dawn
{
class CThreadedObject
{
public:
  static constexpr int THREAD_PRIORITY_DEFAULT = 0;
 
  static constexpr int THREAD_SCHEDULER_DEFAULT = -1;
 
  struct SThreadConfig
  {
    size_t stackSize; 
    int priority;     
    int scheduler;    
 
    constexpr SThreadConfig(size_t stackSizeBytes = 0,
                            int priorityValue = THREAD_PRIORITY_DEFAULT,
                            int schedulerPolicy = THREAD_SCHEDULER_DEFAULT)
      : stackSize(stackSizeBytes)
      , priority(priorityValue)
      , scheduler(schedulerPolicy)
    {
    }
  };
 
  CThreadedObject()
    : th()
    , thCreated(false)
    , thQuit(true)
    , thQuitDone(true)
    , threadFunc(nullptr)
    , threadConfig()
  {
  }
 
  CThreadedObject(const CThreadedObject &) = delete;
  CThreadedObject &operator=(const CThreadedObject &) = delete;
 
  virtual ~CThreadedObject();
 
  template<typename Func>
  void setThreadFunc(Func &&func)
  {
    threadFunc = std::forward<Func>(func);
  }
 
  void setThreadConfig(const SThreadConfig &config)
  {
    threadConfig = config;
  }
 
  const SThreadConfig &getThreadConfig() const
  {
    return threadConfig;
  }
 
  void setThreadStackSize(size_t stackSize)
  {
    threadConfig.stackSize = stackSize;
  }
 
  size_t getThreadStackSize() const
  {
    return threadConfig.stackSize;
  }
 
  void setThreadPriority(int priority)
  {
    threadConfig.priority = priority;
  }
 
  int getThreadPriority() const
  {
    return threadConfig.priority;
  }
 
  void setThreadScheduler(int scheduler)
  {
    threadConfig.scheduler = scheduler;
  }
 
  int getThreadScheduler() const
  {
    return threadConfig.scheduler;
  }
 
  int threadStart();
 
  int threadStop();
 
  bool isRunning() const;
 
  bool shouldQuit() const
  {
    return thQuit.load();
  }
 
  bool isStopped() const
  {
    return thQuitDone.load();
  }
 
  bool hasThreadObject() const
  {
    return thCreated;
  }
 
  void requestStop()
  {
    thQuit = true;
  }
 
  void clearStopRequest()
  {
    thQuit = false;
  }
 
  void markThreadFinished()
  {
    thQuitDone = true;
  }
 
protected:
  template<typename Func>
  int startWorkerThread(Func &&func)
  {
    setThreadFunc(std::forward<Func>(func));
    return threadStart();
  }
 
  int stopWorkerThread()
  {
    return threadStop();
  }
 
  bool workerThreadRunning() const
  {
    return isRunning();
  }
 
  CThreadedObject &workerThread()
  {
    return *this;
  }
 
  const CThreadedObject &workerThread() const
  {
    return *this;
  }
 
private:
  pthread_t th;                     
  bool thCreated;                   
  std::atomic_bool thQuit;          
  std::atomic_bool thQuitDone;      
  std::function<void()> threadFunc; 
  SThreadConfig threadConfig;       
 
  int joinThread();
  int buildThreadAttr(pthread_attr_t &attr, bool &needsDestroy) const;
  void threadWrapper();
  static void *threadEntry(void *arg);
};
 
} // Namespace dawn