void ScheduleEvent(s64 cycles_into_future, int event_type, u64 userdata) {
Event* new_event = GetNewEvent();
new_event->userdata = userdata;
new_event->type = event_type;
new_event->time = GetTicks() + cycles_into_future;
AddEventToQueue(new_event);
}
std::string deserializeString( const ::zeq::Event& event )
{
BOOST_CHECK_EQUAL( event.getType(), EVENT_NEWEVENT );
auto data = GetNewEvent( event.getData( ));
return std::string( data->message()->c_str( ));
}
// This must be run ONLY from within the cpu thread
// cyclesIntoFuture may be VERY inaccurate if called from anything else
// than Advance
void ScheduleEvent(int cyclesIntoFuture, int event_type, u64 userdata)
{
Event *ne = GetNewEvent();
ne->userdata = userdata;
ne->type = event_type;
ne->time = globalTimer + cyclesIntoFuture;
AddEventToQueue(ne);
}
// This must be run ONLY from within the CPU thread
// cyclesIntoFuture may be VERY inaccurate if called from anything else
// than Advance
void ScheduleEvent(int cyclesIntoFuture, int event_type, u64 userdata)
{
// TODO: Fix UI thread safety problems, and enable this assertion
//_assert_msg_(POWERPC, Core::IsCPUThread(), "ScheduleEvent from wrong thread");
Event *ne = GetNewEvent();
ne->userdata = userdata;
ne->type = event_type;
ne->time = globalTimer + cyclesIntoFuture;
AddEventToQueue(ne);
}
// This must be run ONLY from within the CPU thread
// cyclesIntoFuture may be VERY inaccurate if called from anything else
// than Advance
void ScheduleEvent(int cyclesIntoFuture, int event_type, u64 userdata)
{
_assert_msg_(POWERPC, Core::IsCPUThread() || Core::GetState() == Core::CORE_PAUSE,
"ScheduleEvent from wrong thread");
Event *ne = GetNewEvent();
ne->userdata = userdata;
ne->type = event_type;
ne->time = globalTimer + cyclesIntoFuture;
AddEventToQueue(ne);
}
void MoveEvents()
{
BaseEvent sevt;
while (tsQueue.Pop(sevt))
{
Event *evt = GetNewEvent();
evt->time = sevt.time;
evt->userdata = sevt.userdata;
evt->type = sevt.type;
AddEventToQueue(evt);
}
}
/*
===============
=
= CreateEvent
=
===============
*/
eventtype * CreateEvent ( int time, int type )
{
eventtype * event;
event = GetNewEvent ();
event->time = time;
event->effecttype = type;
event->effect = NULL;
AddEvent (event);
return event;
}
// This must be run ONLY from within the CPU thread
// cyclesIntoFuture may be VERY inaccurate if called from anything else
// than Advance
void ScheduleEvent(s64 cyclesIntoFuture, int event_type, u64 userdata)
{
_assert_msg_(POWERPC, Core::IsCPUThread() || Core::GetState() == Core::CORE_PAUSE,
"ScheduleEvent from wrong thread");
Event *ne = GetNewEvent();
ne->userdata = userdata;
ne->type = event_type;
ne->time = GetTicks() + cyclesIntoFuture;
// If this event needs to be scheduled before the next advance(), force one early
if (!globalTimerIsSane)
ForceExceptionCheck(cyclesIntoFuture);
AddEventToQueue(ne);
}
bool WaitConditionImpl::Wait(Mutex *pmutex, unsigned delay)
{
bool result = 0;
unsigned i;
unsigned lockCount = pmutex->pImpl->LockCount;
EventPoolEntry* pentry;
// Mutex must have been locked
if (lockCount == 0)
return 0;
// Add an object to the wait queue
WaitQueueLoc.DoLock();
QueuePush(pentry = GetNewEvent());
WaitQueueLoc.Unlock();
// Finally, release a mutex or semaphore
if (pmutex->pImpl->Recursive)
{
// Release the recursive mutex N times
pmutex->pImpl->LockCount = 0;
for(i=0; i<lockCount; i++)
::ReleaseMutex(pmutex->pImpl->hMutexOrSemaphore);
}
else
{
pmutex->pImpl->LockCount = 0;
::ReleaseSemaphore(pmutex->pImpl->hMutexOrSemaphore, 1, NULL);
}
// Note that there is a gap here between mutex.Unlock() and Wait(). However,
// if notify() comes in at this point in the other thread it will set our
// corresponding event so wait will just fall through, as expected.
// Block and wait on the event
DWORD waitResult = ::WaitForSingleObject(pentry->hEvent,
(delay == OVR_WAIT_INFINITE) ? INFINITE : delay);
/*
repeat_wait:
DWORD waitResult =
::MsgWaitForMultipleObjects(1, &pentry->hEvent, FALSE,
(delay == OVR_WAIT_INFINITE) ? INFINITE : delay,
QS_ALLINPUT);
*/
WaitQueueLoc.DoLock();
switch(waitResult)
{
case WAIT_ABANDONED:
case WAIT_OBJECT_0:
result = 1;
// Wait was successful, therefore the event entry should already be removed
// So just add entry back to a free list
ReleaseEvent(pentry);
break;
/*
case WAIT_OBJECT_0 + 1:
// Messages in WINDOWS queue
{
MSG msg;
PeekMessage(&msg, NULL, 0U, 0U, PM_NOREMOVE);
WaitQueueLoc.Unlock();
goto repeat_wait;
}
break; */
default:
// Timeout, our entry should still be in a queue
QueueFindAndRemove(pentry);
ReleaseEvent(pentry);
}
WaitQueueLoc.Unlock();
// Re-aquire the mutex
for(i=0; i<lockCount; i++)
pmutex->DoLock();
// Return the result
return result;
}
