void func_outer(void* context) { UNREFERENCED_PARAMETER(context); time_a_min = dispatch_time(0, (int64_t)5.5*NSEC_PER_SEC); time_a = dispatch_time(0, 6*NSEC_PER_SEC); time_a_max = dispatch_time(0, (int64_t)6.5*NSEC_PER_SEC); dispatch_after_f(time_a, dispatch_get_current_queue(), NULL, func_a); }
static void dispatch_start(void* context) { dispatch_time_t time_a; time_delta_t* delta = (time_delta_t*)malloc(sizeof(time_delta_t)); delta->min = dispatch_time(0, NSEC_PER_SEC*5.5); time_a = dispatch_time(0, NSEC_PER_SEC*6.0); delta->max = dispatch_time(0, NSEC_PER_SEC*6.5); delta->start = dispatch_time(0,0); dispatch_after_f(time_a, dispatch_get_current_queue(), delta, dispatch_6); }
void func_a(void* context) { dispatch_time_t now_a = dispatch_time(0, 0); UNREFERENCED_PARAMETER(context); test_time_less_than("can't finish faster than 5.5s", 0, now_a - time_a_min); test_time_less_than("must finish faster than 6.5s", 0, time_a_max - now_a); time_b_min = dispatch_time(0, (int64_t)1.5*NSEC_PER_SEC); time_b = dispatch_time(0, 2*NSEC_PER_SEC); time_b_max = dispatch_time(0, (int64_t)2.5*NSEC_PER_SEC); dispatch_after_f(time_b, dispatch_get_current_queue(), NULL, func_b); }
static void dispatch_6(void* context) { dispatch_time_t time_b; time_delta_t* previous = (time_delta_t*)context; time_delta_t* delta = (time_delta_t*)malloc(sizeof(time_delta_t)); dispatch_time_t now_a = dispatch_time(0, 0); MU_MESSAGE("must finish between 5.5s and 6.5s: %f",(now_a-previous->start)/(float)NSEC_PER_SEC); MU_ASSERT_TRUE(0<=(now_a - previous->min)); MU_ASSERT_TRUE(0<=(previous->max - now_a)); delta->min = dispatch_time(0, 1.5*NSEC_PER_SEC); time_b = dispatch_time(0, 2*NSEC_PER_SEC); delta->max = dispatch_time(0, 2.5*NSEC_PER_SEC); delta->start = dispatch_time(0,0); dispatch_after_f(time_b, dispatch_get_current_queue(), delta, dispatch_2); }
void RequestTimer::setTimeout(int seconds) { m_timeoutSeconds = seconds > 0 ? seconds : 0; cancelTimerSource(); if (!m_timeoutSeconds) { return; } dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); m_timerSource = dispatch_source_create( DISPATCH_SOURCE_TYPE_TIMER, 0, DISPATCH_TIMER_STRICT, q); dispatch_time_t t = dispatch_time(DISPATCH_TIME_NOW, m_timeoutSeconds * NSEC_PER_SEC); dispatch_source_set_timer(m_timerSource, t, DISPATCH_TIME_FOREVER, 0); // Use the timer group as a semaphore. When the source is cancelled, // libdispatch will make sure all pending event handlers have finished before // invoking the cancel handler. This means that if we cancel the source and // then wait on the timer group, when we are done waiting, we know the source // is completely done and it's safe to free memory (e.g., in the destructor). // See cancelTimerSource() above. dispatch_group_enter(m_timerGroup); dispatch_source_set_event_handler(m_timerSource, ^{ onTimeout(); // Cancelling ourselves isn't needed for correctness, but we can go ahead // and do it now instead of waiting on it later, so why not. (Also, // getRemainingTime does use this opportunistically, but it's best effort.) dispatch_source_cancel(m_timerSource); });
void test_timer(void) { dispatch_test_start("Dispatch Update Timer"); dispatch_queue_t main_q = dispatch_get_main_queue(); //test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue()); __block int i = 0; struct timeval start_time; gettimeofday(&start_time, NULL); dispatch_source_t s = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, main_q); test_ptr_notnull("dispatch_source_create", s); dispatch_source_set_timer(s, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC), NSEC_PER_SEC, 0); dispatch_source_set_cancel_handler(s, ^{ struct timeval end_time; gettimeofday(&end_time, NULL); // Make sure we actually managed to adjust the interval // duration. Seven one second ticks would blow past // this. test_long_less_than("total duration", end_time.tv_sec - start_time.tv_sec, 3); test_stop(); dispatch_release(s); });
SDMMD_AFCOperationRef SDMMD_AFCOperationCreateGetDeviceInfo() { SDMMD_AFCOperationRef op = calloc(1, sizeof(struct sdmmd_AFCOperation)); op->packet = calloc(1, sizeof(struct sdmmd_AFCPacket)); SDMMD_AFCHeaderInit(&(op->packet->header), SDMMD_AFC_Packet_GetDeviceInfo, sizeof(struct SDMMD_AFCPacketHeader), 0x0, 0x0); op->timeout = dispatch_time(DISPATCH_TIME_NOW, 0); return op; }
dispatch_time_t xdispatch::as_delayed_time( uint64_t delay, dispatch_time_t base ) { return dispatch_time( base, delay ); }
LRESULT CALLBACK window_proc(HWND window, UINT message, WPARAM wParam, LPARAM lParam) { switch(message) { case WM_COMMAND: { switch(HIWORD(wParam)) { case BN_CLICKED: { gcd::queue thread_q(gcd::queue::get_current_thread_queue()); ::OutputDebugStringW(L"WINDOW THREAD\n"); gcd::queue::get_global_queue(0, 0).after(dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC), [=] { ::OutputDebugStringW(L"GLOBAL THREAD\n"); thread_q.async([] { ::OutputDebugStringW(L"BACK ON WINDOW THREAD\n"); }); }); } break; } } break; case WM_DESTROY: ::PostQuitMessage(0); break; default: return ::DefWindowProcW(window, message, wParam, lParam); } return 0; }
static void do_test(void) { size_t i; char buf[1000]; count_down = COUNT; start = dispatch_time(0,0); for (i = 0; i < COUNT; i++) { #ifdef WIN32 _snprintf(buf, sizeof(buf), "com.example.starfish-node#%ld", i); #else snprintf(buf, sizeof(buf), "com.example.starfish-node#%ld", (long int)i); #endif queues[i] = dispatch_queue_create(buf, NULL); dispatch_suspend(queues[i]); } for (i = 0; i < COUNT; i++) { dispatch_async_f(queues[i], queues[i], start_node); } for (i = 0; i < COUNT; i++) { dispatch_resume(queues[i]); } }
extern "C" void Qt_dispatch_group1() { bool res; QDispatchGroup* group; char* argv = QString("test").toAscii().data(); int argc = 1; QDispatchCoreApplication app(argc,&argv); MU_BEGIN_TEST(Qt_dispatch_group1); group = createGroup(100, 0); MU_ASSERT_NOT_NULL(group); group->wait(); // should be OK to re-use a group group->async(new Foo, QDispatch::globalQueue()); group->wait(); delete group; group = NULL; group = createGroup(3, 7); MU_ASSERT_NOT_NULL(group); res = group->wait(dispatch_time(QDispatch::TimeNow, 5ull * NSEC_PER_SEC)); MU_ASSERT_EQUAL(res, false); // retry after timeout (this time succeed) res = group->wait(dispatch_time(QDispatch::TimeNow, 5ull * NSEC_PER_SEC)); MU_ASSERT_EQUAL(res, true); delete group; group = NULL; group = createGroup(100, 0); MU_ASSERT_NOT_NULL(group); group->notify(new GroupNotify, QDispatch::mainQueue()); delete group; group = NULL; app.exec(); MU_FAIL("Should never reach this"); MU_END_TEST }
bool __Platform_Red_Threading_Semaphore_TimeoutWait ( __Platform_Semaphore_t & Target, const Red::Util::Time :: Duration & Timeout ) { dispatch_time_t Delta = dispatch_time ( DISPATCH_TIME_NOW, Timeout.GetTotalNanoSeconds () ); return dispatch_semaphore_wait ( Target, Delta ) != 0; }
static void set_timer(void) { dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, timeoutvalue * NSEC_PER_SEC), timeoutvalue * NSEC_PER_SEC, 1000000); }
static void dispatch_0(void* context) { time_delta_t* previous = (time_delta_t*)context; dispatch_time_t now_c = dispatch_time(0, 0); MU_MESSAGE("must finish between 0.0s and 0.5s: %f",(now_c-previous->start)/(float)NSEC_PER_SEC); MU_ASSERT_TRUE(0<=(now_c - previous->min)); MU_ASSERT_TRUE(0<=(previous->max - now_c)); dispatch_async_f(dispatch_get_current_queue(), NULL, done); }
CF_PRIVATE dispatch_time_t __CFTSRToDispatchTime(uint64_t tsr) { uint64_t tsrInNanoseconds = __CFTSRToNanoseconds(tsr); // It's important to clamp this value to INT64_MAX or it will become interpreted by dispatch_time as a relative value instead of absolute time if (tsrInNanoseconds > INT64_MAX - 1) tsrInNanoseconds = INT64_MAX - 1; // 2nd argument of dispatch_time is a value in nanoseconds, but tsr does not equal nanoseconds on all platforms. return dispatch_time(1, (int64_t)tsrInNanoseconds); }
void dispatch_group_function() { long res; dispatch_group_t group; MU_BEGIN_TEST(dispatch_group_function); group = create_group(100, 0); MU_ASSERT_NOT_NULL(group); dispatch_group_wait(group, DISPATCH_TIME_FOREVER); // should be OK to re-use a group dispatch_group_async_f(group, dispatch_get_global_queue(0, 0), 0, foo); dispatch_group_wait(group, DISPATCH_TIME_FOREVER); dispatch_release(group); group = NULL; group = create_group(3, 7); MU_ASSERT_NOT_NULL(group); res = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC)); MU_ASSERT_EQUAL(!res, 0); // retry after timeout (this time succeed) res = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC)); MU_ASSERT_EQUAL(res, 0); dispatch_release(group); group = NULL; group = create_group(100, 0); MU_ASSERT_NOT_NULL(group); dispatch_group_notify_f(group, dispatch_get_main_queue(), 0, group_notify); dispatch_release(group); group = NULL; dispatch_main(); MU_FAIL("Should never reach this"); MU_END_TEST }
bool SemHelper::wait(int timeout) { #ifdef WIN32 if (timeout <= 0) { timeout = INFINITE; } if (WaitForSingleObject(_hSem, timeout) != WAIT_OBJECT_0) { return false; } #elif defined(__APPLE__) if (dispatch_semaphore_wait(_semid, dispatch_time(DISPATCH_TIME_NOW, timeout*1000)) != 0) { return false; } #else if (timeout <= 0) { return (sem_wait(&_semid) == 0); } else { struct timeval tm; gettimeofday(&tm, NULL); long long endtime = tm.tv_sec *1000 + tm.tv_usec/1000 + timeout; do { sleepMillisecond(50); int ret = sem_trywait(&_semid); if (ret == 0) { return true; } struct timeval tv_cur; gettimeofday(&tv_cur, NULL); if (tv_cur.tv_sec*1000 + tv_cur.tv_usec/1000 > endtime) { return false; } if (ret == -1 && errno == EAGAIN) { continue; } else { return false; } } while (true); return false; } #endif return true; }
void func_c(void* context) { dispatch_time_t now_c = dispatch_time(0, 0); UNREFERENCED_PARAMETER(context); test_time_less_than("can't finish faster than 0s", 0, now_c - time_c_min); test_time_less_than("must finish faster than .5s", 0, time_c_max - now_c); dispatch_async_f(dispatch_get_current_queue(), NULL, done); }
static void collect(void *context) { uint64_t delta; long double math; size_t i; if (--count_down) { return; } delta = dispatch_time(0,0) - start; math = (long double)delta; math /= COUNT * COUNT * 2ul + COUNT * 2ul; MU_MESSAGE("lap: %ld", lap_count_down); MU_MESSAGE("count: %lu", COUNT); MU_MESSAGE("delta: %llu ns", (uintmax_t)delta); MU_MESSAGE("math: %Lf ns / lap", math); for (i = 0; i < COUNT; i++) { dispatch_release(queues[i]); } // our malloc could be a lot better, // this result is really a malloc torture test MU_ASSERT_TRUE((unsigned long)math<10000); if (--lap_count_down) { do_test(); return; } // give the threads some time to settle before test_stop() runs "leaks" // ...also note, this is a total cheat. dispatch_after lets this // thread go idle, so dispatch cleans up the continuations cache. // Doign the "old style" sleep left that stuff around and leaks // took a LONG TIME to complete. Long enough that the test harness // decided to kill us. dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), NULL, MU_PASS_AFTER_DELAY); }
static void collect(void *context) { MU_MESSAGE("All workers done."); // give the threads some time to settle before test_stop() runs "leaks" // ...also note, this is a total cheat. dispatch_after lets this // thread go idle, so dispatch cleans up the continuations cache. // Doign the "old style" sleep left that stuff around and leaks // took a LONG TIME to complete. Long enough that the test harness // decided to kill us. dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), NULL, MU_PASS_AFTER_DELAY); }
static bool clearAllKVS(CFErrorRef *error) { __block bool result = false; const uint64_t maxTimeToWaitInSeconds = 30ull * NSEC_PER_SEC; dispatch_queue_t processQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0); dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, maxTimeToWaitInSeconds); SOSCloudKeychainClearAll(processQueue, ^(CFDictionaryRef returnedValues, CFErrorRef cerror) { result = (cerror != NULL); dispatch_semaphore_signal(waitSemaphore); });
static void setRepeatingTimer(struct nodeInstanceData *ctx, const VuoReal seconds, VuoOutputTrigger(fired,VuoInteger)) { if (ctx->timer) cancelRepeatingTimer(ctx); dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); ctx->timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, q); uint64_t nanoseconds = seconds * NSEC_PER_SEC; dispatch_source_set_timer(ctx->timer, dispatch_time(DISPATCH_TIME_NOW, nanoseconds), nanoseconds, 0); dispatch_source_set_event_handler(ctx->timer, ^{ fired(++ctx->eventCount); });
static void retry_timer(void) { dispatch_source_t s; dispatch_time_t t; s = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, g_queue); t = dispatch_time(DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC); dispatch_source_set_timer(s, t, 0, NSEC_PER_SEC); dispatch_source_set_event_handler(s, ^{ create_dns_sd(); dispatch_release(s); });
static void redirect_atexit(void) { int i; /* stdout is linebuffered, so flush the buffer */ if (redirect_descriptors[STDOUT_FILENO].buf) fflush(stdout); /* Cancel all of our dispatch sources, so they flush to ASL */ for (i=0; i < n_redirect_descriptors; i++) if (redirect_descriptors[i].read_source) dispatch_source_cancel(redirect_descriptors[i].read_source); /* Wait at least three seconds for our sources to flush to ASL */ dispatch_group_wait(read_source_group, dispatch_time(DISPATCH_TIME_NOW, 3LL * NSEC_PER_SEC)); }
static void setRepeatingTimer(struct nodeInstanceData *ctx, const VuoReal seconds, VuoOutputTrigger(fired,void)) { cancelRepeatingTimer(ctx); if (seconds <= 0) return; dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); ctx->timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, q); uint64_t nanoseconds = (seconds > 0.001 ? (seconds * NSEC_PER_SEC) : (NSEC_PER_SEC / 1000)); dispatch_source_set_timer(ctx->timer, dispatch_time(DISPATCH_TIME_NOW, nanoseconds), nanoseconds, 0); dispatch_source_set_event_handler(ctx->timer, ^{ fired(); });
extern "C" void Qt_dispatch_timer() { char* argv = QString("test").toAscii().data(); int argc = 1; QDispatchApplication app(argc,&argv); MU_BEGIN_TEST(Qt_dispatch_timer); MU_MESSAGE("Testing single-shot timer"); checked_time.restart(); QDispatchTimer::singleShot(dispatch_time(QDispatch::TimeNow, 2*NSEC_PER_SEC), QDispatch::globalQueue(), new testSingleShot()); //QDispatchTimer::singleShot(QTime::currentTime().addSecs(2), QDispatch::globalQueue(), new test_single_shot); app.exec(); MU_END_TEST }
void lock() { #if defined (DEBUG) uint64_t timeout = NSEC_PER_SEC; uint64_t locktime = 0; while (dispatch_semaphore_wait(sem_, dispatch_time(DISPATCH_TIME_NOW, timeout))) { locktime += (timeout/NSEC_PER_SEC); printf("WARNING: mutex %p locking for %llu seconds\n", this, locktime); if (timeout < 64*NSEC_PER_SEC) timeout *= 2; } #else dispatch_semaphore_wait(sem_, DISPATCH_TIME_FOREVER); #endif }
static mrb_value mrb_queue_after(mrb_state *mrb, mrb_value self) { mrb_float delay_f; mrb_value blk; dispatch_queue_t q; mrb_get_args(mrb, "f&", &delay_f, &blk); DISPATCH_ENSURE_BLOCK_GIVEN(mrb, blk); q = (dispatch_queue_t)DATA_PTR(self); dispatch_time_t pop_time = dispatch_time(DISPATCH_TIME_NOW, (dispatch_time_t)(delay_f * NSEC_PER_SEC)); dispatch_after(pop_time, q, ^{ mrb_yield(mrb, blk, mrb_nil_value()); });
static int _gcdpoll_timeout_add(AvahiTimeout *t, const struct timeval *tv) { struct timeval e_tv; struct timeval now; int64_t nsecs; int ret; ret = gettimeofday(&now, NULL); if (ret != 0) return -1; if (!t->timer) { t->timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, mdns_sq); if (!t->timer) return -1; dispatch_set_context(t->timer, t); dispatch_source_set_event_handler_f(t->timer, gcdpollcb_timer); } else dispatch_suspend(t->timer); if ((tv->tv_sec == 0) && (tv->tv_usec == 0)) { dispatch_source_set_timer(t->timer, DISPATCH_TIME_NOW, DISPATCH_TIME_FOREVER /* one-shot */, 0); } else { timersub(tv, &now, &e_tv); nsecs = e_tv.tv_sec * NSEC_PER_SEC + e_tv.tv_usec * 1000; dispatch_source_set_timer(t->timer, dispatch_time(DISPATCH_TIME_NOW, nsecs), DISPATCH_TIME_FOREVER /* one-shot */, 0); } dispatch_resume(t->timer); return 0; }
static void retry_timer(void) { dispatch_time_t t; heim_assert(g_dnsRef == NULL, "called create when a connection already existed"); if (g_restart_timer) return; g_restart_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, g_queue); t = dispatch_time(DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC); dispatch_source_set_timer(g_restart_timer, t, 0, NSEC_PER_SEC); dispatch_source_set_event_handler(g_restart_timer, ^{ create_dns_sd(); dispatch_release(g_restart_timer); g_restart_timer = NULL; });