Added own camera object and its vectorial dependency.

3rdparty/vectorial/bench/add_bench.cpp

@@ -0,0 +1,60 @@
+
+#include "bench.h"
+#include <stdlib.h>
+
+#include <iostream>
+#include "vectorial/vec4f.h"
+
+#define NUM (81920)
+#define ITER 100
+using namespace vectorial;
+
+namespace {
+    vec4f* alloc_vec4f(size_t n) {
+        void *ptr = memalign(n*sizeof(vec4f), 16);
+        return static_cast<vec4f*>(ptr);
+    }
+}
+
+
+
+static vec4f * a;
+static vec4f * b;
+static vec4f * c;
+
+
+
+
+void add_func() {
+    
+    vec4f* vectorial_restrict aa = a;
+    vec4f* vectorial_restrict bb = b;
+    vec4f* vectorial_restrict cc = c;
+    
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        cc[i] = aa[i] + bb[i];
+    }    
+}
+
+void add_bench() {
+
+    a = alloc_vec4f(NUM);
+    b = alloc_vec4f(NUM);
+    c = alloc_vec4f(NUM);
+
+
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        a[i]=vec4f(i,i,i,i);
+        b[i]=vec4f(NUM-i, NUM-i, NUM-i, NUM-i);
+    }
+        
+    profile("add", add_func, ITER, NUM);
+
+    memfree(a);
+    memfree(b);
+    memfree(c);
+
+
+}

3rdparty/vectorial/bench/bench.cpp

@@ -0,0 +1,117 @@
+#include "bench.h"
+#include <sstream>
+#include <iostream>
+#include "vectorial/config.h"
+
+
+namespace profiler {
+
+    #ifdef BENCH_MACH
+    mach_timebase_info_data_t info;
+    void init() {
+        mach_timebase_info(&info);
+    }
+    #endif
+    
+    #ifdef BENCH_GTOD
+    void init() {
+    }
+    #endif
+
+    #ifdef BENCH_QPC
+    double frequency;
+    void init() {
+        LARGE_INTEGER freq;
+        QueryPerformanceFrequency(&freq);
+        frequency = (double)freq.QuadPart;
+    }
+    #endif
+
+
+    time_t now() {
+
+        #ifdef BENCH_MACH
+        return mach_absolute_time();
+        #endif
+
+        #ifdef BENCH_GTOD
+        time_t v;
+        gettimeofday(&v, NULL);
+        return v;
+        #endif
+        
+        #ifdef BENCH_QPC
+        LARGE_INTEGER v;
+        QueryPerformanceCounter(&v);
+        return v;
+        #endif
+
+    }
+    
+    
+    double diffTime(time_t start, time_t end) {
+        
+        #ifdef BENCH_GTOD
+        return (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec) / 1000000.0;
+        #endif
+        
+        #ifdef BENCH_MACH        
+        return ((end-start) * info.numer / info.denom) / 1000000000.0;
+        #endif
+
+        #ifdef BENCH_QPC
+        return (end.QuadPart - start.QuadPart) / frequency;
+        #endif
+    }
+    
+}
+
+
+std::string formatTime(double d, double relative ) {
+    const double sec   = 1.0;
+    const double milli = 0.001;
+    const double micro = 0.000001;
+    const double nano  = 0.000000001;
+    std::stringstream ss;
+    if( relative < 0.0) relative=d;
+    if( relative >= sec ) ss << d << "s";
+    else if( relative >= milli ) ss << d/milli << "ms";
+    else if( relative >= micro ) ss << d/micro <<"us";
+    else ss << d/nano << "ns";
+    return ss.str();
+}
+
+void profile(const char* name, void (*func)(), int iterations, int elements) {
+    
+    profiler::init();
+    profiler::time_t start = profiler::now();
+    for(int i = 0; i < iterations; ++i)
+    {
+        func();
+    }
+    profiler::time_t end = profiler::now();
+    
+    std::cout << "Using simd: " << VECTORIAL_SIMD_TYPE << std::endl;
+    std::cout << "Testing: " << name << std::endl;
+    std::cout << "Duration " << formatTime(profiler::diffTime(start,end)) << std::endl;
+    std::cout << "Per iter " << formatTime(profiler::diffTime(start,end) / iterations) << std::endl;
+    std::cout << "Per item " << formatTime(profiler::diffTime(start,end) / iterations / elements) << std::endl;
+
+    
+}
+
+void add_bench();
+void dot_bench();
+void quad_bench();
+void matrix_bench();
+
+int main() {
+    
+//    add_bench();
+//    dot_bench();
+//    quad_bench();
+    matrix_bench();
+
+    return 0;
+}
+

