93 lines
2.2 KiB
C++
93 lines
2.2 KiB
C++
#include "naive_vec4.h"
|
|
|
|
#include <benchmark/benchmark.h>
|
|
|
|
#include <vector>
|
|
#include <random>
|
|
|
|
using namespace naive;
|
|
|
|
// File-local; mirrors make_vecs from bench_vec4.cpp with the same seed,
|
|
// so the naive and tenvex benchmarks run on identical input data.
|
|
static std::vector<vec4> make_vecs(int n, unsigned seed)
|
|
{
|
|
std::mt19937 rng(seed);
|
|
std::uniform_real_distribution<float> d(-1.0f, 1.0f);
|
|
std::vector<vec4> v;
|
|
v.reserve(n);
|
|
for (int i = 0; i < n; ++i)
|
|
v.push_back(vec4 { d(rng), d(rng), d(rng), 0.0f });
|
|
return v;
|
|
}
|
|
|
|
static void BM_Naive_Dot3_Latency(benchmark::State& state)
|
|
{
|
|
vec4 a { 1.0f, 2.0f, 3.0f, 0.0f };
|
|
vec4 b { 0.5f, 0.5f, 0.5f, 0.0f };
|
|
float acc = 0.0f;
|
|
for (auto _ : state)
|
|
{
|
|
vec4 bb = b + vec4 { acc, 0.0f, 0.0f, 0.0f };
|
|
float d = dot3(a, bb);
|
|
acc = d * 1e-7f;
|
|
benchmark::DoNotOptimize(acc);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Naive_Dot3_Latency);
|
|
|
|
static void BM_Naive_Norm3_Latency(benchmark::State& state)
|
|
{
|
|
vec4 v { 1.0f, 2.0f, 3.0f, 1.0f };
|
|
for (auto _ : state)
|
|
{
|
|
v = norm3(v) + vec4 { 1e-3f, 2e-3f, 3e-3f, 0.0f };
|
|
benchmark::DoNotOptimize(v);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Naive_Norm3_Latency);
|
|
|
|
static void BM_Naive_Dot3_Throughput(benchmark::State& state)
|
|
{
|
|
const auto a = make_vecs(1024, 1);
|
|
const auto b = make_vecs(1024, 2);
|
|
std::size_t i = 0;
|
|
for (auto _ : state)
|
|
{
|
|
float d = dot3(a[i], b[i]);
|
|
benchmark::DoNotOptimize(d);
|
|
i = (i + 1) & 1023;
|
|
}
|
|
}
|
|
BENCHMARK(BM_Naive_Dot3_Throughput);
|
|
|
|
static void BM_Naive_Compound(benchmark::State& state)
|
|
{
|
|
const auto va = make_vecs(1024, 1);
|
|
const auto vb = make_vecs(1024, 2);
|
|
const auto vc = make_vecs(1024, 3);
|
|
std::size_t i = 0;
|
|
for (auto _ : state)
|
|
{
|
|
vec4 r = norm3(va[i] + vb[i] * 2.0f) * dot3(vb[i], vc[i]) + vc[i] * 3.0f;
|
|
benchmark::DoNotOptimize(r);
|
|
i = (i + 1) & 1023;
|
|
}
|
|
}
|
|
BENCHMARK(BM_Naive_Compound);
|
|
|
|
static void BM_Naive_FacingSameWay(benchmark::State& state)
|
|
{
|
|
vec4 fa = norm3(vec4 { 1.0f, 0.0f, 0.2f, 0.0f });
|
|
vec4 fb = vec4 { 0.9f, 0.1f, 0.1f, 0.0f };
|
|
float jitter = 0.0f;
|
|
for (auto _ : state)
|
|
{
|
|
vec4 f = norm3(fb + vec4 { jitter, 0.0f, 0.0f, 0.0f });
|
|
float c = dot3(fa, f);
|
|
bool same = c > 0.95f;
|
|
jitter = c * 1e-6f;
|
|
benchmark::DoNotOptimize(same);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Naive_FacingSameWay);
|