change the concurrent access atom size query to return an array

Author: bashbaug

include/CL/opencl.hpp

@@ -1577,8 +1577,8 @@ inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_
     F(cl_platform_info, CL_PLATFORM_SVM_TYPE_CAPABILITIES_KHR, cl::vector<cl_svm_capabilities_khr>) \
     \
     F(cl_device_info, CL_DEVICE_SVM_TYPE_CAPABILITIES_KHR, cl::vector<cl_svm_capabilities_khr>) \
-    F(cl_device_info, CL_DEVICE_SVM_CONCURRENT_ACCESS_ATOM_SIZE_KHR, size_type) \
-    \
+    F(cl_device_info, CL_DEVICE_SVM_CONCURRENT_ACCESS_ATOM_SIZE_KHR, cl::vector<size_type>) \
+    \~
     F(cl_svm_pointer_info_khr, CL_SVM_INFO_TYPE_INDEX_KHR, cl_uint) \
     F(cl_svm_pointer_info_khr, CL_SVM_INFO_CAPABILITIES_KHR, cl_svm_capabilities_khr) \
     F(cl_svm_pointer_info_khr, CL_SVM_INFO_PROPERTIES_KHR, cl::vector<cl_svm_alloc_properties_khr>) \

layers/99_svmplusplus/emulate.cpp

@@ -248,9 +248,9 @@ struct SLayerContext
         return TypeCapsDevice[device];
     }
 
-    const size_t getConcurrentAccessAtomSize(cl_device_id device)
+    const std::vector<size_t>& getConcurrentAccessAtomSizes(cl_device_id device)
     {
-        return ConcurrentAccessAtomSize[device];
+        return ConcurrentAccessAtomSizes[device];
     }
 
     const SUSMFuncs& getUSMFuncs(cl_platform_id platform)
@@ -434,7 +434,7 @@ struct SLayerContext
 
         for (auto device: devices) {
             std::vector<cl_svm_capabilities_khr> typeCapsDevice;
-            size_t concurrentAccessAtomSize = 0;
+            std::vector<size_t> concurrentAccessAtomSizes;
 
             for (auto caps: typeCapsPlatform) {
                 if ((caps & CL_SVM_TYPE_MACRO_DEVICE_KHR) == CL_SVM_TYPE_MACRO_DEVICE_KHR) {
@@ -459,13 +459,17 @@ struct SLayerContext
                     assert(0 && "unknown platform SVM type");
                 }
 
-                if (!typeCapsDevice.empty() && (typeCapsDevice.back() & CL_SVM_CAPABILITY_CONCURRENT_ACCESS_KHR)) {
-                    concurrentAccessAtomSize = 1;
+                if (typeCapsDevice.size() > concurrentAccessAtomSizes.size()) {
+                    if (typeCapsDevice.back() & CL_SVM_CAPABILITY_CONCURRENT_ACCESS_KHR) {
+                        concurrentAccessAtomSizes.push_back(1);
+                    } else {
+                        concurrentAccessAtomSizes.push_back(0);
+                    }
                 }
             }
 
             TypeCapsDevice[device] = typeCapsDevice;
-            ConcurrentAccessAtomSize[device] = concurrentAccessAtomSize;
+            ConcurrentAccessAtomSizes[device] = concurrentAccessAtomSizes;
         }
     }
 
@@ -508,7 +512,7 @@ struct SLayerContext
     std::map<cl_platform_id, std::vector<cl_svm_capabilities_khr>>  TypeCapsPlatform;
     std::map<cl_device_id, std::vector<cl_svm_capabilities_khr>>    TypeCapsDevice;
 
-    std::map<cl_device_id, size_t>  ConcurrentAccessAtomSize;
+    std::map<cl_device_id, std::vector<size_t>> ConcurrentAccessAtomSizes;
 
     std::map<cl_platform_id, SUSMFuncs> USMFuncs;
 
@@ -1121,11 +1125,11 @@ cl_int CL_API_CALL clGetDeviceInfo_override(
         break;
     case CL_DEVICE_SVM_CONCURRENT_ACCESS_ATOM_SIZE_KHR:
         {
-            const auto concurrentAccessAtomSize = getLayerContext().getConcurrentAccessAtomSize(device);
+            const auto& sizes = getLayerContext().getConcurrentAccessAtomSizes(device);
             auto ptr = (size_t*)param_value;
-            return writeParamToMemory(
+            return writeVectorToMemory(
                 param_value_size,
-                concurrentAccessAtomSize,
+                sizes,
                 param_value_size_ret,
                 ptr);
         }

samples/usvm/00_usvmqueries/main.cpp

@@ -117,15 +117,15 @@ int main(
             printf("Device[%zu]: %s\n",
                 d,
                 devices[d].getInfo<CL_DEVICE_NAME>().c_str());
-            printf("USM Concurrent Access Atom Size: %zu\n",
-                devices[d].getInfo<CL_DEVICE_SVM_CONCURRENT_ACCESS_ATOM_SIZE_KHR>());
-
             std::vector<cl_svm_capabilities_khr> typeCapsDevice =
                 devices[d].getInfo<CL_DEVICE_SVM_TYPE_CAPABILITIES_KHR>();
+            std::vector<size_t> concurrentAccessAtomSizes =
+                devices[d].getInfo<CL_DEVICE_SVM_CONCURRENT_ACCESS_ATOM_SIZE_KHR>();
             for (size_t t = 0; t < typeCapsDevice.size(); t++)
             {
                 printf("USM Type[%zu]:\n", t);
                 printf("\tinferred name: %s\n", get_svm_name(typeCapsDevice[t]));
+                printf("\tconcurrent access atom size: %zu\n", concurrentAccessAtomSizes[t]);
                 PrintUSVMCaps("\tcapabilities: ", typeCapsDevice[t]);
             }