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