diff --git a/layers/10_cmdbufemu/README.md b/layers/10_cmdbufemu/README.md index b767c61..77ef568 100644 --- a/layers/10_cmdbufemu/README.md +++ b/layers/10_cmdbufemu/README.md @@ -32,14 +32,18 @@ The following environment variables can modify the behavior of the command buffe | Environment Variable | Behavior | Example Format | |----------------------|----------|-----------------| +| `CMDBUFEMU_EmulateUnconditionally` | Set to a positive value to enables the command buffer emulation layer unconditionally, even when command buffers are supported natively. Set to a negative value to disable emulation. By default, the command buffer emulation layer operates conditionally and will pass through calls unchanged when command buffers are supported. | `export CMDBUFEMU_EmulateUnconditionally=1`

`set CMDBUFEMU_EmulateUnconditionally=1` | | `CMDBUFEMU_EnhancedErrorChecking` | Enables additional error checking when commands are added to a command buffer using a command buffer "test queue". By default, the additional error checking is disabled. | `export CMDBUFEMU_EnhancedErrorChecking=1`

`set CMDBUFEMU_EnhancedErrorChecking=1` | | `CMDBUFEMU_KernelForProfiling` | Enables use of an empty kernel for event profiling instead of event profiling on a command-queue barrier. By default, to minimize overhead, the empty kernel is not used. | `export CMDBUFEMU_KernelForProfiling=1`

`set CMDBUFEMU_KernelForProfiling=1` | | `CMDBUFEMU_SuggestedLocalWorkSize` | Enables use of the suggested local work-group size extension to eliminate `NULL` local work-group sizes. Only valid when an implementation supports the local work-group size extension and the command is not mutable. By default, use of the suggested local work-group size is enabled. | `export CMDBUFEMU_SuggestedLocalWorkSize=0`

