int test_fence_multi_timeline_wait(void) { int timelineA, timelineB, timelineC; int fenceA, fenceB, fenceC, merged; int valid, active, signaled, ret; timelineA = sw_sync_timeline_create(); timelineB = sw_sync_timeline_create(); timelineC = sw_sync_timeline_create(); fenceA = sw_sync_fence_create(timelineA, "fenceA", 5); fenceB = sw_sync_fence_create(timelineB, "fenceB", 5); fenceC = sw_sync_fence_create(timelineC, "fenceC", 5); merged = sync_merge("mergeFence", fenceB, fenceA); merged = sync_merge("mergeFence", fenceC, merged); valid = sw_sync_fence_is_valid(merged); ASSERT(valid, "Failure merging fence from various timelines\n"); /* Confirm fence isn't signaled */ active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE); ASSERT(active == 3, "Fence signaled too early!\n"); ret = sync_wait(merged, 0); ASSERT(ret == 0, "Failure waiting on fence until timeout\n"); ret = sw_sync_timeline_inc(timelineA, 5); active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE); signaled = sync_fence_count_with_status(merged, FENCE_STATUS_SIGNALED); ASSERT(active == 2 && signaled == 1, "Fence did not signal properly!\n"); ret = sw_sync_timeline_inc(timelineB, 5); active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE); signaled = sync_fence_count_with_status(merged, FENCE_STATUS_SIGNALED); ASSERT(active == 1 && signaled == 2, "Fence did not signal properly!\n"); ret = sw_sync_timeline_inc(timelineC, 5); active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE); signaled = sync_fence_count_with_status(merged, FENCE_STATUS_SIGNALED); ASSERT(active == 0 && signaled == 3, "Fence did not signal properly!\n"); /* confirm you can successfully wait */ ret = sync_wait(merged, 100); ASSERT(ret > 0, "Failure waiting on signaled fence\n"); sw_sync_fence_destroy(merged); sw_sync_fence_destroy(fenceC); sw_sync_fence_destroy(fenceB); sw_sync_fence_destroy(fenceA); sw_sync_timeline_destroy(timelineC); sw_sync_timeline_destroy(timelineB); sw_sync_timeline_destroy(timelineA); return 0; }
int GLWorker::DoComposition(Compositor &compositor, Work *work) { int ret = compositor.Composite(work->layers, work->num_layers, work->framebuffer); int timeline_fd = work->timeline_fd; work->timeline_fd = -1; if (ret) { worker_ret_ = ret; glFinish(); sw_sync_timeline_inc(timeline_fd, work->num_layers); close(timeline_fd); return pthread_cond_signal(&work_done_cond_); } unsigned timeline_count = work->num_layers + 1; worker_ret_ = sw_sync_fence_create(timeline_fd, "GLComposition done fence", timeline_count); ret = pthread_cond_signal(&work_done_cond_); glFinish(); sw_sync_timeline_inc(timeline_fd, timeline_count); close(timeline_fd); return ret; }
static int mpcs_consumer_thread(void) { int fence, merged, tmp, valid, it, i; int *producer_timelines = test_data_mpsc.producer_timelines; int consumer_timeline = test_data_mpsc.consumer_timeline; int iterations = test_data_mpsc.iterations; int n = test_data_mpsc.threads; for (it = 1; it <= iterations; it++) { fence = sw_sync_fence_create(producer_timelines[0], "name", it); for (i = 1; i < n; i++) { tmp = sw_sync_fence_create(producer_timelines[i], "name", it); merged = sync_merge("name", tmp, fence); sw_sync_fence_destroy(tmp); sw_sync_fence_destroy(fence); fence = merged; } valid = sw_sync_fence_is_valid(fence); ASSERT(valid, "Failure merging fences\n"); /* * Make sure we see an increment from every producer thread. * Vary the means by which we wait. */ if (iterations % 8 != 0) { ASSERT(sync_wait(fence, -1) > 0, "Producers did not increment as expected\n"); } else { ASSERT(busy_wait_on_fence(fence) == 0, "Producers did not increment as expected\n"); } ASSERT(test_data_mpsc.counter == n * it, "Counter value mismatch!\n"); /* Release the producer threads */ ASSERT(sw_sync_timeline_inc(consumer_timeline, 1) == 0, "Failure releasing producer threads\n"); sw_sync_fence_destroy(fence); } return 0; }
static int mpsc_producer_thread(void *d) { int id = (long)d; int fence, valid, i; int *producer_timelines = test_data_mpsc.producer_timelines; int consumer_timeline = test_data_mpsc.consumer_timeline; int iterations = test_data_mpsc.iterations; for (i = 0; i < iterations; i++) { fence = sw_sync_fence_create(consumer_timeline, "fence", i); valid = sw_sync_fence_is_valid(fence); ASSERT(valid, "Failure creating fence\n"); /* * Wait for the consumer to finish. Use alternate * means of waiting on the fence */ if ((iterations + id) % 8 != 0) { ASSERT(sync_wait(fence, -1) > 0, "Failure waiting on fence\n"); } else { ASSERT(busy_wait_on_fence(fence) == 0, "Failure waiting on fence\n"); } /* * Every producer increments the counter, the consumer * checks and erases it */ pthread_mutex_lock(&test_data_mpsc.lock); test_data_mpsc.counter++; pthread_mutex_unlock(&test_data_mpsc.lock); ASSERT(sw_sync_timeline_inc(producer_timelines[id], 1) == 0, "Error advancing producer timeline\n"); sw_sync_fence_destroy(fence); } return 0; }
int VirtualCompositorWorker::CreateNextTimelineFence() { ++timeline_; return sw_sync_fence_create(timeline_fd_, "drm_fence", timeline_); }