Runnable.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2005,2022 Daniel Barrientos <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
#include <core/Callback.h>
#include <tasking/ProcessScheduler.h>
#include <tasking/GenericProcess.h>
#include <core/CallbackSubscriptor.h>
using mel::core::CallbackSubscriptor;
 
#include <map>
using std::map;
 
using mel::tasking::ProcessScheduler;
using mel::tasking::GenericProcess;
 
#include <mpl/ParamAdder.h>
using mel::mpl::addParam;
#include <mpl/LinkArgs.h>
using mel::mpl::linkFunctor;
#include <mpl/ReturnAdaptor.h>
using mel::mpl::returnAdaptor;
#include <mpl/MemberEncapsulate.h>
using mel::mpl::makeMemberEncapsulate;
#include <mpl/Functor.h>
using mel::mpl::chain;
#include <mpl/AsPtr.h>
using mel::mpl::asPtr;
 
#include <core/ThreadDefs.h>
 
#include <core/Future.h>
using mel::core::Future;
#include <functional>
#include <cassert>
#include <forward_list>
#include <type_traits>
 
#define RUNNABLE_TASK_ALIGNMENT 8
namespace mel
{
    namespace tasking 
    {       
        //some macros to create task functors easily from bool f() functors
        //note: be carefull with f forma, because if it has soma "," inside, maybe you
        // need to use "coma" (defined somewhere in mpl) or use a extra parenthesis
        // for example, if you want to do RUNNABLE_CREATETASK( link1st<false,void>( xxx ) ) this doesn't compile
        //so you need to do RUNNABLE_CREATETASK( (link1st<false,void>( xxx )) ) or RUNNABLE_CREATETASK( link1st<false coma void>( xxx ) )
        //to show de preprocessor that the ',' is not a parameter separator sign
    #define RUNNABLE_CREATETASK( f ) \
        addParam< ::mel::tasking::EGenericProcessResult,Process*,uint64_t,void > \
        (addParam< ::mel::tasking::EGenericProcessResult,uint64_t,void >( f ) ) 
    //useful macro to declare task parameters
    #define RUNNABLE_TASK_PARAMS uint64_t t,Process* p
        class Runnable; //predeclaration
        class MEL_API ProcessFactory
        {
            public:
                inline GenericProcess* create(Runnable* owner)const {return onCreate(owner);};
            protected:
                virtual GenericProcess* onCreate(Runnable* owner) const;
                
        };
        struct MEL_API DefaultAllocator
        {
            static GenericProcess* allocate(Runnable* _this);
        };
        namespace _private
        {
            class MEL_API RunnableTask final: public GenericProcess
            {
            public:     
                //throws bad_alloc oif no enoguh memory
                static void* operator new( size_t s,Runnable* owner );
                void operator delete(void* ptr, Runnable*) noexcept;
                static void operator delete( void* ptr ) noexcept;          
                RunnableTask(){}
            private:
            };
            /*
            //default allocator for new tasks (through post) doing a simple new     
            template <class T>
            struct Allocator
            {
                static T* allocate(Runnable* _this)
                {
                    return new T();
                }
            };
            //special allocator for RunnableTask using internal pool
            template <>
            struct Allocator<RunnableTask>
            {
                static RunnableTask* allocate(Runnable* _this)
                {        
                    return new (_this)RunnableTask();
                }
            };
            */
            
            struct RTMemPool; //predeclaration
            struct RTMemBlock
            {
                enum class EMemState:uint8_t { FREE = 0,USED = 1 } ;                            
                EMemState   memState = EMemState::FREE;  
                alignas(RUNNABLE_TASK_ALIGNMENT) char task[ sizeof( ::mel::tasking::_private::RunnableTask ) ] ;            
                //RunnableTask task;
                RTMemPool*  owner;
            };
            struct MemZoneList
            {
                typedef std::forward_list<RTMemPool> ListType;
                public:
                    MemZoneList():mSize(0){}
                    size_t size(){ return mSize;};
                    void push_front(RTMemPool&& pool)
                    {
                        mList.push_front(std::move(pool));
                        ++mSize;
                    }
                    ListType& getList(){ return mList;}
                    void remove(RTMemPool* pool )
                    {
                        //@todo hacer más eficiente teniendo iterador
                        mList.remove_if([pool](const RTMemPool& p)
                        {
                            auto r = (pool == &p);
                            return r;
                        });
                        --mSize; //todo no guaratee was removed. Since C++20 remove returns number of elements removed
                    }
                private:
                    size_t mSize;
                    ListType mList;
            };
            //typedef std::forward_list<RTMemPool> MemZoneList;
            struct RTMemPool
            {
                RTMemPool():pool(0),count(0){}
                RTMemBlock* pool; //array to memory blocks
                Runnable* owner;
                size_t count;
                //MemZoneList::iterator iterator; quitar
            };
        }
 
