Remove unused variables

8086_assembly_01/Makefile

@@ -1,2 +1,2 @@
 all:
-	clang++ -g dasm.cpp -o dasm
+	clang++ -g dasm.cc -o dasm

8086_assembly_02/Makefile

@@ -1,2 +1,2 @@
 all:
-	clang++ -g dasm.cpp -o dasm
+	clang++ -g dasm.cc -o dasm

8086_assembly_03/Makefile

@@ -1,2 +1,2 @@
 all:
-	clang++ -g dasm.cpp -o dasm
+	clang++ -g dasm.cc -o dasm

8086_sim/Makefile

@@ -1,7 +1,7 @@
 CC=clang++
 CFLAGS=-g -O0 -Wall -Wextra
 LIBS=-Wl,-rpath,./lib -L./lib -lsim86
-SRC=*.cpp
+SRC=*.cc
 OUT=sim86
 
 all:

haversine_01/Makefile

@@ -1,17 +1,17 @@
 mk_haversine_fscanf:
-	clang++ -g cpp/fscanf.cpp cpp/haversine.cpp -o cpp/haverscan
+	clang++ -g cpp/fscanf.cc cpp/haversine.cc -o cpp/haverscan
 
 run_haversine_fscanf:
 	cd ./cpp && ./haverscan
 
 mk_haversine_strtok:
-	clang++ -g cpp/strtok.cpp cpp/haversine.cpp -o cpp/haverstrtok
+	clang++ -g cpp/strtok.cc cpp/haversine.cc -o cpp/haverstrtok
 
 run_haversine_strtok:
 	cd ./cpp && ./haverstrtok
 
 mk_test:
-	clang++ -g -lpthread cpp/test.cpp cpp/haversine.cpp -o cpp/test
+	clang++ -g -lpthread cpp/test.cc cpp/haversine.cc -o cpp/test
 
 run_test:
 	cd ./cpp && ./test

haversine_02/.gitignore

@@ -1,7 +1,13 @@
 .cache
+.vscode
+.idea
 compile_commands.json
 count_and_distances
 pairs.json
+cache_test
 main
 genhavr
 prochavr
+reptest
+memtest
+timer_test*

haversine_02/.vscode/launch.json

@@ -1,35 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "Debug clustered generator",
-            "type": "cppdbg",
-            "request": "launch",
-            "cwd": "${workspaceFolder}",
-            "program": "${workspaceFolder}/genhavr",
-            "args": [
-                "--cluster",
-                "10"
-            ]
-        },
-        {
-            "name": "Debug uniform generator",
-            "type": "cppdbg",
-            "request": "launch",
-            "cwd": "${workspaceFolder}",
-            "program": "${workspaceFolder}/genhavr",
-            "args": [
-                "10"
-            ]
-        },
-        {
-            "name": "Debug processor",
-            "type": "cppdbg",
-            "request": "launch",
-            "cwd": "${workspaceFolder}",
-            "program": "${workspaceFolder}/prochavr",
-            "args": [
-                "${workspaceFolder}/pairs.json"
-            ]
-        }
-    ]
-}

haversine_02/compile

@@ -4,6 +4,12 @@ CC=clang
 CXX=clang++
 CFLAGS="-Wall -Wextra -I$(realpath ./include) "
 
+ASM=nasm
+ASM_FLAGS="-f elf64 "
+
+AR=ar
+AR_FLAGS="rcs"
+
 # PARSE ARGUMENTS
 # From this StackOverflow answer https://stackoverflow.com/a/14203146
 while [[ $# > 0 ]];do
@@ -12,8 +18,12 @@ while [[ $# > 0 ]];do
 			RELEASE=true
 			shift
 			;;
-		--enable-profiling)
+		--basic-profiling)
-			ENABLE_PROFILING=true
+			BASIC_PROFILING=true
+			shift
+			;;
+		--full-profiling)
+			FULL_PROFILING=true
 			shift
 			;;
 		*|-*|--*)
@@ -26,45 +36,73 @@ done
 
 # BUILD TYPE
 if [[ $RELEASE == true ]]; then
-	CFLAGS+="-O3"
+	CFLAGS+="-g -O1"
 else
 	CFLAGS+="-g"
 fi
 
 
 # GENERATOR
-GENSRC="./src/generator/gen_argparser.cpp \
+GENSRC="./src/generator/gen_argparser.cc \
-	./src/generator/generator.cpp \
+	./src/generator/generator.cc \
-	./src/haversine.cpp \
+	./src/haversine.cc \
-	./src/point_types.cpp \
+	./src/point_types.cc \
-	./src/generator/main.cpp"
+	./src/generator/main.cc"
 GENOUT=genhavr
 
 (set -x ; $CXX $CFLAGS $GENSRC -o $GENOUT)
 echo
 
-
 # PROFILER
 PROFSRC="../src/profiler/timer.c"
-PROFFLAGS="-c"
+PROFFLAGS="-c "
 PROF_BUILD_DIR=prof_build
 
 # PROCESSOR
-JSONSRC="../src/json/*.c"
+JSONSRC="../src/json/*.c "
 JSONFLAGS="-c "
 JSON_BUILD_DIR=json_build
 
 PROCSRC="./$JSON_BUILD_DIR/*.o \
-	./src/haversine.cpp \
+	./src/haversine.cc \
-	./src/point_types.cpp \
+	./src/point_types.cc \
-	./src/processor/proc_argparser.cpp \
+	./src/processor/proc_argparser.cc \
-	./src/processor/main.cpp "
+	./src/processor/main.cc "
 PROCOUT=prochavr
 
