156 lines
No EOL
3.5 KiB
C
156 lines
No EOL
3.5 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_
|
|
|
|
BgcAffine3FP32* _create_bgc_affine3_list(int affine_amount)
|
|
{
|
|
BgcAffine3FP32* affines = malloc(affine_amount * sizeof(BgcAffine3FP32));
|
|
|
|
if (affines == 0) {
|
|
return 0;
|
|
}
|
|
|
|
for (int i = 0; i < affine_amount; i++) {
|
|
bgc_affine3_reset_fp32(&affines[i]);
|
|
}
|
|
|
|
return affines;
|
|
}
|
|
|
|
float get_random_value_fp32()
|
|
{
|
|
return rand() * (2.0f / RAND_MAX) - 1.0f;
|
|
}
|
|
|
|
BgcAffine3FP32* _create_bgc_affine3_random_list(int affine_amount)
|
|
{
|
|
BgcAffine3FP32* affines = malloc(affine_amount * sizeof(BgcAffine3FP32));
|
|
|
|
if (affines == 0) {
|
|
return 0;
|
|
}
|
|
|
|
BgcPosition3FP32 position;
|
|
|
|
for (int i = 0; i < affine_amount; i++) {
|
|
bgc_versor_set_values_fp32(
|
|
get_random_value_fp32(),
|
|
get_random_value_fp32(),
|
|
get_random_value_fp32(),
|
|
get_random_value_fp32(),
|
|
&position.turn
|
|
);
|
|
|
|
position.shift.x1 = get_random_value_fp32();
|
|
position.shift.x2 = get_random_value_fp32();
|
|
position.shift.x3 = get_random_value_fp32();
|
|
|
|
bgc_position3_get_affine3_map_fp32(&position, &affines[i]);
|
|
}
|
|
|
|
return affines;
|
|
}
|
|
|
|
BgcVector3FP32* _create_bgc_vector3_list(int amount)
|
|
{
|
|
return malloc(amount * sizeof(BgcVector3FP32));
|
|
}
|
|
|
|
BgcVector3FP32* _create_bgc_vector3_random_list(int amount)
|
|
{
|
|
BgcVector3FP32* 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)
|
|
{
|
|
BgcAffine3FP32* affines;
|
|
BgcVector3FP32* source_vectors;
|
|
BgcVector3FP32* 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_affine3_transform_point_fp32(&affines[i], &source_vectors[vector_index], &result_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;
|
|
} |