3rdparty/vectorial/bench/bench.h

@@ -0,0 +1,65 @@
+#ifndef BENCH_H
+#define BENCH_H
+
+#include <string>
+#include <stdlib.h>
+
+#ifdef __APPLE__
+    #define BENCH_MACH
+    #include <mach/mach_time.h>
+    #include <stdint.h>
+#elif defined(_WIN32)
+    #define BENCH_QPC
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+    #include <malloc.h>
+#else
+    #define BENCH_GTOD
+    #include <sys/time.h>
+#endif
+
+
+static void* memalign(size_t count, size_t align) {
+    #ifdef _WIN32
+    return _aligned_malloc(count,align);
+    #else
+    void *ptr;
+    int e = posix_memalign(&ptr, align, count);
+    //    if( e == EINVAL ) printf("EINVAL posix_memalign\n");
+    //    if( e == ENOMEM ) printf("ENOMEM posix_memalign\n");
+    return ptr;
+    #endif
+}
+
+static void memfree(void* ptr) {
+    #ifdef _WIN32
+    _aligned_free(ptr);
+    #else
+    free(ptr);
+    #endif
+}
+
+namespace profiler {
+
+    #ifdef BENCH_GTOD
+        typedef struct timeval time_t;
+    #endif
+    #ifdef BENCH_MACH
+        typedef const uint64_t time_t;
+    #endif
+    #ifdef BENCH_QPC
+        typedef LARGE_INTEGER time_t;
+    #endif
+
+    void init();
+    time_t now();
+
+    double diffTime(time_t start, time_t end);
+
+}
+
+std::string formatTime(double d, double relative=-1);
+void profile(const char* name, void (*func)(), int iterations, int elements);
+
+
+#endif

3rdparty/vectorial/bench/dot_bench.cpp

@@ -0,0 +1,60 @@
+
+#include "bench.h"
+#include <stdlib.h>
+
+#include <iostream>
+#include "vectorial/vec4f.h"
+
+#define NUM (81920)
+#define ITER 100
+using namespace vectorial;
+
+namespace {
+    vec4f* alloc_vec4f(size_t n) {
+        void *ptr = memalign(n*sizeof(vec4f), 16);
+        return static_cast<vec4f*>(ptr);
+    }    
+}
+
+
+
+static vec4f * a;
+static vec4f * b;
+static float * c;
+
+
+
+
+void dot_func() {
+    
+    vec4f* vectorial_restrict aa = a;
+    vec4f* vectorial_restrict bb = b;
+    float* vectorial_restrict cc = c;
+    
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        cc[i] = dot(aa[i], bb[i]);
+    }    
+}
+
+void dot_bench() {
+
+    a = alloc_vec4f(NUM);
+    b = alloc_vec4f(NUM);
+    c = static_cast<float*>(malloc(NUM * sizeof(float)));
+
+
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        a[i]=vec4f(i,i,i,i);
+        b[i]=vec4f(NUM-i, NUM-i, NUM-i, NUM-i);
+    }
+        
+    profile("dot", dot_func, ITER, NUM);
+
+    memfree(a);
+    memfree(b);
+    memfree(c);
+
+
+}

3rdparty/vectorial/bench/matrix_bench.cpp