`set CMDBUFEMU_SuggestedLocalWorkSize=0` | ## Known Limitations -This section describes some of the limitations of the emulated `cl_khr_command_buffer` functionality: +The command buffer emulation layer now passes most of the conformance tests on most devices :tada:! -* Some error conditions are not properly checked for and returned. +This section describes some of the remaining limitations of the emulated `cl_khr_command_buffer` and `cl_khr_command_buffer_mutable_dispatch` functionality: + +* Some error conditions may still not be properly checked for. +If you find a missing error check, please file an issue so it can be added. * Deferred kernel arguments are supported, but `CL_COMMAND_BUFFER_STATE_FINALIZED_KHR` is not properly handled. * Many functions are not thread safe. diff --git a/layers/10_cmdbufemu/emulate.cpp b/layers/10_cmdbufemu/emulate.cpp index fd483a5..aab8764 100644 --- a/layers/10_cmdbufemu/emulate.cpp +++ b/layers/10_cmdbufemu/emulate.cpp @@ -25,6 +25,177 @@ static constexpr cl_version version_cl_khr_command_buffer = static constexpr cl_version version_cl_khr_command_buffer_mutable_dispatch = CL_MAKE_VERSION(0, 9, 5); +static bool deviceSupportsOpenCL21(cl_device_id device) +{ + size_t size = 0; + g_pNextDispatch->clGetDeviceInfo( + device, + CL_DEVICE_VERSION, + 0, + nullptr, + &size ); + + std::vector deviceVersion(size); + g_pNextDispatch->clGetDeviceInfo( + device, + CL_DEVICE_VERSION, + size, + deviceVersion.data(), + nullptr ); + return getOpenCLVersionFromString(deviceVersion.data()) >= CL_MAKE_VERSION(2, 1, 0); +} + +static void addOrUpdateExtensionVersion( + std::vector& extensions, + const char* extensionName, + cl_version version) +{ + bool found = false; + for (auto& extension : extensions) { + if (strcmp(extension.name, extensionName) == 0) { + extension.version = version; + found = true; + break; + } + } + if (found == false) { + extensions.emplace_back(); + + cl_name_version& extension = extensions.back(); + + memset(extension.name, 0, CL_NAME_VERSION_MAX_NAME_SIZE); + strcpy(extension.name, extensionName); + + extension.version = version; + } +} + +struct SPlatformInfo +{ + bool emulate_cl_khr_command_buffer = false; + bool allDevicesSupportOpenCL21 = false; +}; + +struct SLayerContext +{ + typedef std::map CEventMap; + + SLayerContext() + { + cl_uint numPlatforms = 0; + g_pNextDispatch->clGetPlatformIDs( + 0, + nullptr, + &numPlatforms); + + std::vector platforms; + platforms.resize(numPlatforms); + g_pNextDispatch->clGetPlatformIDs( + numPlatforms, + platforms.data(), + nullptr); + + for (auto platform : platforms) { + checkPlatform(platform); + } + } + + const SPlatformInfo& getPlatformInfo(cl_platform_id platform) + { + return m_PlatformInfo[platform]; + } + + const SPlatformInfo& getPlatformInfo(cl_device_id device) + { + cl_platform_id platform = nullptr; + g_pNextDispatch->clGetDeviceInfo( + device, + CL_DEVICE_PLATFORM, + sizeof(platform), + &platform, + nullptr); + + return getPlatformInfo(platform); + } + + CEventMap& getEventMap() + { + return m_EventMap; + } + +private: + std::map m_PlatformInfo; + CEventMap m_EventMap; + + void checkPlatform(cl_platform_id platform) + { + SPlatformInfo& platformInfo = m_PlatformInfo[platform]; + + bool anyDeviceSupportsCommandBuffers = false; + bool anyDeviceSupportsOpenCL21 = false; + bool allDevicesSupportOpenCL21 = true; + + cl_uint numDevices = 0; + g_pNextDispatch->clGetDeviceIDs( + platform, + CL_DEVICE_TYPE_ALL, + 0, + nullptr, + &numDevices); + + std::vector devices(numDevices); + g_pNextDispatch->clGetDeviceIDs( + platform, + CL_DEVICE_TYPE_ALL, + numDevices, + devices.data(), + nullptr); + + for (auto device : devices) { + bool supportsOpenCL21 = deviceSupportsOpenCL21(device); + + anyDeviceSupportsOpenCL21 |= supportsOpenCL21; + allDevicesSupportOpenCL21 &= supportsOpenCL21; + + size_t size = 0; + g_pNextDispatch->clGetDeviceInfo( + device, + CL_DEVICE_EXTENSIONS, + 0, + nullptr, + &size ); + + std::string deviceExtensions; + deviceExtensions.resize(size); + g_pNextDispatch->clGetDeviceInfo( + device, + CL_DEVICE_EXTENSIONS, + size, + &deviceExtensions[0], + nullptr ); + deviceExtensions.pop_back(); + + bool supportsCommandBuffers = checkStringForExtension( + deviceExtensions.c_str(), + CL_KHR_COMMAND_BUFFER_EXTENSION_NAME); + + anyDeviceSupportsCommandBuffers |= supportsCommandBuffers; + } + + // We're going to do emulation for this platform if we are emulating + // unconditionally and any device supports OpenCL 2.1, or if no device + // supports command buffers. + + platformInfo.emulate_cl_khr_command_buffer = + (g_EmulateUnconditionally > 0 && anyDeviceSupportsOpenCL21) || + (anyDeviceSupportsCommandBuffers == false); + + // Also record if all devices support OpenCL 2.1. + + platformInfo.allDevicesSupportOpenCL21 = allDevicesSupportOpenCL21; + } +}; + SLayerContext& getLayerContext(void) { static SLayerContext c; @@ -207,7 +378,7 @@ typedef struct _cl_mutable_command_khr private: static constexpr cl_uint cMagic = 0x4d434442; // "MCMD" - const cl_uint Magic; + const cl_uint Magic = cMagic; const cl_command_type Type; cl_command_buffer_khr CmdBuf; cl_command_queue Queue; @@ -1152,6 +1323,7 @@ typedef struct _cl_command_buffer_khr cl_int errorCode = CL_SUCCESS; ptrdiff_t numProperties = 0; + cl_context context = nullptr; cl_command_buffer_flags_khr flags = 0; cl_mutable_dispatch_asserts_khr mutableDispatchAsserts = 0; @@ -1203,24 +1375,33 @@ typedef struct _cl_command_buffer_khr } for( cl_uint q = 0; q < num_queues && queues != nullptr; q++ ) { - cl_uint refCount = 0; + cl_context queueContext = nullptr; if( g_pNextDispatch->clGetCommandQueueInfo( queues[q], - CL_QUEUE_REFERENCE_COUNT, - sizeof(refCount), - &refCount, + CL_QUEUE_CONTEXT, + sizeof(queueContext), + &queueContext, nullptr) != CL_SUCCESS ) { errorCode = CL_INVALID_COMMAND_QUEUE; break; } + if( context == nullptr ) + { + context = queueContext; + } + else if( context != queueContext ) + { + errorCode = CL_INVALID_CONTEXT; + break; + } } if( errcode_ret ) { errcode_ret[0] = errorCode; } if( errorCode == CL_SUCCESS) { - cmdbuf = new _cl_command_buffer_khr(flags, mutableDispatchAsserts); + cmdbuf = new _cl_command_buffer_khr(context, flags, mutableDispatchAsserts); cmdbuf->Queues.reserve(num_queues); cmdbuf->Queues.insert( cmdbuf->Queues.begin(), @@ -1411,20 +1592,10 @@ typedef struct _cl_command_buffer_khr // not have it. case CL_COMMAND_BUFFER_CONTEXT_KHR: { - cl_context context = nullptr; - if( cl_int errorCode = g_pNextDispatch->clGetCommandQueueInfo( - getQueue(), - CL_QUEUE_CONTEXT, - sizeof(context), - &context, - nullptr) ) - { - return errorCode; - } auto ptr = (cl_context*)param_value; return writeParamToMemory( param_value_size, - context, + Context, param_value_size_ret, ptr ); } @@ -1470,6 +1641,36 @@ typedef struct _cl_command_buffer_khr return CL_SUCCESS; } + cl_int checkRecordObject( + cl_mem mem ) + { + cl_context checkContext = nullptr; + cl_int errorCode = g_pNextDispatch->clGetMemObjectInfo( + mem, + CL_MEM_CONTEXT, + sizeof(checkContext), + &checkContext, + nullptr ); + return errorCode != CL_SUCCESS ? errorCode : + checkContext != Context ? CL_INVALID_CONTEXT : + CL_SUCCESS; + } + + cl_int checkRecordObject( + cl_kernel kernel ) + { + cl_context checkContext = nullptr; + cl_int errorCode = g_pNextDispatch->clGetKernelInfo( + kernel, + CL_KERNEL_CONTEXT, + sizeof(checkContext), + &checkContext, + nullptr ); + return errorCode != CL_SUCCESS ? errorCode : + checkContext != Context ? CL_INVALID_CONTEXT : + CL_SUCCESS; + } + cl_int checkPlaybackErrors( cl_uint num_queues, cl_command_queue* queues, @@ -1494,14 +1695,22 @@ typedef struct _cl_command_buffer_khr { return CL_INVALID_EVENT_WAIT_LIST; } - - cl_context cmdbuf_context = nullptr; - g_pNextDispatch->clGetCommandQueueInfo( - getQueue(), - CL_QUEUE_CONTEXT, - sizeof(cmdbuf_context), - &cmdbuf_context, - nullptr); + for( cl_uint e = 0; e < num_events_in_wait_list; e++ ) + { + cl_context checkContext = nullptr; + cl_int errorCode = g_pNextDispatch->clGetEventInfo( + event_wait_list[e], + CL_EVENT_CONTEXT, + sizeof(checkContext), + &checkContext, + nullptr ); + if (errorCode != CL_SUCCESS) { + return CL_INVALID_EVENT_WAIT_LIST; + } + if (checkContext != Context) { + return CL_INVALID_CONTEXT; + } + } cl_device_id cmdbuf_device = nullptr; g_pNextDispatch->clGetCommandQueueInfo( @@ -1525,7 +1734,7 @@ typedef struct _cl_command_buffer_khr sizeof(queue_context), &queue_context, nullptr); - if( queue_context != cmdbuf_context ) + if( queue_context != Context ) { return CL_INVALID_CONTEXT; } @@ -1738,10 +1947,11 @@ typedef struct _cl_command_buffer_khr private: static constexpr cl_uint cMagic = 0x434d4442; // "CMDB" - const cl_uint Magic; + const cl_uint Magic = cMagic; + cl_context Context; std::vector Queues; std::vector Properties; - cl_command_buffer_state_khr State; + cl_command_buffer_state_khr State = CL_COMMAND_BUFFER_STATE_RECORDING_KHR; cl_command_buffer_flags_khr Flags; cl_mutable_dispatch_asserts_khr MutableDispatchAsserts; @@ -1787,14 +1997,6 @@ typedef struct _cl_command_buffer_khr { cl_command_queue testQueue = nullptr; - cl_context context = nullptr; - g_pNextDispatch->clGetCommandQueueInfo( - src, - CL_QUEUE_CONTEXT, - sizeof(context), - &context, - nullptr ); - cl_device_id device = nullptr; g_pNextDispatch->clGetCommandQueueInfo( src, @@ -1820,7 +2022,7 @@ typedef struct _cl_command_buffer_khr props.data(), nullptr ); testQueue = g_pNextDispatch->clCreateCommandQueueWithProperties( - context, + Context, device, props.data(), nullptr ); @@ -1833,14 +2035,14 @@ typedef struct _cl_command_buffer_khr &props, nullptr ); testQueue = g_pNextDispatch->clCreateCommandQueue( - context, + Context, device, props, nullptr ); } cl_event blockingEvent = g_pNextDispatch->clCreateUserEvent( - context, + Context, nullptr ); g_pNextDispatch->clEnqueueBarrierWithWaitList( testQueue, @@ -1857,14 +2059,6 @@ typedef struct _cl_command_buffer_khr { if( g_KernelForProfiling ) { - cl_context context = nullptr; - g_pNextDispatch->clGetCommandQueueInfo( - queue, - CL_QUEUE_CONTEXT, - sizeof(context), - &context, - nullptr ); - cl_device_id device = nullptr; g_pNextDispatch->clGetCommandQueueInfo( queue, @@ -1875,7 +2069,7 @@ typedef struct _cl_command_buffer_khr const char* kernelString = "kernel void Empty() {}"; cl_program program = g_pNextDispatch->clCreateProgramWithSource( - context, + Context, 1, &kernelString, nullptr, @@ -1900,10 +2094,10 @@ typedef struct _cl_command_buffer_khr } _cl_command_buffer_khr( + cl_context context, cl_command_buffer_flags_khr flags, cl_mutable_dispatch_asserts_khr mutableDispatchAsserts) : - Magic(cMagic), - State(CL_COMMAND_BUFFER_STATE_RECORDING_KHR), + Context(context), Flags(flags), MutableDispatchAsserts(mutableDispatchAsserts), RefCount(1), @@ -1919,7 +2113,6 @@ _cl_mutable_command_khr::_cl_mutable_command_khr( cl_command_buffer_khr cmdbuf, cl_command_queue queue, cl_command_type type) : - Magic(cMagic), Type(type), CmdBuf(cmdbuf), Queue(queue ? queue : cmdbuf->getQueue()) {} @@ -2200,7 +2393,7 @@ cl_int CL_API_CALL clEnqueueCommandBufferKHR_EMU( { if( errorCode == CL_SUCCESS ) { - getLayerContext().EventMap[event[0]] = startEvent; + getLayerContext().getEventMap()[event[0]] = startEvent; } else { @@ -2287,6 +2480,14 @@ cl_int CL_API_CALL clCommandCopyBufferKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(src_buffer) ) + { + return errorCode; + } + if( cl_int errorCode = cmdbuf->checkRecordObject(dst_buffer) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2361,6 +2562,14 @@ cl_int CL_API_CALL clCommandCopyBufferRectKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(src_buffer) ) + { + return errorCode; + } + if( cl_int errorCode = cmdbuf->checkRecordObject(dst_buffer) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2438,6 +2647,14 @@ cl_int CL_API_CALL clCommandCopyBufferToImageKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(src_buffer) ) + { + return errorCode; + } + if( cl_int errorCode = cmdbuf->checkRecordObject(dst_image) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2507,6 +2724,14 @@ cl_int CL_API_CALL clCommandCopyImageKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(src_image) ) + { + return errorCode; + } + if( cl_int errorCode = cmdbuf->checkRecordObject(dst_image) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2576,6 +2801,14 @@ cl_int CL_API_CALL clCommandCopyImageToBufferKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(src_image) ) + { + return errorCode; + } + if( cl_int errorCode = cmdbuf->checkRecordObject(dst_buffer) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2645,6 +2878,10 @@ cl_int CL_API_CALL clCommandFillBufferKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(buffer) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2713,6 +2950,10 @@ cl_int CL_API_CALL clCommandFillImageKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(image) ) + { + return errorCode; + } if( properties != nullptr && properties[0] != 0 ) { return CL_INVALID_PROPERTY; @@ -2910,6 +3151,10 @@ cl_int CL_API_CALL clCommandNDRangeKernelKHR_EMU( { return errorCode; } + if( cl_int errorCode = cmdbuf->checkRecordObject(kernel) ) + { + return errorCode; + } if( cl_command_queue testQueue = cmdbuf->getTestQueue() ) { if( cl_int errorCode = g_pNextDispatch->clEnqueueNDRangeKernel( @@ -3059,9 +3304,14 @@ bool clGetDeviceInfo_override( size_t* param_value_size_ret, cl_int* errcode_ret) { + const auto& platformInfo = getLayerContext().getPlatformInfo(device); + if (platformInfo.emulate_cl_khr_command_buffer == false) { + return false; + } + switch(param_name) { case CL_DEVICE_EXTENSIONS: - { + if (deviceSupportsOpenCL21(device)) { size_t size = 0; g_pNextDispatch->clGetDeviceInfo( device, @@ -3070,73 +3320,61 @@ bool clGetDeviceInfo_override( nullptr, &size ); - std::vector deviceExtensions(size); + std::string deviceExtensions; + deviceExtensions.resize(size); g_pNextDispatch->clGetDeviceInfo( device, CL_DEVICE_EXTENSIONS, size, - deviceExtensions.data(), + &deviceExtensions[0], nullptr ); + deviceExtensions.pop_back(); - size = 0; - g_pNextDispatch->clGetDeviceInfo( - device, - CL_DEVICE_VERSION, - 0, - nullptr, - &size ); + // If we get this far, we're doing full emulation for the base + // command buffer extension and all layered extensions. Add all + // extensions, unless they're already in the extension string. - std::vector deviceVersion(size); - g_pNextDispatch->clGetDeviceInfo( - device, - CL_DEVICE_VERSION, - size, - deviceVersion.data(), - nullptr ); + std::string newExtensions; - if( checkStringForExtension( - deviceExtensions.data(), - CL_KHR_COMMAND_BUFFER_EXTENSION_NAME ) == false && - getOpenCLVersionFromString( - deviceVersion.data() ) >= CL_MAKE_VERSION(2, 1, 0)) - { - std::string newExtensions; + if (checkStringForExtension( + deviceExtensions.c_str(), + CL_KHR_COMMAND_BUFFER_EXTENSION_NAME ) == false) { newExtensions += CL_KHR_COMMAND_BUFFER_EXTENSION_NAME; newExtensions += ' '; + } + if (checkStringForExtension( + deviceExtensions.data(), + CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME ) == false) { newExtensions += CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME; + newExtensions += ' '; + } - std::string oldExtensions(deviceExtensions.data()); - - // If the old extension string ends with a space ensure the - // new extension string does too. - if( oldExtensions.back() == ' ' ) - { - newExtensions += ' '; - } - else - { - oldExtensions += ' '; - } + // If the old extension string does not end with a space, remove the + // trailing space from the new extension string, and add a space + // separator. + if (!newExtensions.empty() && !deviceExtensions.empty() && + deviceExtensions.back() != ' ') { + newExtensions.pop_back(); + deviceExtensions += ' '; + } - oldExtensions += newExtensions; + deviceExtensions += newExtensions; - auto ptr = (char*)param_value; - cl_int errorCode = writeStringToMemory( - param_value_size, - oldExtensions.c_str(), - param_value_size_ret, - ptr ); + auto ptr = (char*)param_value; + cl_int errorCode = writeStringToMemory( + param_value_size, + deviceExtensions.c_str(), + param_value_size_ret, + ptr ); - if( errcode_ret ) - { - errcode_ret[0] = errorCode; - } - return true; + if (errcode_ret) { + errcode_ret[0] = errorCode; } + return true; } break; case CL_DEVICE_EXTENSIONS_WITH_VERSION: - { + if (deviceSupportsOpenCL21(device)) { size_t size = 0; g_pNextDispatch->clGetDeviceInfo( device, @@ -3154,68 +3392,26 @@ bool clGetDeviceInfo_override( extensions.data(), nullptr ); - size = 0; - g_pNextDispatch->clGetDeviceInfo( - device, - CL_DEVICE_VERSION, - 0, - nullptr, - &size ); - - std::vector deviceVersion(size); - g_pNextDispatch->clGetDeviceInfo( - device, - CL_DEVICE_VERSION, - size, - deviceVersion.data(), - nullptr ); - - bool found = false; - for( const auto& extension : extensions ) - { - if( strcmp(extension.name, CL_KHR_COMMAND_BUFFER_EXTENSION_NAME) == 0 ) - { - found = true; - break; - } - } - - if( found == false && - getOpenCLVersionFromString( - deviceVersion.data() ) >= CL_MAKE_VERSION(2, 1, 0)) - { - { - extensions.emplace_back(); - cl_name_version& extension = extensions.back(); - - memset(extension.name, 0, CL_NAME_VERSION_MAX_NAME_SIZE); - strcpy(extension.name, CL_KHR_COMMAND_BUFFER_EXTENSION_NAME); - - extension.version = version_cl_khr_command_buffer; - } - { - extensions.emplace_back(); - cl_name_version& extension = extensions.back(); - - memset(extension.name, 0, CL_NAME_VERSION_MAX_NAME_SIZE); - strcpy(extension.name, CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME); - - extension.version = version_cl_khr_command_buffer_mutable_dispatch; - } - - auto ptr = (cl_name_version*)param_value; - cl_int errorCode = writeVectorToMemory( - param_value_size, - extensions, - param_value_size_ret, - ptr ); + addOrUpdateExtensionVersion( + extensions, + CL_KHR_COMMAND_BUFFER_EXTENSION_NAME, + version_cl_khr_command_buffer); + addOrUpdateExtensionVersion( + extensions, + CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME, + version_cl_khr_command_buffer_mutable_dispatch); + + auto ptr = (cl_name_version*)param_value; + cl_int errorCode = writeVectorToMemory( + param_value_size, + extensions, + param_value_size_ret, + ptr ); - if( errcode_ret ) - { - errcode_ret[0] = errorCode; - } - return true; + if (errcode_ret) { + errcode_ret[0] = errorCode; } + return true; } break; case CL_DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR: @@ -3340,9 +3536,9 @@ bool clGetEventInfo_override( switch(param_name) { case CL_EVENT_COMMAND_TYPE: { - auto& context = getLayerContext(); - auto it = context.EventMap.find(event); - if (it != context.EventMap.end()) { + const auto& eventMap = getLayerContext().getEventMap(); + auto it = eventMap.find(event); + if (it != eventMap.end()) { cl_command_type type = CL_COMMAND_COMMAND_BUFFER_KHR; auto ptr = (cl_command_type*)param_value; cl_int errorCode = writeParamToMemory( @@ -3364,6 +3560,48 @@ bool clGetEventInfo_override( return false; } +#define CHECK_RETURN_EXTENSION_FUNCTION( _funcname ) \ + if (strcmp(func_name, #_funcname) == 0) { \ + return (void*)_funcname##_EMU; \ + } + +void* clGetExtensionFunctionAddressForPlatform_override( + cl_platform_id platform, + const char* func_name) +{ + const auto& platformInfo = getLayerContext().getPlatformInfo(platform); + if (platformInfo.emulate_cl_khr_command_buffer == false) { + return nullptr; + } + + CHECK_RETURN_EXTENSION_FUNCTION( clCreateCommandBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clFinalizeCommandBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clRetainCommandBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clReleaseCommandBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clEnqueueCommandBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandBarrierWithWaitListKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyBufferRectKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyBufferToImageKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyImageKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyImageToBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandFillBufferKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandFillImageKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandSVMMemcpyKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandSVMMemFillKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clCommandNDRangeKernelKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clGetCommandBufferInfoKHR ); + +#if defined(cl_khr_command_buffer_multi_device) && 0 + CHECK_RETURN_EXTENSION_FUNCTION( clRemapCommandBufferKHR ); +#endif + + CHECK_RETURN_EXTENSION_FUNCTION( clUpdateMutableCommandsKHR ); + CHECK_RETURN_EXTENSION_FUNCTION( clGetMutableCommandInfoKHR ); + + return nullptr; +} + bool clGetEventProfilingInfo_override( cl_event event, cl_profiling_info param_name, @@ -3377,9 +3615,9 @@ bool clGetEventProfilingInfo_override( case CL_PROFILING_COMMAND_SUBMIT: case CL_PROFILING_COMMAND_START: { - auto& context = getLayerContext(); - auto it = context.EventMap.find(event); - if (it != context.EventMap.end()) { + const auto& eventMap = getLayerContext().getEventMap(); + auto it = eventMap.find(event); + if (it != eventMap.end()) { cl_int errorCode = g_pNextDispatch->clGetEventProfilingInfo( it->second, param_name, @@ -3408,9 +3646,14 @@ bool clGetPlatformInfo_override( size_t* param_value_size_ret, cl_int* errcode_ret) { + const auto& platformInfo = getLayerContext().getPlatformInfo(platform); + if (platformInfo.emulate_cl_khr_command_buffer == false) { + return false; + } + switch(param_name) { case CL_PLATFORM_EXTENSIONS: - { + if (platformInfo.allDevicesSupportOpenCL21) { size_t size = 0; g_pNextDispatch->clGetPlatformInfo( platform, @@ -3419,73 +3662,61 @@ bool clGetPlatformInfo_override( nullptr, &size ); - std::vector platformExtensions(size); + std::string platformExtensions; + platformExtensions.resize(size); g_pNextDispatch->clGetPlatformInfo( platform, CL_PLATFORM_EXTENSIONS, size, - platformExtensions.data(), + &platformExtensions[0], nullptr ); + platformExtensions.pop_back(); - size = 0; - g_pNextDispatch->clGetPlatformInfo( - platform, - CL_PLATFORM_VERSION, - 0, - nullptr, - &size ); + // If we get this far, we're doing full emulation for the base + // command buffer extension and all layered extensions. Add all + // extensions, unless they're already in the extension string. - std::vector platformVersion(size); - g_pNextDispatch->clGetPlatformInfo( - platform, - CL_PLATFORM_VERSION, - size, - platformVersion.data(), - nullptr ); + std::string newExtensions; - if( checkStringForExtension( - platformExtensions.data(), - CL_KHR_COMMAND_BUFFER_EXTENSION_NAME ) == false && - getOpenCLVersionFromString( - platformVersion.data() ) >= CL_MAKE_VERSION(2, 1, 0)) - { - std::string newExtensions; + if (checkStringForExtension( + platformExtensions.c_str(), + CL_KHR_COMMAND_BUFFER_EXTENSION_NAME ) == false) { newExtensions += CL_KHR_COMMAND_BUFFER_EXTENSION_NAME; newExtensions += ' '; + } + if (checkStringForExtension( + platformExtensions.c_str(), + CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME ) == false) { newExtensions += CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME; + newExtensions += ' '; + } - std::string oldExtensions(platformExtensions.data()); - - // If the old extension string ends with a space ensure the - // new extension string does too. - if( oldExtensions.back() == ' ' ) - { - newExtensions += ' '; - } - else - { - oldExtensions += ' '; - } + // If the old extension string does not end with a space, remove the + // trailing space from the new extension string, and add a space + // separator. + if (!newExtensions.empty() && !platformExtensions.empty() && + platformExtensions.back() != ' ') { + newExtensions.pop_back(); + platformExtensions += ' '; + } - oldExtensions += newExtensions; + platformExtensions += newExtensions; - auto ptr = (char*)param_value; - cl_int errorCode = writeStringToMemory( - param_value_size, - oldExtensions.c_str(), - param_value_size_ret, - ptr ); + auto ptr = (char*)param_value; + cl_int errorCode = writeStringToMemory( + param_value_size, + platformExtensions.c_str(), + param_value_size_ret, + ptr ); - if( errcode_ret ) - { - errcode_ret[0] = errorCode; - } - return true; + if (errcode_ret) { + errcode_ret[0] = errorCode; } + return true; } break; case CL_PLATFORM_EXTENSIONS_WITH_VERSION: - { + if (platformInfo.allDevicesSupportOpenCL21) { size_t size = 0; g_pNextDispatch->clGetPlatformInfo( platform, @@ -3503,71 +3734,49 @@ bool clGetPlatformInfo_override( extensions.data(), nullptr ); - size = 0; - g_pNextDispatch->clGetPlatformInfo( - platform, - CL_PLATFORM_VERSION, - 0, - nullptr, - &size ); - - std::vector platformVersion(size); - g_pNextDispatch->clGetPlatformInfo( - platform, - CL_PLATFORM_VERSION, - size, - platformVersion.data(), - nullptr ); - - bool found = false; - for( const auto& extension : extensions ) - { - if( strcmp(extension.name, CL_KHR_COMMAND_BUFFER_EXTENSION_NAME) == 0 ) - { - found = true; - break; - } - } - - if( found == false && - getOpenCLVersionFromString( - platformVersion.data() ) >= CL_MAKE_VERSION(2, 1, 0)) - { - { - extensions.emplace_back(); - cl_name_version& extension = extensions.back(); - - memset(extension.name, 0, CL_NAME_VERSION_MAX_NAME_SIZE); - strcpy(extension.name, CL_KHR_COMMAND_BUFFER_EXTENSION_NAME); - - extension.version = version_cl_khr_command_buffer; - } - { - extensions.emplace_back(); - cl_name_version& extension = extensions.back(); - - memset(extension.name, 0, CL_NAME_VERSION_MAX_NAME_SIZE); - strcpy(extension.name, CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME); - - extension.version = version_cl_khr_command_buffer_mutable_dispatch; - } - - auto ptr = (cl_name_version*)param_value; - cl_int errorCode = writeVectorToMemory( - param_value_size, - extensions, - param_value_size_ret, - ptr ); + addOrUpdateExtensionVersion( + extensions, + CL_KHR_COMMAND_BUFFER_EXTENSION_NAME, + version_cl_khr_command_buffer); + addOrUpdateExtensionVersion( + extensions, + CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME, + version_cl_khr_command_buffer_mutable_dispatch); + + auto ptr = (cl_name_version*)param_value; + cl_int errorCode = writeVectorToMemory( + param_value_size, + extensions, + param_value_size_ret, + ptr ); - if( errcode_ret ) - { - errcode_ret[0] = errorCode; - } - return true; + if (errcode_ret) { + errcode_ret[0] = errorCode; } + return true; } break; default: break; } return false; } + +void clReleaseEvent_update( + cl_event event) +{ + cl_uint refCount = 0; + g_pNextDispatch->clGetEventInfo( + event, + CL_EVENT_REFERENCE_COUNT, + sizeof(refCount), + &refCount, + nullptr); + if (refCount == 1) { + auto& eventMap = getLayerContext().getEventMap(); + auto it = eventMap.find(event); + if (it != eventMap.end()) { + g_pNextDispatch->clReleaseEvent(it->second); + eventMap.erase(it); + } + } +} diff --git a/layers/10_cmdbufemu/emulate.h b/layers/10_cmdbufemu/emulate.h index 4bd494e..c7ed912 100644 --- a/layers/10_cmdbufemu/emulate.h +++ b/layers/10_cmdbufemu/emulate.h @@ -9,229 +9,13 @@ #include +extern int g_EmulateUnconditionally; extern bool g_EnhancedErrorChecking; extern bool g_KernelForProfiling; extern bool g_SuggestedLocalWorkSize; extern const struct _cl_icd_dispatch* g_pNextDispatch; -struct SLayerContext -{ - typedef std::map CEventMap; - CEventMap EventMap; -}; - -SLayerContext& getLayerContext(void); - -/////////////////////////////////////////////////////////////////////////////// -// Emulated Functions - -cl_command_buffer_khr CL_API_CALL clCreateCommandBufferKHR_EMU( - cl_uint num_queues, - const cl_command_queue* queues, - const cl_command_buffer_properties_khr* properties, - cl_int* errcode_ret); - -cl_int CL_API_CALL clFinalizeCommandBufferKHR_EMU( - cl_command_buffer_khr command_buffer); - -cl_int CL_API_CALL clRetainCommandBufferKHR_EMU( - cl_command_buffer_khr command_buffer); - -cl_int CL_API_CALL clReleaseCommandBufferKHR_EMU( - cl_command_buffer_khr command_buffer); - -cl_int CL_API_CALL clEnqueueCommandBufferKHR_EMU( - cl_uint num_queues, - cl_command_queue* queues, - cl_command_buffer_khr command_buffer, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event); - -cl_int CL_API_CALL clCommandBarrierWithWaitListKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandCopyBufferKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem src_buffer, - cl_mem dst_buffer, - size_t src_offset, - size_t dst_offset, - size_t size, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandCopyBufferRectKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem src_buffer, - cl_mem dst_buffer, - const size_t* src_origin, - const size_t* dst_origin, - const size_t* region, - size_t src_row_pitch, - size_t src_slice_pitch, - size_t dst_row_pitch, - size_t dst_slice_pitch, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandCopyBufferToImageKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem src_buffer, - cl_mem dst_image, - size_t src_offset, - const size_t* dst_origin, - const size_t* region, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandCopyImageKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem src_image, - cl_mem dst_image, - const size_t* src_origin, - const size_t* dst_origin, - const size_t* region, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandCopyImageToBufferKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem src_image, - cl_mem dst_buffer, - const size_t* src_origin, - const size_t* region, - size_t dst_offset, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandFillBufferKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem buffer, - const void* pattern, - size_t pattern_size, - size_t offset, - size_t size, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandFillImageKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_mem image, - const void* fill_color, - const size_t* origin, - const size_t* region, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandSVMMemcpyKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - void* dst_ptr, - const void* src_ptr, - size_t size, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandSVMMemFillKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - void* svm_ptr, - const void* pattern, - size_t pattern_size, - size_t size, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clCommandNDRangeKernelKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_queue command_queue, - const cl_command_properties_khr* properties, - cl_kernel kernel, - cl_uint work_dim, - const size_t* global_work_offset, - const size_t* global_work_size, - const size_t* local_work_size, - cl_uint num_sync_points_in_wait_list, - const cl_sync_point_khr* sync_point_wait_list, - cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle); - -cl_int CL_API_CALL clGetCommandBufferInfoKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_command_buffer_info_khr param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret); - -#if defined(cl_khr_command_buffer_multi_device) && 0 - -cl_command_buffer_khr CL_API_CALL clRemapCommandBufferKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_bool automatic, - cl_uint num_queues, - const cl_command_queue* queues, - cl_uint num_handles, - const cl_mutable_command_khr* handles, - cl_mutable_command_khr* handles_ret, - cl_int* errcode_ret); - -#endif // defined(cl_khr_command_buffer_multi_device) - -cl_int CL_API_CALL clUpdateMutableCommandsKHR_EMU( - cl_command_buffer_khr command_buffer, - cl_uint num_configs, - const cl_command_buffer_update_type_khr* config_types, - const void** configs ); - -cl_int CL_API_CALL clGetMutableCommandInfoKHR_EMU( - cl_mutable_command_khr command, - cl_mutable_command_info_khr param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret); - /////////////////////////////////////////////////////////////////////////////// // Override Functions @@ -259,6 +43,10 @@ bool clGetEventProfilingInfo_override( size_t* param_value_size_ret, cl_int* errcode_ret); +void* clGetExtensionFunctionAddressForPlatform_override( + cl_platform_id platform, + const char* func_name); + bool clGetPlatformInfo_override( cl_platform_id platform, cl_platform_info param_name, @@ -266,3 +54,9 @@ bool clGetPlatformInfo_override( void* param_value, size_t* param_value_size_ret, cl_int* errcode_ret); + +/////////////////////////////////////////////////////////////////////////////// +// Update Functions + +void clReleaseEvent_update( + cl_event event); diff --git a/layers/10_cmdbufemu/main.cpp b/layers/10_cmdbufemu/main.cpp index 2ac2d9d..160727b 100644 --- a/layers/10_cmdbufemu/main.cpp +++ b/layers/10_cmdbufemu/main.cpp @@ -28,6 +28,11 @@ #include "emulate.h" +// By default, if any devices in the platform support command buffers, +// emulation is not performed. + +int g_EmulateUnconditionally = 0; + // Enhanced error checking can be used to catch additional errors when // commands are recorded into a command buffer, but relies on tricky // use of user events that may not work properly with some implementations. @@ -131,47 +136,21 @@ clGetEventProfilingInfo_layer( return errorCode; } - -#define CHECK_RETURN_EXTENSION_FUNCTION( _funcname ) \ - if (strcmp(func_name, #_funcname) == 0) { \ - return (void*)_funcname##_EMU; \ - } - static void * CL_API_CALL clGetExtensionFunctionAddressForPlatform_layer( cl_platform_id platform, const char * func_name) { - // For now, prefer the emulated functions, even if the extension is - // supported natively. Eventually this should become smarter. - CHECK_RETURN_EXTENSION_FUNCTION( clCreateCommandBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clFinalizeCommandBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clRetainCommandBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clReleaseCommandBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clEnqueueCommandBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandBarrierWithWaitListKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyBufferRectKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyBufferToImageKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyImageKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandCopyImageToBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandFillBufferKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandFillImageKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandSVMMemcpyKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandSVMMemFillKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clCommandNDRangeKernelKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clGetCommandBufferInfoKHR ); - -#if defined(cl_khr_command_buffer_multi_device) && 0 - CHECK_RETURN_EXTENSION_FUNCTION( clRemapCommandBufferKHR ); -#endif - - CHECK_RETURN_EXTENSION_FUNCTION( clUpdateMutableCommandsKHR ); - CHECK_RETURN_EXTENSION_FUNCTION( clGetMutableCommandInfoKHR ); - - return g_pNextDispatch->clGetExtensionFunctionAddressForPlatform( + void* pFunction = clGetExtensionFunctionAddressForPlatform_override( platform, func_name); + if (pFunction == nullptr) { + pFunction = g_pNextDispatch->clGetExtensionFunctionAddressForPlatform( + platform, + func_name); + } + + return pFunction; } static cl_int CL_API_CALL @@ -206,22 +185,7 @@ static cl_int CL_API_CALL clReleaseEvent_layer( cl_event event) { - cl_uint refCount = 0; - g_pNextDispatch->clGetEventInfo( - event, - CL_EVENT_REFERENCE_COUNT, - sizeof(refCount), - &refCount, - nullptr); - if (refCount == 1) { - auto& context = getLayerContext(); - auto it = context.EventMap.find(event); - if (it != context.EventMap.end()) { - g_pNextDispatch->clReleaseEvent(it->second); - context.EventMap.erase(it); - } - } - + clReleaseEvent_update(event); return g_pNextDispatch->clReleaseEvent(event); } @@ -260,7 +224,8 @@ CL_API_ENTRY cl_int CL_API_CALL clGetLayerInfo( char str[256]; snprintf(str, 256, "Emulation Layer for " CL_KHR_COMMAND_BUFFER_EXTENSION_NAME - " (EEC: %s, KFP: %s, SLWS: %s)", + " (EU: %s, EEC: %s, KFP: %s, SLWS: %s)", + g_EmulateUnconditionally > 0 ? "Y" : "N", g_EnhancedErrorChecking ? "Y" : "N", g_KernelForProfiling ? "Y" : "N", g_SuggestedLocalWorkSize ? "Y" : "N"); @@ -299,12 +264,15 @@ CL_API_ENTRY cl_int CL_API_CALL clInitLayerWithProperties( return CL_INVALID_VALUE; } - _init_dispatch(); - + getControl("CMDBUFEMU_EmulateUnconditionally", g_EmulateUnconditionally); getControl("CMDBUFEMU_EnhancedErrorChecking", g_EnhancedErrorChecking); getControl("CMDBUFEMU_KernelForProfiling", g_KernelForProfiling); getControl("CMDBUFEMU_SuggestedLocalWorkSize", g_SuggestedLocalWorkSize); + if (g_EmulateUnconditionally >= 0) { + _init_dispatch(); + } + g_pNextDispatch = target_dispatch; *layer_dispatch_ret = &dispatch;