136 lines
4.3 KiB
C++
136 lines
4.3 KiB
C++
#include "tenvex.h"
|
|
|
|
#include <benchmark/benchmark.h>
|
|
|
|
#include <vector>
|
|
#include <random>
|
|
#include <smmintrin.h>
|
|
|
|
using namespace tnvx;
|
|
|
|
// Runtime data so nothing folds to a compile-time constant.
|
|
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;
|
|
}
|
|
|
|
// =====================================================================
|
|
// LATENCY: each iteration depends on the previous result (serial chain).
|
|
// This is the metric for scattered everyday math: the result is needed
|
|
// before moving on.
|
|
// =====================================================================
|
|
static void BM_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 }; // depends on previous result
|
|
float d = dot3(a, bb);
|
|
acc = d * 1e-7f; // feedback = dependency chain
|
|
benchmark::DoNotOptimize(acc);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Dot3_Latency);
|
|
|
|
static void BM_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 }; // chain through v
|
|
benchmark::DoNotOptimize(v);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Norm3_Latency);
|
|
|
|
// =====================================================================
|
|
// THROUGHPUT: independent inputs, no cross-iteration dependency, so the
|
|
// CPU can pipeline. Contrast to latency.
|
|
// =====================================================================
|
|
static void BM_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_Dot3_Throughput);
|
|
|
|
// =====================================================================
|
|
// Compound expression: tenvex vs hand-written intrinsics.
|
|
// If the numbers are roughly equal, the abstraction is zero-cost.
|
|
// =====================================================================
|
|
static void BM_Compound_tenvex(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_Compound_tenvex);
|
|
|
|
static __m128 dp3_raw(__m128 a, __m128 b) { return _mm_dp_ps(a, b, 0x7F); }
|
|
|
|
static __m128 norm3_raw(__m128 v)
|
|
{
|
|
__m128 len = _mm_sqrt_ps(dp3_raw(v, v));
|
|
return _mm_blend_ps(_mm_div_ps(v, len), v, 0b1000);
|
|
}
|
|
|
|
static void BM_Compound_intrinsics(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)
|
|
{
|
|
__m128 a = va[i].eval(), b = vb[i].eval(), c = vc[i].eval();
|
|
__m128 t = norm3_raw(_mm_add_ps(a, _mm_mul_ps(b, _mm_set1_ps(2.0f))));
|
|
__m128 d = dp3_raw(b, c);
|
|
__m128 r = _mm_add_ps(_mm_mul_ps(t, d), _mm_mul_ps(c, _mm_set1_ps(3.0f)));
|
|
benchmark::DoNotOptimize(r);
|
|
i = (i + 1) & 1023;
|
|
}
|
|
}
|
|
BENCHMARK(BM_Compound_intrinsics);
|
|
|
|
// =====================================================================
|
|
// Gameplay-style query: do two units face roughly the same way?
|
|
// Latency-bound - the answer is needed before branching on it.
|
|
// =====================================================================
|
|
static void BM_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_FacingSameWay);
|