        class MEL_API Runnable
        {
        private:
            
        public:         
            struct RunnableInfo
            {
                Runnable* current = nullptr;
            };      
            static const unsigned int DEFAULT_POOL_SIZE = 512;
            //static const unsigned int DEFAULT_MAX_NEW_TASKS = DEFAULT_POOL_SIZE*4;
            
            struct RunnableCreationOptions
            {
                unsigned int maxPoolSize = DEFAULT_POOL_SIZE; 
                ProcessScheduler::SchedulerOptions schedulerOpts; 
            };
            inline ::mel::core::ThreadId getOwnerThreadId() const { assert(mOwnerThread != 0); return mOwnerThread; }
            inline void setOwnerThreadId(mel::core::ThreadId tid) {mOwnerThread=tid;}
            static Runnable* getCurrentRunnable();
            void setDefaultFactory(ProcessFactory* factory){mDefaultFactory.reset(factory);}
            inline const ProcessFactory* getDefaultFactory() const{return mDefaultFactory.get();}   
        protected:
        private:
        //get info on currently executing Runnable in current thread
            static RunnableInfo* _getCurrentRunnableInfo();
            friend class ::mel::tasking::_private:: RunnableTask;           
            //static thread_local Runnable::RunnableInfo tlCurrentRunnable;
            RunnableInfo* mCurrentInfo;
            std::unique_ptr<ProcessFactory> mDefaultFactory; //factory to use for allocating tasks if no other given
            ProcessScheduler    mTasks;
            RunnableCreationOptions mOpts;
            mel::tasking::_private::MemZoneList mRTZone;
            //std::atomic<State>    mState;
            std::mutex  mMemPoolCS;     
            mel::core::ThreadId mOwnerThread;//thread executing Runnable        
            
            mel::tasking::_private::RTMemPool* _addNewPool();
            void _removePool( ::mel::tasking::_private::RTMemPool* );
            
        protected:
            void processTasks();
            
            virtual void onPostTask(std::shared_ptr<Process> process){};
 
            //template <class F>
            //void setTaskAddedEvent( F functor );
            //inline TTaskAddedEvent* getTaskAddedEvent() const;
        public:
            void postTask(std::shared_ptr<Process> process,unsigned int startTime = 0);
 
            Runnable(RunnableCreationOptions opts);
            virtual ~Runnable();
 
    
            //helper functions to use as the "killFunctor" parameter in post(),fireAndForget(), and execute()
            static std::function<bool()> killTrue;
            static std::function<bool()> killFalse;
            template <bool ignoreNoThrow=false,class AllocatorType = ::mel::tasking::DefaultAllocator, class F,class KF = const std::function<bool()>&>
            std::shared_ptr<Process> post(
                F&& task_proc,
                KF&& killFunction=killFalse,            
                unsigned int period = 0,unsigned int startTime = 0);
            template <bool ignoreNoThrow=false,class AllocatorType = ::mel::tasking::DefaultAllocator, class F,class KF = const std::function<bool()>&>
            std::shared_ptr<Process> fireAndForget(
                F&& task_proc,
                unsigned int startTime = 0,
                KF&& killFunction=killTrue);
            template <class TRet,class F,class KF = const std::function<bool()>&> 
                Future<TRet> execute( F&& function,KF&& killFunction=killFalse) noexcept;
            template <class TRet,class F,class KF = const std::function<bool()>&> 
                Future<TRet> execute( F&& function,Future<TRet>,KF&& killFunction=killFalse) noexcept;
 
            
                    
            inline const ProcessScheduler& getScheduler() const;
            inline ProcessScheduler& getScheduler() ;
 
