abdelrahman/performance-aware-programming
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Complete homework for execution ports video

Browse Source
This commit is contained in:
Abdelrahman Said
2024-02-11 00:42:14 +00:00
parent 4945a298ac
commit 2cb6f1beb6
2 changed files with 518 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

369
haversine_02/src/repetition_testing/main.cpp
View File

@@ -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 MOV ADD", "RAT MOV ADD WITH MALLOC"}, test_rat_mov_add},
// {{"RAT ADD", "RAT ADD WITH MALLOC"}, test_rat_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) {

152
haversine_02/src/repetition_testing/reptest_functions.asm
View File

@@ -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