runPerlinBenchmark()

PerlinBenchResult autoresearch::animartrix_check::runPerlinBenchmark ( int iters )

inline

Definition at line 57 of file AutoResearchAnimartrixBench.h.

                                                       {
    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.
    PerlinBenchState& state = perlinBenchState();
    const int32_t* fade_lut = state.fade_lut;
 
    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 = fl::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 = fl::micros();
        state.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 = fl::micros();
        for (int it = 0; it < iters; it++) {
            ax_i += DRIFT_X;
            ay_i += DRIFT_Y;
            for (int row = 0; row < GRID; row++) {
                int32_t y_i = ay_i + row * STEP_I;
                for (int col = 0; col < GRID; col++) {
                    int32_t x_i = ax_i + col * STEP_I;
                    // pnoise2d_raw returns i32 Q16.16. Scale to int8
                    // the same way the float path does — divide by
                    // (HP_ONE / 127) so the magnitudes line up.
                    int32_t n = fl::perlin_i16_optimized::pnoise2d_raw(
                        x_i, y_i, fade_lut, fl::PERLIN_NOISE);
                    sink += n >> 9;   // crude scale; the actual op cost,
                                       // not the value, is what we measure
                }
            }
        }
        uint32_t t1 = fl::micros();
        state.sink = sink;
        r.pnoise_i16_us = static_cast<int64_t>(t1 - t0);
    }
 
    return r;
}

References autoresearch::animartrix_check::PerlinBenchResult::iterations, fl::micros(), perlinBenchState(), fl::pnoise(), fl::perlin_i16_optimized::pnoise2d_raw(), autoresearch::animartrix_check::PerlinBenchResult::pnoise_float_us, autoresearch::animartrix_check::PerlinBenchResult::pnoise_i16_us, state, x, and y.

Here is the call graph for this function: