Complete homework for execution ports video

haversine_02/src/repetition_testing/main.cpp

@@ -25,6 +25,19 @@ extern "C" void align90_loop(u64 size);
 extern "C" void align112_loop(u64 size);
 extern "C" void rat_add(u64 size);
 extern "C" void rat_mov_add(u64 size);
+extern "C" void read_1(char *buffer, u64 size);
+extern "C" void read_2(char *buffer, u64 size);
+extern "C" void read_4(char *buffer, u64 size);
+extern "C" void read_8(char *buffer, u64 size);
+extern "C" void write_1(char *buffer, u64 size);
+extern "C" void write_2(char *buffer, u64 size);
+extern "C" void write_4(char *buffer, u64 size);
+extern "C" void write_8(char *buffer, u64 size);
+extern "C" void read_1x2_low(char *buffer, u64 size);
+extern "C" void read_1x2_high(char *buffer, u64 size);
+extern "C" void read_2x2(char *buffer, u64 size);
+extern "C" void read_4x2(char *buffer, u64 size);
+extern "C" void read_8x2(char *buffer, u64 size);
 
 void test_fread(reptester *tester, alloc_type type);
 void test_read(reptester *tester, alloc_type type);
@@ -45,6 +58,19 @@ void test_align90_loop(reptester *tester, alloc_type type);
 void test_align112_loop(reptester *tester, alloc_type type);
 void test_rat_add(reptester *tester, alloc_type type);
 void test_rat_mov_add(reptester *tester, alloc_type type);
+void test_read_1(reptester *tester, alloc_type type);
+void test_read_2(reptester *tester, alloc_type type);
+void test_read_4(reptester *tester, alloc_type type);
+void test_read_8(reptester *tester, alloc_type type);
+void test_write_1(reptester *tester, alloc_type type);
+void test_write_2(reptester *tester, alloc_type type);
+void test_write_4(reptester *tester, alloc_type type);
+void test_write_8(reptester *tester, alloc_type type);
+void test_read_1x2_low(reptester *tester, alloc_type type);
+void test_read_1x2_high(reptester *tester, alloc_type type);
+void test_read_2x2(reptester *tester, alloc_type type);
+void test_read_4x2(reptester *tester, alloc_type type);
+void test_read_8x2(reptester *tester, alloc_type type);
 u64 get_file_length(FILE *fp);
 
 int main(int argc, char *argv[]) {
@@ -121,8 +147,21 @@ int main(int argc, char *argv[]) {
       // {{"ALIGN 90", "ALIGN 90 WITH MALLOC"}, test_align90_loop},
       // {{"ALIGN 112", "ALIGN 112 WITH MALLOC"}, test_align112_loop},
       // {{"ALIGN 112", "ALIGN 112 WITH MALLOC"}, test_align112_loop},
-      {{"RAT ADD", "RAT ADD WITH MALLOC"}, test_rat_add},
+      // {{"RAT ADD", "RAT ADD WITH MALLOC"}, test_rat_add},
-      {{"RAT MOV ADD", "RAT MOV ADD WITH MALLOC"}, test_rat_mov_add},
+      // {{"RAT MOV ADD", "RAT MOV ADD WITH MALLOC"}, test_rat_mov_add},
+      // {{"READ 1", "READ 1 WITH MALLOC"}, test_read_1},
+      // {{"READ 2", "READ 2 WITH MALLOC"}, test_read_2},
+      // {{"READ 4", "READ 4 WITH MALLOC"}, test_read_4},
+      // {{"READ 8", "READ 8 WITH MALLOC"}, test_read_8},
+      // {{"WRITE 1", "WRITE 1 WITH MALLOC"}, test_write_1},
+      // {{"WRITE 2", "WRITE 2 WITH MALLOC"}, test_write_2},
+      // {{"WRITE 4", "WRITE 4 WITH MALLOC"}, test_write_4},
+      // {{"WRITE 8", "WRITE 8 WITH MALLOC"}, test_write_8},
+      {{"READ 1x2 LOW", "READ 1x2 LOW WITH MALLOC"}, test_read_1x2_low},
+      {{"READ 1x2 HIGH", "READ 1x2 HIGH WITH MALLOC"}, test_read_1x2_high},
+      {{"READ 2x2", "READ 2x2 WITH MALLOC"}, test_read_2x2},
+      {{"READ 4x2", "READ 4x2 WITH MALLOC"}, test_read_4x2},
+      {{"READ 8x2", "READ 8x2 WITH MALLOC"}, test_read_8x2},
   };
 
   tester.params.read_size = get_file_length(fp);
@@ -132,7 +171,7 @@ int main(int argc, char *argv[]) {
 
   for (u64 i = 0; i < waves; ++i) {
     for (u64 j = 0; j < ARR_LEN(funcs); ++j) {
-      for (u64 k = 0; k < COUNT_ALLOC_TYPE; ++k) {
+      for (u64 k = 0; k < ALLOC_TYPE_WITH_MALLOC; ++k) {
         run_func_test(&tester, funcs[j].func, funcs[j].names[k], (alloc_type)k);
       }
     }
@@ -643,6 +682,330 @@ void test_rat_mov_add(reptester *tester, alloc_type type) {
 
   handle_free(tester, type);
 }
+void test_read_1(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_1(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_2(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_2(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_4(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_4(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_8(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_8(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_write_1(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  write_1(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_write_2(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  write_2(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_write_4(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  write_4(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_write_8(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  write_8(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_1x2_low(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_1x2_low(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_1x2_high(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_1x2_high(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_2x2(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_2x2(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_4x2(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_4x2(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
+
+void test_read_8x2(reptester *tester, alloc_type type) {
+  u64 start = read_cpu_timer();
+  u64 fault_count_start = page_fault_count();
+
+  handle_alloc(tester, type);
+
+  u64 total_size = tester->params.read_size * tester->params.read_count;
+
+  read_8x2(tester->params.buffer, total_size);
+
+  u64 fault_count_end = page_fault_count();
+  u64 end = read_cpu_timer();
+
+  u64 read_time = end - start;
+  u64 page_faults = fault_count_end - fault_count_start;
+
+  tester->results = {
+      total_size,
+      read_time,
+      page_faults,
+  };
+
+  handle_free(tester, type);
+}
 
 u64 get_file_length(FILE *fp) {
   if (!fp) {

haversine_02/src/repetition_testing/reptest_functions.asm

@@ -14,6 +14,19 @@ global align90_loop
 global align112_loop
 global rat_add
 global rat_mov_add
+global read_1
+global read_2
+global read_4
+global read_8
+global write_1
+global write_2
+global write_4
+global write_8
+global read_1x2_low
+global read_1x2_high
+global read_2x2
+global read_4x2
+global read_8x2
 
 mov_all_bytes_asm:
 	xor rax, rax
@@ -214,3 +227,142 @@ rat_mov_add:
 		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_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_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