void test_dispatch_latency(unsigned samples, unsigned sleeptime)
{
unsigned i;
uint64_t *lat = (uint64_t *)malloc(sizeof(uint64_t) * 3);
uint64_t *history = (uint64_t *)malloc(sizeof(uint64_t) * samples);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
for (i = 0; i < samples; i++) {
usleep(sleeptime);
/*
lat[0] to lat[1] is latency to block execution
lat[1] to lat[2] is latency from block execution to block synchronization
*/
lat[0] = libtime_cpu();
dispatch_group_async(group, queue, ^{ lat[1] = libtime_cpu(); });
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
lat[2] = libtime_cpu();
/*
printf("%04u lat[0] = %" PRIu64 "\n", i, lat[0]);
printf("%04u lat[1] = %" PRIu64 ", %" PRIu64 "\n", i, lat[1], lat[1] - lat[0]);
printf("%04u lat[2] = %" PRIu64 ", %" PRIu64 "\n", i, lat[2], lat[2] - lat[1]);
*/
history[i] = lat[1] - lat[0];
//history[i] = lat[2] - lat[1];
}
static void
render(unsigned char *img, int comps, int w, int h, int nsubsamples, int tilew, int tileh)
{
float *fimg = (float *)malloc(sizeof(float) * w * h * 3);
memset((void *)fimg, 0, sizeof(float) * w * h * 3);
dispatch_queue_t dque = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//dispatch_queue_t dque = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t dgroup = dispatch_group_create();
int i, j;
for (j = 0; j < h; j += tileh) {
for (i = 0; i < w; i += tilew) {
void (^renderblock)(void) = ^{
render_tile(img, comps, fimg, w, h, nsubsamples, i, j, tilew, tileh);
};
//renderblock();
dispatch_group_async(dgroup, dque, renderblock);
}
}
dispatch_group_wait(dgroup, DISPATCH_TIME_FOREVER);
//dispatch_release(dgroup);
}
static VALUE
rb_group_wait(VALUE self, SEL sel, int argc, VALUE *argv)
{
VALUE num;
rb_scan_args(argc, argv, "01", &num);
return dispatch_group_wait(RGroup(self)->group, rb_num2timeout(num))
== 0 ? Qtrue : Qfalse;
}
void ISPCSync() {
if (!initialized) {
fprintf(stderr, "You must call TasksInit() before launching tasks.\n");
exit(1);
}
// Wait for all of the tasks in the group to complete before returning
dispatch_group_wait(gcdGroup, DISPATCH_TIME_FOREVER);
}
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
}
void RequestTimer::cancelTimerSource() {
if (m_timerSource) {
dispatch_source_cancel(m_timerSource);
dispatch_group_wait(m_timerGroup, DISPATCH_TIME_FOREVER);
// At this point it is safe to free memory, the source or even ourselves (if
// this is part of the destructor). See the way we set up the timer group
// and cancellation handler in setTimeout() below.
dispatch_release(m_timerSource);
m_timerSource = nullptr;
}
}
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 DWORD WINAPI taskEntry(LPVOID arg) {
#else
static void *taskEntry(void *arg) {
#endif
while (true) {
workerSemaphore.Wait();
// Try to get task from task queue
Task *myTask = NULL;
{ MutexLock lock(*taskQueueMutex);
if (taskQueue.size() == 0)
break;
myTask = taskQueue.back();
taskQueue.pop_back();
}
// Do work for _myTask_
PBRT_STARTED_TASK(myTask);
myTask->Run();
PBRT_FINISHED_TASK(myTask);
tasksRunningCondition.Lock();
int unfinished = --numUnfinishedTasks;
if (unfinished == 0)
tasksRunningCondition.Signal();
tasksRunningCondition.Unlock();
}
// Cleanup from task thread and exit
#ifdef PBRT_HAS_PTHREADS
pthread_exit(NULL);
#endif // PBRT_HAS_PTHREADS
return 0;
}
#endif // !PBRT_USE_GRAND_CENTRAL_DISPATCH
void WaitForAllTasks() {
#ifdef PBRT_USE_GRAND_CENTRAL_DISPATCH
dispatch_group_wait(gcdGroup, DISPATCH_TIME_FOREVER);
#else
tasksRunningCondition.Lock();
while (numUnfinishedTasks > 0)
tasksRunningCondition.Wait();
tasksRunningCondition.Unlock();
#endif
}
long wait(dispatch_group_t g, long time) {
dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, time);
return dispatch_group_wait(g, timeout);
}
bool group::wait(
dispatch_time_t time
)
{
return dispatch_group_wait( m_native, time ) == 0;
}
