Thread.h

[詳解]

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <thread>
#include <functional>
#include "diarkis/common.h"
#include "diarkis/system/Component.h"
#include "diarkis/logging/LoggerFactory.h"
#include "diarkis/logging/Logger.h"
#include "diarkis/system/result.h"
 
// ADD NAMESPACE NAME TAG
namespace Diarkis { namespace System
{
    // Forward declaration
    class DiarkisThreadImpl;
 
    using ThreadFunc = std::function<Diarkis::System::Result(void*)>;
 
    enum class DiarkisThreadPriority : std::uint8_t
    {
        PRIORITY_HIGHEST = 0,
        PRIORITY_ABOVE_NORMAL,
        PRIORITY_NORMAL,
        PRIORITY_BELOW_NORMAL,
        PRIORITY_LOWEST
    };
 
    enum class DiarkisThreadPolicy : std::uint8_t
    {
        STANDARD = 0,
        ROUNDROBIN,
        FIFO
    };
    
    struct DiarkisThreadScheduler
    {
        DiarkisThreadPolicy policy;
        DiarkisThreadPriority priority;
        uint32_t affinity;
    };
 
// some platforms do not use std::uint8_t as native type
#if defined(DIARKIS_PLATFORM_NINTENDO_SWITCH)
using NativeThreadHandle = pthread_t;
#else
using NativeThreadHandle = std::thread::native_handle_type;
#endif // DIARKIS_PLATFORM_NINTENDO_SWITCH
 
    class DiarkisThreadParams
    {
    public:
        Diarkis::StdString              name;
        // ! Thread priority
        DiarkisThreadPriority           priority;
        DiarkisThreadPolicy             policy;
        ThreadFunc                      func;
        uint32_t                         affinityMask;
        uint32_t                        stackSize;
 
    public:
        DiarkisThreadParams()
            : name("DiarkisDefaultThread")
            , priority(DiarkisThreadPriority::PRIORITY_BELOW_NORMAL)
            , policy(DiarkisThreadPolicy::STANDARD)
            , func(nullptr)
            , affinityMask(0x0)
            , stackSize(16 * 1024)
        {
        }
 
        ~DiarkisThreadParams() = default;
    };
 
 
    class DIARKIS_EXPORT DiarkisThread
    {
    public:
        DiarkisThread();
        ~DiarkisThread();
    public:
        void SetLoggerFactory(std::shared_ptr<IDiarkisLoggerFactory> loggerFactory);
 
        Diarkis::System::Result Start(const DiarkisThreadParams& params,void *args);
 
        Diarkis::System::Result Join();
 
        bool Joinable();
 
        Diarkis::System::Result Sleep(uint32_t msec);
 
        int GetCurrentCPU();
 
        Diarkis::System::Result yield();
 
        NativeThreadHandle GetHandle();
 
    private:
        DiarkisThreadImpl* pimpl_;
 
    };
 
} }
// ADD NAMESPACE } TAG