Function runPerlinBenchmark

examples/AutoResearch/AutoResearchAnimartrixBench.h:44–123

Sweep a 2D coordinate grid the same way an Animartrix render pass would (one Perlin lookup per output pixel). 16*16 = 256 pixels per outer iter, matching a 16x16 panel — small enough that the compiler won't unroll the world, large enough that any per-iteration fixed overhead is amortized.

// won't unroll the world, large enough that any per-iteration fixed
// overhead is amortized.
inline PerlinBenchResult runPerlinBenchmark(int iters) {
    PerlinBenchResult r;
    r.iterations = iters;

    // Init the i16 implementation's fade lookup table once, off the
    // benchmark clock. Function-local static so the linter's
    // static-in-header rule stays happy and C++11's thread-safe init
    // guarantees a single initialization across calls. The float path
    // has no equivalent setup.
    struct FadeLut {
        int32_t table[257];
        FadeLut() { fl::perlin_i16_optimized::init_fade_lut(table); }
    };
    static const FadeLut fade_lut_holder;  // C++11 magic statics
    const int32_t* fade_lut = fade_lut_holder.table;

    constexpr int GRID = 16;          // 16x16 pixel pass per iteration
    constexpr float STEP_F = 0.05f;   // Animartrix-typical pixel step in noise space
    // Mirror in fixed-point: 0.05 in Q16.16 = 0.05 * 65536 ≈ 3277
    constexpr int32_t STEP_I = static_cast<int32_t>(0.05f * 65536.0f);

    // ── Float pnoise ──────────────────────────────────────────────
    {
        float ax = 0.0f, ay = 0.0f;
        int32_t sink = 0;
        uint32_t t0 = micros();
        for (int it = 0; it < iters; it++) {
            // Slowly drift the origin across the iter so the compiler
            // can't pre-compute. Same pattern Animartrix uses (the
            // origin advances with `time_speed * dt` each frame).
            ax += 0.011f;
            ay += 0.013f;
            for (int row = 0; row < GRID; row++) {
                float y = ay + row * STEP_F;
                for (int col = 0; col < GRID; col++) {
                    float x = ax + col * STEP_F;
                    float n = fl::pnoise(x, y, 0.0f);
                    // Map [-1, 1] → int8 the way Animartrix's output
                    // stage does. Sink to defeat DCE.
                    sink += static_cast<int32_t>(n * 127.0f);
                }
            }
        }
        uint32_t t1 = micros();
        g_animartrix_bench_sink = sink;
        r.pnoise_float_us = static_cast<int64_t>(t1 - t0);
    }

    // ── i16 fixed-point pnoise2d ──────────────────────────────────
    {
        int32_t ax_i = 0, ay_i = 0;
        // Q16.16 increment for the slow drift (matches 0.011, 0.013 in float)
        constexpr int32_t DRIFT_X = static_cast<int32_t>(0.011f * 65536.0f);
        constexpr int32_t DRIFT_Y = static_cast<int32_t>(0.013f * 65536.0f);
        int32_t sink = 0;
        uint32_t t0 = micros();
        for (int it = 0; it < iters; it++) {
            ax_i += DRIFT_X;