async_tasks_overhead.c 5.7 KB

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