1280 lines
32 KiB
C++
1280 lines
32 KiB
C++
#include "aliases.h"
|
|
#include "profiler/timer.h"
|
|
#include "repetition_testing/reptester.h"
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#define ARR_LEN(ARR) sizeof(ARR) / sizeof(*ARR)
|
|
|
|
extern "C" void mov_all_bytes_asm(char *buffer, u64 size);
|
|
extern "C" void nop_all_bytes_asm(u64 size);
|
|
extern "C" void nop_1x3_all_bytes_asm(u64 size);
|
|
extern "C" void nop_1x9_all_bytes_asm(u64 size);
|
|
extern "C" void inc_all_bytes_asm(u64 size);
|
|
extern "C" void dec_all_bytes_asm(u64 size);
|
|
extern "C" void align64_loop(u64 size);
|
|
extern "C" void align1_loop(u64 size);
|
|
extern "C" void align15_loop(u64 size);
|
|
extern "C" void align31_loop(u64 size);
|
|
extern "C" void align63_loop(u64 size);
|
|
extern "C" void align75_loop(u64 size);
|
|
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_3(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_3(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);
|
|
extern "C" void read_4x2_simd(char *buffer, u64 size);
|
|
extern "C" void read_8x2_simd(char *buffer, u64 size);
|
|
extern "C" void read_16x2_simd(char *buffer, u64 size);
|
|
extern "C" void read_32x2_simd_offset(char *buffer, u64 size);
|
|
extern "C" void read_32x2_simd_no_offset(char *buffer, u64 size);
|
|
extern "C" void read_16x4_simd(char *buffer, u64 size);
|
|
extern "C" void read_32x4_simd(char *buffer, u64 size);
|
|
|
|
void test_fread(reptester *tester, alloc_type type);
|
|
void test_read(reptester *tester, alloc_type type);
|
|
void test_write(reptester *tester, alloc_type type);
|
|
void test_write_mov_all_bytes_asm(reptester *tester, alloc_type type);
|
|
void test_write_nop_all_bytes_asm(reptester *tester, alloc_type type);
|
|
void test_write_nop_1x3_all_bytes_asm(reptester *tester, alloc_type type);
|
|
void test_write_nop_1x9_all_bytes_asm(reptester *tester, alloc_type type);
|
|
void test_write_inc_all_bytes_asm(reptester *tester, alloc_type type);
|
|
void test_write_dec_all_bytes_asm(reptester *tester, alloc_type type);
|
|
void test_align64_loop(reptester *tester, alloc_type type);
|
|
void test_align1_loop(reptester *tester, alloc_type type);
|
|
void test_align15_loop(reptester *tester, alloc_type type);
|
|
void test_align31_loop(reptester *tester, alloc_type type);
|
|
void test_align63_loop(reptester *tester, alloc_type type);
|
|
void test_align75_loop(reptester *tester, alloc_type type);
|
|
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_3(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_3(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);
|
|
void test_read_4x2_simd(reptester *tester, alloc_type type);
|
|
void test_read_8x2_simd(reptester *tester, alloc_type type);
|
|
void test_read_16x2_simd(reptester *tester, alloc_type type);
|
|
void test_read_32x2_simd_offset(reptester *tester, alloc_type type);
|
|
void test_read_32x2_simd_no_offset(reptester *tester, alloc_type type);
|
|
void test_read_16x4_simd(reptester *tester, alloc_type type);
|
|
void test_read_32x4_simd(reptester *tester, alloc_type type);
|
|
u64 get_file_length(FILE *fp);
|
|
|
|
int main(int argc, char *argv[]) {
|
|
const char *filename = NULL;
|
|
u64 waves = 1;
|
|
|
|
switch (argc) {
|
|
case 3:
|
|
waves = atol(argv[2]);
|
|
// break left out intentionally
|
|
case 2:
|
|
filename = argv[1];
|
|
break;
|
|
default:
|
|
printf("Usage: reptest FILENAME [WAVE_COUNT]\n");
|
|
return -1;
|
|
break;
|
|
}
|
|
|
|
// clang-format off
|
|
reptester tester = {
|
|
{filename, NULL, 0, 0}, // params
|
|
get_cpu_freq(500), // cpu_freq
|
|
|
|
10.0, // wait_time_secs
|
|
0.0, // test_time_secs
|
|
read_cpu_timer(), // test_start_time
|
|
|
|
1, // current_run
|
|
{
|
|
UINT64_MAX, // min_time
|
|
0, // max_time
|
|
0, // avg_time
|
|
0, // total_time
|
|
},
|
|
{
|
|
0, // min_faults
|
|
0, // max_faults
|
|
0, // avg_faults
|
|
0, // total_bytes
|
|
0, // total_faults
|
|
},
|
|
{}, // results
|
|
};
|
|
// clang-format on
|
|
|
|
FILE *fp = fopen(tester.params.filename, "rb");
|
|
if (!fp) {
|
|
return -1;
|
|
}
|
|
|
|
func_data funcs[] = {
|
|
// {{"WRITE", "WRITE WITH MALLOC"}, test_write},
|
|
// {{"WRITE MOV ASM", "WRITE MOV ASM WITH MALLOC"},
|
|
// test_write_mov_all_bytes_asm},
|
|
// {{"WRITE NOP ASM", "WRITE NOP ASM WITH MALLOC"},
|
|
// test_write_nop_all_bytes_asm},
|
|
// {{"WRITE NOP 1x3 ASM", "WRITE NOP 1x3 ASM WITH MALLOC"},
|
|
// test_write_nop_1x3_all_bytes_asm},
|
|
// {{"WRITE NOP 1x9 ASM", "WRITE NOP 1x9 ASM WITH MALLOC"},
|
|
// test_write_nop_1x9_all_bytes_asm},
|
|
// {{"WRITE INC ASM", "WRITE INC ASM WITH MALLOC"},
|
|
// test_write_inc_all_bytes_asm},
|
|
// {{"WRITE DEC ASM", "WRITE DEC ASM WITH MALLOC"},
|
|
// test_write_dec_all_bytes_asm},
|
|
// {{"READ", "READ WITH MALLOC"}, test_read},
|
|
// {{"FREAD", "FREAD WITH MALLOC"}, test_fread},
|
|
// {{"ALIGN 64", "ALIGN 64 WITH MALLOC"}, test_align64_loop},
|
|
// {{"ALIGN 1", "ALIGN 1 WITH MALLOC"}, test_align1_loop},
|
|
// {{"ALIGN 15", "ALIGN 15 WITH MALLOC"}, test_align15_loop},
|
|
// {{"ALIGN 31", "ALIGN 31 WITH MALLOC"}, test_align31_loop},
|
|
// {{"ALIGN 63", "ALIGN 63 WITH MALLOC"}, test_align63_loop},
|
|
// {{"ALIGN 75", "ALIGN 75 WITH MALLOC"}, test_align75_loop},
|
|
// {{"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},
|
|
// {{"READ 1", "READ 1 WITH MALLOC"}, test_read_1},
|
|
// {{"READ 2", "READ 2 WITH MALLOC"}, test_read_2},
|
|
// {{"READ 3", "READ 3 WITH MALLOC"}, test_read_3},
|
|
// {{"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 3", "WRITE 3 WITH MALLOC"}, test_write_3},
|
|
// {{"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},
|
|
{{"READ 4x2_simd", "READ 4x2_simd WITH MALLOC"}, test_read_4x2_simd},
|
|
{{"READ 8x2_simd", "READ 8x2_simd WITH MALLOC"}, test_read_8x2_simd},
|
|
{{"READ 16x2_simd", "READ 16x2_simd WITH MALLOC"}, test_read_16x2_simd},
|
|
{{"READ 32x2_simd_offset", "READ 32x2_simd_offset WITH MALLOC"},
|
|
test_read_32x2_simd_offset},
|
|
{{"READ 32x2_simd_no_offset", "READ 32x2_simd_no_offset WITH MALLOC"},
|
|
test_read_32x2_simd_no_offset},
|
|
{{"READ 16x4_simd", "READ 16x4_simd WITH MALLOC"}, test_read_16x4_simd},
|
|
{{"READ 32x4_simd", "READ 32x4_simd WITH MALLOC"}, test_read_32x4_simd},
|
|
};
|
|
|
|
tester.params.read_size = get_file_length(fp);
|
|
tester.params.read_count = 1;
|
|
tester.params.buffer = (char *)malloc(tester.params.read_size + 1);
|
|
memset(tester.params.buffer, 0, tester.params.read_size + 1);
|
|
|
|
for (u64 i = 0; i < waves; ++i) {
|
|
for (u64 j = 0; j < ARR_LEN(funcs); ++j) {
|
|
for (u64 k = 0; k < ALLOC_TYPE_WITH_MALLOC; ++k) {
|
|
run_func_test(&tester, funcs[j].func, funcs[j].names[k], (alloc_type)k);
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
free(tester.params.buffer);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void test_fread(reptester *tester, alloc_type type) {
|
|
FILE *fp = fopen(tester->params.filename, "rb");
|
|
if (!fp) {
|
|
return;
|
|
}
|
|
|
|
u64 start = read_cpu_timer();
|
|
u64 fault_count_start = page_fault_count();
|
|
|
|
handle_alloc(tester, type);
|
|
|
|
u64 obj_count = fread(tester->params.buffer, tester->params.read_size,
|
|
tester->params.read_count, fp);
|
|
|
|
u64 fault_count_end = page_fault_count();
|
|
u64 end = read_cpu_timer();
|
|
|
|
u64 bytes_read = obj_count * tester->params.read_size;
|
|
|
|
u64 read_time = end - start;
|
|
u64 page_faults = fault_count_end - fault_count_start;
|
|
|
|
tester->results = {
|
|
bytes_read,
|
|
read_time,
|
|
page_faults,
|
|
};
|
|
|
|
handle_free(tester, type);
|
|
|
|
fclose(fp);
|
|
}
|
|
|
|
void test_read(reptester *tester, alloc_type type) {
|
|
FILE *fp = fopen(tester->params.filename, "rb");
|
|
if (!fp) {
|
|
return;
|
|
}
|
|
|
|
u64 start = read_cpu_timer();
|
|
u64 fault_count_start = page_fault_count();
|
|
|
|
handle_alloc(tester, type);
|
|
|
|
i32 fd = fileno(fp);
|
|
|
|
u64 bytes_read = read(fd, tester->params.buffer,
|
|
tester->params.read_size * tester->params.read_count);
|
|
|
|
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 = {
|
|
bytes_read,
|
|
read_time,
|
|
page_faults,
|
|
};
|
|
|
|
handle_free(tester, type);
|
|
|
|
fclose(fp);
|
|
}
|
|
|
|
void write_to_all_bytes(char *buffer, u64 size) {
|
|
for (u64 i = 0; i < size; ++i) {
|
|
buffer[i] = i;
|
|
}
|
|
}
|
|
|
|
void test_write(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_to_all_bytes(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_mov_all_bytes_asm(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;
|
|
|
|
mov_all_bytes_asm(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_nop_all_bytes_asm(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;
|
|
|
|
nop_all_bytes_asm(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_nop_1x3_all_bytes_asm(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;
|
|
|
|
nop_1x3_all_bytes_asm(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_nop_1x9_all_bytes_asm(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;
|
|
|
|
nop_1x9_all_bytes_asm(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_inc_all_bytes_asm(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;
|
|
|
|
inc_all_bytes_asm(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_dec_all_bytes_asm(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;
|
|
|
|
dec_all_bytes_asm(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_align64_loop(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;
|
|
|
|
align64_loop(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_align1_loop(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;
|
|
|
|
align1_loop(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_align15_loop(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;
|
|
|
|
align15_loop(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_align31_loop(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;
|
|
|
|
align31_loop(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_align63_loop(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;
|
|
|
|
align63_loop(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_align75_loop(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;
|
|
|
|
align75_loop(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_align90_loop(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;
|
|
|
|
align90_loop(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_align112_loop(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;
|
|
|
|
align112_loop(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_rat_add(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;
|
|
|
|
rat_add(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_rat_mov_add(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;
|
|
|
|
rat_mov_add(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_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_3(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_3(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_3(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_3(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);
|
|
}
|
|
|
|
void test_read_4x2_simd(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_simd(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_simd(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_simd(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_16x2_simd(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_16x2_simd(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_32x2_simd_offset(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_32x2_simd_offset(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_32x2_simd_no_offset(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_32x2_simd_no_offset(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_16x4_simd(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_16x4_simd(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_32x4_simd(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_32x4_simd(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) {
|
|
return 0;
|
|
}
|
|
|
|
fseek(fp, 0, SEEK_END);
|
|
|
|
u64 length = ftell(fp);
|
|
|
|
fseek(fp, 0, SEEK_SET);
|
|
|
|
return length;
|
|
}
|