@@ -0,0 +1,62 @@
+
+#include "bench.h"
+#include <stdlib.h>
+
+#include <iostream>
+#include "vectorial/simd4x4f.h"
+
+#define NUM (819200)
+#define ITER 100
+//using namespace vectorial;
+
+namespace {
+    simd4x4f* alloc_vec4x4f(size_t n) {
+        void *ptr = memalign(n*sizeof(simd4x4f), 16);
+        return static_cast<simd4x4f*>(ptr);
+    }    
+}
+
+
+
+static simd4x4f * a;
+static simd4x4f * b;
+static simd4x4f * c;
+
+
+
+
+void matrix_func() {
+    
+    simd4x4f* vectorial_restrict aa = a;
+    simd4x4f* vectorial_restrict bb = b;
+    simd4x4f* vectorial_restrict cc = c;
+    
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        simd4x4f_matrix_mul(&aa[i], &bb[i], &bb[i]);
+    }    
+}
+
+void matrix_bench() {
+
+    a = alloc_vec4x4f(NUM);
+    b = alloc_vec4x4f(NUM);
+    c = alloc_vec4x4f(NUM);
+
+
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        simd4f v = simd4f_create(i,i,i,i);
+        simd4f vi = simd4f_create(NUM-i,NUM-i,NUM-i,NUM-i);
+        a[i]=simd4x4f_create(v,v,v,v);
+        b[i]=simd4x4f_create(vi,vi,vi,vi);
+    }
+        
+    profile("matrix mul", matrix_func, ITER, NUM);
+
+    memfree(a);
+    memfree(b);
+    memfree(c);
+
+
+}

3rdparty/vectorial/bench/quad_bench.cpp

@@ -0,0 +1,123 @@
+
+#include "bench.h"
+#include <stdlib.h>
+
+#include <iostream>
+#include "vectorial/simd4x4f.h"
+
+#define NUM (81920)
+#define ITER 100
+//using namespace vectorial;
+
+namespace {
+    simd4x4f* alloc_simd4x4f(size_t n) {
+        void *ptr = memalign(n*sizeof(simd4x4f), 16);
+        return static_cast<simd4x4f*>(ptr);
+    }    
+}
+
+
+
+static simd4x4f * a;
+static simd4x4f * b;
+static simd4x4f * c;
+
+
+
+static simd4x4f add_4x4(SIMD_PARAM(simd4x4f, a), SIMD_PARAM(simd4x4f, b)) {
+    return simd4x4f_create(
+        simd4f_add(a.x, b.x),
+        simd4f_add(a.y, b.y),
+        simd4f_add(a.z, b.z),
+        simd4f_add(a.w, b.w)
+        );
+}
+
+static simd4x4f add_4x4_rp(simd4x4f *a, simd4x4f *b) {
+    return simd4x4f_create(
+        simd4f_add(a->x, b->x),
+        simd4f_add(a->y, b->y),
+        simd4f_add(a->z, b->z),
+        simd4f_add(a->w, b->w)
+        );
+}
+
+
+static void add_4x4_p(simd4x4f *a, simd4x4f *b, simd4x4f *out) {
+    out->x = simd4f_add(a->x, b->x);
+    out->y = simd4f_add(a->y, b->y);
+    out->z = simd4f_add(a->z, b->z);
+    out->w = simd4f_add(a->w, b->w);
+}
+
+
+
+
+void quad_return_func() {
+    
+    
+    simd4x4f* aa = a;
+    simd4x4f* bb = b;
+    simd4x4f* cc = c;
+    
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        bb[i] = add_4x4(aa[i], bb[i]);
+    }    
+}
+
+
+void quad_pointer_func() {
+    
+    simd4x4f* aa = a;
+    simd4x4f* bb = b;
+    simd4x4f* cc = c;
+    
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        add_4x4_p(&aa[i], &bb[i], &bb[i]);
+    }
+    
+
+}
+
+void quad_pointer_return_func() {
+    
+    simd4x4f* aa = a;
+    simd4x4f* bb = b;
+    simd4x4f* cc = c;
+    
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        bb[i] = add_4x4_rp(&aa[i], &bb[i]);
+    }    
+    
+
+}
+
+
+void quad_bench() {
+
+    a = alloc_simd4x4f(NUM);
+    b = alloc_simd4x4f(NUM);
+    c = alloc_simd4x4f(NUM);
+
+
+    for(size_t i = 0; i < NUM; ++i)
+    {
+        simd4f t = simd4f_create(i,i,i,i); 
+        simd4f t2 = simd4f_create(NUM-i,NUM-i,NUM-i,NUM-i); 
+        a[i]=simd4x4f_create(t,t,t,t);
+        b[i]=simd4x4f_create(t2,t2,t2,t2);
+    }
+        
+    profile("quad return-value", quad_return_func, ITER, NUM);
+    profile("quad pass-by-pointer", quad_pointer_func, ITER, NUM);
+    profile("quad pass-by-pointer return-value", quad_pointer_return_func, ITER, NUM);
+
+    memfree(a);
+    memfree(b);
+    memfree(c);
+
+
+}