Add devices init to platform

Author: omarahmed1111

source/adapters/opencl/device.cpp

@@ -54,7 +54,7 @@ ur_result_t cl_adapter::checkDeviceExtensions(
 
 UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(ur_platform_handle_t hPlatform,
                                                 ur_device_type_t DeviceType,
-                                                uint32_t NumEntries,
+                                                [[maybe_unused]] uint32_t NumEntries,
                                                 ur_device_handle_t *phDevices,
                                                 uint32_t *pNumDevices) {
 
@@ -75,24 +75,26 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(ur_platform_handle_t hPlatform,
     Type = CL_DEVICE_TYPE_ACCELERATOR;
     break;
   case UR_DEVICE_TYPE_DEFAULT:
-    Type = UR_DEVICE_TYPE_DEFAULT;
+    Type = CL_DEVICE_TYPE_DEFAULT;
     break;
   default:
     return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
-
-  CL_RETURN_ON_FAILURE(hPlatform->GetDevices(Type));
-  size_t NumDevices = hPlatform->Devices.size();
   try {
-    if (pNumDevices) {
-      *pNumDevices = NumDevices;
-    }
-
-    if (phDevices) {
-      for (size_t i = 0; i < std::min(size_t(NumEntries), NumDevices); ++i) {
-        phDevices[i] = hPlatform->Devices[i];
+    uint32_t AllDevicesNum = hPlatform->Devices.size();
+    uint32_t DeviceNumIter = 0;
+    for (uint32_t i = 0; i < AllDevicesNum; i++) {
+      cl_device_type DeviceType = hPlatform->Devices[i]->Type;
+      if (DeviceType == Type || Type == CL_DEVICE_TYPE_ALL) {
+        if (phDevices) {
+          phDevices[DeviceNumIter] = hPlatform->Devices[i];
+        }
+        DeviceNumIter++;
       }
     }
+    if (pNumDevices) {
+      *pNumDevices = DeviceNumIter;
+    }
 
     return UR_RESULT_SUCCESS;
   } catch (ur_result_t Err) {
@@ -329,9 +331,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
    * to UR */
   switch (static_cast<uint32_t>(propName)) {
   case UR_DEVICE_INFO_TYPE: {
-    cl_device_type CLType;
-    CL_RETURN_ON_FAILURE(clGetDeviceInfo(
-        hDevice->get(), CLPropName, sizeof(cl_device_type), &CLType, nullptr));
+    cl_device_type CLType = hDevice->Type;
 
     /* TODO UR: If the device is an Accelerator (FPGA, VPU, etc.), there is not
      * enough information in the OpenCL runtime to know exactly which type it
@@ -861,7 +861,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_MAX_PARAMETER_SIZE:
   case UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION:
   case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE:
-  case UR_DEVICE_INFO_PARENT_DEVICE:
   case UR_DEVICE_INFO_IL_VERSION:
   case UR_DEVICE_INFO_NAME:
   case UR_DEVICE_INFO_VENDOR:
@@ -895,6 +894,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     }
     return UR_RESULT_ERROR_INVALID_DEVICE;
   }
+  case UR_DEVICE_INFO_PARENT_DEVICE: {
+    return ReturnValue(hDevice->ParentDevice);
+  }
   case UR_DEVICE_INFO_EXTENSIONS: {
     cl_device_id Dev = hDevice->get();
     size_t ExtSize = 0;
@@ -997,9 +999,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urDevicePartition(
     CL_RETURN_ON_FAILURE(clCreateSubDevices(hDevice->get(), CLProperties.data(),
                                             CLNumDevicesRet,
                                             CLSubDevices.data(), nullptr));
-
-    std::memcpy(phSubDevices, CLSubDevices.data(),
-                sizeof(cl_device_id) * NumDevices);
+    for (uint32_t i = 0; i < NumDevices; i++) {
+      phSubDevices[i] = new ur_device_handle_t_(CLSubDevices[i], hDevice->Platform, hDevice);
+    }
   }
 
   return UR_RESULT_SUCCESS;
@@ -1031,7 +1033,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
     ur_native_handle_t hNativeDevice, ur_platform_handle_t hPlatform,
     const ur_device_native_properties_t *, ur_device_handle_t *phDevice) {
   cl_device_id NativeHandle = reinterpret_cast<cl_device_id>(hNativeDevice);
-  *phDevice = new ur_device_handle_t_(NativeHandle, hPlatform);
+  *phDevice = new ur_device_handle_t_(NativeHandle, hPlatform, nullptr);
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/opencl/device.hpp

@@ -23,9 +23,17 @@ struct ur_device_handle_t_ {
   using native_type = cl_device_id;
   native_type Device;
   ur_platform_handle_t Platform;
+  cl_device_type Type = 0;
+  ur_device_handle_t ParentDevice = nullptr; 
 
-  ur_device_handle_t_(native_type Dev, ur_platform_handle_t Plat)
-      : Device(Dev), Platform(Plat) {}
+  ur_device_handle_t_(native_type Dev, ur_platform_handle_t Plat, ur_device_handle_t Parent)
+      : Device(Dev), Platform(Plat), ParentDevice(Parent) {
+    if (Parent) {
+      Type = Parent->Type;
+    } else {
+      clGetDeviceInfo(Device, CL_DEVICE_TYPE, sizeof(cl_device_type), &Type, nullptr);
+    }
+  }
 
   ~ur_device_handle_t_() {}
 

source/adapters/opencl/platform.cpp

@@ -87,20 +87,46 @@ UR_APIEXPORT ur_result_t UR_APICALL
 urPlatformGet(ur_adapter_handle_t *, uint32_t, uint32_t NumEntries,
               ur_platform_handle_t *phPlatforms, uint32_t *pNumPlatforms) {
 
-  std::vector<cl_platform_id> CLPlatforms(NumEntries);
-  cl_int Result = clGetPlatformIDs(cl_adapter::cast<cl_uint>(NumEntries),
-                                   CLPlatforms.data(),
-                                   cl_adapter::cast<cl_uint *>(pNumPlatforms));
+  static std::vector<ur_platform_handle_t> URPlatforms;
+  static std::once_flag InitFlag;
+  static uint32_t NumPlatforms = 0;
+  cl_int Result = CL_SUCCESS;
+
+  std::call_once(
+    InitFlag,
+    [](cl_int &Result) {
+      Result = clGetPlatformIDs(0, nullptr, &NumPlatforms);
+      if (Result != CL_SUCCESS) {
+        return Result;
+      }
+      std::vector<cl_platform_id> CLPlatforms(NumPlatforms);
+      Result = clGetPlatformIDs(cl_adapter::cast<cl_uint>(NumPlatforms),
+                                CLPlatforms.data(),
+                                nullptr);
+      if (Result != CL_SUCCESS) {
+        return Result;
+      }
+      URPlatforms.resize(NumPlatforms);
+      for (uint32_t i = 0; i < NumPlatforms; i++) {
+        URPlatforms[i] = new ur_platform_handle_t_(CLPlatforms[i]);
+      }
+      return Result;
+    },
+    Result);
+
   /* Absorb the CL_PLATFORM_NOT_FOUND_KHR and just return 0 in num_platforms */
   if (Result == CL_PLATFORM_NOT_FOUND_KHR) {
     Result = CL_SUCCESS;
     if (pNumPlatforms) {
       *pNumPlatforms = 0;
     }
   }
+  if (pNumPlatforms != nullptr) {
+    *pNumPlatforms = NumPlatforms;
+  }
   if (NumEntries && phPlatforms) {
     for (uint32_t i = 0; i < NumEntries; i++) {
-      phPlatforms[i] = new ur_platform_handle_t_(CLPlatforms[i]);
+      phPlatforms[i] = URPlatforms[i];
     }
   }
   return mapCLErrorToUR(Result);

source/adapters/opencl/platform.hpp

@@ -179,6 +179,7 @@ struct ur_platform_handle_t_ {
 
   ur_platform_handle_t_(native_type Plat) : Platform(Plat) {
     ExtFuncPtr = std::make_unique<cl_adapter::ExtFuncPtrT>();
+    InitDevices();
   }
 
   ~ur_platform_handle_t_() { ExtFuncPtr.reset(); }
@@ -199,16 +200,16 @@ struct ur_platform_handle_t_ {
 
   native_type get() { return Platform; }
 
-  ur_result_t GetDevices(cl_device_type Type) {
+  ur_result_t InitDevices() {
     cl_uint DeviceNum = 0;
-    CL_RETURN_ON_FAILURE(clGetDeviceIDs(Platform, Type, 0, nullptr, &DeviceNum));
+    CL_RETURN_ON_FAILURE(clGetDeviceIDs(Platform, CL_DEVICE_TYPE_ALL, 0, nullptr, &DeviceNum));
 
     std::vector<cl_device_id> CLDevices(DeviceNum);
-    CL_RETURN_ON_FAILURE(clGetDeviceIDs(Platform, Type, DeviceNum, CLDevices.data(), nullptr));
+    CL_RETURN_ON_FAILURE(clGetDeviceIDs(Platform, CL_DEVICE_TYPE_ALL, DeviceNum, CLDevices.data(), nullptr));
 
     Devices = std::vector<ur_device_handle_t>(DeviceNum);
     for (size_t i = 0; i < DeviceNum; i++) {
-        Devices[i] = new ur_device_handle_t_(CLDevices[i], this);
+        Devices[i] = new ur_device_handle_t_(CLDevices[i], this, nullptr);
     }
 
     return UR_RESULT_SUCCESS;