Remove L0 from nvml

zluda_ml/src/impl.rs

@@ -1,10 +1,12 @@
-use level_zero as l0;
 use std::io::Write;
+use std::slice;
 use std::{
     os::raw::{c_char, c_uint},
     ptr,
 };
 
+use ocl_core::ClVersions;
+
 use crate::nvml::nvmlReturn_t;
 
 macro_rules! stringify_nmvlreturn_t {
@@ -68,22 +70,41 @@ pub(crate) fn shutdown() -> nvmlReturn_t {
     nvmlReturn_t::NVML_SUCCESS
 }
 
+static mut DEVICE: Option<ocl_core::DeviceId> = None;
+
 pub(crate) fn init_v2() -> Result<(), nvmlReturn_t> {
-    Ok(l0::init()?)
+    let platforms = ocl_core::get_platform_ids()?;
+    let mut device = platforms.iter().find_map(|plat| {
+        let devices = ocl_core::get_device_ids(plat, Some(ocl_core::DeviceType::GPU), None).ok()?;
+        for dev in devices {
+            let vendor = ocl_core::get_device_info(dev, ocl_core::DeviceInfo::VendorId).ok()?;
+            match vendor {
+                ocl_core::DeviceInfoResult::VendorId(0x8086)
+                | ocl_core::DeviceInfoResult::VendorId(0x1002) => {}
+                _ => continue,
+            };
+            let dev_type = ocl_core::get_device_info(dev, ocl_core::DeviceInfo::Type).ok()?;
+            if let ocl_core::DeviceInfoResult::Type(ocl_core::DeviceType::GPU) = dev_type {
+                return Some(dev);
+            }
+        }
+        None
+    });
+    unsafe { DEVICE = device };
+    if device.is_some() {
+        Ok(())
+    } else {
+        Err(nvmlReturn_t::NVML_ERROR_UNKNOWN)
+    }
 }
 
 pub(crate) fn init_with_flags() -> Result<(), nvmlReturn_t> {
     init_v2()
 }
 
-impl From<l0::sys::ze_result_t> for nvmlReturn_t {
+impl From<ocl_core::Error> for nvmlReturn_t {
-    fn from(l0_err: l0::sys::ze_result_t) -> Self {
+    fn from(err: ocl_core::Error) -> Self {
-        match l0_err {
+        nvmlReturn_t::NVML_ERROR_UNKNOWN
-            l0::sys::ze_result_t::ZE_RESULT_ERROR_UNINITIALIZED => {
-                nvmlReturn_t::NVML_ERROR_UNINITIALIZED
-            }
-            _ => nvmlReturn_t::NVML_ERROR_UNKNOWN,
-        }
     }
 }
 
@@ -119,21 +140,25 @@ pub(crate) fn system_get_driver_version(
     if version_ptr == ptr::null_mut() {
         return Err(nvmlReturn_t::NVML_ERROR_INVALID_ARGUMENT);
     }
-    let drivers = l0::Driver::get()?;
+    let device = match unsafe { DEVICE } {
-    let output_slice =
+        Some(d) => d,
-        unsafe { std::slice::from_raw_parts_mut(version_ptr as *mut u8, (length - 1) as usize) };
+        None => return Err(nvmlReturn_t::NVML_ERROR_UNINITIALIZED),
-    let mut output_write = CountingWriter {
-        base: output_slice,
-        len: 0,
     };
-    for d in drivers {
+
-        let mut props = Default::default();
+    if let Ok(ocl_core::DeviceInfoResult::DriverVersion(driver_version)) =
-        d.get_properties(&mut props)?;
+        ocl_core::get_device_info(device, ocl_core::DeviceInfo::DriverVersion)
-        let driver_version = props.driverVersion;
+    {
+        let output_slice =
+            unsafe { slice::from_raw_parts_mut(version_ptr as *mut u8, (length - 1) as usize) };
+        let mut output_write = CountingWriter {
+            base: output_slice,
+            len: 0,
+        };
         write!(&mut output_write, "{}", driver_version)
             .map_err(|_| nvmlReturn_t::NVML_ERROR_UNKNOWN)?;
         unsafe { *(version_ptr.add(output_write.len)) = 0 };
-        return Ok(());
+        Ok(())
+    } else {
+        Err(nvmlReturn_t::NVML_ERROR_UNKNOWN)
     }
-    Err(nvmlReturn_t::NVML_ERROR_UNKNOWN)
 }