Differential D1999 Diff 6678 intern/cycles/device/device_cuda.cpp

Changeset View

Standalone View

intern/cycles/device/device_cuda.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
class CUDADevice : public Device		class CUDADevice : public Device
{		{
public:		public:
DedicatedTaskPool task_pool;		DedicatedTaskPool task_pool;
CUdevice cuDevice;		CUdevice cuDevice;
CUcontext cuContext;		CUcontext cuContext;
CUmodule cuModule;		CUmodule cuModule;
map<device_ptr, bool> tex_interp_map;		map<device_ptr, bool> tex_interp_map;
int cuDevId;		int cuDevId;
		sergeyUnsubmitted Not Done Inline Actions Eventually we can merge this two maps into one like this: struct MemInfo { bool is_array_data; CUtexObject bindless_texture; }; map<device_ptr, MemInfo> tex_meminfo_map; This can be done later. For now i would only strongly suggest using `CUtexObject` instead of `uint` for non-kernel code. sergey: Eventually we can merge this two maps into one like this: struct MemInfo { bool…
int cuDevArchitecture;		int cuDevArchitecture;
bool first_error;		bool first_error;
bool use_texture_storage;

struct PixelMem {		struct PixelMem {
GLuint cuPBO;		GLuint cuPBO;
CUgraphicsResource cuPBOresource;		CUgraphicsResource cuPBOresource;
GLuint cuTexId;		GLuint cuTexId;
int w, h;		int w, h;
};		};

map<device_ptr, PixelMem> pixel_mem_map;		map<device_ptr, PixelMem> pixel_mem_map;

CUdeviceptr cuda_device_ptr(device_ptr mem)		CUdeviceptr cuda_device_ptr(device_ptr mem)
{		{
return (CUdeviceptr)mem;		return (CUdeviceptr)mem;
		brechtUnsubmitted Done Inline Actions We don't need two arrays, we can have just a single `device_vector<uint> bindless_mapping;`. And then to add slots: if (flat_slot >= bindless_mapping.size()) bindless_mapping.resize(max(bindless_mapping.size() * 2, 1)); bindless_mapping[flat_slot] = tex; brecht: We don't need two arrays, we can have just a single `device_vector<uint> bindless_mapping;`.
		sergeyUnsubmitted Done Inline Actions Use `need_` prefix to distinguish flag from method? sergey: Use `need_` prefix to distinguish flag from method?
}		}

static bool have_precompiled_kernels()		static bool have_precompiled_kernels()
{		{
string cubins_path = path_get("lib");		string cubins_path = path_get("lib");
return path_exists(cubins_path);		return path_exists(cubins_path);
}		}

▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	void cuda_pop_context()
cuda_assert(cuCtxSetCurrent(NULL));		cuda_assert(cuCtxSetCurrent(NULL));
}		}

CUDADevice(DeviceInfo& info, Stats &stats, bool background_)		CUDADevice(DeviceInfo& info, Stats &stats, bool background_)
: Device(info, stats, background_)		: Device(info, stats, background_)
{		{
first_error = true;		first_error = true;
background = background_;		background = background_;
use_texture_storage = true;

cuDevId = info.num;		cuDevId = info.num;
cuDevice = 0;		cuDevice = 0;
cuContext = 0;		cuContext = 0;

/* intialize */		/* intialize */
if(cuda_error(cuInit(0)))		if(cuda_error(cuInit(0)))
return;		return;
Show All 18 Lines	: Device(info, stats, background_)

if(cuda_error_(result, "cuCtxCreate"))		if(cuda_error_(result, "cuCtxCreate"))
return;		return;

int major, minor;		int major, minor;
cuDeviceComputeCapability(&major, &minor, cuDevId);		cuDeviceComputeCapability(&major, &minor, cuDevId);
cuDevArchitecture = major100 + minor10;		cuDevArchitecture = major100 + minor10;

/* In order to use full 6GB of memory on Titan cards, use arrays instead
* of textures. On earlier cards this seems slower, but on Titan it is
* actually slightly faster in tests. */
use_texture_storage = (cuDevArchitecture < 300);

cuda_pop_context();		cuda_pop_context();
}		}

~CUDADevice()		~CUDADevice()
{		{
task_pool.stop();		task_pool.stop();

cuda_assert(cuCtxDestroy(cuContext));		cuda_assert(cuCtxDestroy(cuContext));
}		}
		sergeyUnsubmitted Done Inline Actions Will it work correct if the texture was never allocated? Use parenthesis btw. sergey: Will it work correct if the texture was never allocated? Use parenthesis btw.
		dingtoAuthorUnsubmitted Not Done Inline Actions Yes, because in that case there is no valid mem.device_pointer and the function will do nothing. dingto: Yes, because in that case there is no valid mem.device_pointer and the function will do nothing.

bool support_device(const DeviceRequestedFeatures& /requested_features/)		bool support_device(const DeviceRequestedFeatures& /requested_features/)
{		{
int major, minor;		int major, minor;
cuDeviceComputeCapability(&major, &minor, cuDevId);		cuDeviceComputeCapability(&major, &minor, cuDevId);

/* We only support sm_20 and above */		/* We only support sm_20 and above */
if(major < 2) {		if(major < 2) {
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines	bool load_kernels(const DeviceRequestedFeatures& requested_features)
cuda_pop_context();		cuda_pop_context();

return (result == CUDA_SUCCESS);		return (result == CUDA_SUCCESS);
}		}

void mem_alloc(device_memory& mem, MemoryType /type/)		void mem_alloc(device_memory& mem, MemoryType /type/)
{		{
cuda_push_context();		cuda_push_context();
CUdeviceptr device_pointer;		CUdeviceptr device_pointer;
		brechtUnsubmitted Not Done Inline Actions Call `tex_free(bindless_mapping)` here before `tex_alloc()`, so we don't leak memory on reallocation. brecht: Call `tex_free(bindless_mapping)` here before `tex_alloc()`, so we don't leak memory on…
size_t size = mem.memory_size();		size_t size = mem.memory_size();
cuda_assert(cuMemAlloc(&device_pointer, size));		cuda_assert(cuMemAlloc(&device_pointer, size));
mem.device_pointer = (device_ptr)device_pointer;		mem.device_pointer = (device_ptr)device_pointer;
mem.device_size = size;		mem.device_size = size;
stats.mem_alloc(size);		stats.mem_alloc(size);
cuda_pop_context();		cuda_pop_context();
}		}

▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines	void const_copy_to(const char name, void host, size_t size)
//assert(bytes == size);		//assert(bytes == size);
cuda_assert(cuMemcpyHtoD(mem, host, size));		cuda_assert(cuMemcpyHtoD(mem, host, size));
cuda_pop_context();		cuda_pop_context();
}		}

void tex_alloc(const char *name,		void tex_alloc(const char *name,
device_memory& mem,		device_memory& mem,
InterpolationType interpolation,		InterpolationType interpolation,
ExtensionType extension)		ExtensionType extension,
		uint *bindless_slot)
{		{
VLOG(1) << "Texture allocate: " << name << ", " << mem.memory_size() << " bytes.";		VLOG(1) << "Texture allocate: " << name << ", " << mem.memory_size() << " bytes.";

string bind_name = name;		bool is_kepler_card = info.bindless_textures;
		sergeyUnsubmitted Done Inline Actions it's a bit unclear and misleading. Better to have `has_bindless_textures` or `supports_bindless_textures`. Otherwise: a) In some time it'll be unclear why kepler is so special, you'll have constantly remember that it was first card which supported bindless textures. b) Your Pascal card has bindless textures, but it's not a Kepler apparently. sergey: it's a bit unclear and misleading. Better to have `has_bindless_textures` or…
if(mem.data_depth > 1) {
/* Kernel uses different bind names for 2d and 3d float textures,
* so we have to adjust couple of things here.
*/
vector<string> tokens;
string_split(tokens, name, "_");
bind_name = string_printf("__tex_image_%s_3d_%s",
tokens[2].c_str(),
tokens[3].c_str());
}

/* determine format */		/* General variables for both architectures */
CUarray_format_enum format;		string bind_name = name;
size_t dsize = datatype_size(mem.data_type);		size_t dsize = datatype_size(mem.data_type);
size_t size = mem.memory_size();		size_t size = mem.memory_size();
bool use_texture = (interpolation != INTERPOLATION_NONE) \|\| use_texture_storage;

if(use_texture) {		CUaddress_mode address_mode = CU_TR_ADDRESS_MODE_WRAP;
		switch(extension) {
		case EXTENSION_REPEAT:
		address_mode = CU_TR_ADDRESS_MODE_WRAP;
		break;
		case EXTENSION_EXTEND:
		address_mode = CU_TR_ADDRESS_MODE_CLAMP;
		break;
		case EXTENSION_CLIP:
		address_mode = CU_TR_ADDRESS_MODE_BORDER;
		break;
		default:
		assert(0);
		break;
		}

		CUfilter_mode filter_mode;
		if(interpolation == INTERPOLATION_CLOSEST) {
		filter_mode = CU_TR_FILTER_MODE_POINT;
		}
		else {
		filter_mode = CU_TR_FILTER_MODE_LINEAR;
		}

		CUarray_format_enum format;
switch(mem.data_type) {		switch(mem.data_type) {
case TYPE_UCHAR: format = CU_AD_FORMAT_UNSIGNED_INT8; break;		case TYPE_UCHAR: format = CU_AD_FORMAT_UNSIGNED_INT8; break;
case TYPE_UINT: format = CU_AD_FORMAT_UNSIGNED_INT32; break;		case TYPE_UINT: format = CU_AD_FORMAT_UNSIGNED_INT32; break;
case TYPE_INT: format = CU_AD_FORMAT_SIGNED_INT32; break;		case TYPE_INT: format = CU_AD_FORMAT_SIGNED_INT32; break;
case TYPE_FLOAT: format = CU_AD_FORMAT_FLOAT; break;		case TYPE_FLOAT: format = CU_AD_FORMAT_FLOAT; break;
default: assert(0); return;		default: assert(0); return;
}		}

		/* General variables for Fermi */
CUtexref texref = NULL;		CUtexref texref = NULL;

		if(!is_kepler_card) {
		if(mem.data_depth > 1) {
		/* Kernel uses different bind names for 2d and 3d float textures,
		* so we have to adjust couple of things here.
		*/
		vector<string> tokens;
		string_split(tokens, name, "_");
		bind_name = string_printf("__tex_image_%s_3d_%s",
		sergeyUnsubmitted Done Inline Actions Indentation here seems to be weird, don't use tabs to indent pass the parent line. sergey: Indentation here seems to be weird, don't use tabs to indent pass the parent line.
		tokens[2].c_str(),
		tokens[3].c_str());
		}

cuda_push_context();		cuda_push_context();
		brechtUnsubmitted Done Inline Actions Push/pops don't seem to be matched anymore, or at least the logic is hard the follow. Better to do it more often than have confusing logic. brecht: Push/pops don't seem to be matched anymore, or at least the logic is hard the follow. Better to…
cuda_assert(cuModuleGetTexRef(&texref, cuModule, bind_name.c_str()));		cuda_assert(cuModuleGetTexRef(&texref, cuModule, bind_name.c_str()));

if(!texref) {		if(!texref) {
cuda_pop_context();		cuda_pop_context();
return;		return;
}		}
		}

		/* Data Storage */
		brechtUnsubmitted Not Done Inline Actions Just have a single `cuda_pop_context()` above the `if()`. brecht: Just have a single `cuda_pop_context()` above the `if()`.
		if(interpolation == INTERPOLATION_NONE) {
		if(is_kepler_card) {
		mem_alloc(mem, MEM_READ_ONLY);
		brechtUnsubmitted Not Done Inline Actions Remove this, it doesn't correspond to any push. brecht: Remove this, it doesn't correspond to any push.
		dingtoAuthorUnsubmitted Not Done Inline Actions Done, and removed in the else branch below too. dingto: Done, and removed in the else branch below too.
		mem_copy_to(mem);

		cuda_push_context();

		CUdeviceptr cumem;
		size_t cubytes;

		cuda_assert(cuModuleGetGlobal(&cumem, &cubytes, cuModule, bind_name.c_str()));

		if(cubytes == 8) {
		/* 64 bit device pointer */
		uint64_t ptr = mem.device_pointer;
		cuda_assert(cuMemcpyHtoD(cumem, (void*)&ptr, cubytes));
		}
		else {
		/* 32 bit device pointer */
		uint32_t ptr = (uint32_t)mem.device_pointer;
		cuda_assert(cuMemcpyHtoD(cumem, (void*)&ptr, cubytes));
		}

		cuda_pop_context();
		}
		else {
		cuda_pop_context();

if(interpolation != INTERPOLATION_NONE) {		mem_alloc(mem, MEM_READ_ONLY);
		mem_copy_to(mem);

		cuda_push_context();

		cuda_assert(cuTexRefSetAddress(NULL, texref, cuda_device_ptr(mem.device_pointer), size));
		cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_POINT));
		cuda_assert(cuTexRefSetFlags(texref, CU_TRSF_READ_AS_INTEGER));
		}
		}
		/* Texture Storage */
		else {
CUarray handle = NULL;		CUarray handle = NULL;

		cuda_push_context();

if(mem.data_depth > 1) {		if(mem.data_depth > 1) {
CUDA_ARRAY3D_DESCRIPTOR desc;		CUDA_ARRAY3D_DESCRIPTOR desc;

desc.Width = mem.data_width;		desc.Width = mem.data_width;
desc.Height = mem.data_height;		desc.Height = mem.data_height;
desc.Depth = mem.data_depth;		desc.Depth = mem.data_depth;
desc.Format = format;		desc.Format = format;
desc.NumChannels = mem.data_elements;		desc.NumChannels = mem.data_elements;
desc.Flags = 0;		desc.Flags = 0;

cuda_assert(cuArray3DCreate(&handle, &desc));		cuda_assert(cuArray3DCreate(&handle, &desc));
}		}
else {		else {
CUDA_ARRAY_DESCRIPTOR desc;		CUDA_ARRAY_DESCRIPTOR desc;

desc.Width = mem.data_width;		desc.Width = mem.data_width;
desc.Height = mem.data_height;		desc.Height = mem.data_height;
desc.Format = format;		desc.Format = format;
desc.NumChannels = mem.data_elements;		desc.NumChannels = mem.data_elements;

cuda_assert(cuArrayCreate(&handle, &desc));		cuda_assert(cuArrayCreate(&handle, &desc));
}		}

if(!handle) {		if(!handle) {
cuda_pop_context();		cuda_pop_context();
return;		return;
}		}

		/* Allocate 3D, 2D or 1D memory */
if(mem.data_depth > 1) {		if(mem.data_depth > 1) {
CUDA_MEMCPY3D param;		CUDA_MEMCPY3D param;
memset(&param, 0, sizeof(param));		memset(&param, 0, sizeof(param));
param.dstMemoryType = CU_MEMORYTYPE_ARRAY;		param.dstMemoryType = CU_MEMORYTYPE_ARRAY;
param.dstArray = handle;		param.dstArray = handle;
param.srcMemoryType = CU_MEMORYTYPE_HOST;		param.srcMemoryType = CU_MEMORYTYPE_HOST;
param.srcHost = (void*)mem.data_pointer;		param.srcHost = (void*)mem.data_pointer;
param.srcPitch = mem.data_widthdsizemem.data_elements;		param.srcPitch = mem.data_widthdsizemem.data_elements;
		sergeyUnsubmitted Not Done Inline Actions This have to be doublechecked actually. sergey: This have to be doublechecked actually.
		dingtoAuthorUnsubmitted Not Done Inline Actions Not sure whats wrong here? dingto: Not sure whats wrong here?
param.WidthInBytes = param.srcPitch;		param.WidthInBytes = param.srcPitch;
param.Height = mem.data_height;		param.Height = mem.data_height;
param.Depth = mem.data_depth;		param.Depth = mem.data_depth;

cuda_assert(cuMemcpy3D(&param));		cuda_assert(cuMemcpy3D(&param));
}		}
else if(mem.data_height > 1) {		else if(mem.data_height > 1) {
CUDA_MEMCPY2D param;		CUDA_MEMCPY2D param;
memset(&param, 0, sizeof(param));		memset(&param, 0, sizeof(param));
param.dstMemoryType = CU_MEMORYTYPE_ARRAY;		param.dstMemoryType = CU_MEMORYTYPE_ARRAY;
param.dstArray = handle;		param.dstArray = handle;
param.srcMemoryType = CU_MEMORYTYPE_HOST;		param.srcMemoryType = CU_MEMORYTYPE_HOST;
param.srcHost = (void*)mem.data_pointer;		param.srcHost = (void*)mem.data_pointer;
param.srcPitch = mem.data_widthdsizemem.data_elements;		param.srcPitch = mem.data_widthdsizemem.data_elements;
param.WidthInBytes = param.srcPitch;		param.WidthInBytes = param.srcPitch;
param.Height = mem.data_height;		param.Height = mem.data_height;

cuda_assert(cuMemcpy2D(&param));		cuda_assert(cuMemcpy2D(&param));
}		}
else		else
		sergeyUnsubmitted Done Inline Actions This we should add a check that `tex` fits into `uint` and print a warning or abort rendering otherwise. `CUtexObject` is `unsigned long long` after all which is not necessarily gonna to fit into a smaller type. sergey: This we should add a check that `tex` fits into `uint` and print a warning or abort rendering…
cuda_assert(cuMemcpyHtoA(handle, 0, (void*)mem.data_pointer, size));		cuda_assert(cuMemcpyHtoA(handle, 0, (void*)mem.data_pointer, size));

cuda_assert(cuTexRefSetArray(texref, handle, CU_TRSA_OVERRIDE_FORMAT));		/* Bindless Textures - Kepler */
		if(is_kepler_card) {
if(interpolation == INTERPOLATION_CLOSEST) {		CUDA_RESOURCE_DESC resDesc;
		sergeyUnsubmitted Not Done Inline Actions Tried using `CUDA_RESOURCE_DESC resDesc = {0};`? sergey: Tried using `CUDA_RESOURCE_DESC resDesc = {0};`?
		dingtoAuthorUnsubmitted Not Done Inline Actions This is giving me a compile error. error: invalid conversion from ‘int’ to ‘CUresourcetype {aka CUresourcetype_enum}’ [-fpermissive] dingto: This is giving me a compile error. error: invalid conversion from ‘int’ to ‘CUresourcetype…
		sergeyUnsubmitted Done Inline Actions Screw it then for now. sergey: Screw it then for now.
cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_POINT));		memset(&resDesc, 0, sizeof(resDesc));
}		resDesc.resType = CU_RESOURCE_TYPE_ARRAY;
else if(interpolation == INTERPOLATION_LINEAR) {		resDesc.res.array.hArray = handle;
cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_LINEAR));		resDesc.flags = 0;
}
else {/* CUBIC and SMART are unsupported for CUDA */		CUDA_TEXTURE_DESC texDesc;
cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_LINEAR));		memset(&texDesc, 0, sizeof(texDesc));
		texDesc.addressMode[0] = address_mode;
		texDesc.addressMode[1] = address_mode;
		texDesc.addressMode[2] = address_mode;
		texDesc.filterMode = filter_mode;
		texDesc.flags = CU_TRSF_NORMALIZED_COORDINATES;

		CUtexObject tex = 0;
		cuda_assert(cuTexObjectCreate(&tex, &resDesc, &texDesc, NULL));
		*bindless_slot = tex;
}		}
		/* Regular Textures - Fermi */
		else {
		cuda_assert(cuTexRefSetArray(texref, handle, CU_TRSA_OVERRIDE_FORMAT));
		cuda_assert(cuTexRefSetFilterMode(texref, filter_mode));
cuda_assert(cuTexRefSetFlags(texref, CU_TRSF_NORMALIZED_COORDINATES));		cuda_assert(cuTexRefSetFlags(texref, CU_TRSF_NORMALIZED_COORDINATES));
		}

		/* Fermi and Kepler */
