[thirdparty/glibc.git] / sysdeps / unix / sysv / linux / tst-skeleton-thread-affinity.c

/* Generic test for CPU affinity functions, multi-threaded variant.
   Copyright (C) 2015-2016 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* Before including this file, a test has to declare the helper
   getaffinity and setaffinity functions described in
   tst-skeleton-affinity.c, which is included below.  */

#include <errno.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdlib.h>
#include <sys/time.h>

struct conf;
static bool early_test (struct conf *);

/* Arbitrary run time for each pass.  */
#define PASS_TIMEOUT 2

/* There are two passes (one with sched_yield, one without), and we
   double the timeout to be on the safe side.  */
#define TIMEOUT (2 * PASS_TIMEOUT * 2)

#include "tst-skeleton-affinity.c"

/* 0 if still running, 1 of stopping requested.  */
static int still_running;

/* 0 if no scheduling failures, 1 if failures are encountered.  */
static int failed;

static void *
thread_burn_one_cpu (void *closure)
{
  int cpu = (uintptr_t) closure;
  while (__atomic_load_n (&still_running, __ATOMIC_RELAXED) == 0)
    {
      int current = sched_getcpu ();
      if (sched_getcpu () != cpu)
	{
	  printf ("error: Pinned thread %d ran on impossible cpu %d\n",
		  cpu, current);
	  __atomic_store_n (&failed, 1, __ATOMIC_RELAXED);
	  /* Terminate early.  */
	  __atomic_store_n (&still_running, 1, __ATOMIC_RELAXED);
	}
    }
  return NULL;
}

struct burn_thread
{
  pthread_t self;
  struct conf *conf;
  cpu_set_t *initial_set;
  cpu_set_t *seen_set;
  int thread;
};

static void *
thread_burn_any_cpu (void *closure)
{
  struct burn_thread *param = closure;

  /* Schedule this thread around a bit to see if it lands on another
     CPU.  Run this for 2 seconds, once with sched_yield, once
     without.  */
  for (int pass = 1; pass <= 2; ++pass)
    {
      time_t start = time (NULL);
      while (time (NULL) - start <= PASS_TIMEOUT)
	{
	  int cpu = sched_getcpu ();
	  if (cpu > param->conf->last_cpu
	      || !CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (param->conf->set_size),
			       param->initial_set))
	    {
	      printf ("error: Unpinned thread %d ran on impossible CPU %d\n",
		      param->thread, cpu);
	      __atomic_store_n (&failed, 1, __ATOMIC_RELAXED);
	      return NULL;
	    }
	  CPU_SET_S (cpu, CPU_ALLOC_SIZE (param->conf->set_size),
		     param->seen_set);
	  if (pass == 1)
	    sched_yield ();
	}
    }
  return NULL;
}

static void
stop_and_join_threads (struct conf *conf, cpu_set_t *set,
		       pthread_t *pinned_first, pthread_t *pinned_last,
		       struct burn_thread *other_first,
		       struct burn_thread *other_last)
{
  __atomic_store_n (&still_running, 1, __ATOMIC_RELAXED);
  for (pthread_t *p = pinned_first; p < pinned_last; ++p)
    {
      int cpu = p - pinned_first;
      if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), set))
	continue;

      int ret = pthread_join (*p, NULL);
      if (ret != 0)
	{
	  printf ("error: Failed to join thread %d: %s\n", cpu, strerror (ret));
	  fflush (stdout);
	  /* Cannot shut down cleanly with threads still running.  */
	  abort ();
	}
    }

  for (struct burn_thread *p = other_first; p < other_last; ++p)
    {
      int cpu = p - other_first;
      if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), set))
	continue;

      int ret = pthread_join (p->self, NULL);
      if (ret != 0)
	{
	  printf ("error: Failed to join thread %d: %s\n", cpu, strerror (ret));
	  fflush (stdout);
	  /* Cannot shut down cleanly with threads still running.  */
	  abort ();
	}
    }
}

/* Tries to check that the initial set of CPUs is complete and that
   the main thread will not run on any other threads.  */
static bool
early_test (struct conf *conf)
{
  pthread_t *pinned_threads
    = calloc (conf->last_cpu + 1, sizeof (*pinned_threads));
  struct burn_thread *other_threads
    = calloc (conf->last_cpu + 1, sizeof (*other_threads));
  cpu_set_t *initial_set = CPU_ALLOC (conf->set_size);
  cpu_set_t *scratch_set = CPU_ALLOC (conf->set_size);

  if (pinned_threads == NULL || other_threads == NULL
      || initial_set == NULL || scratch_set == NULL)
    {
      puts ("error: Memory allocation failure");
      return false;
    }
  if (getaffinity (CPU_ALLOC_SIZE (conf->set_size), initial_set) < 0)
    {
      printf ("error: pthread_getaffinity_np failed: %m\n");
      return false;
    }
  for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
    {
      if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
	continue;
      other_threads[cpu].conf = conf;
      other_threads[cpu].initial_set = initial_set;
      other_threads[cpu].thread = cpu;
      other_threads[cpu].seen_set = CPU_ALLOC (conf->set_size);
      if (other_threads[cpu].seen_set == NULL)
	{
	  puts ("error: Memory allocation failure");
	  return false;
	}
      CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size),
		  other_threads[cpu].seen_set);
    }

  pthread_attr_t attr;
  int ret = pthread_attr_init (&attr);
  if (ret != 0)
    {
      printf ("error: pthread_attr_init failed: %s\n", strerror (ret));
      return false;
    }

  /* Spawn a thread pinned to each available CPU.  */
  for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
    {
      if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
	continue;
      CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set);
      CPU_SET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), scratch_set);
      ret = pthread_attr_setaffinity_np
	(&attr, CPU_ALLOC_SIZE (conf->set_size), scratch_set);
      if (ret != 0)
	{
	  printf ("error: pthread_attr_setaffinity_np for CPU %d failed: %s\n",
		  cpu, strerror (ret));
	  stop_and_join_threads (conf, initial_set,
				 pinned_threads, pinned_threads + cpu,
				 NULL, NULL);
	  return false;
	}
      ret = pthread_create (pinned_threads + cpu, &attr,
			    thread_burn_one_cpu, (void *) (uintptr_t) cpu);
      if (ret != 0)
	{
	  printf ("error: pthread_create for CPU %d failed: %s\n",
		  cpu, strerror (ret));
	  stop_and_join_threads (conf, initial_set,
				 pinned_threads, pinned_threads + cpu,
				 NULL, NULL);
	  return false;
	}
    }

  /* Spawn another set of threads running on all CPUs.  */
  for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
    {
      if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
	continue;
      ret = pthread_create (&other_threads[cpu].self, NULL,
			    thread_burn_any_cpu, other_threads + cpu);
      if (ret != 0)
	{
	  printf ("error: pthread_create for thread %d failed: %s\n",
		  cpu, strerror (ret));
	  stop_and_join_threads (conf, initial_set,
				 pinned_threads,
				 pinned_threads + conf->last_cpu + 1,
				 other_threads, other_threads + cpu);
	  return false;
	}
    }

  /* Main thread.  */
  struct burn_thread main_thread;
  main_thread.conf = conf;
  main_thread.initial_set = initial_set;
  main_thread.seen_set = scratch_set;
  main_thread.thread = -1;
  CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size), main_thread.seen_set);
  thread_burn_any_cpu (&main_thread);
  stop_and_join_threads (conf, initial_set,
			 pinned_threads,
			 pinned_threads + conf->last_cpu + 1,
			 other_threads, other_threads + conf->last_cpu + 1);

  printf ("info: Main thread ran on %d CPU(s) of %d available CPU(s)\n",
	  CPU_COUNT_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set),
	  CPU_COUNT_S (CPU_ALLOC_SIZE (conf->set_size), initial_set));
  CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set);
  for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
    {
      if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
	continue;
      CPU_OR_S (CPU_ALLOC_SIZE (conf->set_size),
		scratch_set, scratch_set, other_threads[cpu].seen_set);
      CPU_FREE (other_threads[cpu].seen_set);
    }
  printf ("info: Other threads ran on %d CPU(s)\n",
	  CPU_COUNT_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set));;


  pthread_attr_destroy (&attr);
  CPU_FREE (scratch_set);
  CPU_FREE (initial_set);
  free (pinned_threads);
  free (other_threads);
  return failed == 0;
}
Commit	Line	Data
2359035a	1	/* Generic test for CPU affinity functions, multi-threaded variant.
f7a9f785	2	Copyright (C) 2015-2016 Free Software Foundation, Inc.
2359035a FW	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with the GNU C Library; if not, see
	17	<http://www.gnu.org/licenses/>. */
	18
	19	/* Before including this file, a test has to declare the helper
	20	getaffinity and setaffinity functions described in
	21	tst-skeleton-affinity.c, which is included below. */
	22
	23	#include <errno.h>
	24	#include <pthread.h>
	25	#include <stdbool.h>
	26	#include <stdlib.h>
	27	#include <sys/time.h>
	28
	29	struct conf;
	30	static bool early_test (struct conf *);
	31
	32	/* Arbitrary run time for each pass. */
	33	#define PASS_TIMEOUT 2
	34
	35	/* There are two passes (one with sched_yield, one without), and we
	36	double the timeout to be on the safe side. */
	37	#define TIMEOUT (2 * PASS_TIMEOUT * 2)
	38
	39	#include "tst-skeleton-affinity.c"
	40
	41	/* 0 if still running, 1 of stopping requested. */
	42	static int still_running;
	43
	44	/* 0 if no scheduling failures, 1 if failures are encountered. */
	45	static int failed;
	46
	47	static void *
	48	thread_burn_one_cpu (void *closure)
	49	{
	50	int cpu = (uintptr_t) closure;
	51	while (__atomic_load_n (&still_running, __ATOMIC_RELAXED) == 0)
	52	{
	53	int current = sched_getcpu ();
	54	if (sched_getcpu () != cpu)
	55	{
	56	printf ("error: Pinned thread %d ran on impossible cpu %d\n",
	57	cpu, current);
	58	__atomic_store_n (&failed, 1, __ATOMIC_RELAXED);
	59	/* Terminate early. */
	60	__atomic_store_n (&still_running, 1, __ATOMIC_RELAXED);
	61	}
	62	}
	63	return NULL;
	64	}
	65
	66	struct burn_thread
