ThreadRunnable.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2022 Daniel Barrientos <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
#include <core/Thread.h>
using mel::core::Thread;
#include <tasking/Runnable.h>
using mel::tasking::Runnable;
// can alternate between custom "clasic" events to C++11 condition_variables
// which seems to get better performance at least on Windows platforms
#ifndef USE_CUSTOM_EVENT
#include <condition_variable>
#endif
 
namespace mel
{
    namespace tasking
    {
        class MEL_API ThreadRunnable
            : public Runnable
            ,
              public std::enable_shared_from_this<ThreadRunnable>
        {
          public:
            enum EThreadState
            {
                THREAD_INIT = binary<1>::value,
                THREAD_RUNNING = binary<10>::value,
                THREAD_SUSPENDED = binary<100>::value,
                THREAD_FINISHING = binary<1000>::value,
                THREAD_FINISHING_DONE = binary<10000>::value,
                THREAD_FINISHED = binary<100000>::value
            };
            static std::shared_ptr<ThreadRunnable>
            create( bool autoRun = true,
                    Runnable::RunnableCreationOptions opts = sDefaultOpts )
            {
                auto th = new ThreadRunnable( std::move( opts ) );
                th->start();
                std::shared_ptr<ThreadRunnable> result( th );
                if ( !autoRun ) // really means auto pause if no autorun, always
                                // create running
                    result->suspend();
                return result;
            }
            ~ThreadRunnable();
            void start();
            // void finish() override { terminate(0); }
            // bool finished()  override {return getState() == THREAD_FINISHED;
            // }
            bool join( unsigned int millis = 0xFFFFFFFF );
            bool setAffinity( uint64_t aff )
            {
                return mThread->setAffinity( aff );
            }
 
            unsigned int suspend();
            unsigned int resume();
            EThreadState getState() const { return mState; }
            void terminate();
            bool getTerminateRequest() { return mEnd; }
            static ThreadRunnable* getCurrentThreadRunnable();
 
          private:
            static Runnable::RunnableCreationOptions sDefaultOpts;
            std::unique_ptr<Thread> mThread;
#ifdef USE_CUSTOM_EVENT
            Event mWaitForTasks;
#else
            volatile bool mSignaled;
            std::condition_variable mWaitForTasksCond;
            std::mutex mCondMut;
#endif
            volatile bool mEnd; // request
            EThreadState mState;
            ::mel::core::Event mPauseEV;
 
            ::mel::core::ECallbackResult
            _processAwaken( std::shared_ptr<Process> p );
            void _execute();
            ::mel::tasking::EGenericProcessResult
            _suspendInternal( uint64_t millis, Process* proc ) noexcept;
            void _signalWakeup();
 
          protected:
            ThreadRunnable(
                Runnable::RunnableCreationOptions opts = sDefaultOpts );
            virtual void onStart(){};
            virtual void onThreadStart() {}
            virtual void onThreadEnd() {}
            virtual void onJoined() {}
            void onCycleEnd();
 
            void onPostTask( std::shared_ptr<Process> process ) override;
        };
 
    } // namespace tasking
} // namespace mel