void Run(SMInvoker &invoker, bigtime_t targetUnblock,
bigtime_t targetReply, status_t result, bool deliverySuccess,
bool replySuccess, bigtime_t duration)
{
//printf("SMTester::Run(%lld, %lld, %lx, %d, %d, %lld)\n", targetUnblock,
//targetReply, result, deliverySuccess, replySuccess, duration);
enum { JITTER = 10000 };
enum { SETUP_LATENCY = 100000 };
enum { DELIVERY_LATENCY = 10000 };
enum { TARGET_HEAD_START = 1000 };
if (targetUnblock == 0)
targetUnblock = -TARGET_HEAD_START;
// create the target
SMTarget *target = NULL;
switch (fTargetKind) {
case TARGET_UNINITIALIZED:
target = new SMTarget;
break;
case TARGET_LOCAL_PREFERRED:
target = new LocalSMTarget(true);
break;
case TARGET_LOCAL_SPECIFIC:
target = new LocalSMTarget(false);
break;
case TARGET_REMOTE_PREFERRED:
target = new RemoteSMTarget(true);
break;
case TARGET_REMOTE_SPECIFIC:
target = new RemoteSMTarget(false);
break;
}
AutoDeleter<SMTarget> deleter(target);
// create the reply target
SMReplyTarget replyTarget;
// init the target and send the message
BHandler *replyHandler = replyTarget.Handler();
BMessenger replyMessenger = replyTarget.Messenger();
bigtime_t startTime = system_time() + SETUP_LATENCY;
target->Init(startTime + targetUnblock, targetReply);
BMessenger targetMessenger = target->Messenger();
snooze_until(startTime, B_SYSTEM_TIMEBASE);
status_t actualResult = invoker.Invoke(targetMessenger, replyHandler,
replyMessenger);
bigtime_t actualDuration = system_time() - startTime;
//printf("duration: %lld vs %lld\n", actualDuration, duration);
// We need to wait for the reply, if reply mode is asynchronous.
snooze_until(startTime + targetUnblock + targetReply
+ 2 * DELIVERY_LATENCY, B_SYSTEM_TIMEBASE);
bool actualReplySuccess = invoker.ReplySuccess();
if (!invoker.DirectReply())
actualReplySuccess = replyTarget.ReplySuccess();
// check the results
if (actualResult != result)
printf("result: %lx vs %lx\n", actualResult, result);
CHK(actualResult == result);
CHK(target->DeliverySuccess() == deliverySuccess);
CHK(actualReplySuccess == replySuccess);
CHK(actualDuration > duration - JITTER
&& actualDuration < duration + JITTER);
}
int32 ViewPulserCode (void *PassedInData)
{
int i;
bigtime_t CurrentTime;
bigtime_t WakeupTime = 0;
BWindow *WindowOfView;
CounterView *ViewPntr;
ViewPntr = (CounterView *) PassedInData;
WindowOfView = ViewPntr->Window ();
for (i = 0; i < 20000 && !TimeToDie; i++)
{
WakeupTime += 10000;
WindowOfView->Lock ();
ViewPntr->Animate ();
WindowOfView->Unlock ();
// Go to sleep until the next update time, accounting for
// time wasted locking the window.
CurrentTime = system_time ();
if (WakeupTime < CurrentTime)
WakeupTime = CurrentTime;
else
snooze_until (WakeupTime, B_SYSTEM_TIMEBASE);
}
return B_OK; // Return code of thread.
}
void
GenericThread::SnoozeUntil(bigtime_t microseconds, int timebase)
{
Suspend();
snooze_until(microseconds, timebase);
Resume();
}
void stub_source_run(je_source_plugin *cookie)
{
source_private *data = (source_private *)cookie->data;
BMessage drawBitmap(JE_DRAW_BITMAP);
BMessage msg;
msg.what = JE_FRAMERATE_CHANGED;
msg.AddInt64("framerate", 33000);
msg.AddInt32("which", data->id);
data->graphics_pipeline->SendMessage(&msg);
msg.RemoveName("framerate");
msg.what = JE_FRAME_SIZE_CHANGED;
msg.AddRect("rect", data->outSize);
data->graphics_pipeline->SendMessage(&msg);
msg.RemoveName("rect");
msg.what = JE_SOURCE_READY;
data->graphics_pipeline->SendMessage(&msg);
while (1)
{
data->nextFrame = system_time() + 33000;
snooze_until(data->nextFrame, B_SYSTEM_TIMEBASE);
if (data->exit)
break;
drawBitmap.RemoveName("bitmap");
drawBitmap.AddPointer("bitmap", data->frame);
data->window->SendMessage(&drawBitmap);
}
// it's ok to kill us now
release_sem(data->exitSem);
}
void sleep(int milliseconds)
{
#if defined TORRENT_WINDOWS || defined TORRENT_CYGWIN
Sleep(milliseconds);
#elif defined TORRENT_BEOS
snooze_until(system_time() + boost::int64_t(milliseconds) * 1000, B_SYSTEM_TIMEBASE);
#else
usleep(milliseconds * 1000);
#endif
}
void
MidiPortConsumer::Data(uchar* data, size_t length,
bool atomic, bigtime_t time)
{
snooze_until(time - Latency(), B_SYSTEM_TIMEBASE);
if (write(fFileDescriptor, data, length) == -1) {
perror("Error sending data to driver");
}
}
status_t
BTimeSource::SnoozeUntil(bigtime_t performance_time,
bigtime_t with_latency,
bool retry_signals)
{
CALLED();
bigtime_t time;
status_t err;
do {
time = RealTimeFor(performance_time, with_latency);
err = snooze_until(time, B_SYSTEM_TIMEBASE);
} while (err == B_INTERRUPTED && retry_signals);
return err;
}
static int32 timer_func(void *arg)
{
while (thread_active) {
// Wait until time specified by wakeup_time
snooze_until(wakeup_time, B_SYSTEM_TIMEBASE);
while (acquire_sem(wakeup_time_sem) == B_INTERRUPTED) ;
if (wakeup_time < system_time()) {
// Timer expired, trigger interrupt
wakeup_time = 0x7fffffffffffffff;
SetInterruptFlag(INTFLAG_TIMER);
TriggerInterrupt();
}
release_sem(wakeup_time_sem);
}
return 0;
}
int32 ticker(void *data) {
BMessage *msg = (BMessage *)data;
int64 snooze_time = 0;
msg->FindInt64("snooze", &snooze_time);
BLooper *looper = 0;
msg->FindPointer("looper", (void **)&looper);
delete msg;
if (looper==0 || snooze_time==0) return 10;
long long nexttick = system_time();
for (;;) {
nexttick += snooze_time;
snooze_until(nexttick, B_SYSTEM_TIMEBASE);
looper->PostMessage('tick');
}
return 0;
}
void
StandAloneTaskLoop::Run()
{
for(;;) {
AutoLock<BLocker> autoLock(&fLock);
if (!autoLock)
return;
if (fNeedToQuit) {
// task loop being deleted, let go of the thread allowing the
// to go through deletion
fScanThread = -1;
return;
}
if (Pulse()) {
fScanThread = -1;
return;
}
// figure out when to run next by checking out when the different
// tasks wan't to be woken up, snooze until a little bit before that
// time
bigtime_t now = system_time();
bigtime_t latestRunTime = LatestRunTime() - 1000;
bigtime_t afterHeartBeatTime = now + fHeartBeat;
bigtime_t snoozeTill = latestRunTime < afterHeartBeatTime ?
latestRunTime : afterHeartBeatTime;
autoLock.Unlock();
if (snoozeTill > now)
snooze_until(snoozeTill, B_SYSTEM_TIMEBASE);
else
snooze(1000);
}
}
