26ed4d3892
This change switches Cycles to an opensource HIP-RT library which
implements hardware ray-tracing. This library is now used on
both Windows and Linux. While there should be no noticeable changes
on Windows, on Linux this adds support for hardware ray-tracing on
AMD GPUs.
The majority of the change is typical platform code to add new
library to the dependency builder, and a change in the way how
ahead-of-time (AoT) kernels are compiled. There are changes in
Cycles itself, but they are rather straightforward: some APIs
changed in the opensource version of the library.
There are a couple of extra files which are needed for this to
work: hiprt02003_6.1_amd.hipfb and oro_compiled_kernels.hipfb.
There are some assumptions in the HIP-RT library about how they
are available. Currently they follow the same rule as AoT
kernels for oneAPI:
- On Windows they are next to blender.exe
- On Linux they are in the lib/ folder
Performance comparison on Ubuntu 22.04.5:
```
GPU: AMD Radeon PRO W7800
Driver: amdgpu-install_6.1.60103-1_all.deb
main hip-rt
attic 0.1414s 0.0932s
barbershop_interior 0.1563s 0.1258s
bistro 0.2134s 0.1597s
bmw27 0.0119s 0.0099s
classroom 0.1006s 0.0803s
fishy_cat 0.0248s 0.0178s
junkshop 0.0916s 0.0713s
koro 0.0589s 0.0720s
monster 0.0435s 0.0385s
pabellon 0.0543s 0.0391s
sponza 0.0223s 0.0180s
spring 0.1026s 1.5145s
victor 0.1901s 0.1239s
wdas_cloud 0.1153s 0.1125s
```
Co-authored-by: Brecht Van Lommel <brecht@blender.org>
Co-authored-by: Ray Molenkamp <github@lazydodo.com>
Co-authored-by: Sergey Sharybin <sergey@blender.org>
Pull Request: https://projects.blender.org/blender/blender/pulls/121050
83 lines
2.6 KiB
C++
83 lines
2.6 KiB
C++
/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 */
|
|
|
|
#ifdef WITH_HIPRT
|
|
|
|
# include "device/hiprt/queue.h"
|
|
|
|
# include "device/hip/graphics_interop.h"
|
|
# include "device/hip/kernel.h"
|
|
# include "device/hiprt/device_impl.h"
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
HIPRTDeviceQueue::HIPRTDeviceQueue(HIPRTDevice *device)
|
|
: HIPDeviceQueue((HIPDevice *)device), hiprt_device_(device)
|
|
{
|
|
}
|
|
|
|
bool HIPRTDeviceQueue::enqueue(DeviceKernel kernel,
|
|
const int work_size,
|
|
DeviceKernelArguments const &args)
|
|
{
|
|
if (hiprt_device_->have_error()) {
|
|
return false;
|
|
}
|
|
|
|
if (!device_kernel_has_intersection(kernel)) {
|
|
return HIPDeviceQueue::enqueue(kernel, work_size, args);
|
|
}
|
|
|
|
debug_enqueue_begin(kernel, work_size);
|
|
|
|
const HIPContextScope scope(hiprt_device_);
|
|
const HIPDeviceKernel &hip_kernel = hiprt_device_->kernels.get(kernel);
|
|
|
|
if (!hiprt_device_->global_stack_buffer.stackData) {
|
|
uint32_t max_path = num_concurrent_states(0);
|
|
hiprtGlobalStackBufferInput stack_buffer_input{
|
|
hiprtStackTypeGlobal, hiprtStackEntryTypeInteger, HIPRT_THREAD_STACK_SIZE, max_path};
|
|
|
|
hiprtError rt_result = hiprtCreateGlobalStackBuffer(hiprt_device_->get_hiprt_context(),
|
|
stack_buffer_input,
|
|
hiprt_device_->global_stack_buffer);
|
|
|
|
if (rt_result != hiprtSuccess) {
|
|
LOG(ERROR) << "Failed to create hiprt Global Stack Buffer";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
DeviceKernelArguments args_copy = args;
|
|
args_copy.add(DeviceKernelArguments::HIPRT_GLOBAL_STACK,
|
|
(void *)(&hiprt_device_->global_stack_buffer),
|
|
sizeof(hiprtGlobalStackBuffer));
|
|
|
|
/* Compute kernel launch parameters. */
|
|
const int num_threads_per_block = HIPRT_THREAD_GROUP_SIZE;
|
|
const int num_blocks = divide_up(work_size, num_threads_per_block);
|
|
int shared_mem_bytes = 0;
|
|
|
|
assert_success(hipModuleLaunchKernel(hip_kernel.function,
|
|
num_blocks,
|
|
1,
|
|
1,
|
|
num_threads_per_block,
|
|
1,
|
|
1,
|
|
shared_mem_bytes,
|
|
hip_stream_,
|
|
const_cast<void **>(args_copy.values),
|
|
0),
|
|
"enqueue");
|
|
|
|
debug_enqueue_end();
|
|
|
|
return !(hiprt_device_->have_error());
|
|
}
|
|
|
|
CCL_NAMESPACE_END
|
|
|
|
#endif /* WITH_HIPRT */
|