mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2026-10-02 10:53:44 +00:00
07dbf30dc8
HIPRT (MIT) behind the CMake option DLU_HIPRT (off): its headers come from its SDK (HIPRT_ROOT, else ROCm's /opt/rocm) and are copied next to the servers; its library is loaded when first used (hiprtew), as HIP or CUDA are by Orochi (MIT, fetched pinned by hash; CUDA when its toolkit is found). The trace kernels (nearest hit skipping the triangle a ray leaves, any hit) are compiled the first time and kept in cache/hiprt. One GPU context for the process (hiprt_device picks the GPU); the workers take turns on it. When HIPRT, the GPU or a scene's upload fails, Embree is used instead, and the UGC server logs why at start. For a GPU the rays go in batches (UgcRays::Scene gets batch queries; the CPU backends answer them a ray at a time): - hidden faces: with a batch backend the paths are traced side by side, a bounce at a time (the path code split into Start, Scatter and Bounce, the one by one tracing unchanged); the same paths with the same random numbers, so the same triangles are decided (tested with builtin side by side) - the occlusion bake and the denoised icons' traced occlusion always ask in batches (the same rays, the same results) Its symbols are hidden: the servers export theirs (-rdynamic), and HIPRT's library, which has an Orochi of its own, would otherwise call ours. Check: configure with -DDLU_HIPRT=ON on a machine with ROCm (or HIPRT's SDK) and an AMD RDNA or NVIDIA GPU; UgcServer --make-model x.lxfml out hiprt; the UGC tests (hits, hidden faces and occlusion against builtin); a build without it leaves everything as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
26 lines
868 B
C++
26 lines
868 B
C++
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "UgcRays.h"
|
|
|
|
/**
|
|
* UgcRays' hiprt backend (built with DLU_HIPRT): AMD's HIPRT on the GPU, with HIP or CUDA loaded at run time through
|
|
* Orochi. One GPU context for the process; the threads take turns on it. The trace kernels are compiled the first time
|
|
* (HIPRT keeps them in its cache folder after that).
|
|
*/
|
|
namespace UgcRaysHiprt {
|
|
// Whether the GPU can be used: loads HIP or CUDA and HIPRT, makes the context and compiles the kernels the first time
|
|
bool Available();
|
|
|
|
// Why it can't (empty when it can, or before it was first asked)
|
|
std::string Problem();
|
|
|
|
// The mesh on the GPU; null when the GPU fails (the caller uses another backend)
|
|
std::unique_ptr<UgcRays::Scene> Make(const UgcModel::Mesh& mesh);
|
|
|
|
// Which device (0: the first); before it is first used
|
|
void SetDevice(int index);
|
|
}
|