src/vppinfra/test_rwlock.c - fdio/vpp - Gitiles

 /*
  * Copyright (c) 2019 Arm Limited.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif

 #include <vppinfra/mem.h>
 #include <vppinfra/cache.h>
 #include <vppinfra/lock.h>
 #include <pthread.h>
 #include <vppinfra/format.h>
 #include <vppinfra/error.h>
 #include <vppinfra/time.h>
 #include <sched.h>
 #include <vppinfra/atomics.h>

 static u32 all_threads_online = 0;

 typedef struct
 {
   uword threads_per_core;
   uword cpu_mask_read;
   uword read_cores;
   uword cpu_mask_write;
   uword write_cores;
   uword increment_per_thread;
   clib_rwlock_t rwlock;
   uword shared_count;
   uword iterations;
 } rwlock_test_main_t;

 void *
 write_shared_counter (void *arg)
 {
   f64 *time = vec_new (f64, 1);
   *time = 0;
   rwlock_test_main_t *rtm = arg;

   /* Wait for all threads to be created */
   while (!clib_atomic_load_acq_n (&all_threads_online));

   f64 start = clib_cpu_time_now ();
   for (uword i = 0; i < rtm->increment_per_thread; i++)
     {
       clib_rwlock_writer_lock (&rtm->rwlock);
       rtm->shared_count++;
       clib_rwlock_writer_unlock (&rtm->rwlock);
     }
   *time = clib_cpu_time_now () - start;
   return time;
 }

 void *
 read_shared_counter (void *arg)
 {
   f64 *time = vec_new (f64, 1);
   *time = 0;
   rwlock_test_main_t *rtm = arg;
   uword cnt_cpy = 0, exp = rtm->increment_per_thread * rtm->write_cores *
     rtm->threads_per_core;

   /* Wait for all threads to be created */
   while (!clib_atomic_load_acq_n (&all_threads_online));

   f64 start = clib_cpu_time_now ();
   while (cnt_cpy < exp)
     {
       clib_rwlock_reader_lock (&rtm->rwlock);
       cnt_cpy = rtm->shared_count;
       clib_rwlock_reader_unlock (&rtm->rwlock);
     }
   *time = clib_cpu_time_now () - start;
   return time;
 }

 unsigned
 test_rwlock (rwlock_test_main_t * rtm, f64 * elapse_time)
 {
   int error = 0, total_threads = (rtm->read_cores + rtm->write_cores)
     * rtm->threads_per_core;
   pthread_t pthread[total_threads];

   cpu_set_t cpuset;
   unsigned cores_set = 0, cpu_id = 0;

   /* Spawn reader (consumer) threads */
   for (unsigned cpu_mask = rtm->cpu_mask_read; cpu_mask; cpu_mask >>= 1)
     {
       if (!(cpu_mask & 1))
 	{
 	  cpu_id++;
 	  continue;
 	}

       CPU_ZERO (&cpuset);
       CPU_SET (cpu_id, &cpuset);
       for (uword t_num = 0; t_num < rtm->threads_per_core; t_num++)
 	{
 	  uword t_index = cores_set * rtm->threads_per_core + t_num;
 	  if ((error = pthread_create (&pthread[t_index], NULL,
 				       &read_shared_counter, rtm)))
 	    clib_unix_warning ("pthread_create failed with %d", error);

 	  if ((error = pthread_setaffinity_np (pthread[t_index],
 					       sizeof (cpu_set_t), &cpuset)))
 	    clib_unix_warning ("pthread_set_affinity_np failed with %d",
 			       error);
 	}
       cores_set++;
       cpu_id++;
     }

   /* Spawn writer (producer) threads */
   cpu_id = 0;
   for (unsigned cpu_mask = rtm->cpu_mask_write; cpu_mask; cpu_mask >>= 1)
     {
       if (!(cpu_mask & 1))
 	{
 	  cpu_id++;
 	  continue;
 	}

       CPU_ZERO (&cpuset);
       CPU_SET (cpu_id, &cpuset);
       for (uword t_num = 0; t_num < rtm->threads_per_core; t_num++)
 	{
 	  uword t_index = cores_set * rtm->threads_per_core + t_num;
 	  if ((error = pthread_create (&pthread[t_index], NULL,
 				       &write_shared_counter, rtm)))
 	    clib_unix_warning ("pthread_create failed with %d", error);

 	  if ((error = pthread_setaffinity_np (pthread[t_index],
 					       sizeof (cpu_set_t), &cpuset)))
 	    clib_unix_warning ("pthread_set_affinity_np failed with %d",
 			       error);
 	}
       cores_set++;
       cpu_id++;
     }

   /* Launch all threads */
   clib_atomic_store_rel_n (&all_threads_online, 1);

   for (uword thread_num = 0; thread_num < total_threads; thread_num++)
     {
       f64 *time;
       if ((error = pthread_join (pthread[thread_num], (void *) &time)))
 	clib_unix_warning ("pthread_join failed with %d", error);
       *elapse_time += *time;
       vec_free (time);
     }

   fformat (stdout, "Time elapsed: %.4e\n", *elapse_time);
   return rtm->shared_count;
 }

 uword
 num_cores_in_cpu_mask (uword mask)
 {
   uword num_cores = 0;
   for (uword cpu_mask = mask; cpu_mask; cpu_mask >>= 1)
     num_cores += (cpu_mask & 1);
   return num_cores;
 }

 int
 test_rwlock_main (unformat_input_t * i)
 {
   rwlock_test_main_t _rtm, *rtm = &_rtm;
   clib_memset (rtm, 0, sizeof (rwlock_test_main_t));

   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
     {
       if (0 == unformat (i, "threads/core %d", &rtm->threads_per_core)
 	  && 0 == unformat (i, "cpu_mask_read %x", &rtm->cpu_mask_read)
 	  && 0 == unformat (i, "cpu_mask_write %x", &rtm->cpu_mask_write)
 	  && 0 == unformat (i, "increment %d", &rtm->increment_per_thread)
 	  && 0 == unformat (i, "iterations %d", &rtm->iterations))
 	{
 	  clib_unix_warning ("unknown input '%U'", format_unformat_error, i);
 	  return 1;
 	}
     }

   rtm->read_cores = num_cores_in_cpu_mask (rtm->cpu_mask_read);
   rtm->write_cores = num_cores_in_cpu_mask (rtm->cpu_mask_write);

   uword total_increment = rtm->threads_per_core * rtm->write_cores *
     rtm->increment_per_thread;

   clib_rwlock_init (&rtm->rwlock);

   f64 average_time = 0;
   for (uword trial = 0; trial < rtm->iterations; trial++)
     {
       rtm->shared_count = 0;
       f64 elapse_time = 0;
       if (test_rwlock (rtm, &elapse_time) != total_increment)
 	{
 	  clib_rwlock_free (&rtm->rwlock);
 	  fformat (stdout, "FAILED: expected count: %d, actual count: %d\n",
 		   total_increment, rtm->shared_count);
 	  return 1;
 	}
       fformat (stdout, "Trial %d SUCCESS: %d = %d\n",
 	       trial, rtm->shared_count, total_increment);
       average_time = (average_time * trial + elapse_time) / (trial + 1);
       fformat (stdout, "Average lock/unlock cycles: %.4e\n", average_time);
     }
   clib_rwlock_free (&rtm->rwlock);
   return 0;
 }

 #ifdef CLIB_UNIX
 /** Launches a number of writer threads to simultaneously increment a global
     counter and a number of reader threads to continuously poll the counter,
     and records timestamps for rwlock performance benchmarking

     @param "threads/core [# threads/core]" - number of threads per core
     @param "cpu_mask_read [cpu_mask]" - reader thread cpu string e.g. input
             ff sets cpus 0 - 7
     @param "cpu_mask_write [cpu_mask]" - writer thread cpu string
     @param "increment [# increments]" - number of increments per writer thread
     @param "iterations [# iterations]" - number of iterations
     @returns exit code
 */
 int
 main (int argc, char *argv[])
 {
   unformat_input_t i;
   i32 ret;
   clib_time_t time;

   clib_mem_init (0, 3ULL << 30);
   clib_time_init (&time);

   unformat_init_command_line (&i, argv);
   ret = test_rwlock_main (&i);
   unformat_free (&i);

   return ret;
 }
 #endif /* CLIB_UNIX */

 /*
  * fd.io coding-style-patch-verification: ON
  *
  * Local Variables:
  * eval: (c-set-style "gnu")
  * End:
  */
	/*
	* Copyright (c) 2019 Arm Limited.
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef _GNU_SOURCE
	#define _GNU_SOURCE
	#endif

	#include <vppinfra/mem.h>
	#include <vppinfra/cache.h>
	#include <vppinfra/lock.h>
	#include <pthread.h>
	#include <vppinfra/format.h>
	#include <vppinfra/error.h>
	#include <vppinfra/time.h>
	#include <sched.h>
	#include <vppinfra/atomics.h>

	static u32 all_threads_online = 0;

	typedef struct
	{
	uword threads_per_core;
	uword cpu_mask_read;
	uword read_cores;
	uword cpu_mask_write;
	uword write_cores;
	uword increment_per_thread;
	clib_rwlock_t rwlock;
	uword shared_count;
	uword iterations;
	} rwlock_test_main_t;

	void *
	write_shared_counter (void *arg)
	{
	f64 *time = vec_new (f64, 1);
	*time = 0;
	rwlock_test_main_t *rtm = arg;

	/* Wait for all threads to be created */
	while (!clib_atomic_load_acq_n (&all_threads_online));

	f64 start = clib_cpu_time_now ();
	for (uword i = 0; i < rtm->increment_per_thread; i++)
	{
	clib_rwlock_writer_lock (&rtm->rwlock);
	rtm->shared_count++;
	clib_rwlock_writer_unlock (&rtm->rwlock);
	}
	*time = clib_cpu_time_now () - start;
	return time;
	}

	void *
	read_shared_counter (void *arg)
	{
	f64 *time = vec_new (f64, 1);
	*time = 0;
	rwlock_test_main_t *rtm = arg;
	uword cnt_cpy = 0, exp = rtm->increment_per_thread * rtm->write_cores *
	rtm->threads_per_core;

	/* Wait for all threads to be created */
	while (!clib_atomic_load_acq_n (&all_threads_online));

	f64 start = clib_cpu_time_now ();
	while (cnt_cpy < exp)
	{
	clib_rwlock_reader_lock (&rtm->rwlock);
	cnt_cpy = rtm->shared_count;
	clib_rwlock_reader_unlock (&rtm->rwlock);
	}
	*time = clib_cpu_time_now () - start;
	return time;
	}

	unsigned
	test_rwlock (rwlock_test_main_t * rtm, f64 * elapse_time)
	{
	int error = 0, total_threads = (rtm->read_cores + rtm->write_cores)
	* rtm->threads_per_core;
	pthread_t pthread[total_threads];

	cpu_set_t cpuset;
	unsigned cores_set = 0, cpu_id = 0;

	/* Spawn reader (consumer) threads */
	for (unsigned cpu_mask = rtm->cpu_mask_read; cpu_mask; cpu_mask >>= 1)
	{
	if (!(cpu_mask & 1))
	{
	cpu_id++;
	continue;
	}

	CPU_ZERO (&cpuset);
	CPU_SET (cpu_id, &cpuset);
	for (uword t_num = 0; t_num < rtm->threads_per_core; t_num++)
	{
	uword t_index = cores_set * rtm->threads_per_core + t_num;
	if ((error = pthread_create (&pthread[t_index], NULL,
	&read_shared_counter, rtm)))
	clib_unix_warning ("pthread_create failed with %d", error);

	if ((error = pthread_setaffinity_np (pthread[t_index],
	sizeof (cpu_set_t), &cpuset)))
	clib_unix_warning ("pthread_set_affinity_np failed with %d",
	error);
	}
	cores_set++;
	cpu_id++;
	}

	/* Spawn writer (producer) threads */
	cpu_id = 0;
	for (unsigned cpu_mask = rtm->cpu_mask_write; cpu_mask; cpu_mask >>= 1)
	{
	if (!(cpu_mask & 1))
	{
	cpu_id++;
	continue;
	}

	CPU_ZERO (&cpuset);
	CPU_SET (cpu_id, &cpuset);
	for (uword t_num = 0; t_num < rtm->threads_per_core; t_num++)
	{
	uword t_index = cores_set * rtm->threads_per_core + t_num;
	if ((error = pthread_create (&pthread[t_index], NULL,
	&write_shared_counter, rtm)))
	clib_unix_warning ("pthread_create failed with %d", error);

	if ((error = pthread_setaffinity_np (pthread[t_index],
	sizeof (cpu_set_t), &cpuset)))
	clib_unix_warning ("pthread_set_affinity_np failed with %d",
	error);
	}
	cores_set++;
	cpu_id++;
	}

	/* Launch all threads */
	clib_atomic_store_rel_n (&all_threads_online, 1);

	for (uword thread_num = 0; thread_num < total_threads; thread_num++)
	{
	f64 *time;
	if ((error = pthread_join (pthread[thread_num], (void *) &time)))
	clib_unix_warning ("pthread_join failed with %d", error);
	elapse_time += time;
	vec_free (time);
	}

	fformat (stdout, "Time elapsed: %.4e\n", *elapse_time);
	return rtm->shared_count;
	}

	uword
	num_cores_in_cpu_mask (uword mask)
	{
	uword num_cores = 0;
	for (uword cpu_mask = mask; cpu_mask; cpu_mask >>= 1)
	num_cores += (cpu_mask & 1);
	return num_cores;
	}

	int
	test_rwlock_main (unformat_input_t * i)
	{
	rwlock_test_main_t _rtm, *rtm = &_rtm;
	clib_memset (rtm, 0, sizeof (rwlock_test_main_t));

	while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
	{
	if (0 == unformat (i, "threads/core %d", &rtm->threads_per_core)
	&& 0 == unformat (i, "cpu_mask_read %x", &rtm->cpu_mask_read)
	&& 0 == unformat (i, "cpu_mask_write %x", &rtm->cpu_mask_write)
	&& 0 == unformat (i, "increment %d", &rtm->increment_per_thread)
	&& 0 == unformat (i, "iterations %d", &rtm->iterations))
	{
	clib_unix_warning ("unknown input '%U'", format_unformat_error, i);
	return 1;
	}
	}

	rtm->read_cores = num_cores_in_cpu_mask (rtm->cpu_mask_read);
	rtm->write_cores = num_cores_in_cpu_mask (rtm->cpu_mask_write);

	uword total_increment = rtm->threads_per_core * rtm->write_cores *
	rtm->increment_per_thread;

	clib_rwlock_init (&rtm->rwlock);

	f64 average_time = 0;
	for (uword trial = 0; trial < rtm->iterations; trial++)
	{
	rtm->shared_count = 0;
	f64 elapse_time = 0;
	if (test_rwlock (rtm, &elapse_time) != total_increment)
	{
	clib_rwlock_free (&rtm->rwlock);
	fformat (stdout, "FAILED: expected count: %d, actual count: %d\n",
	total_increment, rtm->shared_count);
	return 1;
	}
	fformat (stdout, "Trial %d SUCCESS: %d = %d\n",
	trial, rtm->shared_count, total_increment);
	average_time = (average_time * trial + elapse_time) / (trial + 1);
	fformat (stdout, "Average lock/unlock cycles: %.4e\n", average_time);
	}
	clib_rwlock_free (&rtm->rwlock);
	return 0;
	}

	#ifdef CLIB_UNIX
	/** Launches a number of writer threads to simultaneously increment a global
	counter and a number of reader threads to continuously poll the counter,
	and records timestamps for rwlock performance benchmarking

	@param "threads/core [# threads/core]" - number of threads per core
	@param "cpu_mask_read [cpu_mask]" - reader thread cpu string e.g. input
	ff sets cpus 0 - 7
	@param "cpu_mask_write [cpu_mask]" - writer thread cpu string
	@param "increment [# increments]" - number of increments per writer thread
	@param "iterations [# iterations]" - number of iterations
	@returns exit code
	*/
	int
	main (int argc, char *argv[])
	{
	unformat_input_t i;
	i32 ret;
	clib_time_t time;

	clib_mem_init (0, 3ULL << 30);
	clib_time_init (&time);

	unformat_init_command_line (&i, argv);
	ret = test_rwlock_main (&i);
	unformat_free (&i);

	return ret;
	}
	#endif /* CLIB_UNIX */

	/*
	* fd.io coding-style-patch-verification: ON
	*
	* Local Variables:
	* eval: (c-set-style "gnu")
	* End:
	*/