mem.device_pointer = (device_ptr)handle;		mem.device_pointer = (device_ptr)handle;
mem.device_size = size;		mem.device_size = size;

stats.mem_alloc(size);		stats.mem_alloc(size);
}		}
else {
cuda_pop_context();

mem_alloc(mem, MEM_READ_ONLY);
mem_copy_to(mem);

cuda_push_context();

cuda_assert(cuTexRefSetAddress(NULL, texref, cuda_device_ptr(mem.device_pointer), size));
cuda_assert(cuTexRefSetFilterMode(texref, CU_TR_FILTER_MODE_POINT));
cuda_assert(cuTexRefSetFlags(texref, CU_TRSF_READ_AS_INTEGER));
}

CUaddress_mode address_mode = CU_TR_ADDRESS_MODE_WRAP;		/* Fermi, Data and Image Textures */
switch(extension) {		if(!is_kepler_card) {
case EXTENSION_REPEAT:
address_mode = CU_TR_ADDRESS_MODE_WRAP;
break;
case EXTENSION_EXTEND:
address_mode = CU_TR_ADDRESS_MODE_CLAMP;
break;
case EXTENSION_CLIP:
address_mode = CU_TR_ADDRESS_MODE_BORDER;
break;
default:
assert(0);
break;
}
cuda_assert(cuTexRefSetAddressMode(texref, 0, address_mode));		cuda_assert(cuTexRefSetAddressMode(texref, 0, address_mode));
cuda_assert(cuTexRefSetAddressMode(texref, 1, address_mode));		cuda_assert(cuTexRefSetAddressMode(texref, 1, address_mode));
if(mem.data_depth > 1) {		if(mem.data_depth > 1) {
cuda_assert(cuTexRefSetAddressMode(texref, 2, address_mode));		cuda_assert(cuTexRefSetAddressMode(texref, 2, address_mode));
}		}

cuda_assert(cuTexRefSetFormat(texref, format, mem.data_elements));		cuda_assert(cuTexRefSetFormat(texref, format, mem.data_elements));

cuda_pop_context();		cuda_pop_context();
}		}
else {
mem_alloc(mem, MEM_READ_ONLY);
mem_copy_to(mem);

cuda_push_context();

CUdeviceptr cumem;
size_t cubytes;

cuda_assert(cuModuleGetGlobal(&cumem, &cubytes, cuModule, bind_name.c_str()));

if(cubytes == 8) {
/* 64 bit device pointer */
uint64_t ptr = mem.device_pointer;
cuda_assert(cuMemcpyHtoD(cumem, (void*)&ptr, cubytes));
}
else {
/* 32 bit device pointer */
uint32_t ptr = (uint32_t)mem.device_pointer;
cuda_assert(cuMemcpyHtoD(cumem, (void*)&ptr, cubytes));
}

cuda_pop_context();
}

		/* Fermi and Kepler */
