Andrew Haynes
96 lines
2.8 KiB
C
96 lines
2.8 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
typedef struct {
|
|
char* arr;
|
|
size_t size;
|
|
} Vec8_t;
|
|
|
|
Vec8_t create(size_t init_size) {
|
|
Vec8_t vec = { .arr = nullptr, .size = 0 };
|
|
if (init_size > 0) {
|
|
vec.arr = malloc(init_size * sizeof(char));
|
|
vec.size = init_size;
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
void delete(Vec8_t* vec) {
|
|
if (vec->arr != nullptr) free(vec->arr);
|
|
vec->arr = nullptr;
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
size_t count = 100000000; // 100M
|
|
int vec_count = 1;
|
|
|
|
if (argc > 1) count = atoll(argv[1]);
|
|
if (argc > 2) vec_count = atoi(argv[2]);
|
|
|
|
size_t total = count * (size_t)vec_count;
|
|
printf("=== Direct Allocation Memory Test ===\n");
|
|
printf("Elements per vector: %zu\n", count);
|
|
printf("Number of vectors: %d\n", vec_count);
|
|
printf("Total elements: %zu\n", total);
|
|
printf("Total memory: %.1f GB\n", (total * sizeof(char)) / (1024.0 * 1024.0 * 1024.0));
|
|
printf("\n");
|
|
|
|
struct timespec start, end;
|
|
Vec8_t* vecs = malloc(vec_count * sizeof(Vec8_t));
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
|
|
printf("Allocating %d vectors of %zu elements each...\n", vec_count, count);
|
|
for (int v = 0; v < vec_count; v++) {
|
|
vecs[v] = create(count);
|
|
if (vecs[v].arr == nullptr) {
|
|
printf(" ERROR: Failed to allocate vector %d!\n", v);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
double alloc_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
|
|
printf("Allocation time: %.2f seconds\n", alloc_time);
|
|
|
|
printf("\nFilling vectors...\n");
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
|
|
for (int v = 0; v < vec_count; v++) {
|
|
for (size_t i = 0; i < count; i++) {
|
|
vecs[v].arr[i] = (char)(i % 256);
|
|
}
|
|
}
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
double fill_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
|
|
printf("Fill time: %.2f seconds\n", fill_time);
|
|
|
|
printf("\nVerifying...\n");
|
|
int errors = 0;
|
|
for (int v = 0; v < vec_count; v++) {
|
|
if (vecs[v].size != count) errors++;
|
|
if (vecs[v].arr[0] != 0) errors++;
|
|
if (vecs[v].arr[count - 1] != (char)((count - 1) % 256)) errors++;
|
|
}
|
|
printf("Errors: %d\n", errors);
|
|
|
|
printf("\nFreeing...\n");
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
for (int v = 0; v < vec_count; v++) {
|
|
delete(&vecs[v]);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
double free_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
|
|
printf("Free time: %.2f seconds\n", free_time);
|
|
|
|
free(vecs);
|
|
|
|
printf("\n=== Complete ===\n");
|
|
printf("Total time: %.2f seconds\n", alloc_time + fill_time + free_time);
|
|
|
|
return errors > 0 ? 1 : 0;
|
|
}
|