spacepaste

Paste details

reply | raw

  1.  
  2. /*
  4. 1 argument(s):
  5. 0
  6. 3 argument(s):
  7. 10
  8. 20
  9. 30
  10. 9 argument(s):
  11. 1
  12. 2
  13. 3
  14. 4
  15. 5
  16. 6
  17. 7
  18. 8
  19. 9
  20. cpu time: 0.00 seconds
  21. cpu time: 0.36 seconds
  22. cpu time: 0.000 seconds
  23. cpu time: 0.360 seconds
  24. cpu time: 0.344 seconds
  25. cpu time: 0.331 seconds
  26. total cpu time: 1.035 seconds
  27. total real cpu time: 1.035 seconds
  30. */
  32. #include <stdio.h>
  33. #include <stdarg.h>
  35. /*
  36. clock__total(
  37. clock__get(whereis_start),
  38. clock__get(whereis_end),
  39. clock__get(create_start),
  40. clock__get(create_end),
  41. clock__get(build_start),
  42. clock__get(build_end),
  43. clock__get(link_start),
  44. clock__get(link_end),
  45. clock__get(run_start),
  46. clock__get(run_end),
  47. clock__get(delete_start),
  48. clock__get(delete_end));
  49. */
  50. #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
  52. /* C99-style: anonymous argument referenced by __VA_ARGS__, empty arg not OK */
  54. # define N_ARGS(...) N_ARGS_HELPER1(__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
  55. # define N_ARGS_HELPER1(...) N_ARGS_HELPER2(__VA_ARGS__)
  56. # define N_ARGS_HELPER2(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, n, ...) n
  58. # define foo(...) foo_helper(N_ARGS(__VA_ARGS__), __VA_ARGS__)
  59. # define clock__total(...) clock__total_h(N_ARGS(__VA_ARGS__), __VA_ARGS__)
  61. #elif defined(__GNUC__)
  63. /* GCC-style: named argument, empty arg is OK */
  65. # define N_ARGS(args...) N_ARGS_HELPER1(args, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
  66. # define N_ARGS_HELPER1(args...) N_ARGS_HELPER2(args)
  67. # define N_ARGS_HELPER2(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, n, x...) n
  69. # define foo(args...) foo_helper(N_ARGS(args), args)
  70. # define clock__total(args...) clock_total__h(N_ARGS(args), args)
  72. #else
  74. #error variadic macros for your compiler here
  76. #endif
  78. static inline void foo_helper(unsigned int n_args, ...)
  79. {
  80. unsigned int i, arg;
  81. va_list ap;
  82. va_start(ap, n_args);
  83. printf("%u argument(s):\n", n_args);
  84. for (i = 0; i < n_args; i++) {
  85. arg = va_arg(ap, unsigned int);
  86. printf(" %u\n", arg);
  87. }
  88. va_end(ap);
  89. }
  92. #include <time.h>
  93. #include <stdbool.h>
  95. bool has_time = false;
  97. #define clock__get(clock) builtin_clock_##clock
  98. #define clock__add(clocka) clock_t clock__get(clocka) = 0
  99. #define clock__calculate(clock_start, clock_end) (double)(clock__get(clock_end) - clock__get(clock_start)) / CLOCKS_PER_SEC
  100. #define clock__set(clockb) clock__get(clockb) = clock()
  102. clock__add(timefunc_start);
  103. clock__add(timefunc_end);
  105. #define timefunc(func) { \
  106. clock__set(timefunc_start); \
  107. func; \
  108. clock__set(timefunc_end); \
  109. printf("cpu time: %.2f seconds\n", clock__calculate(timefunc_start, timefunc_end)); \
  110. }
  112. #include <stdio.h>
  113. #include <stdlib.h>
  114. #include <unistd.h>
  116. clock__add (base);
  117. #define clock__init() clock__set(base)
  118. static inline void clock__total_h(unsigned int n_args, ...)
  119. {
  120. unsigned int i;
  121. clock__add(arg1);
  122. clock__add(arg2);
  123. clock__add(total_last);
  124. clock__add(total_current);
  125. clock__add(largest);
  126. clock__get(total_last) = 0;
  127. clock__get(total_current) = 0;
  128. va_list ap;
  129. va_start(ap, n_args);
  130. for (i = 0; i < n_args; i++) {
  131. clock__get(total_current) += clock__get(arg2) - clock__get(arg1);
  132. clock__get(arg1) = va_arg(ap, clock_t);
  133. if (clock__get(arg1)>clock__get(largest)) clock__get(largest)=clock__get(arg1);
  135. clock__get(arg2) = va_arg(ap, clock_t);
  136. if (clock__get(arg2)>clock__get(largest)) clock__get(largest)=clock__get(arg2);
  137. clock__get(total_last) = clock__get(arg1) - clock__get(arg2);
  138. printf("cpu time: %.3f seconds\n", clock__calculate(arg1, arg2));
  139. i++;
  140. }
  141. printf("total cpu time: %.3f seconds\n", clock__calculate(total_last, total_current));
  142. printf("total real cpu time: %.3f seconds\n", clock__calculate(base, largest));
  143. va_end(ap);
  144. }
  146. #include <unistd.h>
  148. #define fc(x) builtin_clock_##x##_end
  150. int main(void)
  151. {
  152. clock__set(base);
  153. clock__add(a);
  154. clock__add(b);
  155. clock__set(a);
  156. foo(0);
  157. foo(10, 20, 30);
  158. foo(1, 2, 3, 4, 5, 6, 7, 8, 9);
  159. clock__set(b);
  160. printf("cpu time: %.2f seconds\n", clock__calculate(a, b));
  161. timefunc(sleep(1))
  162. clock__add(sleep1);
  163. clock__add(sleep2);
  164. clock__add(sleep3);
  165. clock__add(sleep4);
  166. clock__set(sleep1);
  167. sleep(1);
  168. clock__set(sleep2);
  169. clock__set(sleep3);
  170. sleep(1);
  171. clock__set(sleep4);
  172. clock__total(clock__get(a), clock__get(b), clock__get(timefunc_start), fc(timefunc), clock__get(sleep1),clock__get(sleep2),clock__get(sleep3),clock__get(sleep4));
  173. return 0;
  174. }
  175.  
Powered by spacepaste. Paste removal.