14#include "device/cpu/kernel.h"
33bool Device::need_types_update =
true;
34bool Device::need_devices_update =
true;
36uint Device::devices_initialized_mask = 0;
41 static vector<DeviceInfo> devices_;
47 static vector<DeviceInfo> devices_;
53 static vector<DeviceInfo> devices_;
59 static vector<DeviceInfo> devices_;
65 static vector<DeviceInfo> devices_;
71 static vector<DeviceInfo> devices_;
92 BVH2 *
const bvh2 =
static_cast<BVH2 *
>(bvh);
94 bvh2->
refit(progress);
160 if (device ==
nullptr) {
169 if (strcmp(name,
"CPU") == 0) {
172 if (strcmp(name,
"CUDA") == 0) {
175 if (strcmp(name,
"OPTIX") == 0) {
178 if (strcmp(name,
"MULTI") == 0) {
181 if (strcmp(name,
"HIP") == 0) {
184 if (strcmp(name,
"METAL") == 0) {
187 if (strcmp(name,
"ONEAPI") == 0) {
190 if (strcmp(name,
"HIPRT") == 0) {
260#if defined(WITH_CUDA) || defined(WITH_OPTIX)
270 devices.push_back(
info);
279 bool meets_nvidia_driver_requirement =
true;
280 if (
device_optix_init(&meets_nvidia_driver_requirement) || !meets_nvidia_driver_requirement)
294 devices.push_back(
info);
302 bool meets_amd_driver_requirement =
true;
309 else if (meets_amd_driver_requirement ==
false) {
317 info.
id =
"unknown_amd_device_with_outdated_driver";
320 hip_devices().push_back(
info);
329 devices.push_back(
info);
343 devices.push_back(
info);
354 devices.push_back(
info);
367 devices.push_back(
info);
389 capabilities +=
"\nCPU device capabilities: ";
398 capabilities +=
"\nCUDA device capabilities:\n";
410 capabilities +=
"\nHIP device capabilities:\n";
422 capabilities +=
"\noneAPI device capabilities:\n";
434 capabilities +=
"\nMetal device capabilities:\n";
448 assert(!subdevices.empty());
450 if (subdevices.size() == 1) {
452 return subdevices.front();
472 if (device.type ==
DEVICE_CPU && subdevices.size() > 1) {
475 const int cpu_threads =
max(orig_cpu_threads - (subdevices.size() - 1),
size_t(0));
477 LOG_INFO <<
"CPU render threads reduced from " << orig_cpu_threads <<
" to " << cpu_threads
478 <<
", to dedicate to GPU.";
480 if (cpu_threads >= 1) {
490 LOG_INFO <<
"CPU render threads disabled for interactive render.";
505 else if (device.type !=
info.
type) {
530 devices_initialized_mask = 0;
531 cuda_devices().free_memory();
532 optix_devices().free_memory();
533 hip_devices().free_memory();
534 oneapi_devices().free_memory();
535 cpu_devices().free_memory();
536 metal_devices().free_memory();
541 LOG_FATAL <<
"Device does not support queues.";
554 LOG_FATAL <<
"Device does not support CPU kernels.";
570 LOG_ERROR <<
"Request guiding field from a device which does not support it.";
590 uint8_t *combined =
static_cast<uint8_t *
>(mem.
host_pointer);
595 for (
size_t i = 0; i < size; i++) {
596 combined[i] |= src[i];
603 assert(sub_device ==
this);
664 const size_t preferred_working_headroom)
669 const size_t default_limit = 4 * 1024 * 1024 * 1024LL;
672 if (system_ram > 0) {
673 if (system_ram / 2 > default_limit) {
681 LOG_WARNING <<
"Mapped host memory disabled, failed to get system RAM";
708 if (size + headroom < free) {
716 bool max_is_image =
false;
721 Mem *cmem = &pair.second;
731 const bool is_image = is_texture && (mem.
data_height > 1);
739 if (for_texture && !is_image) {
744 if (is_image > max_is_image || (is_image == max_is_image && mem.
device_size > max_size)) {
745 max_is_image = is_image;
768 size = (max_size >= size) ? 0 : size - max_size;
781 void *device_pointer =
nullptr;
782 const size_t size = mem.
memory_size() + pitch_padding;
784 bool mem_alloc_result =
false;
785 const char *status =
"";
796 const bool is_image = is_texture && (mem.
data_height > 1);
818 if ((size + headroom) < free || no_host_fallback) {
820 if (mem_alloc_result) {
821 status =
" in device memory";
828 void *shared_pointer =
nullptr;
830 if (!mem_alloc_result &&
can_map_host && !no_host_fallback) {
833 mem_alloc_result =
true;
840 assert((mem_alloc_result && shared_pointer !=
nullptr) ||
841 (!mem_alloc_result && shared_pointer ==
nullptr));
844 if (mem_alloc_result) {
847 status =
" in host memory";
851 if (!mem_alloc_result) {
852 if (no_host_fallback) {
853 status =
" failed, out of device memory";
854 set_error(
"System is out of GPU memory");
857 status =
" failed, out of device and host memory";
858 set_error(
"System is out of GPU and shared host memory");
877 if (shared_pointer !=
nullptr) {
918 assert(!
"GPU device should not copy memory back to host");
958 return (shared_pointer && device_pointer &&
CCL_NAMESPACE_BEGIN void * util_aligned_malloc(const size_t size, const int alignment)
void util_aligned_free(void *ptr, const size_t size)
void refit(btStridingMeshInterface *triangles, const btVector3 &aabbMin, const btVector3 &aabbMax)
void refit(Progress &progress)
void build(Progress &progress, Stats *stats)
bool meets_driver_requirement
vector< DeviceInfo > multi_devices
DenoiserTypeMask denoisers
bool use_hardware_raytracing
virtual void host_free(const MemoryType type, void *host_pointer, const size_t size)
virtual void * get_guiding_device() const
static void free_memory()
static DeviceInfo dummy_device(const string &error_msg="")
Device(const DeviceInfo &info_, Stats &stats_, Profiler &profiler_, bool headless_)
static DeviceInfo get_multi_device(const vector< DeviceInfo > &subdevices, const int threads, bool background)
static const CPUKernels & get_cpu_kernels()
friend class device_memory
virtual ~Device() noexcept(false)
virtual unique_ptr< DeviceQueue > gpu_queue_create()
virtual void build_bvh(BVH *bvh, Progress &progress, bool refit)
virtual device_ptr mem_device_ptr(const device_memory &mem, Device *sub_device)
static DeviceType type_from_string(const char *name)
virtual void set_error(const string &error)
virtual void mem_or_from_device(device_memory &mem)
virtual void mem_copy_from(device_memory &mem, const size_t y, size_t w, const size_t h, size_t elem)=0
virtual vector< ThreadKernelGlobalsCPU > * acquire_cpu_kernel_thread_globals()
static string device_capabilities(const uint device_type_mask=DEVICE_MASK_ALL)
static vector< DeviceType > available_types()
static string string_from_type(DeviceType type)
virtual OSLGlobals * get_cpu_osl_memory()
static vector< DeviceInfo > available_devices(const uint device_type_mask=DEVICE_MASK_ALL)
static unique_ptr< Device > create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
virtual void release_cpu_kernel_thread_globals()
virtual void * host_alloc(const MemoryType type, const size_t size)
bool is_shared(const void *shared_pointer, const device_ptr device_pointer, Device *sub_device) override
virtual bool shared_alloc(void *&shared_pointer, const size_t size)=0
virtual bool load_image_info(DeviceQueue *queue)
GPUDevice(const DeviceInfo &info_, Stats &stats_, Profiler &profiler_, bool headless_)
virtual void get_device_memory_info(size_t &total, size_t &free)=0
virtual bool alloc_device(void *&device_pointer, const size_t size)=0
size_t device_working_headroom
friend class device_memory
void image_info_update(uint image_info_id, const KernelImageInfo &info)
virtual void * shared_to_device_pointer(const void *shared_pointer)=0
virtual void generic_copy_to(device_memory &mem)
virtual void move_textures_to_host(const size_t size, const size_t headroom, const bool for_texture)
virtual void shared_free(void *shared_pointer, const size_t size)=0
thread_mutex image_info_mutex
virtual void copy_host_to_device(void *device_pointer, void *host_pointer, const size_t size)=0
device_vector< KernelImageInfo > image_info
virtual void free_device(void *device_pointer)=0
thread_mutex device_mem_map_mutex
virtual void generic_free(device_memory &mem)
virtual void init_host_memory(const size_t preferred_texture_headroom=0, const size_t preferred_working_headroom=0)
size_t device_image_headroom
thread_mutex image_info_resize_mutex
virtual GPUDevice::Mem * generic_alloc(device_memory &mem, const size_t pitch_padding=0)
~GPUDevice() noexcept(false) override
void mem_alloc(const size_t size)
void mem_free(const size_t size)
static int max_concurrency()
bool is_resident(Device *sub_device) const
void * host_alloc(const size_t size)
bool is_shared(Device *sub_device) const
device_ptr device_pointer
void device_move_to_host()
virtual string log_name() const
T * host_only_resize(const size_t new_count)
@ MEM_FLAG_NO_HOST_FALLBACK
#define MIN_ALIGNMENT_DEVICE_MEMORY
void device_cpu_info(vector< DeviceInfo > &devices)
string device_cpu_capabilities()
CCL_NAMESPACE_BEGIN unique_ptr< Device > device_cpu_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
#define CCL_NAMESPACE_END
void device_cuda_info(vector< DeviceInfo > &devices)
string device_cuda_capabilities()
CCL_NAMESPACE_BEGIN bool device_cuda_init()
unique_ptr< Device > device_cuda_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
unique_ptr< Device > device_dummy_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
CCL_NAMESPACE_BEGIN bool device_hip_init(bool *r_meets_driver_requirement)
void device_hip_info(vector< DeviceInfo > &devices)
string device_hip_capabilities()
unique_ptr< Device > device_hip_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, const bool headless)
unique_ptr< Device > device_multi_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
unique_ptr< Device > device_oneapi_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
void device_oneapi_info(vector< DeviceInfo > &devices)
CCL_NAMESPACE_BEGIN bool device_oneapi_init()
string device_oneapi_capabilities()
CCL_NAMESPACE_BEGIN bool device_optix_init(bool *r_meets_driver_requirement)
void device_optix_info(const vector< DeviceInfo > &cuda_devices, vector< DeviceInfo > &devices)
unique_ptr< Device > device_optix_create(const DeviceInfo &info, Stats &stats, Profiler &profiler, bool headless)
#define assert(assertion)
#define DCHECK(expression)
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
string string_human_readable_size(size_t size)
string string_human_readable_number(size_t num)
size_t system_physical_ram()
std::unique_lock< std::mutex > thread_scoped_lock