-if [[ $ENABLE_PROFILING == true ]]; then
+# MEMTESTER
-	JSONFLAGS+="-DENABLE_PROFILING"
+MEMTESTSRC="./src/memtester/*.c"
-	PROCSRC+="./$PROF_BUILD_DIR/*.o"
+MEMTESTOUT=memtest
-	PROCFLAGS="-DENABLE_PROFILING"
+
+(set -x ; $CC $CFLAGS $MEMTESTSRC -o $MEMTESTOUT)
+echo
+
+# REPTEST ASSEMBLY
+ASM_BUILD_DIR=reptest_build
+ASM_SRC="./src/repetition_testing/reptest_functions.asm"
+ASM_OBJ="./$ASM_BUILD_DIR/funcs.o"
+ASM_LIB="./$ASM_BUILD_DIR/libfuncs.a"
+
+mkdir $ASM_BUILD_DIR
+
+(set -x ; $ASM $ASM_FLAGS $ASM_SRC -o $ASM_OBJ)
+(set -x ; $AR $AR_FLAGS $ASM_LIB $ASM_OBJ)
+echo
+
+if [[ $BASIC_PROFILING == true ]] || [[ $FULL_PROFILING == true ]]; then
+	if [[ $FULL_PROFILING == true ]]; then
+		JSONFLAGS+="-DFULL_PROFILING"
+		PROCFLAGS="-DFULL_PROFILING"
+		REPTESTFLAGS="-DFULL_PROFILING"
+		PROFFLAGS+="-DFULL_PROFILING"
+	elif [[ $BASIC_PROFILING == true ]]; then
+		JSONFLAGS+="-DBASIC_PROFILING"
+		PROCFLAGS="-DBASIC_PROFILING"
+		REPTESTFLAGS="-DBASIC_PROFILING"
+		PROFFLAGS+="-DBASIC_PROFILING"
+	fi
+
+	PROCSRC+=./$PROF_BUILD_DIR/*.o
 
 	mkdir $PROF_BUILD_DIR
 	cd $PROF_BUILD_DIR
@@ -73,6 +111,13 @@ if [[ $ENABLE_PROFILING == true ]]; then
 	echo
 
 	cd ../
+
+	# REPETITION TESTING
+	REPTESTSRC="./src/repetition_testing/*.cc ./$PROF_BUILD_DIR/*.o $ASM_LIB"
+	REPTESTOUT=reptest
+
+	(set -x ; $CXX $CFLAGS $REPTESTFLAGS $REPTESTSRC -o $REPTESTOUT)
+	echo
 fi
 
 mkdir $JSON_BUILD_DIR
@@ -86,6 +131,5 @@ cd ../
 (set -x ; $CXX $CFLAGS $PROCFLAGS $PROCSRC -o $PROCOUT)
 echo
 
-
 # CLEAR BUILD FILES
-rm -rvf $JSON_BUILD_DIR $PROF_BUILD_DIR
+rm -rvf $JSON_BUILD_DIR $PROF_BUILD_DIR $ASM_BUILD_DIR

haversine_02/include/processor/ids.h

@@ -6,15 +6,14 @@ enum profiler_ids {
   PROFILER_ID_JSON_PARSE,
   PROFILER_ID_READ_JSON_FILE,
   PROFILER_ID_PARSER_SETUP,
-  PROFILER_ID_LEX_GET_TOKEN,
+  PROFILER_ID_PARSER_PARSE_TOKENS,
-  PROFILER_ID_PARSE_TOKEN,
   PROFILER_ID_PARSER_TEAR_DOWN,
   PROFILER_ID_LOAD_JSON_PAIRS,
   PROFILER_ID_READ_BINARY,
   PROFILER_ID_HAVERSINE_SUM,
-  PROFILER_ID_HAVERSINE_DISTANCE,
   PROFILER_ID_HAVERSINE_AVG,
   PROFILER_ID_TEAR_DOWN,
+  PROFILER_ID_FREE_JSON,
 
   COUNT_PROFILER_IDS,
 };

haversine_02/include/profiler/timer.h

@@ -7,17 +7,31 @@
 #define MAX_PROFILE_SAMPLES 1024
 #endif // !MAX_PROFILE_SAMPLES
 
-#ifdef ENABLE_PROFILING
+#ifdef FULL_PROFILING
+#define SAMPLE_START(ID, TITLE) sample_start(ID, TITLE)
+#define SAMPLE_END(ID, BYTES) sample_end(ID, BYTES)
+#define SAMPLE_END_DEFAULT(ID) sample_end(ID, 0)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void sample_start(u64 id, const char *title);
+void sample_end(u64 id, u64 byte_count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#else
+#define SAMPLE_START(ID, TITLE)
+#define SAMPLE_END(ID, BYTES)
+#define SAMPLE_END_DEFAULT(ID)
+#endif // FULL_PROFILING
+
+#if defined(BASIC_PROFILING) || defined(FULL_PROFILING)
 #define PROFILE_START(COUNT) profile_start(COUNT)
 #define PROFILE_END profile_end()
-#define SAMPLE_START(ID, TITLE) sample_start(ID, TITLE)
-#define SAMPLE_END(ID) sample_end(ID)
-#else
-#define PROFILE_START(COUNT)
-#define PROFILE_END
-#define SAMPLE_START(ID, TITLE)
-#define SAMPLE_END(ID)
-#endif // ENABLE_PROFILING
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,10 +41,12 @@ typedef struct sample profiler_sample_t;
 
 struct sample {
   const char *title;
+  u64 first_start;
   u64 start;
-  u64 duration;
+  u64 exclusive_time;
-  u64 children_duration;
+  u64 children_time;
   u64 hit_count;
+  u64 byte_count;
   profiler_sample_t *parent;
 };
 
@@ -45,14 +61,18 @@ u64 read_cpu_timer(void);
 // CPU frequency in hz/sec
 u64 get_cpu_freq(u64 milliseconds);
 
+f64 time_in_seconds(u64 cpu_time, u64 cpu_freq);
+
 void profile_start(u64 count);
 void profile_end();
 
-void sample_start(u64 id, const char *title);
-void sample_end(u64 id);
-
 #ifdef __cplusplus
 }
 #endif
 
+#else
+#define PROFILE_START(COUNT)
+#define PROFILE_END
+#endif // BASIC_PROFILING || FULL_PROFILING
+
 #endif // !TIMER_H

haversine_02/include/repetition_testing/reptester.h

@@ -0,0 +1,71 @@
+#ifndef REPTESTER_H
+#define REPTESTER_H
+
+#include "aliases.h"
+
+struct reptest_params {
+  const char *filename;
+  char *buffer;
+  u64 read_size;
+  u64 read_count;
+};
+
+struct reptest_results {
+  u64 bytes_read;
+  u64 read_time;
+  u64 page_faults;
+};
+
+struct time_stats {
+  u64 min_time;
+  u64 max_time;
+  u64 avg_time;
+  u64 total_time;
+};
+
+struct mem_stats {
+  u64 min_faults;
+  u64 max_faults;
+  u64 avg_faults;
+  u64 total_bytes;
+  u64 total_faults;
+};
+
+struct reptester {
+  reptest_params params;
+
+  const u64 cpu_freq;
+
+  f64 wait_time_secs;
+  f64 test_time_secs;
+  u64 test_start_time;
+
+  u64 current_run;
+  time_stats tstats;
+  mem_stats mstats;
+
+  reptest_results results;
+};
+
+enum alloc_type {
+  ALLOC_TYPE_WITHOUT_MALLOC,
+  ALLOC_TYPE_WITH_MALLOC,
+
+  COUNT_ALLOC_TYPE,
+};
+
+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);
+u64 page_fault_count();
+void print_results(reptester *tester, const char *name);
+
+#endif // !REPTESTER_H

haversine_02/src/json/json_entities.c

@@ -1,5 +1,7 @@
 #include "json/json_entities.h"
 #include "aliases.h"
+#include "processor/ids.h"
+#include "profiler/timer.h"
 #include "json/dstring.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -110,58 +112,90 @@ void print_json(const jentity_t *entity, u32 indent) {
   }
 }
 
-void free_json(jentity_t **entity) {
+void free_json(jentity_t **root) {
-  if (!(*entity)) {
+  if (!(*root)) {
     return;
   }
 
-  jentity_t *entt_ptr = *entity;
+  SAMPLE_START(PROFILER_ID_FREE_JSON, "FREE JSON");
 
+  jentity_t *current = *root;
+  jentity_t *temp = NULL;
   dstr_t *key = NULL;
-  const jval_t *value = NULL;
+  jval_t *value = NULL;
 
-  if (entt_ptr->type == JENTITY_SINGLE) {
+  while (current) {
-    value = &(entt_ptr->value);
+    if (current->parent) {
-  } else {
+      // Move the beginning pointer of the collection to the next child
-    key = entt_ptr->pair.key;
-    value = &(entt_ptr->pair.value);
-  }
 
-  if (key) {
+      // TODO (Abdelrahman): This part gets repeated for some elements. Try to
-    dstr_free(&(entt_ptr->pair.key));
+      // avoid that repetition
-  }
 
-  if (!value) {
+      jentity_t *parent = current->parent;
-    return;
+      jcoll_t *collection = NULL;
-  }
 
-  switch (value->type) {
+      if (parent->type == JENTITY_SINGLE) {
-  case JVAL_COLLECTION:
+        collection = parent->value.collection;
-    if (!(value->collection)) {
+      } else {
+        collection = parent->pair.value.collection;
+      }
+
+      if (collection) {
+        collection->begin = current->next;
+      }
+    }
+
+    if (current->type == JENTITY_SINGLE) {
+      key = NULL;
+      value = &(current->value);
+    } else {
+      key = current->pair.key;
+      value = &(current->pair.value);
+    }
+
+    if (key) {
+      dstr_free(&(current->pair.key));
+    }
+
+    if (!value) {
       break;
     }
 
-    if (value->collection->begin) {
+    if (value->type == JVAL_COLLECTION) {
-      free_json(&(value->collection->begin));
+      if (!(value->collection->begin)) {
+        // Once all children of the collection has been freed, free the memory
+        // allocated to the collection and the entity that holds it
+
+        free(value->collection);
+
+        temp = current;
+
+        current = current->next != NULL ? current->next : current->parent;
+
+        free(temp);
+        temp = NULL;
+
+        continue;
+      }
+
+      current = value->collection->begin;
+    } else {
+      if (value->type == JVAL_STRING) {
+        dstr_free(&(value->string));
+      }
+
+      temp = current;
+
+      current = current->next != NULL ? current->next : current->parent;
+
+      free(temp);
+      temp = NULL;
     }
-
-    free(value->collection);
-
-    break;
-  case JVAL_STRING:
-    dstr_free(&(entt_ptr->pair.value.string));
-
-    break;
-  default:
-    break;
   }
 
-  if (entt_ptr->next) {
+  *root = NULL;
-    free_json(&(entt_ptr->next));
-  }
 
-  free(*entity);
+  SAMPLE_END_DEFAULT(PROFILER_ID_FREE_JSON);
-  *entity = NULL;
 }
 
 jcoll_t *get_collection_from_entity(const jentity_t *entity) {

haversine_02/src/json/parser.c

@@ -1,6 +1,6 @@
 #include "json/parser.h"
 #include "aliases.h"
-#include "profiler/ids.h"
+#include "processor/ids.h"
 #include "profiler/timer.h"
 #include "json/dstring.h"
 #include "json/json_entities.h"
@@ -23,8 +23,6 @@ INTERNAL jentity_t *add_value(parser_t *parser);
 INTERNAL void add_collection(parser_t *parser);
 
 jentity_t *load_json(const char *filepath) {
-  SAMPLE_START(PROFILER_ID_READ_JSON_FILE, "READ JSON FILE");
-
   FILE *fp = fopen(filepath, "r");
 
   if (!fp) {
@@ -40,11 +38,13 @@ jentity_t *load_json(const char *filepath) {
   char *json = (char *)malloc(sizeof(char) * (length + 1));
   memset(json, 0, length + 1);
 
+  SAMPLE_START(PROFILER_ID_READ_JSON_FILE, "READ JSON FILE");
+
   fread(json, sizeof(char), length, fp);
 
-  fclose(fp);
+  SAMPLE_END(PROFILER_ID_READ_JSON_FILE, length);
 
-  SAMPLE_END(PROFILER_ID_READ_JSON_FILE);
+  fclose(fp);
 
   SAMPLE_START(PROFILER_ID_PARSER_SETUP, "JSON PARSER SETUP");
 
@@ -63,23 +63,19 @@ jentity_t *load_json(const char *filepath) {
     return NULL;
   }
 
-  SAMPLE_END(PROFILER_ID_PARSER_SETUP);
+  SAMPLE_END_DEFAULT(PROFILER_ID_PARSER_SETUP);
+
+  SAMPLE_START(PROFILER_ID_PARSER_PARSE_TOKENS, "PARSE TOKENS");
 
-  SAMPLE_START(PROFILER_ID_LEX_GET_TOKEN, "GET NEXT TOKEN");
   lex_result_t result = get_next_token(lexer, json);
-  SAMPLE_END(PROFILER_ID_LEX_GET_TOKEN);
 
   if (result.error.errno) {
     printf("%s\n", result.error.msg);
   } else {
     while (result.token.type != TK_NO_TOKEN) {
-      SAMPLE_START(PROFILER_ID_PARSE_TOKEN, "PARSE TOKEN");
       parse_token(parser, result.token);
-      SAMPLE_END(PROFILER_ID_PARSE_TOKEN);
 
-      SAMPLE_START(PROFILER_ID_LEX_GET_TOKEN, "GET NEXT TOKEN");
       result = get_next_token(lexer, NULL);
-      SAMPLE_END(PROFILER_ID_LEX_GET_TOKEN);
 
       if (result.error.errno) {
         printf("%s\n", result.error.msg);
@@ -88,6 +84,8 @@ jentity_t *load_json(const char *filepath) {
     }
   }
 
+  SAMPLE_END_DEFAULT(PROFILER_ID_PARSER_PARSE_TOKENS);
+
   jentity_t *root = parser->root;
 
   SAMPLE_START(PROFILER_ID_PARSER_TEAR_DOWN, "PARSER TEAR DOWN");
@@ -96,7 +94,7 @@ jentity_t *load_json(const char *filepath) {
   lexer_free(&lexer);
   free(json);
 
-  SAMPLE_END(PROFILER_ID_PARSER_TEAR_DOWN);
+  SAMPLE_END_DEFAULT(PROFILER_ID_PARSER_TEAR_DOWN);
 
   return root;
 }

haversine_02/src/memtester/main.c

@@ -0,0 +1,125 @@
+#include "aliases.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PAGESIZE 4096
+
+#if _WIN32
+
+// clang-format off
+#include <intrin.h>
+#include <windows.h>
+#include <psapi.h>
+// clang-format on
+
+typedef struct {
+  bool Initialized;
+  HANDLE ProcessHandle;
+} os_metrics;
+
+static os_metrics GlobalMetrics;
+
+static u64 ReadWindowsPageFaultCount(void) {
+  PROCESS_MEMORY_COUNTERS_EX MemoryCounters = {0};
+  MemoryCounters.cb = sizeof(MemoryCounters);
+  GetProcessMemoryInfo(GlobalMetrics.ProcessHandle,
+                       (PROCESS_MEMORY_COUNTERS *)&MemoryCounters,
+                       sizeof(MemoryCounters));
+
+  u64 Result = MemoryCounters.PageFaultCount;
+  return Result;
+}
+
+static void InitializeOSMetrics(void) {
+  if (!GlobalMetrics.Initialized) {
+    GlobalMetrics.Initialized = true;
+    GlobalMetrics.ProcessHandle =
+        OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE,
+                    GetCurrentProcessId());
+  }
+}
+
+#else // _WIN32
+
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+typedef struct rusage rusage_t;
+
+u64 nix_page_fault_count() {
+  rusage_t usage;
+
+  getrusage(RUSAGE_SELF, &usage);
+
+  return usage.ru_minflt + usage.ru_majflt;
+}
+
+#endif // _WIN32
+
+u64 page_fault_count() {
+#if _WIN32
+  return ReadWindowsPageFaultCount();
+#else
+  return nix_page_fault_count();
+#endif
+}
+
+int main(int argc, char *argv[]) {
+  if (argc < 2 || argc > 2) {
+    printf("Usage: %s [NUMBER OF PAGES TO ALLOCATE]\n", argv[0]);
+
+    return EXIT_FAILURE;
+  }
+
+#if _WIN32
+  InitializeOSMetrics();
+#endif
+
+  u64 page_count = atol(argv[1]);
+  u64 alloc_size = page_count * PAGESIZE;
+  u64 touch_size = 0;
+
+  printf("Page Count,Touch Count,Fault Count,Extra Faults\n");
+
+  for (u64 touch_count = 0; touch_count <= page_count; ++touch_count) {
+    touch_size = touch_count * PAGESIZE;
+
+#if _WIN32
+    u8 *data = (u8 *)VirtualAlloc(0, alloc_size, MEM_RESERVE | MEM_COMMIT,
+                                  PAGE_READWRITE);
+#else
+    u8 *data = (u8 *)mmap(NULL, alloc_size, PROT_READ | PROT_WRITE,
+                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+#endif
+
+    if (!data) {
+      printf("Failed to allocate memory\n");
+
+      return EXIT_FAILURE;
+    }
+
+    u64 fault_start = page_fault_count();
+
+    for (u64 i = 0; i < touch_size; ++i) {
+      data[i] = (u8)i;
+    }
+
+    u64 fault_end = page_fault_count();
+
+    u64 faults = fault_end - fault_start;
+
+    printf("%llu,%llu,%llu,%lld\n", (unsigned long long)page_count,
+           (unsigned long long)touch_count, (unsigned long long)faults,
+           ((long long)faults - touch_count));
+
+#if _WIN32
+    VirtualFree(data, 0, MEM_RELEASE);
+#else
+    munmap((void *)data, alloc_size);
+#endif
+  }
+
+  return EXIT_SUCCESS;
+}

haversine_02/src/processor/main.cc

@@ -1,7 +1,7 @@
 #include "haversine.h"
 #include "point_types.h"
+#include "processor/ids.h"
 #include "processor/proc_argparser.h"
-#include "profiler/ids.h"
 #include "profiler/timer.h"
 #include "json/dstring.h"
 #include "json/json_entities.h"
@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
 
   SAMPLE_START(PROFILER_ID_CLI_PARSE, "CLI PARSING");
   ProcessorArgs args = parse_args(argc, argv);
-  SAMPLE_END(PROFILER_ID_CLI_PARSE);
+  SAMPLE_END_DEFAULT(PROFILER_ID_CLI_PARSE);
 
   SAMPLE_START(PROFILER_ID_JSON_PARSE, "JSON PARSING");
 
@@ -27,7 +27,7 @@ int main(int argc, char *argv[]) {
 
   assert(root->type == JENTITY_SINGLE && root->value.type == JVAL_COLLECTION);
 
-  SAMPLE_END(PROFILER_ID_JSON_PARSE);
+  SAMPLE_END_DEFAULT(PROFILER_ID_JSON_PARSE);
 
   SAMPLE_START(PROFILER_ID_LOAD_JSON_PAIRS, "LOAD JSON PAIRS");
 
@@ -62,7 +62,7 @@ int main(int argc, char *argv[]) {
     point_pairs[index++] = p;
   }
 
-  SAMPLE_END(PROFILER_ID_LOAD_JSON_PAIRS);
+  SAMPLE_END_DEFAULT(PROFILER_ID_LOAD_JSON_PAIRS);
 
   SAMPLE_START(PROFILER_ID_READ_BINARY, "BINARY READ");
 
@@ -76,7 +76,7 @@ int main(int argc, char *argv[]) {
     fseek(fp, sizeof(u64), SEEK_SET);
   }
 
-  SAMPLE_END(PROFILER_ID_READ_BINARY);
+  SAMPLE_END_DEFAULT(PROFILER_ID_READ_BINARY);
 
   SAMPLE_START(PROFILER_ID_HAVERSINE_SUM, "HAVERSINE SUM");
 
@@ -84,9 +84,7 @@ int main(int argc, char *argv[]) {
   f64 distance = 0.0;
   f64 saved_distance = 0.0;
   for (u64 i = 0; i < pair_count; ++i) {
-    SAMPLE_START(PROFILER_ID_HAVERSINE_DISTANCE, "HAVERSINE DISTANCE");
     distance = haversine_of_degrees(point_pairs[i], EARTH_RADIUS_KM);
-    SAMPLE_END(PROFILER_ID_HAVERSINE_DISTANCE);
 
     if (fp) {
       fread(&saved_distance, sizeof(f64), 1, fp);
@@ -100,11 +98,11 @@ int main(int argc, char *argv[]) {
     sum += distance;
   }
 
-  SAMPLE_END(PROFILER_ID_HAVERSINE_SUM);
+  SAMPLE_END(PROFILER_ID_HAVERSINE_SUM, sizeof(f64) * pair_count);
 
   SAMPLE_START(PROFILER_ID_HAVERSINE_AVG, "HAVERSINE AVERAGE");
   printf("\nAVERAGE DISTANCE: %f\n", sum / pair_count);
-  SAMPLE_END(PROFILER_ID_HAVERSINE_AVG);
+  SAMPLE_END_DEFAULT(PROFILER_ID_HAVERSINE_AVG);
 
   SAMPLE_START(PROFILER_ID_TEAR_DOWN, "TEAR DOWN");
 
@@ -114,7 +112,9 @@ int main(int argc, char *argv[]) {
 
   free(point_pairs);
 
-  SAMPLE_END(PROFILER_ID_TEAR_DOWN);
+  free_json(&root);
+
+  SAMPLE_END_DEFAULT(PROFILER_ID_TEAR_DOWN);
 
   PROFILE_END;
 

haversine_02/src/profiler/timer.c

@@ -1,11 +1,13 @@
 #include "profiler/timer.h"
 #include "aliases.h"
+#include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 
 #include <x86intrin.h>
 
+#if defined(BASIC_PROFILING) || defined(FULL_PROFILING)
 typedef struct {
   profiler_sample_t samples[MAX_PROFILE_SAMPLES];
   u64 cpu_freq;
@@ -36,12 +38,13 @@ u64 read_cpu_timer(void) { return __rdtsc(); }
 
 u64 get_cpu_freq(u64 milliseconds) {
   u64 os_freq = get_os_frequency();
-  u64 os_start = get_os_time();
-  u64 cpu_start = read_cpu_timer();
   u64 os_end = 0;
   u64 os_elapsed = 0;
   u64 os_wait_time = os_freq * milliseconds / 1000;
 
+  u64 os_start = get_os_time();
+  u64 cpu_start = read_cpu_timer();
+
   while (os_elapsed < os_wait_time) {
     os_end = get_os_time();
     os_elapsed = os_end - os_start;
@@ -59,8 +62,12 @@ u64 get_cpu_freq(u64 milliseconds) {
   return cpu_freq;
 }
 
+f64 time_in_seconds(u64 cpu_time, u64 cpu_freq) {
+  return (f64)cpu_time / cpu_freq;
+}
+
 void profile_start(u64 count) {
-  profiler.cpu_freq = get_cpu_freq(500);
+  profiler.cpu_freq = get_cpu_freq(1000);
   profiler.start = read_cpu_timer();
   profiler.max_title_length = 0;
   profiler.size = count;
@@ -81,20 +88,27 @@ void profile_end() {
 
   u16 time_precision = 16;
   u16 time_char_count = 20;
+
+  // clang-format off
+  printf("\n============================================================PROFILING============================================================\n");
+  // clang-format on
+
+  if (profiler.cpu_freq) {
+    printf("Total: %*.*f seconds, %zu (CPU frequency: %llu hz/sec)\n\n",
+           time_char_count, time_precision, (f64)total / profiler.cpu_freq,
+           total, (unsigned long long)profiler.cpu_freq);
+  }
+
+#ifdef FULL_PROFILING
+  f64 byte_to_mb = 1.0 / (1024.0 * 1024.0);
+  f64 mb_to_gb = 1.0 / 1024.0;
+
   u16 duration_char_count = 22;
   u16 hits_char_count = 10;
   u16 percentage_precision = 8;
   u16 percentage_char_count = 12;
-
+  u16 throughput_precision = 24;
-  // clang-format off
+  u16 throughput_char_count = 32;
-  printf("\n==============================PROFILING==============================\n");
-  // clang-format on
-
-  if (profiler.cpu_freq) {
-    printf("Total: %*.*f seconds (CPU frequency: %llu hz/sec)\n\n",
-           time_char_count, time_precision, (f64)total / profiler.cpu_freq,
-           (unsigned long long)profiler.cpu_freq);
-  }
 
   profiler_sample_t *sample = NULL;
 
@@ -105,27 +119,38 @@ void profile_end() {
       continue;
     }
 
-    u64 duration = 0;
-
-    if (sample->duration >= sample->children_duration) {
-      duration = sample->duration - sample->children_duration;
-    }
-
     printf("%*s (hits: %*lld): %*lld (%*.*f %%", (i32)profiler.max_title_length,
            sample->title, hits_char_count,
            (unsigned long long)sample->hit_count, duration_char_count,
-           (unsigned long long)duration, percentage_char_count,
+           (unsigned long long)sample->exclusive_time, percentage_char_count,
-           percentage_precision, (f64)duration / total * 100.0);
+           percentage_precision, (f64)(sample->exclusive_time) / total * 100.0);
 
-    if (sample->children_duration > 0) {
+    if (sample->children_time > 0) {
       printf(", w/ children: %*.*f %%", percentage_char_count,
-             percentage_precision, (f64)sample->duration / total * 100.0);
+             percentage_precision,
+             (f64)(sample->exclusive_time + sample->children_time) / total *
+                 100.0);
+    }
+
+    if (sample->byte_count > 0) {
+      f64 data_read = (f64)(sample->byte_count) * byte_to_mb;
+      f64 sample_time_in_seconds =
+          (f64)(sample->exclusive_time + sample->children_time) /
+          profiler.cpu_freq;
+
+      printf(", Data read: %*.*f MB, Throughput: %*.*f GB/s",
+             throughput_char_count, throughput_precision, data_read,
+             throughput_char_count, throughput_precision,
+             data_read * mb_to_gb / sample_time_in_seconds);
     }
 
     printf(")\n");
   }
+#endif // FULL_PROFILING
 }
+#endif // BASIC_PROFILING || FULL_PROFILING
 
+#ifdef FULL_PROFILING
 void sample_start(u64 id, const char *title) {
   if (id >= MAX_PROFILE_SAMPLES) {
     return;
@@ -135,10 +160,12 @@ void sample_start(u64 id, const char *title) {
 
   if (!(sample->title) || strcmp(title, sample->title) != 0) {
     sample->title = title;
+    sample->first_start = 0;
     sample->start = 0;
-    sample->duration = 0;
+    sample->exclusive_time = 0;
-    sample->children_duration = 0;
+    sample->children_time = 0;
     sample->hit_count = 0;
+    sample->byte_count = 0;
     sample->parent = NULL;
 
     u64 length = strlen(sample->title);
@@ -149,9 +176,20 @@ void sample_start(u64 id, const char *title) {
   }
 
   sample->start = read_cpu_timer();
+
+  if (sample->hit_count == 0) {
+    sample->first_start = sample->start;
+  }
+
   ++(sample->hit_count);
 
-  if (sample != profiler.active) {
+  if (profiler.active) {
+    u64 duration = sample->start - (profiler.active->start);
+
+    profiler.active->exclusive_time += duration;
+  }
+
+  if (!(profiler.active) || sample != profiler.active) {
     // This handles recursive functions by changing the parent only when a
     // function isn't calling itself
     sample->parent = profiler.active;
@@ -160,7 +198,7 @@ void sample_start(u64 id, const char *title) {
   profiler.active = sample;
 }
 
-void sample_end(u64 id) {
+void sample_end(u64 id, u64 byte_count) {
   if (id >= MAX_PROFILE_SAMPLES) {
     return;
   }
@@ -169,17 +207,27 @@ void sample_end(u64 id) {
 
   u64 duration = read_cpu_timer() - sample->start;
 
-  if (!(sample->parent) || sample != sample->parent) {
+  sample->exclusive_time += duration;
-    // This handles recursive functions by adding to the duration only when a
+  sample->byte_count += byte_count;
-    // function isn't calling itself
-    sample->duration += duration;
-  }
 
-  if (sample->parent && sample != sample->parent) {
+  u64 now = read_cpu_timer();
-    // This handles recursive functions by adding to the children_duration only
+
-    // when a function isn't calling itself
+  // Reset the start time at the end of the sample to handle recursion
-    sample->parent->children_duration += duration;
+  sample->start = now;
+
+  profiler_sample_t *parent = sample->parent;
+
+  if (parent) {
+    // Add sample duration to all parents. This handles deep call stacks
+    while (parent) {
+      parent->children_time += duration;
+
+      parent = parent->parent;
+    }
+
+    sample->parent->start = now;
   }
 
   profiler.active = sample->parent;
 }
+#endif // FULL_PROFILING

haversine_02/src/repetition_testing/reptest_functions.asm

@@ -0,0 +1,529 @@
+global mov_all_bytes_asm
+global nop_all_bytes_asm
+global nop_1x3_all_bytes_asm
+global nop_1x9_all_bytes_asm
+global inc_all_bytes_asm
+global dec_all_bytes_asm
+global align64_loop
+global align1_loop
+global align15_loop
+global align31_loop
+global align63_loop
+global align75_loop
+global align90_loop
+global align112_loop
+global rat_add
+global rat_mov_add
+global read_1
+global read_2
+global read_3
+global read_4
+global read_8
+global write_1
+global write_2
+global write_3
+global write_4
+global write_8
+global read_1x2_low
+global read_1x2_high
+global read_2x2
+global read_4x2
+global read_8x2
+global read_4x2_simd
+global read_8x2_simd
+global read_16x2_simd
+global read_32x2_simd_offset
+global read_32x2_simd_no_offset
+global read_16x4_simd
+global read_32x4_simd
+global cache_test ; Expects 3 inputs (pointer, read_count, mask)
+global cache_test_unaligned ; Expects 3 inputs (pointer, read_count, mask)
+
+mov_all_bytes_asm:
+  xor rax, rax
+
+  .loop:
+    mov BYTE [rdi + rax * 1], al
+    inc rax
+    cmp rsi, rax
+    jne .loop
+
+  ret
+
+nop_all_bytes_asm:
+  xor rax, rax
+
+  .loop:
+    db 0x0f, 0x1f, 0x00
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+nop_1x3_all_bytes_asm:
+  xor rax, rax
+
+  .loop:
+    nop
+    nop
+    nop
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+nop_1x9_all_bytes_asm:
+  xor rax, rax
+
+  .loop:
+    nop
+    nop
+    nop
+    nop
+    nop
+    nop
+    nop
+    nop
+    nop
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+inc_all_bytes_asm:
+  xor rax, rax
+
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+dec_all_bytes_asm:
+  .loop:
+    dec rdi
+    jnz .loop
+
+  ret
+
+align64_loop:
+  xor rax, rax
+
+  align 64
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align1_loop:
+  xor rax, rax
+
+  align 64
+  nop
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align15_loop:
+  xor rax, rax
+
+  align 64
+  %rep 15
+  nop
+  %endrep
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align31_loop:
+  xor rax, rax
+
+  align 64
+  %rep 31
+  nop
+  %endrep
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align63_loop:
+  xor rax, rax
+
+  align 64
+  %rep 63
+  nop
+  %endrep
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align75_loop:
+  xor rax, rax
+
+  align 64
+  %rep 75
+  nop
+  %endrep
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align90_loop:
+  xor rax, rax
+
+  align 64
+  %rep 90
+  nop
+  %endrep
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+align112_loop:
+  xor rax, rax
+
+  align 64
+  %rep 112
+  nop
+  %endrep
+  .loop:
+    inc rax
+    cmp rdi, rax
+    jne .loop
+
+  ret
+
+rat_add:
+  mov rax, rdi
+
+  .loop:
+    add rcx, 1
+    add rcx, 1
+    dec rax
+    jnz .loop
+  ret
+
+rat_mov_add:
+  mov rax, rdi
+
+  .loop:
+    mov rcx, rax
+    add rcx, 1
+    mov rcx, rax
+    add rcx, 1
+    dec rax
+    jnz .loop
+  ret
+
+read_1:
+  align 64
+  .loop:
+    mov rax, [rdi]
+    sub rsi, 1
+    jnle .loop
+
+  ret
+
+read_2:
+  align 64
+  .loop:
+    %rep 2
+    mov rax, [rdi]
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+read_3:
+  align 64
+  .loop:
+    %rep 3
+    mov rax, [rdi]
+    %endrep
+    sub rsi, 3
+    jnle .loop
+
+  ret
+
+read_4:
+  align 64
+  .loop:
+    %rep 4
+    mov rax, [rdi]
+    %endrep
+    sub rsi, 4
+    jnle .loop
+
+  ret
+
+read_8:
+  align 64
+  .loop:
+    %rep 8
+    mov rax, [rdi]
+    %endrep
+    sub rsi, 8
+    jnle .loop
+
+  ret
+
+write_1:
+  align 64
+  .loop:
+    mov QWORD [rdi], 0
+    sub rsi, 1
+    jnle .loop
+
+  ret
+
+write_2:
+  align 64
+  .loop:
+    %rep 2
+    mov QWORD [rdi], 0
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+write_3:
+  align 64
+  .loop:
+    %rep 3
+    mov QWORD [rdi], 0
+    %endrep
+    sub rsi, 3
+    jnle .loop
+
+  ret
+
+write_4:
+  align 64
+  .loop:
+    %rep 4
+    mov QWORD [rdi], 0
+    %endrep
+    sub rsi, 4
+    jnle .loop
+
+  ret
+
+write_8:
+  align 64
+  .loop:
+    %rep 8
+    mov QWORD [rdi], 0
+    %endrep
+    sub rsi, 8
+    jnle .loop
+
+  ret
+
+read_1x2_low:
+  align 64
+  .loop:
+    %rep 2
+    mov al, [rdi]
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+read_1x2_high:
+  align 64
+  .loop:
+    %rep 2
+    mov ah, [rdi]
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+read_2x2:
+  align 64
+  .loop:
+    %rep 2
+    mov ax, [rdi]
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+read_4x2:
+  align 64
+  .loop:
+    %rep 2
+    mov eax, [rdi]
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+read_8x2:
+  align 64
+  .loop:
+    %rep 2
+    mov rax, [rdi]
+    %endrep
+    sub rsi, 2
+    jnle .loop
+
+  ret
+
+read_4x2_simd:
+  xor rax, rax
+
+  align 64
+  .loop:
+    mov r8d, [rdi]
+    mov r8d, [rdi + 4]
+    add rax, 8
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+read_8x2_simd:
+  xor rax, rax
+
+  align 64
+  .loop:
+    mov r8, [rdi]
+    mov r8, [rdi + 8]
+    add rax, 16
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+read_16x2_simd:
+  xor rax, rax
+
+  align 64
+  .loop:
+    vmovdqu xmm0, [rdi]
+    vmovdqu xmm0, [rdi + 16]
+    add rax, 32
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+read_32x2_simd_offset:
+  xor rax, rax
+
+  align 64
+  .loop:
+    vmovdqu ymm0, [rdi]
+    vmovdqu ymm0, [rdi + 32]
+    add rax, 64
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+read_32x2_simd_no_offset:
+  xor rax, rax
+
+  align 64
+  .loop:
+    vmovdqu ymm0, [rdi]
+    vmovdqu ymm0, [rdi]
+    add rax, 64
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+read_16x4_simd:
+  xor rax, rax
+
+  align 64
+  .loop:
+    %rep 2
+    vmovdqu xmm0, [rdi]
+    vmovdqu xmm0, [rdi + 16]
+    %endrep
+    add rax, 64
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+read_32x4_simd:
+  xor rax, rax
+
+  align 64
+  .loop:
+    %rep 2
+    vmovdqu ymm0, [rdi]
+    vmovdqu ymm0, [rdi]
+    %endrep
+    add rax, 128
+    cmp rax, rsi
+    jb .loop
+
+  ret
+
+cache_test:
+  xor r10, r10           ; Zero loop counter
+  mov rbx, rdi           ; Save original pointer
+  .loop:
+    add rdi, r10         ; Advance the pointer
+    add r10, 128         ; Increment loop counter
+    and r10, rdx         ; Mask offset
+    vmovdqu ymm0, [rdi + 0]
+    vmovdqu ymm1, [rdi + 32]
+    vmovdqu ymm2, [rdi + 64]
+    vmovdqu ymm3, [rdi + 96]
+    mov rdi, rbx         ; Restore original pointer
+    sub rsi, 128         ; Decrement count
+    ja .loop
+  ret
+
+cache_test_unaligned:
+  xor r10, r10           ; Zero loop counter
+	add rdi, 5             ; Unalign pointer
+  mov rbx, rdi           ; Save original pointer
+  .loop:
+    add rdi, r10         ; Advance the pointer
+    add r10, 128         ; Increment loop counter
+    and r10, rdx         ; Mask offset
+    vmovdqu ymm0, [rdi + 0]
+    vmovdqu ymm1, [rdi + 32]
+    vmovdqu ymm2, [rdi + 64]
+    vmovdqu ymm3, [rdi + 96]
+    mov rdi, rbx         ; Restore original pointer
+    sub rsi, 128         ; Decrement count
+    ja .loop
+  ret

haversine_02/src/repetition_testing/reptester.cc

@@ -0,0 +1,168 @@
+#include "repetition_testing/reptester.h"
+#include "profiler/timer.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+void handle_alloc(reptester *tester, alloc_type type) {
+  switch (type) {
+  case ALLOC_TYPE_WITH_MALLOC:
+    if (!(tester->params.buffer)) {
+      tester->params.buffer = (char *)mmap(
+          NULL, tester->params.read_size + 1, PROT_READ | PROT_WRITE,
+          MAP_ANON | MAP_SHARED | MAP_NORESERVE, -1, 0);
+      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) {
+      munmap(tester->params.buffer, tester->params.read_size + 1);
+      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;
+  tester->tstats = {
+      UINT64_MAX, // min_time
+      0,          // max_time
+      0,          // avg_time
+      0,          // total_time
+  };
+  tester->mstats = {
+      UINT64_MAX, // min_faults
+      0,          // max_faults
+      0,          // avg_faults
+      0,          // total_bytes
+      0,          // total_faults
+  };
+  tester->results = {};
+
+  char *buffer = NULL;
+
+  if (type == ALLOC_TYPE_WITH_MALLOC) {
+    buffer = tester->params.buffer;
+    tester->params.buffer =
+        (char *)mmap(NULL, tester->params.read_size + 1, PROT_READ | PROT_WRITE,
+                     MAP_ANON | MAP_SHARED | MAP_NORESERVE, -1, 0);
+    memset(tester->params.buffer, 0, tester->params.read_size + 1);
+  }
+
+  while (tester->test_time_secs <= tester->wait_time_secs) {
+    func(tester, type);
+
+    if (tester->results.bytes_read <
+        tester->params.read_size * tester->params.read_count) {
+      printf("Failed to read the entire file (Total size: %lu, Bytes read: "
+             "%lu)\n",
+             tester->params.read_size, tester->results.bytes_read);
+
+      return;
+    }
+
+    tester->tstats.total_time += tester->results.read_time;
+    tester->mstats.total_bytes += tester->results.bytes_read;
+    tester->mstats.total_faults += tester->results.page_faults;
+
+    if (tester->results.read_time > tester->tstats.max_time) {
+      tester->tstats.max_time = tester->results.read_time;
+      tester->mstats.max_faults = tester->results.page_faults;
+    } else if (tester->results.read_time < tester->tstats.min_time) {
+      tester->test_start_time = read_cpu_timer();
+      tester->tstats.min_time = tester->results.read_time;
+      tester->mstats.min_faults = tester->results.page_faults;
+    }
+
+    if (tester->results.page_faults > tester->mstats.max_faults) {
+      tester->mstats.max_faults = tester->results.page_faults;
+    } else if (tester->results.page_faults < tester->mstats.min_faults) {
+      tester->mstats.min_faults = tester->results.page_faults;
+    }
+
+    tester->test_time_secs = time_in_seconds(
+        read_cpu_timer() - tester->test_start_time, tester->cpu_freq);
+
+    ++(tester->current_run);
+  }
+
+  if (type == ALLOC_TYPE_WITH_MALLOC) {
+    munmap(tester->params.buffer, tester->params.read_size + 1);
+    tester->params.buffer = buffer;
+  }
+
+  print_results(tester, func_name);
+}
+
+u64 page_fault_count() {
+  rusage usage;
+
+  getrusage(RUSAGE_SELF, &usage);
+
+  return usage.ru_minflt + usage.ru_majflt;
+}
+
+void print_results(reptester *tester, const char *name) {
+  f64 kb = 1024.0;
+  f64 gb = kb * kb * kb;
+
+  f64 size_in_kb =
+      (f64)(tester->params.read_size * tester->params.read_count) / kb;
+  f64 size_in_gb =
+      (f64)(tester->params.read_size * tester->params.read_count) / gb;
+
+  u64 run_count = tester->current_run - 1;
+
+  tester->tstats.avg_time = tester->tstats.total_time / run_count;
+  tester->mstats.avg_faults = tester->mstats.total_faults / run_count;
+
+  printf("\n%s: %lu runs\n", name, run_count);
+
+  printf("MIN: %lu (%fGB/s)", tester->tstats.min_time,
+         size_in_gb /
+             time_in_seconds(tester->tstats.min_time, tester->cpu_freq));
+  if (tester->mstats.min_faults > 0) {
+    printf(", FAULTS: %lu (%fK/fault)\n", tester->mstats.min_faults,
+           size_in_kb / tester->mstats.min_faults);
+  } else {
+    printf("\n");
+  }
+
+  printf("MAX: %lu (%fGB/s)", tester->tstats.max_time,
+         size_in_gb /
+             time_in_seconds(tester->tstats.max_time, tester->cpu_freq));
+  if (tester->mstats.max_faults > 0) {
+    printf(", FAULTS: %lu (%fK/fault)\n", tester->mstats.max_faults,
+           size_in_kb / tester->mstats.max_faults);
+  } else {
+    printf("\n");
+  }
+
+  printf("AVG: %lu (%fGB/s)", tester->tstats.avg_time,
+         size_in_gb /
+             time_in_seconds(tester->tstats.avg_time, tester->cpu_freq));
+  if (tester->mstats.avg_faults > 0) {
+    printf(", FAULTS: %lu (%fK/fault)\n", tester->mstats.avg_faults,
+           tester->mstats.total_bytes / kb / tester->mstats.avg_faults);
+  } else {
+    printf("\n");
+  }
+}