            void setTimer( std::shared_ptr<Timer> timer );
            inline const std::shared_ptr<Timer> getTimer( ) const;
            inline std::shared_ptr<Timer> getTimer( );
            inline unsigned int getPendingTaskCount() const 
            {
                return (unsigned int)getScheduler().getProcessCount();
            }
            /*
            * get number of processes running (not sleeped or paused)
            */
        //  intentar flexibilizarlo para cuando considere los wait
            inline unsigned int getActiveTaskCount() const 
            {
                return (unsigned int)getScheduler().getActiveProcessCount();
            }
            inline unsigned int getMaxPoolSize() const{ return mOpts.maxPoolSize;}
        private:
 
        };
        
        template <bool ignoreNoThrow, class AllocatorType, class F,class KF>
        std::shared_ptr<Process> Runnable::post(
            F&& task_proc,
            KF&& killFunction,
            unsigned int period,unsigned int startTime )
        {
            static_assert( !ignoreNoThrow || std::is_nothrow_invocable<F,uint64_t,Process*>::value,"Runnable::post. Task must be noexcept");
            ::std::shared_ptr<GenericProcess> p(AllocatorType::allocate(this));         
            p->setProcessCallback( ::std::forward<F>(task_proc) );
            p->setPeriod( period );
            p->setKillCallback( ::std::forward<KF>(killFunction) );
            postTask(p,startTime);
            return p;   
        }
        template <bool ignoreNoThrow, class AllocatorType, class F,class KF>
            std::shared_ptr<Process> Runnable::fireAndForget(
                F&& task_proc,
                unsigned int startTime,
                KF&& killFunction)
        {   
            return post<ignoreNoThrow,AllocatorType>(
                [f=std::forward<F>(task_proc)](RUNNABLE_TASK_PARAMS) mutable noexcept( noexcept(task_proc()) )
                {
                    f();
                    return ::mel::tasking::EGenericProcessResult::KILL;
                }
                ,std::forward<KF>(killFunction),0,startTime
            );
            
        }
 
        const ProcessScheduler& Runnable::getScheduler() const
        {
            return mTasks;
        }
        ProcessScheduler& Runnable::getScheduler() 
        {
            return mTasks;
        }
        const std::shared_ptr<Timer> Runnable::getTimer( ) const
        {
            return mTasks.getTimer();
        }
        std::shared_ptr<Timer> Runnable::getTimer( )
        {
            return mTasks.getTimer();
        }
        
        template <class TRet, class F,class KF> 
        Future<TRet> Runnable::execute( F&& function,KF&& killFunction) noexcept
        {
            Future<TRet> future;    
            return execute(std::forward<F>(function),future,std::forward<KF>(killFunction));        
        }
        template <class TRet, class F,class KF> 
        Future<TRet> Runnable::execute( F&& f,Future<TRet> output,KF&& killFunction) noexcept
        {
            //always post the task, despite being in same thread. This is the most consistent way of doing it
 
        //PRUEBAS
            // try
            // {
            //  if constexpr (std::is_same<void,TRet>::value)
            //  {
            //      f();
            //      output.setValue();
            //  }
            //  else
            //      output.setValue(f());
            // }
            // //check chances of Exception
            // catch( std::exception& e )
            // {                    
            //  output.setError( ErrorType(Runnable::ERRORCODE_EXCEPTION,e.what()) );   
            // }
            // catch(...)
            // {
                
            //  output.setError( ErrorType(Runnable::ERRORCODE_UNKNOWN_EXCEPTION,"Unknown exception") );    
 
            // }
            
            post(
                [output,f = std::forward<F>(f)](RUNNABLE_TASK_PARAMS) mutable noexcept
                {
                    if constexpr (noexcept(f()))
                    {
                        if constexpr (std::is_same<void,TRet>::value)
                        {
                            f();
                            output.setValue();
                        }
                        else
                        {
                            output.setValue(f());
                        }
                    }else
                    {
                        try 
                        {
                            if constexpr (std::is_same<void,TRet>::value)
                            {
                                f();
                                output.setValue();
                            }
                            else
                            {
                                output.setValue(f());
                            }
                        }
                        catch(...)
                        {
                            //output.setError( ErrorType(Runnable::ERRORCODE_UNKNOWN_EXCEPTION,"Unknown exception") );  
                            output.setError( std::current_exception() );    
                        }
                    }
                    /*
                    //check chances of Exception
                    catch( std::exception& e )
                    {                   
                        output.setError( ErrorType(Runnable::ERRORCODE_EXCEPTION,e.what()) );                       
                    }*/
                    
                    return ::mel::tasking::EGenericProcessResult::KILL;
                },std::forward<KF>(killFunction)        
            );
            
        
            return output;
        }                       
        
    }
}