How to Retrieve BVH Size in OptiX?

Gaming and Visualization Technologies Visualization OptiX
1

Hello,

I’ve been experimenting with OptiX and trying to retrieve the size of a BVH (Bounding Volume Hierarchy) structure after it’s been built. I came across some discussions where developers mentioned the build time and memory usage of different primitives used to construct BVH trees, but I couldn’t find a direct method for retrieving the size of the BVH in OptiX.

Could anyone please share the recommended method to get the size of a BVH in OptiX? Is there a function that directly provides this information, or is it something that needs to be estimated using specific calculations?

Thank you in advance for your assistance!

2

Hi @Thomas_pzm_21, welcome!

The final size of a BVH in OptiX is calculated during the BVH build, and can be emitting as a property of the build. This will allow you to allocate a smaller buffer, move your BVH, and release the initial buffer that is slightly oversized, if you want. We call this process ‘compaction’, and you can find examples of it in the OptiX SDK. You can find more info in the OptiX Programming Guide’s section on compacting acceleration structures.

Here’s a code snippet from optixPathTracer demonstrating how to get the final BVH size, which is stored in the variable compacted_gas_size. I’ve included the call to optixAccelCompact after the final size is queried, just to show the context.

    OptixAccelEmitDesc emitProperty = {};
    emitProperty.type               = OPTIX_PROPERTY_TYPE_COMPACTED_SIZE;
    emitProperty.result             = ( CUdeviceptr )( (char*)d_buffer_temp_output_gas_and_compacted_size + compactedSizeOffset );

    OPTIX_CHECK( optixAccelBuild(
                state.context,
                0,                                  // CUDA stream
                &accel_options,
                &triangle_input,
                1,                                  // num build inputs
                d_temp_buffer,
                gas_buffer_sizes.tempSizeInBytes,
                d_buffer_temp_output_gas_and_compacted_size,
                gas_buffer_sizes.outputSizeInBytes,
                &state.gas_handle,
                &emitProperty,                      // emitted property list
                1                                   // num emitted properties
                ) );

    CUDA_CHECK( cudaFree( reinterpret_cast<void*>( d_temp_buffer ) ) );
    CUDA_CHECK( cudaFree( reinterpret_cast<void*>( d_mat_indices ) ) );

    size_t compacted_gas_size;
    CUDA_CHECK( cudaMemcpy( &compacted_gas_size, (void*)emitProperty.result, sizeof(size_t), cudaMemcpyDeviceToHost ) );

    if( compacted_gas_size < gas_buffer_sizes.outputSizeInBytes )
    {
        CUDA_CHECK( cudaMalloc( reinterpret_cast<void**>( &state.d_gas_output_buffer ), compacted_gas_size ) );

        // use handle as input and output
        OPTIX_CHECK( optixAccelCompact( state.context, 0, state.gas_handle, state.d_gas_output_buffer, compacted_gas_size, &state.gas_handle ) );

        CUDA_CHECK( cudaFree( (void*)d_buffer_temp_output_gas_and_compacted_size ) );
    }
    else
    {
        state.d_gas_output_buffer = d_buffer_temp_output_gas_and_compacted_size;
    }

–
David.

3

Thanks a lot! That has solved my problem. Very helpful.