Process.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2005,2022 Daniel Barrientos
 * <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
 
#include <MelLibType.h>
 
#include <mpl/binary.h>
using mel::mpl::binary;
 
#include <core/Callback.h>
using mel::core::Callback;
#include <memory>
#include <mpl/Tuple.h>
#include <stdint.h>
 
#if defined( MEL_IOS ) || defined( MEL_MACOSX )
#include <TargetConditionals.h>
#endif
#if defined( MEL_X86_GCC ) || TARGET_CPU_X86 || defined( MEL_X86_MSVC )
#include <tasking/Process_X86.h>
#elif TARGET_CPU_X86_64
#include <tasking/Process_X64_MAC.h>
#elif TARGET_CPU_ARM64
#include <tasking/Process_ARM64_IPhone.h>
#elif defined( _ARM_GCC ) && ( !defined( MEL_IOS ) )
#include <tasking/Process_ARM_GCC.h>
#elif defined( MEL_IOS )
#if !TARGET_IPHONE_SIMULATOR
#if defined( __arm__ )
#include <tasking/Process_ARM_IPhone.h>
#elif defined( __arm64__ )
#include <tasking/Process_ARM64_IPhone.h>
#else
#pragma message "Unknown ARM architecture"
#endif
#else
#include <core/Process_X86.h>
#endif
#elif defined( MEL_ANDROID )
#include <tasking/Process_ARM_Android.h>
#elif defined( MEL_X64_GCC ) || defined( MEL_X64_CLANG )
#include <tasking/Process_X64_GCC.h>
#elif defined( MEL_WINDOWS ) && defined( MEL_X64_MSVC )
#include <tasking/Process_X64_MSVC.h>
#endif
#if defined( MEL_IOS ) || defined( MEL_MACOSX )
#define OPTIMIZE_FLAGS __attribute__( ( optnone ) )
#elif defined( MEL_ANDROID )
#define OPTIMIZE_FLAGS
#elif defined( _ARM_GCC ) || defined( MEL_X86_GCC ) || defined( MEL_X64_GCC )
#define OPTIMIZE_FLAGS __attribute__( ( optimize( 0 ) ) )
#elif defined( MEL_X64_CLANG )
#define OPTIMIZE_FLAGS __attribute__( ( optnone ) )
#elif defined( MEL_WINDOWS )
#define OPTIMIZE_FLAGS
#endif
namespace mel
{
    namespace tasking
    {
        class ProcessScheduler; // predeclaration
        class MEL_API Process :
            public std::enable_shared_from_this<Process>,
            public MThreadAttributtes
        {
 
            static void _switchProcess() OPTIMIZE_FLAGS;
 
          public:
            enum EProcessState : uint8_t
            {
                PREPARED,        
                INITIATED,       
                ASLEEP,          
                PREPARED_TO_DIE, 
                TRYING_TO_KILL,  
                KILLING_WAITING_FOR_SCHEDULED, 
                DEAD 
            };
            enum class ESwitchResult
            {
                ESWITCH_OK,     
                ESWITCH_WAKEUP, 
                ESWITCH_ERROR,  
                ESWITCH_KILL    
            };
 
            Process( unsigned short capacity = 0 );
            virtual ~Process( void );
            void setProcessScheduler( ProcessScheduler* const mgr );
            void pause();
 
            void kill( bool force = false );
            virtual void reset();
            inline void setPeriod( unsigned int value );
 
            EProcessState getState() const { return mState; }
            inline bool getDead() const;
            // inline bool getPreparedToDie() const;
            inline unsigned int getPeriod() const;
            unsigned int getElapsedTime() const;
            inline uint64_t getLastUpdateTime() const;
            inline void resetTime();
 
            inline ProcessScheduler* const getProcessScheduler() const;
 
            static ESwitchResult wait( unsigned int msegs ) OPTIMIZE_FLAGS;
            static ESwitchResult
            switchProcess( bool continueInmediately ) OPTIMIZE_FLAGS;
            template <class F> static ESwitchResult sleepAndDo( F postSleep );
            template <class F>
            static ESwitchResult waitAndDo( unsigned int msegs,
                                            F postWait ) OPTIMIZE_FLAGS;
            static ESwitchResult sleep() OPTIMIZE_FLAGS;
            inline bool getAsleep() const;
            void wakeUp();
 
          private:
            // static ESwitchResult _sleep(  Callback<void,void>* )
            // OPTIMIZE_FLAGS;
            static mel::mpl::Tuple<TYPELIST( int, Process*, unsigned int )>
            _preSleep() OPTIMIZE_FLAGS;
            static ESwitchResult _postSleep(
                mel::mpl::Tuple<TYPELIST( int, Process*, unsigned int )> )
                OPTIMIZE_FLAGS;
            // static ESwitchResult _wait( unsigned int msegs,
            // Callback<void,void>* ) OPTIMIZE_FLAGS;
            static mel::mpl::Tuple<TYPELIST( bool, Process* )>
            _preWait() OPTIMIZE_FLAGS;
            static ESwitchResult _postWait(
                uint64_t msegs,
                mel::mpl::Tuple<TYPELIST( bool, Process* )> ) OPTIMIZE_FLAGS;
            EProcessState mState;
            EProcessState mPreviousState;
            volatile bool mWakeup; // temp value to know if context switch comes
                                   // from a wakeup
            bool mPauseReq;
            unsigned int mPeriod;
            uint64_t mLastUpdateTime; 
            ProcessScheduler*
                mOwnerProcessScheduler; 
            void _execute( uint64_t msegs ) OPTIMIZE_FLAGS;
            volatile void checkMicrothread( uint64_t msegs ) OPTIMIZE_FLAGS;
            void update( uint64_t msegs ) OPTIMIZE_FLAGS;
            inline void setDead();
 
          protected:
            virtual void onUpdate( uint64_t msecs ) = 0;
            virtual void onInit( uint64_t msecs ){};
            virtual bool onKill() { return true; };
            virtual void onPause(){};
            virtual void onWakeUp() {}
            virtual void killDone(){};
 
            friend class ProcessScheduler;
        };
 
