Implement sw_sync test
cover Implement sw_sync test
From: Robert Foss <[email protected]>
This series implements the sw_sync test and the lib/sw_sync helper functions for said test.
Gustavo Padovans sw_sync series was just de-staged in gregkh-staging/staging-next [1], and this test is targeted at verifying the functionality implemented in that series.
The sw_sync subtests range from very basic tests of the sw_sync functionality, to stress testing and randomized tests.
[1] http://git.kernel.org/cgit/linux/kernel/git/gregkh/staging.git/
Robert Foss (13):
lib/sw_sync: Add helper functions for managing synchronization
primitives
tests/sw_sync: Add sw_sync test
tests/sw_sync: Add subtest test_alloc_fence tests/sw_sync: Add subtest test_alloc_fence_invalid_timeline tests/sw_sync: Add subtest test_alloc_merge_fence tests/sw_sync: Add subtest test_sync_wait
tests/sw_sync: Add subtest test_sync_merge tests/sw_sync: Add subtest test_sync_merge_same tests/sw_sync: Add subtest test_sync_multi_consumer tests/sw_sync: Add subtest test_sync_multi_consumer_producer tests/sw_sync: Add subtest test_sync_random_merge tests/sw_sync: Add subtest test_sync_multi_timeline_wait tests/sw_sync: Add subtest test_sync_multi_producer_single_consumer
lib/Makefile.sources | 2 + lib/sw_sync.c | 237 +++++++++++++++++ lib/sw_sync.h | 49 ++++ tests/Makefile.sources | 1 + tests/sw_sync.c | 693 +++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 982 insertions(+) create mode 100644 lib/sw_sync.c create mode 100644 lib/sw_sync.h create mode 100644 tests/sw_sync.c
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 1/13 lib/sw_sync: Add helper functions for managing synchronization primitives
From: Robert Foss <[email protected]>
Base functions to help testing the Sync File Framework (explicit fencing mechanism ported from Android).
These functions allow you to create, use and destroy timelines and fences.
--- lib/Makefile.sources | 2 + lib/sw_sync.c | 238 +++++++++++++++++++++++++++++++++++++++++++++++++++ lib/sw_sync.h | 49 +++++++++++ 3 files changed, 289 insertions(+) create mode 100644 lib/sw_sync.c create mode 100644 lib/sw_sync.h
lib/Makefile.sources +2 -0
@@ -61,6 +61,8 @@ lib_source_list = \ rendercopy_gen8.c \ rendercopy_gen9.c \ rendercopy.h \ + sw_sync.c \ + sw_sync.h \ intel_reg_map.c \ intel_iosf.c \ igt_kms.c \
lib/sw_sync.c new file +238 -0
238 lines not on this page · raw message
lib/sw_sync.h new file +49 -0
49 lines not on this page · raw message
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 2/13 tests/sw_sync: Add sw_sync test
In reply to [email protected]From: Robert Foss <[email protected]>
Add initial tests for sw_sync.
--- lib/sw_sync.c | 13 ++++++------- lib/sw_sync.h | 2 +- tests/Makefile.sources | 1 + tests/sw_sync.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 59 insertions(+), 8 deletions(-) create mode 100644 tests/sw_sync.c
lib/sw_sync.c +6 -7
@@ -150,8 +150,6 @@ int sw_sync_wait(int fence, int timeout) ret =poll (&fds,1 , timeout); -sw_sync_fd_close (fence); -return ret; }
@@ -179,9 +177,10 @@ static struct sync_file_info *sync_file_info(int fd) info->num_fences = num_fences; fence_info =calloc (num_fences,sizeof (struct sync_fence_info )); -if (!fence_info) +if (!fence_info) {free (info);return NULL ; + } info->sync_fence_info = (uint64_t )(unsigned long ) (fence_info);
@@ -217,18 +216,18 @@ int sw_sync_fence_size(int fd)return count; } -int sw_sync_fence_count_with_status (int fd,int status) +int sw_sync_fence_count_status (int fd,int status) {int i, count =0 ; -struct sync_fence_info *fenceInfo =NULL ; +struct sync_fence_info *fence_info =NULL ;struct sync_file_info *info =sync_file_info (fd);if (!info)return -1 ; - fenceInfo = (struct sync_fence_info *)(uintptr_t )info->sync_fence_info; + fence_info = (struct sync_fence_info *)(uintptr_t )info->sync_fence_info;for (i =0 ; i < info->num_fences ; i++) { -if (fenceInfo[i].status == status) +if (fence_info[i].status == status) count++; }
lib/sw_sync.h +1 -1
@@ -43,7 +43,7 @@ void sw_sync_timeline_inc(int fd, uint32_t count);int sw_sync_merge (int fd1,int fd2);int sw_sync_wait (int fence,int timeout);int sw_sync_fence_size (int fd); -int sw_sync_fence_count_with_status (int fd,int status); +int sw_sync_fence_count_status (int fd,int status);#endif
tests/Makefile.sources +1 -0
@@ -125,6 +125,7 @@ TESTS_progs_M = \ prime_mmap_kms \ prime_self_import \ prime_vgem \ + sw_sync \ template \ vgem_basic \ vgem_slow \
tests/sw_sync.c new file +51 -0
51 lines not on this page · raw message
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 3/13 tests/sw_sync: Add subtest test_alloc_fence
In reply to [email protected]From: Robert Foss <[email protected]>
Add subtest alloc_fence that verifies that it's possible to allocate a fence on a timeline.
--- tests/sw_sync.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
tests/sw_sync.c +16 -0
@@ -43,9 +43,25 @@ static void test_alloc_timeline(void)sw_sync_timeline_destroy (timeline); } +static void test_alloc_fence (void ) +{ +int in_fence; +int timeline; + + timeline =sw_sync_timeline_create (); + in_fence =sw_sync_fence_create (timeline,0 ); + +sw_sync_fence_destroy (in_fence); +sw_sync_timeline_destroy (timeline); +} + + igt_main { igt_subtest("alloc_timeline")test_alloc_timeline (); + + igt_subtest("alloc_fence") +test_alloc_fence (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 4/13 tests/sw_sync: Add subtest test_alloc_fence_invalid_timeline
In reply to [email protected]From: Robert Foss <[email protected]>
This subtests tests that creating fences on negative timelines fail.
--- tests/sw_sync.c | 7 +++++++ 1 file changed, 7 insertions(+)
tests/sw_sync.c +7 -0
@@ -55,6 +55,10 @@ static void test_alloc_fence(void)sw_sync_timeline_destroy (timeline); } +static void test_alloc_fence_invalid_timeline (void ) +{ +sw_sync_fence_create (-1 ,0 ); +} igt_main {
@@ -63,5 +67,8 @@ igt_main igt_subtest("alloc_fence")test_alloc_fence (); + + igt_subtest("alloc_fence_invalid_timeline") +test_alloc_fence_invalid_timeline (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 5/13 tests/sw_sync: Add subtest test_alloc_merge_fence
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest verifies that merging two fences works in the simples possible case.
--- tests/sw_sync.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
tests/sw_sync.c +23 -0
@@ -60,6 +60,26 @@ static void test_alloc_fence_invalid_timeline(void)sw_sync_fence_create (-1 ,0 ); } +static void test_alloc_merge_fence (void ) +{ +int in_fence[2 ]; +int fence_merge; +int timeline[2 ]; + + timeline[0 ] =sw_sync_timeline_create (); + timeline[1 ] =sw_sync_timeline_create (); + + in_fence[0 ] =sw_sync_fence_create (timeline[0 ],1 ); + in_fence[1 ] =sw_sync_fence_create (timeline[1 ],1 ); + fence_merge =sw_sync_merge (in_fence[1 ], in_fence[0 ]); + +sw_sync_fence_destroy (in_fence[0 ]); +sw_sync_fence_destroy (in_fence[1 ]); +sw_sync_fence_destroy (fence_merge); +sw_sync_timeline_destroy (timeline[0 ]); +sw_sync_timeline_destroy (timeline[1 ]); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -70,5 +90,8 @@ igt_main igt_subtest("alloc_fence_invalid_timeline")test_alloc_fence_invalid_timeline (); + + igt_subtest("alloc_merge_fence") +test_alloc_merge_fence (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 6/13 tests/sw_sync: Add subtest test_sync_wait
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest verifies that waiting on fences works properly.
--- tests/sw_sync.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+)
tests/sw_sync.c +38 -0
@@ -80,6 +80,41 @@ static void test_alloc_merge_fence(void)sw_sync_timeline_destroy (timeline[1 ]); } +static void test_sync_wait (void ) +{ +int fence, ret; +int timeline; + + timeline =sw_sync_timeline_create (); + fence =sw_sync_fence_create (timeline,5 ); + +/* Wait on fence until timeout */ + ret =sw_sync_wait (fence,0 ); +igt_assert_f (ret ==0 ,"Failure waiting on fence until timeout\n" ); + +/* Advance timeline from 0 -> 1 */ +sw_sync_timeline_inc (timeline,1 ); + +/* Wait on fence until timeout */ + ret =sw_sync_wait (fence,0 ); +igt_assert_f (ret ==0 ,"Failure waiting on fence until timeout\n" ); + +/* Signal the fence */ +sw_sync_timeline_inc (timeline,4 ); + +/* Wait successfully */ + ret =sw_sync_wait (fence,0 ); +igt_assert_f (ret >0 ,"Failure waiting on fence\n" ); + +/* Go even further, and confirm wait still succeeds */ +sw_sync_timeline_inc (timeline,10 ); + ret =sw_sync_wait (fence,0 ); +igt_assert_f (ret >0 ,"Failure waiting ahead\n" ); + +sw_sync_fence_destroy (fence); +sw_sync_timeline_destroy (timeline); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -93,5 +128,8 @@ igt_main igt_subtest("alloc_merge_fence")test_alloc_merge_fence (); + + igt_subtest("sync_wait") +test_sync_wait (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 7/13 tests/sw_sync: Add subtest test_sync_merge
In reply to [email protected]From: Robert Foss <[email protected]>
Add subtest test_sync_merge that tests merging fences and the validity of the resulting merged fence.
--- tests/sw_sync.c | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+)
tests/sw_sync.c +67 -0
@@ -115,6 +115,70 @@ static void test_sync_wait(void)sw_sync_timeline_destroy (timeline); } +static void test_sync_merge (void ) +{ +int in_fence[3 ]; +int fence_merge; +int timeline; +int active, signaled; + + timeline =sw_sync_timeline_create (); + in_fence[0 ] =sw_sync_fence_create (timeline,1 ); + in_fence[1 ] =sw_sync_fence_create (timeline,2 ); + in_fence[2 ] =sw_sync_fence_create (timeline,3 ); + + fence_merge =sw_sync_merge (in_fence[0 ], in_fence[1 ]); + fence_merge =sw_sync_merge (in_fence[2 ], fence_merge); + +/* confirm all fences have one active point (even d) */ + active =sw_sync_fence_count_status (in_fence[0 ], +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (active ==1 ,"in_fence[0] has too many active fences\n" ); + active =sw_sync_fence_count_status (in_fence[1 ], +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (active ==1 ,"in_fence[1] has too many active fences\n" ); + active =sw_sync_fence_count_status (in_fence[2 ], +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (active ==1 ,"in_fence[2] has too many active fences\n" ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (active ==1 ,"fence_merge has too many active fences\n" ); + +/* confirm that fence_merge is not signaled until the max of fence 0,1,2 */ +sw_sync_timeline_inc (timeline,1 ); + signaled =sw_sync_fence_count_status (in_fence[0 ], +SW_SYNC_FENCE_STATUS_SIGNALED ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (signaled ==1 ,"in_fence[0] did not signal\n" ); +igt_assert_f (active ==1 ,"fence_merge signaled too early\n" ); + +sw_sync_timeline_inc (timeline,1 ); + signaled =sw_sync_fence_count_status (in_fence[1 ], +SW_SYNC_FENCE_STATUS_SIGNALED ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (signaled ==1 ,"in_fence[1] did not signal\n" ); +igt_assert_f (active ==1 ,"fence_merge signaled too early\n" ); + +sw_sync_timeline_inc (timeline,1 ); + signaled =sw_sync_fence_count_status (in_fence[2 ], +SW_SYNC_FENCE_STATUS_SIGNALED ); +igt_assert_f (signaled ==1 ,"in_fence[2] did not signal\n" ); + signaled =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_SIGNALED ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (active ==0 && signaled ==1 , +"fence_merge did not signal\n" ); + +sw_sync_fence_destroy (in_fence[0 ]); +sw_sync_fence_destroy (in_fence[1 ]); +sw_sync_fence_destroy (in_fence[2 ]); +sw_sync_fence_destroy (fence_merge); +sw_sync_timeline_destroy (timeline); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -131,5 +195,8 @@ igt_main igt_subtest("sync_wait")test_sync_wait (); + + igt_subtest("sync_merge") +test_sync_merge (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 8/13 tests/sw_sync: Add subtest test_sync_merge_same
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest verifies merging a fence with itself does not fail.
--- tests/sw_sync.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
tests/sw_sync.c +27 -0
@@ -179,6 +179,30 @@ static void test_sync_merge(void)sw_sync_timeline_destroy (timeline); } +static void test_sync_merge_same (void ) +{ +int in_fence[2 ]; +int timeline; +int signaled; + + timeline =sw_sync_timeline_create (); + in_fence[0 ] =sw_sync_fence_create (timeline,1 ); + in_fence[1 ] =sw_sync_merge (in_fence[0 ], in_fence[0 ]); + + signaled =sw_sync_fence_count_status (in_fence[0 ], +SW_SYNC_FENCE_STATUS_SIGNALED ); +igt_assert_f (signaled ==0 ,"fence signaled too early\n" ); + +sw_sync_timeline_inc (timeline,1 ); + signaled =sw_sync_fence_count_status (in_fence[0 ], +SW_SYNC_FENCE_STATUS_SIGNALED ); +igt_assert_f (signaled ==1 ,"fence did not signal\n" ); + +sw_sync_fence_destroy (in_fence[0 ]); +sw_sync_fence_destroy (in_fence[1 ]); +sw_sync_timeline_destroy (timeline); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -198,5 +222,8 @@ igt_main igt_subtest("sync_merge")test_sync_merge (); + + igt_subtest("sync_merge_same") +test_sync_merge_same (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 9/13 tests/sw_sync: Add subtest test_sync_multi_consumer
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest verifies the access ordering of multiple consumer threads.
--- tests/sw_sync.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+)
tests/sw_sync.c +103 -0
@@ -27,6 +27,8 @@* Robert Foss <[email protected]> */ +#include <pthread.h> +#include <semaphore.h> #include <stdint.h> #include "sw_sync.h"
@@ -35,6 +37,15 @@IGT_TEST_DESCRIPTION ("Test SW Sync Framework" ); +typedef struct { +int timeline; +uint32_t thread_id; +uint32_t nbr_threads; +uint32_t nbr_iterations; +volatile uint32_t *volatile counter; +sem_t *sem; +}data_t ; +static void test_alloc_timeline (void ) {int timeline;
@@ -203,6 +214,95 @@ static void test_sync_merge_same(void)sw_sync_timeline_destroy (timeline); } +static void *test_sync_multi_consumer_thread (void *arg) +{ +data_t *data = arg; +int thread_id = data->thread_id; +int nbr_threads = data->nbr_threads; +int timeline = data->timeline; +int iterations = data->nbr_iterations; +int ret, i; + +for (i =0 ; i < iterations; i++) { +int next_point = i * nbr_threads + thread_id; +int fence =sw_sync_fence_create (timeline, next_point); + + ret =sw_sync_wait (fence,1000 ); +if (ret <=0 ) + { +return (void *)1 ; + } + +if (*(data->counter) != next_point) + { +return (void *)1 ; + } + +sem_post (data->sem); +sw_sync_fence_destroy (fence); + } +return NULL ; +} + +static void test_sync_multi_consumer (void ) +{ +const uint32_t nbr_threads =8 ; +const uint32_t nbr_iterations =1 <<14 ; +data_t data_arr[nbr_threads]; +pthread_t thread_arr[nbr_threads]; +sem_t sem; +int timeline; +volatile uint32_t counter =0 ; +uintptr_t thread_ret =0 ; +data_t data; +int i, ret; + +sem_init (&sem,0 ,0 ); + timeline =sw_sync_timeline_create (); + + data.nbr_iterations = nbr_iterations; + data.nbr_threads = nbr_threads; + data.counter = &counter; + data.timeline = timeline; + data.sem = &sem; + +/* Start sync threads. */ +for (i =0 ; i < nbr_threads; i++) + { + data_arr[i] = data; + data_arr[i].thread_id = i; + ret =pthread_create (&thread_arr[i],NULL , + test_sync_multi_consumer_thread, + (void *) &(data_arr[i])); +igt_assert_eq (ret,0 ); + } + +/* Produce 'content'. */ +for (i =0 ; i < nbr_threads * nbr_iterations; i++) + { +sem_wait (&sem); + + counter++; +sw_sync_timeline_inc (timeline,1 ); + } + +/* Wait for threads to complete. */ +for (i =0 ; i < nbr_threads; i++) + { +uintptr_t local_thread_ret; +pthread_join (thread_arr[i], (void **)&local_thread_ret); + thread_ret |= local_thread_ret; + } + +sw_sync_timeline_destroy (timeline); +sem_destroy (&sem); + +igt_assert_f (counter == nbr_threads * nbr_iterations, +"Counter has unexpected value.\n" ); + +igt_assert_f (thread_ret ==0 ,"A sync thread reported failure.\n" ); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -225,5 +325,8 @@ igt_main igt_subtest("sync_merge_same")test_sync_merge_same (); + + igt_subtest("sync_multi_consumer") +test_sync_multi_consumer (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 10/13 tests/sw_sync: Add subtest test_sync_multi_consumer_producer
In reply to [email protected]From: Robert Foss <[email protected]>
This test verifies that stressing the kernel by creating multiple consumer/producer threads that wait on a single timeline to be incremented by another conumer/producer thread does not fail.
And that the order amongst the threads is maintained.
--- tests/sw_sync.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+)
tests/sw_sync.c +83 -0
@@ -303,6 +303,86 @@ static void test_sync_multi_consumer(void)igt_assert_f (thread_ret ==0 ,"A sync thread reported failure.\n" ); } +static void *test_sync_multi_consumer_producer_thread (void *arg) +{ +data_t *data = arg; +int thread_id = data->thread_id; +int nbr_threads = data->nbr_threads; +int timeline = data->timeline; +int iterations = data->nbr_iterations; +int ret, i; + +for (i =0 ; i < iterations; i++) { +int next_point = i * nbr_threads + thread_id; +int fence =sw_sync_fence_create (timeline, next_point); + + ret =sw_sync_wait (fence,1000 ); +if (ret <=0 ) + { +return (void *)1 ; + } + +if (*(data->counter) != next_point) + { +return (void *)1 ; + } + + (*data->counter)++; + +/* Kick off the next thread. */ +sw_sync_timeline_inc (timeline,1 ); + +sw_sync_fence_destroy (fence); + } +return NULL ; +} + +static void test_sync_multi_consumer_producer (void ) +{ +const uint32_t nbr_threads =8 ; +const uint32_t nbr_iterations =1 <<14 ; +data_t data_arr[nbr_threads]; +pthread_t thread_arr[nbr_threads]; +int timeline; +volatile uint32_t counter =0 ; +uintptr_t thread_ret =0 ; +data_t data; +int i, ret; + + timeline =sw_sync_timeline_create (); + + data.nbr_iterations = nbr_iterations; + data.nbr_threads = nbr_threads; + data.counter = &counter; + data.timeline = timeline; + +/* Start consumer threads. */ +for (i =0 ; i < nbr_threads; i++) + { + data_arr[i] = data; + data_arr[i].thread_id = i; + ret =pthread_create (&thread_arr[i],NULL , + test_sync_multi_consumer_producer_thread, + (void *) &(data_arr[i])); +igt_assert_eq (ret,0 ); + } + +/* Wait for threads to complete. */ +for (i =0 ; i < nbr_threads; i++) + { +uintptr_t local_thread_ret; +pthread_join (thread_arr[i], (void **)&local_thread_ret); + thread_ret |= local_thread_ret; + } + +sw_sync_timeline_destroy (timeline); + +igt_assert_f (counter == nbr_threads * nbr_iterations, +"Counter has unexpected value.\n" ); + +igt_assert_f (thread_ret ==0 ,"A sync thread reported failure.\n" ); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -328,5 +408,8 @@ igt_main igt_subtest("sync_multi_consumer")test_sync_multi_consumer (); + + igt_subtest("sync_multi_consumer_producer") +test_sync_multi_consumer_producer (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 11/13 tests/sw_sync: Add subtest test_sync_random_merge
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest verifies that creating many timelines and merging random fences from each timeline with eachother results in merged fences that are fully functional.
--- tests/sw_sync.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+)
tests/sw_sync.c +73 -0
@@ -383,6 +383,76 @@ static void test_sync_multi_consumer_producer(void)igt_assert_f (thread_ret ==0 ,"A sync thread reported failure.\n" ); } +static void test_sync_random_merge (void ) +{ +int i, size, ret; +const int nbr_timeline =32 ; +const int nbr_merge =1024 ; +int fence_map[nbr_timeline]; +int timeline_arr[nbr_timeline]; +int fence, tmpfence, merged; +int timeline, timeline_offset, sync_pt; + +srand (time (NULL )); + +for (i =0 ; i < nbr_timeline; i++) + timeline_arr[i] =sw_sync_timeline_create (); + +memset (fence_map,-1 ,sizeof (fence_map)); + + sync_pt =rand (); + fence =sw_sync_fence_create (timeline_arr[0 ], sync_pt); + + fence_map[0 ] = sync_pt; + +/* Randomly create syncpoints out of a fixed set of timelines, +* and merge them together. +*/ +for (i =0 ; i < nbr_merge; i++) { +/* Generate syncpoint. */ + timeline_offset =rand () % nbr_timeline; + timeline = timeline_arr[timeline_offset]; + sync_pt =rand (); + +/* Keep track of the latest sync_pt in each timeline. */ +if (fence_map[timeline_offset] ==-1 ) + fence_map[timeline_offset] = sync_pt; +else if (fence_map[timeline_offset] < sync_pt) + fence_map[timeline_offset] = sync_pt; + +/* Merge. */ + tmpfence =sw_sync_fence_create (timeline, sync_pt); + merged =sw_sync_merge (tmpfence, fence); +sw_sync_fence_destroy (tmpfence); +sw_sync_fence_destroy (fence); + fence = merged; + } + + size =0 ; +for (i =0 ; i < nbr_timeline; i++) +if (fence_map[i] !=-1 ) + size++; + +/* Trigger the merged fence. */ +for (i =0 ; i < nbr_timeline; i++) { +if (fence_map[i] !=-1 ) { + ret =sw_sync_wait (fence,0 ); +igt_assert_f (ret ==0 , +"Failure waiting on fence until timeout\n" ); +/* Increment the timeline to the last sync_pt */ +sw_sync_timeline_inc (timeline_arr[i], fence_map[i]); + } + } + +/* Check that the fence is triggered. */ + ret =sw_sync_wait (fence,0 ); +igt_assert_f (ret >0 ,"Failure triggering fence\n" ); + +sw_sync_fence_destroy (fence); +for (i =0 ; i < nbr_timeline; i++) +sw_sync_timeline_destroy (timeline_arr[i]); +} + igt_main {igt_subtest ("alloc_timeline" )
@@ -411,5 +481,8 @@ igt_main igt_subtest("sync_multi_consumer_producer")test_sync_multi_consumer_producer (); + + igt_subtest("sync_random_merge") +test_sync_random_merge (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 12/13 tests/sw_sync: Add subtest test_sync_multi_timeline_wait
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest verifies that waiting, timing out on a wait and that counting fences in various states works.
--- tests/sw_sync.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)
tests/sw_sync.c +66 -0
@@ -214,6 +214,69 @@ static void test_sync_merge_same(void)sw_sync_timeline_destroy (timeline); } +static void test_sync_multi_timeline_wait (void ) +{ +int timeline[3 ]; +int in_fence[3 ]; +int fence_merge; +int active, signaled, ret; + + timeline[0 ] =sw_sync_timeline_create (); + timeline[1 ] =sw_sync_timeline_create (); + timeline[2 ] =sw_sync_timeline_create (); + + in_fence[0 ] =sw_sync_fence_create (timeline[0 ],5 ); + in_fence[1 ] =sw_sync_fence_create (timeline[1 ],5 ); + in_fence[2 ] =sw_sync_fence_create (timeline[2 ],5 ); + + fence_merge =sw_sync_merge (in_fence[0 ], in_fence[1 ]); + fence_merge =sw_sync_merge (in_fence[2 ], fence_merge); + +/* Confirm fence isn't signaled */ + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); +igt_assert_f (active ==3 ,"Fence signaled too early\n" ); + + ret =sw_sync_wait (fence_merge,0 ); +igt_assert_f (ret ==0 ,"Failure waiting on fence until timeout\n" ); + +sw_sync_timeline_inc (timeline[0 ],5 ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); + signaled =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_SIGNALED ); +igt_assert_f (active ==2 && signaled ==1 , +"Fence did not signal properly\n" ); + +sw_sync_timeline_inc (timeline[1 ],5 ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); + signaled =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_SIGNALED ); +igt_assert_f (active ==1 && signaled ==2 , +"Fence did not signal properly\n" ); + +sw_sync_timeline_inc (timeline[2 ],5 ); + active =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_ACTIVE ); + signaled =sw_sync_fence_count_status (fence_merge, +SW_SYNC_FENCE_STATUS_SIGNALED ); +igt_assert_f (active ==0 && signaled ==3 , +"Fence did not signal properly\n" ); + +/* confirm you can successfully wait */ + ret =sw_sync_wait (fence_merge,100 ); +igt_assert_f (ret >0 ,"Failure waiting on signaled fence\n" ); + +sw_sync_fence_destroy (in_fence[0 ]); +sw_sync_fence_destroy (in_fence[1 ]); +sw_sync_fence_destroy (in_fence[2 ]); +sw_sync_fence_destroy (fence_merge); +sw_sync_timeline_destroy (timeline[0 ]); +sw_sync_timeline_destroy (timeline[1 ]); +sw_sync_timeline_destroy (timeline[2 ]); +} +static void *test_sync_multi_consumer_thread (void *arg) {data_t *data = arg;
@@ -476,6 +539,9 @@ igt_main igt_subtest("sync_merge_same")test_sync_merge_same (); + igt_subtest("sync_multi_timeline_wait") +test_sync_multi_timeline_wait (); + igt_subtest("sync_multi_consumer")test_sync_multi_consumer ();
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 13/13 tests/sw_sync: Add subtest test_sync_multi_producer_single_consumer
In reply to [email protected]From: Robert Foss <[email protected]>
This subtest runs a single consumer thread and multiple producer thread that are synchronized using multiple timelines.
--- tests/sw_sync.c | 139 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 139 insertions(+)
tests/sw_sync.c +139 -0
@@ -446,6 +446,142 @@ static void test_sync_multi_consumer_producer(void)igt_assert_f (thread_ret ==0 ,"A sync thread reported failure.\n" ); } +static int test_mspc_wait_on_fence (int fence) +{ +int error, active; + +do { + error =sw_sync_fence_count_status (fence, +SW_SYNC_FENCE_STATUS_ERROR ); +igt_assert_f (error ==0 ,"Error occurred on fence\n" ); + active =sw_sync_fence_count_status (fence, +SW_SYNC_FENCE_STATUS_ACTIVE ); + }while (active); + +return 0 ; +} + +static struct { +int iterations; +int threads; +int counter; +int cons_timeline; +int *prod_timeline; +pthread_mutex_t lock; +} test_mpsc_data; + +static int mpsc_producer_thread (void *d) +{ +int id = (long )d; +int fence, i; +int *prod_timeline = test_mpsc_data.prod_timeline; +int cons_timeline = test_mpsc_data.cons_timeline; +int iterations = test_mpsc_data.iterations; + +for (i =0 ; i < iterations; i++) { + fence =sw_sync_fence_create (cons_timeline, i); + +/* Wait for the consumer to finish. Use alternate +* means of waiting on the fence +*/ +if ((iterations + id) %8 !=0 ) { +igt_assert_f (sw_sync_wait (fence,-1 ) >0 , +"Failure waiting on fence\n" ); + }else { +igt_assert_f (test_mspc_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_mpsc_data.lock); + test_mpsc_data.counter++; +pthread_mutex_unlock (&test_mpsc_data.lock); + +sw_sync_timeline_inc (prod_timeline[id],1 ); +sw_sync_fence_destroy (fence); + } + +return 0 ; +} + +static int mpsc_consumer_thread (void ) +{ +int fence, merged, tmp, it, i; +int *prod_timeline = test_mpsc_data.prod_timeline; +int cons_timeline = test_mpsc_data.cons_timeline; +int iterations = test_mpsc_data.iterations; +int n = test_mpsc_data.threads; + +for (it =1 ; it <= iterations; it++) { + fence =sw_sync_fence_create (prod_timeline[0 ], it); +for (i =1 ; i < n; i++) { + tmp =sw_sync_fence_create (prod_timeline[i], it); + merged =sw_sync_merge (tmp, fence); +sw_sync_fence_destroy (tmp); +sw_sync_fence_destroy (fence); + fence = merged; + } + +/* Make sure we see an increment from every producer thread. +* Vary the means by which we wait. +*/ +if (iterations %8 !=0 ) { +igt_assert_f (sw_sync_wait (fence,-1 ) ==0 , +"Producers did not increment as expected\n" ); + }else { +igt_assert_f (test_mspc_wait_on_fence (fence) ==0 , +"Failure waiting on fence\n" ); + } + +igt_assert_f (test_mpsc_data.counter == n * it, +"Counter value mismatch\n" ); + +/* Release the producer threads */ +sw_sync_timeline_inc (cons_timeline,1 ); +sw_sync_fence_destroy (fence); + } + +return 0 ; +} + +/* IMPORTANT NOTE: if you see this test failing on your system, it may be +* due to a shortage of file descriptors. Please ensure your system has +* a sensible limit for this test to finish correctly. +*/ +static void test_sync_multi_producer_single_consumer (void ) +{ +int iterations =1 <<12 ; +int n =5 ; +int prod_timeline[n]; +int cons_timeline; +pthread_t threads[n]; +long i; + + cons_timeline =sw_sync_timeline_create (); +for (i =0 ; i < n; i++) + prod_timeline[i] =sw_sync_timeline_create (); + + test_mpsc_data.prod_timeline = prod_timeline; + test_mpsc_data.cons_timeline = cons_timeline; + test_mpsc_data.iterations = iterations; + test_mpsc_data.threads = n; + test_mpsc_data.counter =0 ; +pthread_mutex_init (&test_mpsc_data.lock,NULL ); + +for (i =0 ; i < n; i++) { +pthread_create (&threads[i],NULL , (void * (*)(void *)) + mpsc_producer_thread, + (void *)i); + } + +mpsc_consumer_thread (); + +for (i =0 ; i < n; i++) +pthread_join (threads[i],NULL ); +} +static void test_sync_random_merge (void ) {int i, size, ret;
@@ -548,6 +684,9 @@ igt_main igt_subtest("sync_multi_consumer_producer")test_sync_multi_consumer_producer (); + igt_subtest("sync_multi_producer_single_consumer") +test_sync_multi_producer_single_consumer (); + igt_subtest("sync_random_merge")test_sync_random_merge (); }
Signature · 6 lines
2.7.4 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx