| /* Generic test for CPU affinity functions, multi-threaded variant. |
| Copyright (C) 2015-2018 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; |
| } |
