/* * sync stress test: parallelism * Copyright 2015-2016 Collabora Ltd. * * Based on the implementation from the Android Open Source Project, * * Copyright 2012 Google, Inc * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include <pthread.h> #include "sync.h" #include "sw_sync.h" #include "synctest.h" static struct { int iterations; int timeline; int counter; } test_data_two_threads; static int test_stress_two_threads_shared_timeline_thread(void *d) { int thread_id = (long)d; int timeline = test_data_two_threads.timeline; int iterations = test_data_two_threads.iterations; int fence, valid, ret, i; for (i = 0; i < iterations; i++) { fence = sw_sync_fence_create(timeline, "fence", i * 2 + thread_id); valid = sw_sync_fence_is_valid(fence); ASSERT(valid, "Failure allocating fence\n"); /* Wait on the prior thread to complete */ ret = sync_wait(fence, -1); ASSERT(ret > 0, "Problem occurred on prior thread\n"); /* * Confirm the previous thread's writes are visible * and then increment */ ASSERT(test_data_two_threads.counter == i * 2 + thread_id, "Counter got damaged!\n"); test_data_two_threads.counter++; /* Kick off the other thread */ ret = sw_sync_timeline_inc(timeline, 1); ASSERT(ret == 0, "Advancing timeline failed\n"); sw_sync_fence_destroy(fence); } return 0; } int test_stress_two_threads_shared_timeline(void) { pthread_t a, b; int valid; int timeline = sw_sync_timeline_create(); valid = sw_sync_timeline_is_valid(timeline); ASSERT(valid, "Failure allocating timeline\n"); test_data_two_threads.iterations = 1 << 16; test_data_two_threads.counter = 0; test_data_two_threads.timeline = timeline; /* * Use a single timeline to synchronize two threads * hammmering on the same counter. */ pthread_create(&a, NULL, (void *(*)(void *)) test_stress_two_threads_shared_timeline_thread, (void *)0); pthread_create(&b, NULL, (void *(*)(void *)) test_stress_two_threads_shared_timeline_thread, (void *)1); pthread_join(a, NULL); pthread_join(b, NULL); /* make sure the threads did not trample on one another */ ASSERT(test_data_two_threads.counter == test_data_two_threads.iterations * 2, "Counter has unexpected value\n"); sw_sync_timeline_destroy(timeline); return 0; }