fork download
copy 
  1. // #include <stdio.h>
  2. // #include <stdlib.h>
  3. // #include <time.h>
  4.  
  5. // #ifndef N
  6. // #define N 500 // 800
  7. // #endif
  8.  
  9. // static double elapsed_seconds(clock_t start, clock_t end)
  10. // {
  11. //     return (double)(end - start) / CLOCKS_PER_SEC;
  12. // }
  13.  
  14. // static void initialize_matrix(double *matrix, int n, double value)
  15. // {
  16. //     for (int i = 0; i < n * n; i++) {
  17. //         matrix[i] = value;
  18. //     }
  19. // }
  20.  
  21. // /* Loop order: i-j-k.  B[k][j] is accessed column-wise in row-major C. */
  22. // static void matmul_ijk(const double *a, const double *b, double *c, int n)
  23. // {
  24. //     for (int i = 0; i < n; i++) {
  25. //         for (int j = 0; j < n; j++) {
  26. //             double sum = 0.0;
  27. //             for (int k = 0; k < n; k++) {
  28. //                 sum += a[i * n + k] * b[k * n + j];
  29. //             }
  30. //             c[i * n + j] = sum;
  31. //         }
  32. //     }
  33. // }
  34.  
  35. // /* Loop order: i-k-j.  B[k][j] and C[i][j] are accessed row-wise. */
  36. // static void matmul_ikj(const double *a, const double *b, double *c, int n)
  37. // {
  38. //     for (int i = 0; i < n; i++) {
  39. //         for (int k = 0; k < n; k++) {
  40. //             double aik = a[i * n + k];
  41. //             for (int j = 0; j < n; j++) {
  42. //                 c[i * n + j] += aik * b[k * n + j];
  43. //             }
  44. //         }
  45. //     }
  46. // }
  47.  
  48. // static double checksum(const double *matrix, int n)
  49. // {
  50. //     double result = 0.0;
  51. //     for (int i = 0; i < n * n; i++) {
  52. //         result += matrix[i];
  53. //     }
  54. //     return result;
  55. // }
  56.  
  57. // int main(void)
  58. // {
  59. //     const int n = N;
  60. //     const size_t bytes = (size_t)n * n * sizeof(double);
  61.  
  62. //     double *a = malloc(bytes);
  63. //     double *b = malloc(bytes);
  64. //     double *c = malloc(bytes);
  65.  
  66. //     if (a == NULL || b == NULL || c == NULL) {
  67. //         fprintf(stderr, "Memory allocation failed for N=%d\n", n);
  68. //         free(a);
  69. //         free(b);
  70. //         free(c);
  71. //         return 1;
  72. //     }
  73.  
  74. //     initialize_matrix(a, n, 1.0);
  75. //     initialize_matrix(b, n, 2.0);
  76.  
  77. //     initialize_matrix(c, n, 0.0);
  78. //     clock_t start_ijk = clock();
  79. //     matmul_ijk(a, b, c, n);
  80. //     clock_t end_ijk = clock();
  81. //     double time_ijk = elapsed_seconds(start_ijk, end_ijk);
  82. //     double check_ijk = checksum(c, n);
  83.  
  84. //     initialize_matrix(c, n, 0.0);
  85. //     clock_t start_ikj = clock();
  86. //     matmul_ikj(a, b, c, n);
  87. //     clock_t end_ikj = clock();
  88. //     double time_ikj = elapsed_seconds(start_ikj, end_ikj);
  89. //     double check_ikj = checksum(c, n);
  90.  
  91. //     printf("N = %d\n", n);
  92. //     printf("i-j-k time = %.6f seconds, checksum = %.2f\n", time_ijk, check_ijk);
  93. //     printf("i-k-j time = %.6f seconds, checksum = %.2f\n", time_ikj, check_ikj);
  94.  
  95. //     free(a);
  96. //     free(b);
  97. //     free(c);
  98. //     return 0;
  99. // }
  100.  
  101.  
  102. #include <stdio.h>
  103. #include <time.h>
  104.  
  105. #define N 1000000
  106. #define PI 3.141592653589793
  107.  
  108. static double radius[N];
  109. static double area[N];
  110. static double diameter[N];
  111. static double circumference[N];
  112.  
  113. int main(void)
  114. {
  115.     int i;
  116.     clock_t start, end;
  117.     double time_one_record, time_one_operation;
  118.     double check = 0.0;
  119.  
  120.     /* Create one million records. */
  121.     for (i = 0; i < N; i++) {
  122.         radius[i] = (i % 100) + 1.0;
  123.     }
  124.  
  125.     /* Method 1: process one record completely, then move to the next. */
  126.     start = clock();
  127.  
  128.     for (i = 0; i < N; i++) {
  129.         double r = radius[i];
  130.  
  131.         area[i] = PI * r * r;
  132.         diameter[i] = 2.0 * r;
  133.         circumference[i] = 2.0 * PI * r;
  134.     }
  135.  
  136.     end = clock();
  137.     time_one_record = (double)(end - start) / CLOCKS_PER_SEC;
  138.  
  139.     /* Method 2: make one complete pass for each operation. */
  140.     start = clock();
  141.  
  142.     for (i = 0; i < N; i++) {
  143.         double r = radius[i];
  144.         area[i] = PI * r * r;
  145.     }
  146.  
  147.     for (i = 0; i < N; i++) {
  148.         double r = radius[i];
  149.         diameter[i] = 2.0 * r;
  150.     }
  151.  
  152.     for (i = 0; i < N; i++) {
  153.         double r = radius[i];
  154.         circumference[i] = 2.0 * PI * r;
  155.     }
  156.  
  157.     end = clock();
  158.     time_one_operation = (double)(end - start) / CLOCKS_PER_SEC;
  159.  
  160.     /* Use the results so the compiler cannot remove the calculations. */
  161.     for (i = 0; i < N; i++) {
  162.         check += area[i] + diameter[i] + circumference[i];
  163.     }
  164.  
  165.     printf("Method 1 - one record at a time: %.6f seconds\n", time_one_record);
  166.     printf("Method 2 - one operation at a time: %.6f seconds\n", time_one_operation);
  167.     printf("Check = %.2f\n", check);
  168.  
  169.     return 0;
  170. }
  171.  
Success #stdin #stdout 0.02s 32864KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Method 1 - one record at a time: 0.004206 seconds
Method 2 - one operation at a time: 0.005956 seconds
Check = 11047879601.43
https://ideone.com/iE52kp
language:
C (gcc 8.3)
created:
1 hour ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!