67	{
68	pthread_t self;
69	struct conf *conf;
70	cpu_set_t *initial_set;
71	cpu_set_t *seen_set;
72	int thread;
73	};
74
75	static void *
76	thread_burn_any_cpu (void *closure)
77	{
78	struct burn_thread *param = closure;
79
80	/* Schedule this thread around a bit to see if it lands on another
81	CPU. Run this for 2 seconds, once with sched_yield, once
82	without. */
83	for (int pass = 1; pass <= 2; ++pass)
84	{
85	time_t start = time (NULL);
86	while (time (NULL) - start <= PASS_TIMEOUT)
87	{
88	int cpu = sched_getcpu ();
89	if (cpu > param->conf->last_cpu
90	\|\| !CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (param->conf->set_size),
91	param->initial_set))
92	{
93	printf ("error: Unpinned thread %d ran on impossible CPU %d\n",
94	param->thread, cpu);
95	__atomic_store_n (&failed, 1, __ATOMIC_RELAXED);
96	return NULL;
97	}
98	CPU_SET_S (cpu, CPU_ALLOC_SIZE (param->conf->set_size),
99	param->seen_set);
100	if (pass == 1)
101	sched_yield ();
102	}
103	}
104	return NULL;
105	}
106
107	static void
108	stop_and_join_threads (struct conf conf, cpu_set_t set,
109	pthread_t pinned_first, pthread_t pinned_last,
110	struct burn_thread *other_first,
111	struct burn_thread *other_last)
112	{
113	__atomic_store_n (&still_running, 1, __ATOMIC_RELAXED);
114	for (pthread_t *p = pinned_first; p < pinned_last; ++p)
115	{
116	int cpu = p - pinned_first;
117	if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), set))
118	continue;
119
120	int ret = pthread_join (*p, NULL);
121	if (ret != 0)
122	{
123	printf ("error: Failed to join thread %d: %s\n", cpu, strerror (ret));
124	fflush (stdout);
125	/* Cannot shut down cleanly with threads still running. */
126	abort ();
127	}
128	}
129
130	for (struct burn_thread *p = other_first; p < other_last; ++p)
131	{
132	int cpu = p - other_first;
133	if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), set))
134	continue;
135
136	int ret = pthread_join (p->self, NULL);
137	if (ret != 0)
138	{
139	printf ("error: Failed to join thread %d: %s\n", cpu, strerror (ret));
140	fflush (stdout);
141	/* Cannot shut down cleanly with threads still running. */
142	abort ();
143	}
144	}
145	}
146
147	/* Tries to check that the initial set of CPUs is complete and that
148	the main thread will not run on any other threads. */
149	static bool
150	early_test (struct conf *conf)
151	{
152	pthread_t *pinned_threads
153	= calloc (conf->last_cpu + 1, sizeof (*pinned_threads));
154	struct burn_thread *other_threads
155	= calloc (conf->last_cpu + 1, sizeof (*other_threads));
156	cpu_set_t *initial_set = CPU_ALLOC (conf->set_size);
157	cpu_set_t *scratch_set = CPU_ALLOC (conf->set_size);
158
159	if (pinned_threads == NULL \|\| other_threads == NULL
160	\|\| initial_set == NULL \|\| scratch_set == NULL)
161	{
162	puts ("error: Memory allocation failure");
163	return false;
164	}
165	if (getaffinity (CPU_ALLOC_SIZE (conf->set_size), initial_set) < 0)
166	{
167	printf ("error: pthread_getaffinity_np failed: %m\n");
168	return false;
169	}
170	for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
171	{
172	if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
173	continue;
174	other_threads[cpu].conf = conf;
175	other_threads[cpu].initial_set = initial_set;
176	other_threads[cpu].thread = cpu;
177	other_threads[cpu].seen_set = CPU_ALLOC (conf->set_size);
178	if (other_threads[cpu].seen_set == NULL)
179	{
180	puts ("error: Memory allocation failure");
181	return false;
182	}
183	CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size),
184	other_threads[cpu].seen_set);
185	}
186
187	pthread_attr_t attr;
188	int ret = pthread_attr_init (&attr);
189	if (ret != 0)
190	{
191	printf ("error: pthread_attr_init failed: %s\n", strerror (ret));
192	return false;
193	}
194
195	/* Spawn a thread pinned to each available CPU. */
196	for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
197	{
198	if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
199	continue;
200	CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set);
201	CPU_SET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), scratch_set);
202	ret = pthread_attr_setaffinity_np
203	(&attr, CPU_ALLOC_SIZE (conf->set_size), scratch_set);
204	if (ret != 0)
205	{
206	printf ("error: pthread_attr_setaffinity_np for CPU %d failed: %s\n",
207	cpu, strerror (ret));
208	stop_and_join_threads (conf, initial_set,
209	pinned_threads, pinned_threads + cpu,
210	NULL, NULL);
211	return false;
212	}
213	ret = pthread_create (pinned_threads + cpu, &attr,
214	thread_burn_one_cpu, (void *) (uintptr_t) cpu);
215	if (ret != 0)
216	{
217	printf ("error: pthread_create for CPU %d failed: %s\n",
218	cpu, strerror (ret));
219	stop_and_join_threads (conf, initial_set,
220	pinned_threads, pinned_threads + cpu,
221	NULL, NULL);
222	return false;
223	}
224	}
225
226	/* Spawn another set of threads running on all CPUs. */
227	for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
228	{
229	if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
230	continue;
231	ret = pthread_create (&other_threads[cpu].self, NULL,
232	thread_burn_any_cpu, other_threads + cpu);
233	if (ret != 0)
234	{
235	printf ("error: pthread_create for thread %d failed: %s\n",
236	cpu, strerror (ret));
237	stop_and_join_threads (conf, initial_set,
238	pinned_threads,
239	pinned_threads + conf->last_cpu + 1,
240	other_threads, other_threads + cpu);
241	return false;
242	}
243	}
244
245	/* Main thread. */
246	struct burn_thread main_thread;
247	main_thread.conf = conf;
248	main_thread.initial_set = initial_set;
249	main_thread.seen_set = scratch_set;
250	main_thread.thread = -1;
251	CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size), main_thread.seen_set);
252	thread_burn_any_cpu (&main_thread);
253	stop_and_join_threads (conf, initial_set,
254	pinned_threads,
255	pinned_threads + conf->last_cpu + 1,
256	other_threads, other_threads + conf->last_cpu + 1);
257
258	printf ("info: Main thread ran on %d CPU(s) of %d available CPU(s)\n",
259	CPU_COUNT_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set),
260	CPU_COUNT_S (CPU_ALLOC_SIZE (conf->set_size), initial_set));
261	CPU_ZERO_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set);
262	for (int cpu = 0; cpu <= conf->last_cpu; ++cpu)
263	{
264	if (!CPU_ISSET_S (cpu, CPU_ALLOC_SIZE (conf->set_size), initial_set))
265	continue;
266	CPU_OR_S (CPU_ALLOC_SIZE (conf->set_size),
267	scratch_set, scratch_set, other_threads[cpu].seen_set);
268	CPU_FREE (other_threads[cpu].seen_set);
269	}
270	printf ("info: Other threads ran on %d CPU(s)\n",
271	CPU_COUNT_S (CPU_ALLOC_SIZE (conf->set_size), scratch_set));;
272
273
274	pthread_attr_destroy (&attr);
275	CPU_FREE (scratch_set);
276	CPU_FREE (initial_set);
277	free (pinned_threads);
278	free (other_threads);
279	return failed == 0;
280	}