        void Process::setPeriod( unsigned int value ) { mPeriod = value; }
 
        void Process::setDead() { mState = EProcessState::DEAD; }
        ProcessScheduler* const Process::getProcessScheduler() const
        {
            return mOwnerProcessScheduler;
        }
        /*bool Process::getDead() const
        {
                return (mState ==EProcessState:: DEAD );
        }
        bool Process::getPreparedToDie() const
        {
                return (mState == EProcessState::PREPARED_TO_DIE);
        }*/
        unsigned int Process::getPeriod() const { return mPeriod; }
 
        void Process::resetTime() { mLastUpdateTime = 0; }
        // uint64_t Process::getPreviousTime() const
        // {
        //  return mPreviousTime;
        // }
 
        // uint64_t Process::getLastTime() const
        // {
        //  return mLastTime;
        // }
        uint64_t Process::getLastUpdateTime() const { return mLastUpdateTime; }
 
        bool Process::getAsleep() const
        {
            return mState == EProcessState::ASLEEP && !mWakeup;
        }
 
        template <class F>
        Process::ESwitchResult Process::waitAndDo( unsigned int msegs,
                                                   F postWait )
        {
            auto v = _preWait();
            // trigger callback
            postWait();
            return _postWait( msegs, v );
            // return _wait( msegs,new Callback<void,void>(
            // postWait,::core::use_functor ) );
        }
        template <class F>
        Process::ESwitchResult Process::sleepAndDo( F postSleep )
        {
            auto v = _preSleep();
            // trigger callback
            postSleep();
            return _postSleep( v );
            // return _sleep( new Callback<void,void>(
            // postSleep,::core::use_functor ) );
        }
    } // namespace tasking
} // namespace mel