Test reading with and without malloc

haversine_02/include/repetition_testing/reptester.h

@@ -33,12 +33,24 @@ struct reptester {
   reptest_results results;
 };
 
-struct reptest_func {
-  const char *name;
-  void (*func)(reptester *tester);
+enum alloc_type {
+  ALLOC_TYPE_WITHOUT_MALLOC,
+  ALLOC_TYPE_WITH_MALLOC,
+
+  COUNT_ALLOC_TYPE,
 };
 
-void run_func_test(reptester *tester, reptest_func func_obj);
+typedef void (*reptest_func)(reptester *tester, alloc_type type);
+
+struct func_data {
+  const char *names[COUNT_ALLOC_TYPE];
+  reptest_func func;
+};
+
+void handle_alloc(reptester *tester, alloc_type type);
+void handle_free(reptester *tester, alloc_type type);
+void run_func_test(reptester *tester, reptest_func func, const char *func_name,
+                   alloc_type type);
 void print_results(reptester *tester, const char *name);
 
 #endif // !REPTESTER_H

haversine_02/src/repetition_testing/main.cpp

@@ -9,8 +9,8 @@
 
 #define ARR_LEN(ARR) sizeof(ARR) / sizeof(*ARR)
 
-void test_fread(reptester *tester);
-void test_read(reptester *tester);
+void test_fread(reptester *tester, alloc_type type);
+void test_read(reptester *tester, alloc_type type);
 u64 get_file_length(FILE *fp);
 
 int main(int argc, char *argv[]) {
@@ -32,7 +32,7 @@ int main(int argc, char *argv[]) {
 
   // clang-format off
   reptester tester = {
-      {filename, NULL, 0, 0}, // params
+      {filename, NULL, 0, 0},     // params
       get_cpu_freq(500),          // cpu_freq
 
       10.0,                       // wait_time_secs
@@ -53,7 +53,8 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 
-  reptest_func funcs[] = {{"FREAD", test_fread}, {"READ", test_read}};
+  func_data funcs[] = {{{"READ", "READ WITH MALLOC"}, test_read},
+                       {{"FREAD", "FREAD WITH MALLOC"}, test_fread}};
 
   tester.params.read_size = get_file_length(fp);
   tester.params.read_count = 1;
@@ -62,7 +63,9 @@ int main(int argc, char *argv[]) {
 
   for (u64 i = 0; i < waves; ++i) {
     for (u64 j = 0; j < ARR_LEN(funcs); ++j) {
-      run_func_test(&tester, funcs[j]);
+      for (u64 k = 0; k < COUNT_ALLOC_TYPE; ++k) {
+        run_func_test(&tester, funcs[j].func, funcs[j].names[k], (alloc_type)k);
+      }
     }
   }
 
@@ -73,12 +76,14 @@ int main(int argc, char *argv[]) {
   return 0;
 }
 
-void test_fread(reptester *tester) {
+void test_fread(reptester *tester, alloc_type type) {
   FILE *fp = fopen(tester->params.filename, "rb");
   if (!fp) {
     return;
   }
 
+  handle_alloc(tester, type);
+
   u64 start = read_cpu_timer();
   u64 obj_count = fread(tester->params.buffer, tester->params.read_size,
                         tester->params.read_count, fp);
@@ -93,15 +98,19 @@ void test_fread(reptester *tester) {
       read_time,
   };
 
+  handle_free(tester, type);
+
   fclose(fp);
 }
 
-void test_read(reptester *tester) {
+void test_read(reptester *tester, alloc_type type) {
   FILE *fp = fopen(tester->params.filename, "rb");
   if (!fp) {
     return;
   }
 
+  handle_alloc(tester, type);
+
   i32 fd = fileno(fp);
 
   u64 start = read_cpu_timer();
@@ -116,6 +125,8 @@ void test_read(reptester *tester) {
       read_time,
   };
 
+  handle_free(tester, type);
+
   fclose(fp);
 }
 

haversine_02/src/repetition_testing/reptester.cpp

@@ -1,8 +1,39 @@
 #include "repetition_testing/reptester.h"
 #include "profiler/timer.h"
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-void run_func_test(reptester *tester, reptest_func func_obj) {
+void handle_alloc(reptester *tester, alloc_type type) {
+  switch (type) {
+  case ALLOC_TYPE_WITH_MALLOC:
+    if (!(tester->params.buffer)) {
+      tester->params.buffer = (char *)malloc(tester->params.read_size + 1);
+      memset(tester->params.buffer, 0, tester->params.read_size + 1);
+    }
+
+    break;
+  default:
+    break;
+  }
+}
+
+void handle_free(reptester *tester, alloc_type type) {
+  switch (type) {
+  case ALLOC_TYPE_WITH_MALLOC:
+    if (tester->params.buffer) {
+      free(tester->params.buffer);
+      tester->params.buffer = NULL;
+    }
+
+    break;
+  default:
+    break;
+  }
+}
+
+void run_func_test(reptester *tester, reptest_func func, const char *func_name,
+                   alloc_type type) {
   tester->test_start_time = read_cpu_timer();
   tester->test_time_secs = 0.0;
   tester->current_run = 1;
@@ -12,8 +43,13 @@ void run_func_test(reptester *tester, reptest_func func_obj) {
   tester->total = 0;
   tester->results = {};
 
+  if (type == ALLOC_TYPE_WITHOUT_MALLOC && !(tester->params.buffer)) {
+    tester->params.buffer = (char *)malloc(tester->params.read_size + 1);
+    memset(tester->params.buffer, 0, tester->params.read_size + 1);
+  }
+
   while (tester->test_time_secs <= tester->wait_time_secs) {
-    func_obj.func(tester);
+    func(tester, type);
 
     if (tester->results.bytes_read <
         tester->params.read_size * tester->params.read_count) {
@@ -39,7 +75,12 @@ void run_func_test(reptester *tester, reptest_func func_obj) {
     ++(tester->current_run);
   }
 
-  print_results(tester, func_obj.name);
+  if (type == ALLOC_TYPE_WITHOUT_MALLOC && tester->params.buffer) {
+    free(tester->params.buffer);
+    tester->params.buffer = NULL;
+  }
+
+  print_results(tester, func_name);
 }
 
 void print_results(reptester *tester, const char *name) {