workers_cpuid.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209
  1. /* StarPU --- Runtime system for heterogeneous multicore architectures.
  2. *
  3. * Copyright (C) 2010-2012, 2015-2016 Université de Bordeaux
  4. * Copyright (C) 2010, 2011, 2012, 2013, 2016 CNRS
  5. *
  6. * StarPU is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU Lesser General Public License as published by
  8. * the Free Software Foundation; either version 2.1 of the License, or (at
  9. * your option) any later version.
  10. *
  11. * StarPU is distributed in the hope that it will be useful, but
  12. * WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14. *
  15. * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  16. */
  17. #include <starpu.h>
  18. #include "../helper.h"
  19. #include <common/config.h>
  20. /*
  21. * Try various values for STARPU_WORKERS_CPUID, checking that the
  22. * expected binding does happen
  23. */
  24. #if !defined(STARPU_HAVE_UNSETENV) || !defined(STARPU_USE_CPU) || !defined(STARPU_HAVE_HWLOC)
  25. #warning unsetenv is not defined or no cpu are available. Skipping test
  26. int main(int argc, char **argv)
  27. {
  28. return STARPU_TEST_SKIPPED;
  29. }
  30. #else
  31. #include <hwloc.h>
  32. #define NB_TESTS 5
  33. int nhwpus;
  34. long workers_cpuid[STARPU_NMAXWORKERS];
  35. int workers_id[STARPU_NMAXWORKERS];
  36. static int check_workers_mapping(long *cpuid, int *workerids, int nb_workers)
  37. {
  38. int i;
  39. for (i=0; i<nb_workers; i++)
  40. {
  41. int workerid = workerids[i];
  42. long bindid = starpu_worker_get_bindid(workerid);
  43. if ( bindid != cpuid[i])
  44. {
  45. fprintf(stderr, "Worker %d (%s) is on cpu %ld rather than on %ld\n",
  46. workerid, starpu_worker_get_type_as_string(starpu_worker_get_type(workerid)),
  47. bindid, cpuid[i]);
  48. return 0;
  49. }
  50. }
  51. return 1;
  52. }
  53. static void copy_cpuid_array(long *dst, long *src, unsigned n)
  54. {
  55. int i;
  56. memcpy(dst, src, n * sizeof(long));
  57. for (i=n; i<STARPU_NMAXWORKERS; i++)
  58. dst[i] = src[i%n];
  59. }
  60. static char *array_to_str(long *array, int n)
  61. {
  62. int i;
  63. char *str = malloc(n * 3 * sizeof(long));
  64. char *ptr = str;
  65. for (i=0; i<n; i++)
  66. {
  67. int nchar;
  68. nchar = sprintf(ptr, "%ld ", array[i]);
  69. ptr += nchar;
  70. }
  71. return str;
  72. }
  73. static int test_combination(long *combination, unsigned n)
  74. {
  75. int type, ret, device_workers;
  76. char *str;
  77. copy_cpuid_array(workers_cpuid, combination, n);
  78. str = array_to_str(workers_cpuid, n);
  79. setenv("STARPU_WORKERS_CPUID", str, 1);
  80. free(str);
  81. ret = starpu_init(NULL);
  82. if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
  83. STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
  84. device_workers = 0;
  85. /* Check for all devices */
  86. for (type=STARPU_CUDA_WORKER; type<STARPU_NARCH; type++)
  87. {
  88. int nb_workers;
  89. nb_workers = starpu_worker_get_ids_by_type(type, workers_id, starpu_worker_get_count());
  90. device_workers += nb_workers ;
  91. if (!check_workers_mapping(workers_cpuid, workers_id, nb_workers))
  92. return -1;
  93. }
  94. /* Check for all cpus */
  95. {
  96. int nb_workers;
  97. nb_workers = starpu_worker_get_ids_by_type(STARPU_CPU_WORKER, workers_id, starpu_worker_get_count());
  98. if (!check_workers_mapping(workers_cpuid + device_workers, workers_id, nb_workers))
  99. return -1;
  100. }
  101. starpu_shutdown();
  102. return 1;
  103. }
  104. static long * generate_arrangement(int arr_size, long *set, int set_size)
  105. {
  106. int i, j;
  107. long tmp;
  108. STARPU_ASSERT(arr_size <= set_size);
  109. srandom(time(0));
  110. for (i=0; i<arr_size; i++)
  111. {
  112. /* Pick a random value in the set */
  113. j = random() % (set_size - i);
  114. /* Switch the value picked up with the beginning value of set */
  115. tmp = set[i+j];
  116. set[i] = set[i+j];
  117. set[i+j] = tmp;
  118. }
  119. return set;
  120. }
  121. static void init_array(long *a, int n)
  122. {
  123. int i;
  124. for(i=0; i<n; i++)
  125. a[i] = i;
  126. }
  127. int main(int argc, char **argv)
  128. {
  129. int ret, i, j;
  130. long *cpuids;
  131. hwloc_topology_t topology;
  132. hwloc_topology_init(&topology);
  133. hwloc_topology_load(topology);
  134. nhwpus = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_PU);
  135. if (nhwpus > STARPU_NMAXWORKERS)
  136. nhwpus = STARPU_NMAXWORKERS;
  137. unsetenv("STARPU_NCUDA");
  138. unsetenv("STARPU_NOPENCL");
  139. unsetenv("STARPU_NCPUS");
  140. for (i=0; i<STARPU_NMAXWORKERS; i++)
  141. workers_id[i] = -1;
  142. cpuids = malloc(nhwpus * sizeof(long));
  143. /* Evaluate several random values of STARPU_WORKERS_CPUID
  144. * and check mapping for each one
  145. */
  146. for (i=1; i<=nhwpus; i++)
  147. {
  148. for (j=0; j<NB_TESTS; j++)
  149. {
  150. init_array(cpuids, nhwpus);
  151. generate_arrangement(i, cpuids, nhwpus);
  152. ret = test_combination(cpuids, i);
  153. if (!ret)
  154. {
  155. free(cpuids);
  156. hwloc_topology_destroy(topology);
  157. return EXIT_FAILURE;
  158. }
  159. }
  160. }
  161. free(cpuids);
  162. hwloc_topology_destroy(topology);
  163. return EXIT_SUCCESS;
  164. }
  165. #endif