loader.c 8.8 KB

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