84 lines
2.8 KiB
C
84 lines
2.8 KiB
C
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <assert.h>
|
|
|
|
// Define the number of iterations for the benchmark
|
|
#define ARRAY_SIZE 50000000 // 50 Million random data points
|
|
|
|
size_t align_up(size_t value, size_t align)
|
|
{
|
|
size_t remainder = value % align;
|
|
if (remainder == 0)
|
|
return value;
|
|
return value + (align - remainder);
|
|
}
|
|
|
|
size_t align_arithmetic(size_t value, size_t alignment)
|
|
{
|
|
return ((value + alignment - 1) / alignment) * alignment;
|
|
}
|
|
|
|
size_t align_bitwise(size_t value, size_t alignment)
|
|
{
|
|
// TODO: assumendo che alignment è una potenza di 2
|
|
return (value + alignment - 1) & ~(alignment - 1);
|
|
}
|
|
|
|
void benchmark(const char *name,
|
|
size_t (*func)(size_t, size_t),
|
|
size_t alignment,
|
|
const size_t *data_array,
|
|
long long num_elements)
|
|
{
|
|
clock_t start, end;
|
|
double cpu_time_used;
|
|
size_t result_checksum = 0;
|
|
|
|
start = clock();
|
|
for (long long i = 0; i < num_elements; i++) {
|
|
result_checksum += func(data_array[i], alignment);
|
|
}
|
|
end = clock();
|
|
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
|
|
printf(" %-30s: %.4f seconds (Checksum: %zu)\n", name, cpu_time_used, result_checksum);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
size_t alignment_pot = 16;
|
|
size_t alignment_non_pot = 7;
|
|
|
|
printf("Generating %lld random input values...\n", (long long)ARRAY_SIZE);
|
|
srand((unsigned int)time(NULL));
|
|
size_t *random_data = (size_t *)malloc(ARRAY_SIZE * sizeof(size_t));
|
|
if (random_data == NULL) {
|
|
fprintf(stderr, "Memory allocation failed!\n");
|
|
return 1;
|
|
}
|
|
for (long long i = 0; i < ARRAY_SIZE; i++) {
|
|
// pseudo-random values up to 1MB
|
|
random_data[i] = rand() % (1024 * 1204);
|
|
}
|
|
printf("Data generation complete. \n\n");
|
|
printf("--- Alignment Function Stress Benchmark (%lld Random Inputs) --\n\n", (long long)ARRAY_SIZE);
|
|
|
|
// ================================== SCENARIO 1: Power-of-Two Alignment ======================
|
|
printf("Scenario 1: Alignment = %zu (Power of Two, Stress Test)\n", alignment_pot);
|
|
|
|
benchmark("1. Bitwise (PoT Specialized)", align_bitwise, alignment_pot, random_data, ARRAY_SIZE);
|
|
benchmark("2. Arithmetic (General)", align_arithmetic, alignment_pot, random_data, ARRAY_SIZE);
|
|
benchmark("3. Modulo (General)", align_up, alignment_pot, random_data, ARRAY_SIZE);
|
|
|
|
// ================================== SCENARIO 2: Non-Power-of-Two Alignment ======================
|
|
printf("Scenario 2: Alignment = %zu (Non-Power of Two, Stress Test)\n", alignment_non_pot);
|
|
|
|
//benchmark("1. Bitwise (PoT Specialized)", align_bitwise, alignment_pot, random_data, ARRAY_SIZE);
|
|
benchmark("2. Arithmetic (General)", align_arithmetic, alignment_non_pot, random_data, ARRAY_SIZE);
|
|
benchmark("3. Modulo (General)", align_up, alignment_non_pot, random_data, ARRAY_SIZE);
|
|
|
|
free(random_data);
|
|
return 0;
|
|
}
|