coroutines.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef COMMON_COROUTINES_H
#define COMMON_COROUTINES_H

#include "common/scummsys.h"
#include "common/util.h"    // for SCUMMVM_CURRENT_FUNCTION
#include "common/list.h"
#include "common/singleton.h"

namespace Common {

#define CoroScheduler (Common::CoroutineScheduler::instance())


// Enable this macro to enable some debugging support in the coroutine code.
//#define COROUTINE_DEBUG

struct CoroBaseContext {
    int _line;
    int _sleep;
    CoroBaseContext *_subctx;
#ifdef COROUTINE_DEBUG
    const char *_funcName;
#endif

    CoroBaseContext(const char *func);

    virtual ~CoroBaseContext();
};

typedef CoroBaseContext *CoroContext;


extern CoroContext nullContext;

class CoroContextHolder {
    CoroContext &_ctx;
public:
    CoroContextHolder(CoroContext &ctx) : _ctx(ctx) {
        assert(ctx);
        assert(ctx->_sleep >= 0);
        ctx->_sleep = 0;
    }
    ~CoroContextHolder() {
        if (_ctx && _ctx->_sleep == 0) {
            delete _ctx;
            _ctx = nullptr;
        }
    }
};

#define CORO_PARAM    Common::CoroContext &coroParam


#define CORO_BEGIN_CONTEXT  \
    struct CoroContextTag : Common::CoroBaseContext { \
 CoroContextTag() : CoroBaseContext(SCUMMVM_CURRENT_FUNCTION) { DUMMY = 0; } \
        int DUMMY

#define CORO_END_CONTEXT(x)    } *x = (CoroContextTag *)coroParam

#define CORO_BEGIN_CODE(x) \
    if (&coroParam == &Common::nullContext) assert(!Common::nullContext); \
    if (!x) { coroParam = x = new CoroContextTag(); } \
    x->DUMMY = 0; \
    Common::CoroContextHolder tmpHolder(coroParam); \
    switch (coroParam->_line) { default: break; case 0:;

#define CORO_END_CODE \
    if (&coroParam == &Common::nullContext) { \
        delete Common::nullContext; \
        Common::nullContext = NULL; \
    } \
    }

#define CORO_SLEEP(delay) \
    do { \
        coroParam->_line = __LINE__; \
        coroParam->_sleep = delay; \
        assert(&coroParam != &Common::nullContext); \
        return; case __LINE__:; \
    } while (0)

#define CORO_GIVE_WAY do { CoroScheduler.giveWay(); CORO_SLEEP(1); } while (0)
#define CORO_RESCHEDULE do { CoroScheduler.reschedule(); CORO_SLEEP(1); } while (0)

#define CORO_KILL_SELF() \
    do { if (&coroParam != &Common::nullContext) { coroParam->_sleep = -1; } return; } while (0)


#define CORO_SUBCTX   coroParam->_subctx

#define CORO_INVOKE_ARGS(subCoro, ARGS) \
    do { \
        coroParam->_line = __LINE__; \
        coroParam->_subctx = 0; \
        do { \
            subCoro ARGS; \
            if (!coroParam->_subctx) break; \
            coroParam->_sleep = coroParam->_subctx->_sleep; \
            assert(&coroParam != &Common::nullContext); \
            return; case __LINE__:; \
        } while (1); \
    } while (0)

#define CORO_INVOKE_ARGS_V(subCoro, RESULT, ARGS) \
    do { \
        coroParam->_line = __LINE__; \
        coroParam->_subctx = 0; \
        do { \
            subCoro ARGS; \
            if (!coroParam->_subctx) break; \
            coroParam->_sleep = coroParam->_subctx->_sleep; \
            assert(&coroParam != &Common::nullContext); \
            return RESULT; case __LINE__:; \
        } while (1); \
    } while (0)

#define CORO_INVOKE_0(subCoroutine) \
    CORO_INVOKE_ARGS(subCoroutine, (CORO_SUBCTX))

#define CORO_INVOKE_1(subCoroutine, a0) \
    CORO_INVOKE_ARGS(subCoroutine, (CORO_SUBCTX, a0))

#define CORO_INVOKE_2(subCoroutine, a0,a1) \
    CORO_INVOKE_ARGS(subCoroutine, (CORO_SUBCTX, a0, a1))

#define CORO_INVOKE_3(subCoroutine, a0,a1,a2) \
    CORO_INVOKE_ARGS(subCoroutine, (CORO_SUBCTX, a0, a1, a2))

#define CORO_INVOKE_4(subCoroutine, a0,a1,a2,a3) \
    CORO_INVOKE_ARGS(subCoroutine, (CORO_SUBCTX, a0, a1, a2, a3))



#define CORO_PARAM_SIZE 40

#define CORO_NUM_PROCESS    100
#define CORO_MAX_PROCESSES  100
#define CORO_MAX_PID_WAITING 5

#define CORO_INFINITE 0xffffffff
#define CORO_INVALID_PID_VALUE 0

typedef void (*CORO_ADDR)(CoroContext &, const void *);

struct PROCESS {
    PROCESS *pNext;     
    PROCESS *pPrevious; 

