async_tasks_overhead.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216
  1. /* StarPU --- Runtime system for heterogeneous multicore architectures.
  2. *
  3. * Copyright (C) 2010-2011 Université de Bordeaux 1
  4. * Copyright (C) 2010, 2011 Centre National de la Recherche Scientifique
  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 <sys/time.h>
  18. #include <pthread.h>
  19. #include <stdio.h>
  20. #include <unistd.h>
  21. #include <starpu.h>
  22. #include <starpu_profiling.h>
  23. #include "../helper.h"
  24. static unsigned ntasks = 65536;
  25. //static unsigned finished = 0;
  26. static double cumulated = 0.0;
  27. static double cumulated_push = 0.0;
  28. static double cumulated_pop = 0.0;
  29. static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
  30. {
  31. }
  32. static struct starpu_codelet dummy_codelet =
  33. {
  34. .where = STARPU_CPU|STARPU_CUDA|STARPU_OPENCL|STARPU_GORDON,
  35. .cpu_funcs = {dummy_func, NULL},
  36. .cuda_funcs = {dummy_func, NULL},
  37. .opencl_funcs = {dummy_func, NULL},
  38. #ifdef STARPU_USE_GORDON
  39. .gordon_func = 0, /* this will be defined later */
  40. #endif
  41. .model = NULL,
  42. .nbuffers = 0
  43. };
  44. static void init_gordon_kernel(void)
  45. {
  46. #ifdef STARPU_USE_GORDON
  47. unsigned elf_id =
  48. gordon_register_elf_plugin("./microbenchs/null_kernel_gordon.spuelf");
  49. gordon_load_plugin_on_all_spu(elf_id);
  50. unsigned gordon_null_kernel =
  51. gordon_register_kernel(elf_id, "empty_kernel");
  52. gordon_load_kernel_on_all_spu(gordon_null_kernel);
  53. dummy_codelet.gordon_func = gordon_null_kernel;
  54. #endif
  55. }
  56. //static void inject_one_task(void)
  57. //{
  58. // struct starpu_task *task = starpu_task_create();
  59. //
  60. // task->cl = &dummy_codelet;
  61. // task->cl_arg = NULL;
  62. // task->detach = 0;
  63. //
  64. // int ret = starpu_task_submit(task);
  65. // STARPU_ASSERT(!ret);
  66. //}
  67. static struct starpu_conf conf =
  68. {
  69. .sched_policy_name = NULL,
  70. .ncpus = -1,
  71. .ncuda = -1,
  72. .nopencl = -1,
  73. .nspus = -1,
  74. .use_explicit_workers_bindid = 0,
  75. .use_explicit_workers_cuda_gpuid = 0,
  76. .use_explicit_workers_opencl_gpuid = 0,
  77. .calibrate = 0
  78. };
  79. static void usage(char **argv)
  80. {
  81. fprintf(stderr, "%s [-i ntasks] [-p sched_policy] [-h]\n", argv[0]);
  82. exit(-1);
  83. }
  84. static void parse_args(int argc, char **argv)
  85. {
  86. int c;
  87. while ((c = getopt(argc, argv, "i:p:h")) != -1)
  88. switch(c)
  89. {
  90. case 'i':
  91. ntasks = atoi(optarg);
  92. break;
  93. case 'p':
  94. conf.sched_policy_name = optarg;
  95. break;
  96. case 'h':
  97. usage(argv);
  98. break;
  99. }
  100. }
  101. int main(int argc, char **argv)
  102. {
  103. int ret;
  104. unsigned i;
  105. double timing;
  106. struct timeval start;
  107. struct timeval end;
  108. parse_args(argc, argv);
  109. ret = starpu_init(&conf);
  110. STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
  111. init_gordon_kernel();
  112. starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
  113. fprintf(stderr, "#tasks : %u\n", ntasks);
  114. /* Create an array of tasks */
  115. struct starpu_task **tasks = (struct starpu_task **) malloc(ntasks*sizeof(struct starpu_task *));
  116. for (i = 0; i < ntasks; i++)
  117. {
  118. struct starpu_task *task = starpu_task_create();
  119. task->cl = &dummy_codelet;
  120. task->cl_arg = NULL;
  121. task->detach = 0;
  122. tasks[i] = task;
  123. }
  124. gettimeofday(&start, NULL);
  125. for (i = 0; i < ntasks; i++)
  126. {
  127. int ret = starpu_task_submit(tasks[i]);
  128. if (ret == -ENODEV) goto enodev;
  129. STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
  130. }
  131. ret = starpu_task_wait_for_all();
  132. STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
  133. gettimeofday(&end, NULL);
  134. /* Read profiling feedback */
  135. for (i = 0; i < ntasks; i++)
  136. {
  137. struct starpu_task_profiling_info *info;
  138. info = tasks[i]->profiling_info;
  139. double queued = starpu_timing_timespec_delay_us(&info->push_end_time, &info->pop_end_time);
  140. double length = starpu_timing_timespec_delay_us(&info->submit_time, &info->end_time);
  141. double push_duration = starpu_timing_timespec_delay_us(&info->push_start_time, &info->push_end_time);
  142. double pop_duration = starpu_timing_timespec_delay_us(&info->pop_start_time, &info->pop_end_time);
  143. cumulated += (length - queued);
  144. cumulated_push += push_duration;
  145. cumulated_pop += pop_duration;
  146. }
  147. timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
  148. fprintf(stderr, "Total: %f secs\n", timing/1000000);
  149. fprintf(stderr, "Per task: %f usecs\n", timing/ntasks);
  150. fprintf(stderr, "Per task (except scheduler): %f usecs\n", cumulated/ntasks);
  151. fprintf(stderr, "Per task (push): %f usecs\n", cumulated_push/ntasks);
  152. fprintf(stderr, "Per task (pop): %f usecs\n", cumulated_pop/ntasks);
  153. {
  154. char *output_dir = getenv("STARPU_BENCH_DIR");
  155. char *bench_id = getenv("STARPU_BENCH_ID");
  156. if (output_dir && bench_id)
  157. {
  158. char file[1024];
  159. FILE *f;
  160. sprintf(file, "%s/async_tasks_overhead_total.dat", output_dir);
  161. f = fopen(file, "a");
  162. fprintf(f, "%s\t%f\n", bench_id, timing/1000000);
  163. fclose(f);
  164. sprintf(file, "%s/async_tasks_overhead_per_task.dat", output_dir);
  165. f = fopen(file, "a");
  166. fprintf(f, "%s\t%f\n", bench_id, timing/ntasks);
  167. fclose(f);
  168. }
  169. }
  170. starpu_shutdown();
  171. free(tasks);
  172. return EXIT_SUCCESS;
  173. enodev:
  174. fprintf(stderr, "WARNING: No one can execute this task\n");
  175. /* yes, we do not perform the computation but we did detect that no one
  176. * could perform the kernel, so this is not an error from StarPU */
  177. starpu_shutdown();
  178. return STARPU_TEST_SKIPPED;
  179. }