371 lines
9.4 KiB
C++
371 lines
9.4 KiB
C++
#include <bfc/platform/platform.h>
|
|
#include "timermul.h"
|
|
|
|
#include <api.h>
|
|
#include <api/config/items/attribs.h>
|
|
#include <api/config/items/cfgitem.h>
|
|
|
|
// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
|
|
const GUID uioptions_guid =
|
|
{ 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
|
|
|
|
PtrListQuickSorted<MultiplexerServer, MultiplexerServerComparatorTID> servers_tid;
|
|
PtrListQuickSorted<MultiplexerServer, MultiplexerServerComparatorTID> servers_mux;
|
|
|
|
TimerMultiplexer::TimerMultiplexer() {
|
|
timerset = 0;
|
|
nslices = 0;
|
|
resolution = -1;
|
|
check_resolution = true;
|
|
client = NULL;
|
|
curslice = 0;
|
|
running_timer = NULL;
|
|
uioptions = NULL;
|
|
justexited = 0;
|
|
firstevent = 1;
|
|
resetTimer(50); // initial, is changed for config value on first event
|
|
}
|
|
|
|
TimerMultiplexer::~TimerMultiplexer() {
|
|
doShutdown();
|
|
}
|
|
|
|
void TimerMultiplexer::setClient(TimerMultiplexerClient *_client) {
|
|
client = _client;
|
|
}
|
|
|
|
void TimerMultiplexer::addTimer(int ms, void *data) {
|
|
//if (ms < 0) { DebugString("Timer with negative delay set, ignored coz the time machine service isn't ready yet\n"); }
|
|
MultiplexedTimer *t = new MultiplexedTimer(ms, data);
|
|
if (ms >= MAX_TIMER_DELAY) {
|
|
lptimers.addItem(t);
|
|
t->nexttick = Wasabi::Std::getTickCount() + t->ms;
|
|
} else {
|
|
timers.addItem(t);
|
|
if (nslices > 0)
|
|
distribute(t);
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::removeTimer(void *data) {
|
|
|
|
if (running_timer && running_timer->data == data)
|
|
running_timer = NULL;
|
|
|
|
int i;
|
|
for (i=0;i<timers.getNumItems();i++) {
|
|
MultiplexedTimer *t = timers.enumItem(i);
|
|
if (t->data == data) {
|
|
removeFromWheel(t);
|
|
timers.removeByPos(i);
|
|
delete t;
|
|
return;
|
|
}
|
|
}
|
|
for (i=0;i<lptimers.getNumItems();i++) {
|
|
MultiplexedTimer *t = lptimers.enumItem(i);
|
|
if (t->data == data) {
|
|
removeFromLowPrecision(t);
|
|
delete t;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::setResolution(int ms) {
|
|
resolution = ms;
|
|
}
|
|
|
|
void TimerMultiplexer::shutdown() {
|
|
doShutdown();
|
|
}
|
|
|
|
void TimerMultiplexer::doShutdown() {
|
|
timers.deleteAll();
|
|
wheel.deleteAll();
|
|
lptimers.deleteAll();
|
|
if (timerset) {
|
|
MultiplexerServer *s = servers_mux.findItem((const wchar_t *)this);
|
|
if (s) {
|
|
#ifdef WIN32
|
|
KillTimer(NULL, s->getId());
|
|
#elif defined(LINUX)
|
|
|
|
#endif
|
|
}
|
|
timerset = 0;
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::checkResolution(DWORD now) {
|
|
if (check_resolution == true)
|
|
{
|
|
if (WASABI_API_CONFIG)
|
|
{
|
|
if (uioptions == NULL)
|
|
{
|
|
uioptions = WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid);
|
|
if (uioptions)
|
|
{
|
|
ifc_dependent *ui_change = uioptions->getDependencyPtr();
|
|
ui_change->dependent_regViewer(this, 1);
|
|
}
|
|
}
|
|
check_resolution = uioptions?false:true;
|
|
int nresolution = uioptions ? _intVal(uioptions, L"Multiplexed timers resolution") : DEF_RES;
|
|
|
|
nresolution = MAX(10, MIN(MAX_TIMER_DELAY/LOW_RES_DIV, nresolution));
|
|
if (nresolution != resolution) {
|
|
resetTimer(nresolution);
|
|
resolution = nresolution;
|
|
resetWheel();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID CALLBACK timerMultiplexerServerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) {
|
|
MultiplexerServer *s = servers_tid.findItem((const wchar_t *)&idEvent);
|
|
if (s) s->getMultiplexer()->onServerTimer();
|
|
}
|
|
|
|
void TimerMultiplexer::resetTimer(int newresolution) {
|
|
if (timerset) {
|
|
MultiplexerServer *s = servers_mux.findItem((const wchar_t *)this);
|
|
if (s)
|
|
KillTimer(NULL, s->getId());
|
|
}
|
|
|
|
// linux port implements settimer
|
|
UINT_PTR id = SetTimer(NULL, 0, newresolution, timerMultiplexerServerProc);
|
|
MultiplexerServer *s = servers_mux.findItem((const wchar_t *)this);
|
|
if (!s) {
|
|
s = new MultiplexerServer(this, (UINT)id);
|
|
servers_mux.addItem(s);
|
|
servers_tid.addItem(s);
|
|
} else {
|
|
s->setId(id);
|
|
servers_tid.sort();
|
|
}
|
|
timerset = 1;
|
|
}
|
|
|
|
PtrList<MultiplexedTimer> *TimerMultiplexer::getSlice(int n) {
|
|
ASSERT(nslices > 0);
|
|
return wheel.enumItem(n % nslices);
|
|
}
|
|
|
|
void TimerMultiplexer::resetWheel() {
|
|
|
|
wheel.deleteAll();
|
|
|
|
nslices = MAX_TIMER_DELAY / resolution;
|
|
|
|
for (int i=0;i<nslices;i++)
|
|
wheel.addItem(new PtrList< MultiplexedTimer >);
|
|
|
|
curslice = 0;
|
|
distributeAll();
|
|
}
|
|
|
|
void TimerMultiplexer::distributeAll() {
|
|
for (int i=0;i<timers.getNumItems();i++) {
|
|
distribute(timers.enumItem(i));
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::distribute(MultiplexedTimer *t) {
|
|
ASSERT(t != NULL);
|
|
|
|
int delay = t->ms;
|
|
|
|
int slice = delay / resolution + curslice;
|
|
PtrList<MultiplexedTimer> *l = getSlice(slice);
|
|
|
|
ASSERT(l != NULL);
|
|
|
|
l->addItem(t);
|
|
}
|
|
|
|
void TimerMultiplexer::onServerTimer() {
|
|
|
|
justexited = 0;
|
|
|
|
DWORD now = Wasabi::Std::getTickCount();
|
|
|
|
checkResolution(now);
|
|
|
|
runCurSlice(now);
|
|
|
|
if ((curslice % (nslices/LOW_RES_DIV)) == 0) { // execute low precision timers every MAX_TIMER_DELAY/LOW_RES_DIV
|
|
runLowPrecisionTimers(now);
|
|
}
|
|
|
|
if (!justexited) {
|
|
curslice++;
|
|
curslice %= nslices;
|
|
}
|
|
|
|
justexited = 1;
|
|
|
|
if (firstevent) {
|
|
firstevent = 0;
|
|
checkResolution(Wasabi::Std::getTickCount());
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::runCurSlice(DWORD now) {
|
|
//DebugString("Running slice %d\n", curslice);
|
|
PtrList<MultiplexedTimer> *slice = getSlice(curslice);
|
|
ASSERT(slice != NULL);
|
|
|
|
// mark them clean
|
|
int i;
|
|
for (i=0;i<slice->getNumItems();i++)
|
|
slice->enumItem(i)->flag = 0;
|
|
|
|
// run events
|
|
int n;
|
|
do {
|
|
n = 0;
|
|
for (i=0;i<slice->getNumItems();i++) {
|
|
MultiplexedTimer *t = slice->enumItem(i);
|
|
if (t == NULL) break; // do not remove this line even if you think it's useless
|
|
// t might have been removed by a previous runTimer in this slice, so see if it's still here and if not, ignore
|
|
if (!timers.haveItem(t)) { slice->removeItem(t); i--; continue; }
|
|
if (t->flag == 1) continue;
|
|
t->flag = 1;
|
|
int lastdelay = MAX(0, (int)(now - t->lastmscount));
|
|
DWORD last = t->lastmscount;
|
|
if (last == 0) last = now;
|
|
t->lastmscount = now;
|
|
t->lastdelay = lastdelay;
|
|
running_timer = t;
|
|
runTimer(now, last, t, slice, i);
|
|
// -----------------------------------------------------------------------
|
|
// WARNING
|
|
//
|
|
// below this line, you can no longer assume that t is pointing at valid
|
|
// memory, because runTimer can eventually call removeTimer
|
|
// -----------------------------------------------------------------------
|
|
n++;
|
|
}
|
|
} while (n > 0);
|
|
}
|
|
|
|
void TimerMultiplexer::runTimer(DWORD now, DWORD last, MultiplexedTimer *t, PtrList<MultiplexedTimer> *slice, int pos) {
|
|
|
|
int nextslice = curslice + t->ms / resolution;
|
|
int spent = now - last;
|
|
int lost = spent - t->ms;
|
|
|
|
if (lost > 0) {
|
|
t->lost += (float)lost / (float)t->ms;
|
|
}
|
|
|
|
PtrList<MultiplexedTimer> *next = getSlice(nextslice);
|
|
ASSERT(next != NULL);
|
|
|
|
if (slice == next) {
|
|
nextslice++;
|
|
next = getSlice(nextslice);
|
|
}
|
|
|
|
slice->removeByPos(pos);
|
|
next->addItem(t);
|
|
|
|
int skip = (int)t->lost;
|
|
t->lost -= (int)t->lost;
|
|
if (client) {
|
|
client->onMultiplexedTimer(t->data, skip, t->lastdelay);
|
|
// -----------------------------------------------------------------------
|
|
// WARNING
|
|
//
|
|
// below this line, you can no longer assume that t is pointing at valid
|
|
// memory, because onMultiplexedTimer can eventually call removeTimer
|
|
// -----------------------------------------------------------------------
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::removeFromWheel(MultiplexedTimer *t) {
|
|
for (int i=0;i<nslices;i++) {
|
|
PtrList<MultiplexedTimer> *slice = getSlice(i);
|
|
for (int j=0;j<slice->getNumItems();j++) {
|
|
if (slice->enumItem(j) == t) {
|
|
slice->removeByPos(j);
|
|
j--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::removeFromLowPrecision(MultiplexedTimer *t) {
|
|
for (int i=0;i<lptimers.getNumItems();i++) {
|
|
if (lptimers.enumItem(i) == t) {
|
|
lptimers.removeByPos(i);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TimerMultiplexer::runLowPrecisionTimers(DWORD now) {
|
|
int restart;
|
|
do {
|
|
restart = 0;
|
|
for (int i=0;i<lptimers.getNumItems();i++) {
|
|
MultiplexedTimer *t = lptimers.enumItem(i);
|
|
if (t->nexttick < now) {
|
|
if (client) {
|
|
running_timer = t;
|
|
t->lost += (now - t->nexttick) / t->ms;
|
|
int skip = (int)t->lost;
|
|
t->lost -= skip; // remove integer part
|
|
DWORD last = t->lastmscount;
|
|
t->lastdelay = now-last;
|
|
t->lastmscount = now;
|
|
t->nexttick = t->nexttick+(t->ms)*(skip+1);
|
|
client->onMultiplexedTimer(t->data, skip, t->lastdelay);
|
|
// -----------------------------------------------------------------------
|
|
// WARNING
|
|
//
|
|
// below this line, you can no longer assume that t is pointing at valid
|
|
// memory, because onMultiplexedTimer can eventually call removeTimer
|
|
// -----------------------------------------------------------------------
|
|
}
|
|
if (running_timer == NULL) { // onMultiplexedTimer called removeTimer
|
|
restart =1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} while (restart);
|
|
}
|
|
|
|
|
|
int TimerMultiplexer::getNumTimers() {
|
|
return timers.getNumItems();
|
|
}
|
|
|
|
int TimerMultiplexer::getNumTimersLP() {
|
|
return lptimers.getNumItems();
|
|
}
|
|
|
|
int TimerMultiplexer::dependentViewer_callback(ifc_dependent *item, const GUID *classguid, int cb, intptr_t param1, intptr_t param2 , void *ptr, size_t ptrlen)
|
|
{
|
|
if (param1 == CfgItem::Event_ATTRIBUTE_CHANGED)
|
|
{
|
|
check_resolution=true;
|
|
}
|
|
else if (param1 == CfgItem::Event_ATTRIBUTE_REMOVED)
|
|
{
|
|
uioptions=0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#define CBCLASS TimerMultiplexer
|
|
START_DISPATCH;
|
|
CB(DEPENDENTVIEWER_CALLBACK, dependentViewer_callback)
|
|
END_DISPATCH;
|
|
#undef CBCLASS
|