loader.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404
  1. /* StarPU --- Runtime system for heterogeneous multicore architectures.
  2. *
  3. * Copyright (C) 2011,2012,2017 Inria
  4. * Copyright (C) 2011-2020 CNRS
  5. * Copyright (C) 2010,2014-2018 Université de Bordeaux
  6. *
  7. * StarPU is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU Lesser General Public License as published by
  9. * the Free Software Foundation; either version 2.1 of the License, or (at
  10. * your option) any later version.
  11. *
  12. * StarPU is distributed in the hope that it will be useful, but
  13. * WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  15. *
  16. * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  17. */
  18. #include <common/config.h>
  19. #include <sys/types.h>
  20. #include <sys/stat.h>
  21. #include <sys/wait.h>
  22. #include <sys/resource.h>
  23. #include <unistd.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <signal.h>
  27. #include <string.h>
  28. #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
  29. #include <windows.h>
  30. #else
  31. #include <sys/time.h>
  32. #endif
  33. #ifdef STARPU_QUICK_CHECK
  34. /* Quick checks are supposed to be real quick, typically less than 1s each, sometimes 10s */
  35. #define DEFAULT_TIMEOUT 60
  36. #elif !defined(STARPU_LONG_CHECK)
  37. /* Normal checks are supposed to be short enough, typically less than 10s each, sometimes 1-2m */
  38. #define DEFAULT_TIMEOUT 300
  39. #else
  40. /* Long checks can be very long */
  41. #define DEFAULT_TIMEOUT 1800
  42. #endif
  43. #define AUTOTEST_SKIPPED_TEST 77
  44. static pid_t child_pid = 0;
  45. static int timeout;
  46. #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
  47. static int mygettimeofday(struct timeval *tv, void *tz)
  48. {
  49. if (tv)
  50. {
  51. FILETIME ft;
  52. unsigned long long res;
  53. GetSystemTimeAsFileTime(&ft);
  54. /* 100-nanosecond intervals since January 1, 1601 */
  55. res = ft.dwHighDateTime;
  56. res <<= 32;
  57. res |= ft.dwLowDateTime;
  58. res /= 10;
  59. /* Now we have microseconds */
  60. res -= (((1970-1601)*365) + 89) * 24ULL * 3600ULL * 1000000ULL;
  61. /* Now we are based on epoch */
  62. tv->tv_sec = res / 1000000ULL;
  63. tv->tv_usec = res % 1000000ULL;
  64. }
  65. }
  66. #else
  67. #define mygettimeofday(tv,tz) gettimeofday(tv,tz)
  68. #endif
  69. #ifdef STARPU_GDB_PATH
  70. static int try_launch_gdb(const char *exe, const char *core)
  71. {
  72. # define GDB_ALL_COMMAND "thread apply all bt full"
  73. # define GDB_COMMAND "bt full"
  74. int err;
  75. pid_t pid;
  76. struct stat st;
  77. const char *top_builddir;
  78. char *gdb;
  79. err = stat(core, &st);
  80. if (err != 0)
  81. {
  82. fprintf(stderr, "while looking for core file of %s: %s: %m\n",
  83. exe, core);
  84. return -1;
  85. }
  86. if (!(st.st_mode & S_IFREG))
  87. {
  88. fprintf(stderr, "%s: not a regular file\n", core);
  89. return -1;
  90. }
  91. top_builddir = getenv("top_builddir");
  92. pid = fork();
  93. switch (pid)
  94. {
  95. case 0: /* kid */
  96. if (top_builddir != NULL)
  97. {
  98. /* Run gdb with Libtool. */
  99. gdb = alloca(strlen(top_builddir)
  100. + sizeof("/libtool") + 1);
  101. strcpy(gdb, top_builddir);
  102. strcat(gdb, "/libtool");
  103. err = execl(gdb, "gdb", "--mode=execute",
  104. STARPU_GDB_PATH, "--batch",
  105. "-ex", GDB_COMMAND,
  106. "-ex", GDB_ALL_COMMAND,
  107. exe, core, NULL);
  108. }
  109. else
  110. {
  111. /* Run gdb directly */
  112. gdb = STARPU_GDB_PATH;
  113. err = execl(gdb, "gdb", "--batch",
  114. "-ex", GDB_COMMAND,
  115. "-ex", GDB_ALL_COMMAND,
  116. exe, core, NULL);
  117. }
  118. if (err != 0)
  119. {
  120. fprintf(stderr, "while launching `%s': %m\n", gdb);
  121. exit(EXIT_FAILURE);
  122. }
  123. exit(EXIT_SUCCESS);
  124. break;
  125. case -1:
  126. fprintf(stderr, "fork: %m\n");
  127. return -1;
  128. default: /* parent */
  129. {
  130. pid_t who;
  131. int status;
  132. who = waitpid(pid, &status, 0);
  133. if (who != pid)
  134. fprintf(stderr, "while waiting for gdb "
  135. "process %d: %m\n", pid);
  136. }
  137. }
  138. return 0;
  139. # undef GDB_COMMAND
  140. # undef GDB_ALL_COMMAND
  141. }
  142. #endif /* STARPU_GDB_PATH */
  143. static void launch_gdb(const char *exe)
  144. {
  145. #ifdef STARPU_GDB_PATH
  146. char s[32];
  147. snprintf(s, sizeof(s), "core.%d", child_pid);
  148. if (try_launch_gdb(exe, s) < 0)
  149. try_launch_gdb(exe, "core");
  150. #endif /* STARPU_GDB_PATH */
  151. }
  152. static char *test_name;
  153. static void test_cleaner(int sig)
  154. {
  155. pid_t child_gid;
  156. int status;
  157. (void) sig;
  158. // send signal to all loader family members
  159. fprintf(stderr, "[error] test %s has been blocked for %d seconds. Mark it as failed\n", test_name, timeout);
  160. child_gid = getpgid(child_pid);
  161. kill(-child_gid, SIGQUIT);
  162. waitpid(child_pid, &status, 0);
  163. launch_gdb(test_name);
  164. exit(EXIT_FAILURE);
  165. }
  166. static int _decode(char **src, char *motif, const char *value)
  167. {
  168. char *found;
  169. found = strstr(*src, motif);
  170. if (found == NULL) return 0;
  171. char *new_src = calloc(1, strlen(*src)-strlen(motif)+strlen(value)+1);
  172. strncpy(new_src, *src, found - *src);
  173. strcat(new_src, value);
  174. strcat(new_src, found+strlen(motif));
  175. *src = new_src;
  176. return 1;
  177. }
  178. static void decode(char **src, char *motif, const char *value)
  179. {
  180. if (*src)
  181. {
  182. if (strstr(*src, motif) && value == NULL)
  183. {
  184. fprintf(stderr, "error: $%s undefined\n", motif);
  185. exit(EXIT_FAILURE);
  186. }
  187. int d = _decode(src, motif, value);
  188. while (d)
  189. d = _decode(src, motif, value);
  190. }
  191. }
  192. int main(int argc, char *argv[])
  193. {
  194. int child_exit_status;
  195. char *test_args;
  196. char *launcher;
  197. char *launcher_args;
  198. struct sigaction sa;
  199. int ret;
  200. struct timeval start;
  201. struct timeval end;
  202. double timing;
  203. int x=1;
  204. (void) argc;
  205. test_args = NULL;
  206. timeout = 0;
  207. if (argv[x] && strcmp(argv[x], "-t") == 0)
  208. {
  209. timeout = strtol(argv[x+1], NULL, 10);
  210. x += 2;
  211. }
  212. else if (getenv("STARPU_TIMEOUT_ENV"))
  213. {
  214. /* get user-defined iter_max value */
  215. timeout = strtol(getenv("STARPU_TIMEOUT_ENV"), NULL, 10);
  216. }
  217. if (timeout <= 0)
  218. timeout = DEFAULT_TIMEOUT;
  219. #ifdef STARPU_USE_MPI_MASTER_SLAVE
  220. /* compare values between the 2 values of timeout */
  221. if (getenv("MPIEXEC_TIMEOUT"))
  222. {
  223. int mpiexec_timeout = strtol(getenv("MPIEXEC_TIMEOUT"), NULL, 10);
  224. if (mpiexec_timeout != timeout)
  225. fprintf(stderr, "[warning] MPIEXEC_TIMEOUT and STARPU_TIMEOUT_ENV values are different (%d and %d). The behavior may be different than expected !\n", mpiexec_timeout, timeout);
  226. }
  227. #endif
  228. if (argv[x] && strcmp(argv[x], "-p") == 0)
  229. {
  230. test_name = malloc(strlen(argv[x+1]) + 1 + strlen(argv[x+2]) + 1);
  231. sprintf(test_name, "%s/%s", argv[x+1], argv[x+2]);
  232. }
  233. else
  234. test_name = argv[x];
  235. if (!test_name)
  236. {
  237. fprintf(stderr, "[error] Need name of program to start\n");
  238. exit(EXIT_FAILURE);
  239. }
  240. if (strstr(test_name, "tasks_size_overhead_scheds.sh") || strstr(test_name, "schedulers.sh"))
  241. /* This extensively tests various schedulers, let it run longer */
  242. timeout *= 10;
  243. if (strstr(test_name, "spmv/dw_block_spmv"))
  244. {
  245. test_args = (char *) calloc(150, sizeof(char));
  246. snprintf(test_args, 150, "%s/examples/spmv/matrix_market/examples/fidapm05.mtx", STARPU_SRC_DIR);
  247. }
  248. else if (strstr(test_name, "starpu_perfmodel_display"))
  249. {
  250. test_args = strdup("-l");
  251. }
  252. else if (strstr(test_name, "starpu_perfmodel_plot"))
  253. {
  254. test_args = strdup("-l");
  255. }
  256. /* get launcher program */
  257. launcher=getenv("STARPU_CHECK_LAUNCHER");
  258. launcher_args=getenv("STARPU_CHECK_LAUNCHER_ARGS");
  259. if (launcher_args)
  260. launcher_args=strdup(launcher_args);
  261. setenv("STARPU_OPENCL_PROGRAM_DIR", STARPU_SRC_DIR, 1);
  262. /* set SIGALARM handler */
  263. sa.sa_flags = 0;
  264. sigemptyset(&sa.sa_mask);
  265. sa.sa_handler = test_cleaner;
  266. if (-1 == sigaction(SIGALRM, &sa, NULL))
  267. perror("sigaction");
  268. child_pid = fork();
  269. if (child_pid == 0)
  270. {
  271. if (launcher)
  272. {
  273. /* "Launchers" such as Valgrind need to be inserted
  274. * after the Libtool-generated wrapper scripts, hence
  275. * this special-case. */
  276. const char *top_builddir = getenv ("top_builddir");
  277. const char *top_srcdir = getenv("top_srcdir");
  278. if (top_builddir != NULL)
  279. {
  280. char *launcher_argv[100];
  281. int i=3;
  282. char libtool[strlen(top_builddir)
  283. + sizeof("libtool") + 1];
  284. strcpy(libtool, top_builddir);
  285. strcat(libtool, "/libtool");
  286. decode(&launcher, "@top_srcdir@", top_srcdir);
  287. decode(&launcher_args, "@top_srcdir@", top_srcdir);
  288. launcher_argv[0] = libtool;
  289. launcher_argv[1] = "--mode=execute";
  290. launcher_argv[2] = launcher;
  291. if (launcher_args)
  292. {
  293. launcher_argv[i] = strtok(launcher_args, " ");
  294. while (launcher_argv[i])
  295. {
  296. i++;
  297. launcher_argv[i] = strtok(NULL, " ");
  298. }
  299. }
  300. launcher_argv[i] = test_name;
  301. launcher_argv[i+1] = test_args;
  302. launcher_argv[i+2] = NULL;
  303. execvp(*launcher_argv, launcher_argv);
  304. }
  305. else
  306. {
  307. fprintf(stderr,
  308. "warning: $top_builddir undefined, "
  309. "so $STARPU_CHECK_LAUNCHER ignored\n");
  310. execl(test_name, test_name, test_args, NULL);
  311. }
  312. }
  313. else
  314. execl(test_name, test_name, test_args, NULL);
  315. fprintf(stderr, "[error] '%s' failed to exec. test marked as failed\n", test_name);
  316. exit(EXIT_FAILURE);
  317. }
  318. if (child_pid == -1)
  319. {
  320. fprintf(stderr, "[error] fork. test marked as failed\n");
  321. exit(EXIT_FAILURE);
  322. }
  323. free(test_args);
  324. ret = EXIT_SUCCESS;
  325. gettimeofday(&start, NULL);
  326. alarm(timeout);
  327. if (child_pid == waitpid(child_pid, &child_exit_status, 0))
  328. {
  329. if (WIFEXITED(child_exit_status))
  330. {
  331. int status = WEXITSTATUS(child_exit_status);
  332. if (status == EXIT_SUCCESS)
  333. {
  334. alarm(0);
  335. }
  336. else
  337. {
  338. if (status != AUTOTEST_SKIPPED_TEST)
  339. fprintf(stdout, "`%s' exited with return code %d\n",
  340. test_name, status);
  341. ret = status;
  342. }
  343. }
  344. else if (WIFSIGNALED(child_exit_status))
  345. {
  346. fprintf(stderr, "[error] `%s' killed with signal %d; test marked as failed\n",
  347. test_name, WTERMSIG(child_exit_status));
  348. launch_gdb(test_name);
  349. ret = EXIT_FAILURE;
  350. }
  351. else
  352. {
  353. fprintf(stderr, "[error] `%s' did not terminate normally; test marked as failed\n",
  354. test_name);
  355. ret = EXIT_FAILURE;
  356. }
  357. }
  358. gettimeofday(&end, NULL);
  359. timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
  360. fprintf(stderr, "#Execution_time_in_seconds %f %s\n", timing/1000000, test_name);
  361. return ret;
  362. }