bboard

class CPU {

 private :

     //internal clock
     uint _clock;

     //DeviceConroller
     CPUController* _controller;

     //internal bus reader
     u16 readBus(u32 addr) {

        _clock = _clock + 2;
        _controller->CPUEvent(DEVICEA::EVENT_BUS_READED);
        _clock = _clock + 4; //Improve could be to add wait potential extra cycles due to device latency
     }

 public :

     // exec loop
     void exec(){

         clock_instruction = execInstruction();
         _clock = _clock + clock_instruction;

         _controller->CPU(CPU::INSTRUCTION_ENDED);
     }

     uint getClock(){
        return _clock;
     }
}

class DevicesManager :: CPUController, GPUController {

    private :

        Device[] _devices;
        uint[]   _devicesState;

        uint _CPUID = 0;
        uint _GPUID = 1;

    public :

        void runDevices() {

            CPU->exec();
        }

        void CPUEvent(uint clock, u8 event) {

            if(event == CPU::EVENT_READ_BUS || CPU::INSTRUCTION_ENDED) {
                    uint[] devices = {_GPUID};
                    sync(clock, _GPUID);
            }
        }

        void GPUEvent(uint clock, u8 event) {

            if(event == GPU::SLOT_ENDED){
                    uint[] devices = {_CPUID};
                    sync(clock, _CPUID);
            }
        }

        void sync(clock, uint waitingDevice, uint[] deviceToSync) {

            _devicesState[waitingDevice] = WAITING;

            for(uint = 0; i < nbDevices; i++) {

                    if(_devicesState[deviceID] != WAITING) {

                        if(device->getClock() < clock)
                            device->exec(clock);
            }

            _devicesState[waitingDevice] = RUNNING;
        }
};

Posted by Sintendo
What you're showing us here looks like a very basic scheduler, in which you run the CPU ahead and let the GPU play catch-up. Whether this particular scheme will suffice for the Megadrive I can't say; I imagine the answer depends on how the different devices are capable of interacting with each other, and what level of accuracy you're aiming for with your emulator.

However, a scheduler doesn't have a whole lot to do with whether you use cooperative threads (e.g. libco) or not. The true advantage of using cooperative threads, is that you can suspend execution at any point without requiring additional logic. This maps beautifully to cycle-level emulation, where you can suspend in the middle of an instruction. State machines are an alternative, but can be very cumbersome to write. byuu wrote a nice article on this topic, if you haven't read it yet.