tex_interp_map[mem.device_pointer] = (interpolation != INTERPOLATION_NONE);		tex_interp_map[mem.device_pointer] = (interpolation != INTERPOLATION_NONE);
}		}

void tex_free(device_memory& mem)		void tex_free(device_memory& mem)
{		{
if(mem.device_pointer) {		if(mem.device_pointer) {
if(tex_interp_map[mem.device_pointer]) {		if(tex_interp_map[mem.device_pointer]) {
cuda_push_context();		cuda_push_context();
Show All 14 Lines	#endif
}		}

void path_trace(RenderTile& rtile, int sample, bool branched)		void path_trace(RenderTile& rtile, int sample, bool branched)
{		{
if(have_error())		if(have_error())
return;		return;

cuda_push_context();		cuda_push_context();

		brechtUnsubmitted Done Inline Actions This architecture check is unnecessary as we should never have `sync_bindless_mapping = true` with other architectures. And the copying code can be simplified if we have a single array. Also, this code should be moved to a separate function and called also from `shader()`, since baking can access textures too. brecht: This architecture check is unnecessary as we should never have `sync_bindless_mapping = true`…
		sergeyUnsubmitted Done Inline Actions Shall we do a call from `thread_run()` instead? `path_trace()` is run for each sample, and trying to load bindless mapping for each of them is a bit redundant. sergey: Shall we do a call from `thread_run()` instead? `path_trace()` is run for each sample, and…
CUfunction cuPathTrace;		CUfunction cuPathTrace;
CUdeviceptr d_buffer = cuda_device_ptr(rtile.buffer);		CUdeviceptr d_buffer = cuda_device_ptr(rtile.buffer);
CUdeviceptr d_rng_state = cuda_device_ptr(rtile.rng_state);		CUdeviceptr d_rng_state = cuda_device_ptr(rtile.rng_state);

/* get kernel function */		/* get kernel function */
if(branched) {		if(branched) {
cuda_assert(cuModuleGetFunction(&cuPathTrace, cuModule, "kernel_cuda_branched_path_trace"));		cuda_assert(cuModuleGetFunction(&cuPathTrace, cuModule, "kernel_cuda_branched_path_trace"));
}		}
▲ Show 20 Lines • Show All 563 Lines • ▼ Show 20 Lines	for(int num = 0; num < count; num++) {
DeviceInfo info;		DeviceInfo info;

info.type = DEVICE_CUDA;		info.type = DEVICE_CUDA;
info.description = string(name);		info.description = string(name);
info.id = string_printf("CUDA_%d", num);		info.id = string_printf("CUDA_%d", num);
info.num = num;		info.num = num;

info.advanced_shading = (major >= 2);		info.advanced_shading = (major >= 2);
info.extended_images = (major >= 3);		info.bindless_textures = (major >= 3);
info.pack_images = false;		info.pack_images = false;

/* if device has a kernel timeout, assume it is used for display */		/* if device has a kernel timeout, assume it is used for display */
if(cuDeviceGetAttribute(&attr, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, num) == CUDA_SUCCESS && attr == 1) {		if(cuDeviceGetAttribute(&attr, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, num) == CUDA_SUCCESS && attr == 1) {
info.display_device = true;		info.display_device = true;
display_devices.push_back(info);		display_devices.push_back(info);
}		}
else		else
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines