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); } }