    CoroContext state;      
    CORO_ADDR  coroAddr;    

    int sleepTime;      
    uint32 pid;         
    uint32 pidWaiting[CORO_MAX_PID_WAITING];    
#ifndef NO_CXX11_ALIGNAS
    alignas(max_align_t)
#endif
    char param[CORO_PARAM_SIZE];    
};
typedef PROCESS *PPROCESS;


struct EVENT {
    uint32 pid;
    bool manualReset;
    bool signalled;
    bool pulsing;
};


class CoroutineScheduler : public Singleton<CoroutineScheduler> {
public:
    typedef void (*VFPTRPP)(PROCESS *);

private:
    friend class Singleton<CoroutineScheduler>;

    CoroutineScheduler();

    ~CoroutineScheduler();


    PROCESS *processList;

    PROCESS *active;

    PROCESS *pFreeProcesses;

    PROCESS *pCurrent;

    int pidCounter;

    Common::List<EVENT *> _events;

#ifdef DEBUG

    int numProcs;
    int maxProcs;

    void checkStack();
#endif

    VFPTRPP pRCfunction;

    PROCESS *getProcess(uint32 pid);
    EVENT *getEvent(uint32 pid);
public:
    void reset();

#ifdef DEBUG

    void printStats();
#endif

    void schedule();

    void rescheduleAll();

    void reschedule(PPROCESS pReSchedProc = nullptr);

    void giveWay(PPROCESS pReSchedProc = nullptr);

    void waitForSingleObject(CORO_PARAM, int pid, uint32 duration, bool *expired = nullptr);

    void waitForMultipleObjects(CORO_PARAM, int nCount, uint32 *pidList, bool bWaitAll,
                                uint32 duration, bool *expired = nullptr);

    void sleep(CORO_PARAM, uint32 duration);

    PROCESS *createProcess(uint32 pid, CORO_ADDR coroAddr, const void *pParam, int sizeParam);

    uint32 createProcess(CORO_ADDR coroAddr, const void *pParam, int sizeParam);

    uint32 createProcess(CORO_ADDR coroAddr, const void *pParam);

    void killProcess(PROCESS *pKillProc);

    PROCESS *getCurrentProcess();

    int getCurrentPID() const;

    int killMatchingProcess(uint32 pidKill, int pidMask = -1);

    void setResourceCallback(VFPTRPP pFunc);

    uint32 createEvent(bool bManualReset, bool bInitialState);

    void closeEvent(uint32 pidEvent);

    void setEvent(uint32 pidEvent);

    void resetEvent(uint32 pidEvent);

    void pulseEvent(uint32 pidEvent);
};

} // end of namespace Common

#endif // COMMON_COROUTINES_H