156 lines
3.6 KiB
C
156 lines
3.6 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <basic-geometry.h>
|
|
#include "affine3.h"
|
|
|
|
#ifdef _WIN64
|
|
#include <windows.h>
|
|
#else
|
|
#include <time.h>
|
|
#endif // _WINDOWS_
|
|
|
|
BGC_FP32_Affine3* _create_bgc_affine3_list(int affine_amount)
|
|
{
|
|
BGC_FP32_Affine3* affines = malloc(affine_amount * sizeof(BGC_FP32_Affine3));
|
|
|
|
if (affines == 0) {
|
|
return 0;
|
|
}
|
|
|
|
for (int i = 0; i < affine_amount; i++) {
|
|
bgc_fp32_affine3_reset(&affines[i]);
|
|
}
|
|
|
|
return affines;
|
|
}
|
|
|
|
float get_random_value_fp32()
|
|
{
|
|
return rand() * (2.0f / RAND_MAX) - 1.0f;
|
|
}
|
|
|
|
BGC_FP32_Affine3* _create_bgc_affine3_random_list(int affine_amount)
|
|
{
|
|
BGC_FP32_Affine3* affines = malloc(affine_amount * sizeof(BGC_FP32_Affine3));
|
|
|
|
if (affines == 0) {
|
|
return 0;
|
|
}
|
|
|
|
BGC_FP32_Position3 position;
|
|
|
|
for (int i = 0; i < affine_amount; i++) {
|
|
bgc_fp32_versor_make(
|
|
&position.turn,
|
|
get_random_value_fp32(),
|
|
get_random_value_fp32(),
|
|
get_random_value_fp32(),
|
|
get_random_value_fp32()
|
|
);
|
|
|
|
position.shift.x1 = get_random_value_fp32();
|
|
position.shift.x2 = get_random_value_fp32();
|
|
position.shift.x3 = get_random_value_fp32();
|
|
|
|
bgc_fp32_position3_get_outward_affine(&affines[i], &position);
|
|
}
|
|
|
|
return affines;
|
|
}
|
|
|
|
BGC_FP32_Vector3* _create_bgc_vector3_list(int amount)
|
|
{
|
|
return malloc(amount * sizeof(BGC_FP32_Vector3));
|
|
}
|
|
|
|
BGC_FP32_Vector3* _create_bgc_vector3_random_list(int amount)
|
|
{
|
|
BGC_FP32_Vector3* vectors = _create_bgc_vector3_list(amount);
|
|
|
|
if (vectors == 0) {
|
|
return 0;
|
|
}
|
|
|
|
for (int i = 0; i < amount; i++) {
|
|
vectors[i].x1 = get_random_value_fp32();
|
|
vectors[i].x2 = get_random_value_fp32();
|
|
vectors[i].x3 = get_random_value_fp32();
|
|
}
|
|
|
|
return vectors;
|
|
}
|
|
|
|
float test_bgc_affine3_performance(int affine_amount, int vector_per_affine)
|
|
{
|
|
BGC_FP32_Affine3* affines;
|
|
BGC_FP32_Vector3* source_vectors;
|
|
BGC_FP32_Vector3* result_vectors;
|
|
|
|
int vector_index = 0;
|
|
float time = -1.0f;
|
|
|
|
#ifdef _WIN64
|
|
ULONGLONG start, end;
|
|
|
|
start = GetTickCount64();
|
|
|
|
srand((unsigned int)(start & 0xfffffff));
|
|
#else
|
|
struct timespec start, end;
|
|
clock_gettime(0, &start);
|
|
srand((unsigned int)(start.tv_nsec & 0xfffffff));
|
|
#endif // _WIN64
|
|
|
|
affines = _create_bgc_affine3_random_list(affine_amount);
|
|
|
|
if (affines == 0) {
|
|
return time;
|
|
}
|
|
|
|
source_vectors = _create_bgc_vector3_random_list(affine_amount * vector_per_affine);
|
|
|
|
if (source_vectors == 0) {
|
|
free(affines);
|
|
return time;
|
|
}
|
|
|
|
result_vectors = _create_bgc_vector3_list(affine_amount * vector_per_affine);
|
|
|
|
if (result_vectors == 0) {
|
|
free(source_vectors);
|
|
free(affines);
|
|
return time;
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
start = GetTickCount64();
|
|
#else
|
|
clock_gettime(CLOCK_REALTIME, &start);
|
|
#endif // _WIN64
|
|
|
|
for (int i = 0; i < affine_amount; i++)
|
|
{
|
|
for (int j = 0; j < vector_per_affine; j++) {
|
|
bgc_fp32_affine3_transform_point(&result_vectors[vector_index], &affines[i], &source_vectors[vector_index]);
|
|
vector_index++;
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
end = GetTickCount64();
|
|
|
|
time = (end - start) * 0.001f;
|
|
#else
|
|
clock_gettime(CLOCK_REALTIME, &end);
|
|
|
|
time = (float)(end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) * 0.000000001f;
|
|
#endif // _WIN64
|
|
|
|
printf("Result vector [0] = (%f, %f, %f)\n", result_vectors[0].x1, result_vectors[0].x2, result_vectors[0].x3);
|
|
|
|
free(result_vectors);
|
|
free(source_vectors);
|
|
free(affines);
|
|
|
|
return time;
|
|
}
|