Function bench_lookup_sample

tools/openpgl_bench/openpgl_bench.cpp:357–431

}

void bench_lookup_sample(BenchParams &benchParams, bool applyCosine, bool sample)
{
    int nThreads = benchParams.num_threads;
    int nRepetitions = 10;

    int num_threads = 0;  // tbb::info::default_concurrency();
    if (nThreads > 0)
    {
        num_threads = nThreads;
    }
    tbb::global_control global_limit(tbb::global_control::max_allowed_parallelism, num_threads);
    std::cout << "num_threads = " << num_threads << std::endl;

    openpgl::cpp::Device device(benchParams.device_type);
    openpgl::cpp::Field field(&device, benchParams.field_file_name);
    openpgl::cpp::SampleStorage sampleStorage(benchParams.samples_file_names[0]);

    std::cout << "Field::Validate: " << field.Validate() << std::endl;

    int nSurfaceSamples = sampleStorage.GetSizeSurface();

    std::cout << "Prepare Data: START" << std::endl;
    std::mt19937_64 gen(1337);
    std::uniform_real_distribution<float> distU(0.f, 1.f);

    float *samplesSurfaceU = new float[nSurfaceSamples];
    pgl_vec2f *samplesSurfaceDirectionUV = new pgl_vec2f[nSurfaceSamples];
    pgl_vec3f *sampleSurfaceNormal = new pgl_vec3f[nSurfaceSamples];
    pgl_vec3f *sampleSurfaceSampledDirection = new pgl_vec3f[nSurfaceSamples];
    pgl_vec3f *positionsSurface = new pgl_vec3f[nSurfaceSamples];

    for (int i = 0; i < nSurfaceSamples; i++)
    {
        int idx = i;
        samplesSurfaceU[idx] = distU(gen);
        samplesSurfaceDirectionUV[idx].x = distU(gen);
        samplesSurfaceDirectionUV[idx].y = distU(gen);
        sampleSurfaceNormal[idx] = squareToUniformSphere(distU(gen), distU(gen));

        openpgl::cpp::SampleData sd = sampleStorage.GetSampleSurface(i);
        positionsSurface[idx] = sd.position;
    }

    std::cout << "Prepare Data: END" << std::endl;

    Timer timer;
    timer.reset();
    int step = nSurfaceSamples / num_threads;
    tbb::parallel_for(tbb::blocked_range<int>(0, num_threads), [&](tbb::blocked_range<int> r) {
        for (int n = r.begin(); n < r.end(); ++n)
        {
            openpgl::cpp::SurfaceSamplingDistribution ssd(&field);
            for (int m = 0; m < nRepetitions; m++)
            {
                int tStep = n * step;
                for (int i = 0; i < nSurfaceSamples; i++)
                {
                    int idx = (i + tStep) % nSurfaceSamples;