fix: opencl.lib not found issue, by changing library that works dynamically

Author: WrldEngine

.github/workflows/release.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Installing OpenCL
         run: |
           sudo apt update
-          sudo apt install ocl-icd-opencl-dev
+          sudo apt install ocl-icd-opencl-dev -y
 
       - uses: actions/checkout@v4
       - name: Testing Rust modules
@@ -150,7 +150,7 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-    needs: [sdist]
+    needs: [test, sdist]
     permissions:
       id-token: write
       contents: write
@@ -159,7 +159,7 @@ jobs:
       - name: Installing OpenCL
         run: |
           sudo apt update
-          sudo apt install ocl-icd-opencl-dev
+          sudo apt install ocl-icd-opencl-dev -y
 
       - uses: actions/download-artifact@v4
       - name: Generate artifact attestation

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rem_math"
-version = "0.2.7"
+version = "0.2.8"
 edition = "2021"
 
 [lib]
@@ -19,7 +19,10 @@ crate-type = ["cdylib", "rlib"]
 numpy = "0.25.0"
 pyo3 = { version = "0.25.1", features = ["extension-module"] }
 rayon = "1.10.0"
-ocl = "0.19"
+
+[dependencies.opencl3]
+version = "0.11"
+features = ["CL_VERSION_2_1", "CL_VERSION_2_2", "CL_VERSION_3_0"]
 
 [dev-dependencies]
 criterion = "0.3"

build.rs

@@ -1,6 +1,6 @@
 [project]
 name = "rem_math"
-version = "0.2.7"
+version = "0.2.8"
 description = ""
 authors = [
     {name = "WrldEngine",email = "kamran_pulatov@outlook.com"}

pyproject.toml

@@ -0,0 +1,25 @@
+# syntax=docker/dockerfile:1
+
+FROM python:3.12
+
+WORKDIR /sandbox
+
+# OpenCLのライブラリインストールをします
+RUN apt update
+RUN apt install ocl-icd-opencl-dev -y
+
+RUN --mount=type=cache,target=/root/.cache/pip \
+    pip install rem-math
+
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/sbin/nologin" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+USER appuser
+
+ENTRYPOINT ["/bin/bash", "-c"]

python.Dockerfile

@@ -15,3 +15,7 @@ def multiply_two_nparr_ints32(
     arr_1: List[int] | NDArray, arr_2: List[int] | NDArray, method: str
 ) -> List: ...
 def multiply_two_ints32(arr_1: List[int], arr_2: List[int], method: str) -> List: ...
+def dot_two_nparr_floats32(
+    arr_1: List[float] | NDArray, arr_2: List[float] | NDArray, method: str
+) -> float: ...
+def dot_two_floats32(arr_1: List[float], arr_2: List[float], method: str) -> float: ...

rem_math/_rem_math.pyi

@@ -15,15 +15,17 @@ RUN apt-get update -y && \
   apt-get install -y pkg-config make g++ libssl-dev && \
   rustup target add x86_64-unknown-linux-gnu
 
+# OpenCLのライブラリインストールをします
+RUN apt update
+RUN apt install ocl-icd-opencl-dev -y
+
 RUN --mount=type=bind,source=src,target=src \
     --mount=type=bind,source=Cargo.toml,target=Cargo.toml \
     --mount=type=bind,source=Cargo.lock,target=Cargo.lock \
     --mount=type=cache,target=/$APP_WORKDIR/target/ \
     --mount=type=cache,target=/usr/local/cargo/registry/ \
     RUSTFLAGS="-Z threads=8" cargo +nightly build --release --locked
 
-WORKDIR ${APP_WORKDIR}
-
 ARG UID=10001
 RUN adduser \
     --disabled-password \
@@ -35,5 +37,4 @@ RUN adduser \
     appuser
 USER appuser
 
-COPY --from=build ${APP_WORKDIR} ${APP_WORKDIR}
 ENTRYPOINT ["/bin/bash", "-c"]

Dockerfile rust.DockerfileDockerfile renamed to rust.Dockerfile

@@ -1,86 +1,191 @@
 // NOTE: Work in progress, will be refactored
 
-extern crate ocl;
-use ocl::{Buffer, MemFlags, ProQue};
+use opencl3::command_queue::{CommandQueue, CL_QUEUE_PROFILING_ENABLE};
+use opencl3::context::Context;
+use opencl3::device::{get_all_devices, Device, CL_DEVICE_TYPE_GPU};
+use opencl3::kernel::{ExecuteKernel, Kernel};
+use opencl3::memory::{
+    Buffer, CL_MAP_WRITE, CL_MEM_COPY_HOST_PTR, CL_MEM_READ_ONLY, CL_MEM_READ_WRITE,
+    CL_MEM_WRITE_ONLY,
+};
+use opencl3::program::{Program, CL_STD_2_0};
+use opencl3::types::{
+    cl_double, cl_event, cl_float, cl_int, cl_long, CL_BLOCKING, CL_NON_BLOCKING,
+};
+
+use std::ptr;
 
 const KERNEL_SRC: &'static str = include_str!("kernel.cl");
 
-pub fn sum_two_ints32(arr_1: &[i32], arr_2: &[i32], result_vec: &mut Vec<i64>) {
-    let pro_que = ProQue::builder()
-        .src(KERNEL_SRC)
-        .dims(arr_1.len())
-        .build()
-        .unwrap();
-
-    let buffer_1 = Buffer::builder()
-        .queue(pro_que.queue().clone())
-        .flags(MemFlags::new().read_write())
-        .len(arr_1.len())
-        .copy_host_slice(&arr_1)
-        .build()
-        .unwrap();
-
-    let buffer_2 = Buffer::builder()
-        .queue(pro_que.queue().clone())
-        .flags(MemFlags::new().read_write())
-        .len(arr_1.len())
-        .copy_host_slice(&arr_2)
-        .build()
-        .unwrap();
-
-    let result = pro_que.create_buffer::<i64>().unwrap();
-
-    let kernel = pro_que
-        .kernel_builder("add_i")
-        .arg(&buffer_1)
-        .arg(&buffer_2)
-        .arg(&result)
-        .build()
-        .unwrap();
-
-    unsafe {
-        kernel.enq().unwrap();
-    }
-
-    result.read(result_vec).enq().unwrap();
+pub struct GPUKernelsDispatcher {
+    context: Context,
+    program: Program,
+    queue: CommandQueue,
 }
 
-pub fn dot_float(arr_1: &[f32], arr_2: &[f32], result_vec: &mut Vec<f32>) {
-    let pro_que = ProQue::builder()
-        .src(KERNEL_SRC)
-        .dims(arr_1.len())
-        .build()
-        .unwrap();
-
-    let buffer_1 = Buffer::builder()
-        .queue(pro_que.queue().clone())
-        .flags(MemFlags::new().read_write())
-        .len(arr_1.len())
-        .copy_host_slice(&arr_1)
-        .build()
-        .unwrap();
-
-    let buffer_2 = Buffer::builder()
-        .queue(pro_que.queue().clone())
-        .flags(MemFlags::new().read_write())
-        .len(arr_1.len())
-        .copy_host_slice(&arr_2)
-        .build()
-        .unwrap();
-
-    let result = pro_que.create_buffer::<f32>().unwrap();
-
-    let kernel = pro_que
-        .kernel_builder("dot_f")
-        .arg(&buffer_1)
-        .arg(&buffer_2)
-        .arg(&result)
-        .build()
-        .unwrap();
-
-    unsafe {
-        kernel.enq().unwrap();
+impl GPUKernelsDispatcher {
+    pub fn new() -> Self {
+        let device_id: *mut std::ffi::c_void = *get_all_devices(CL_DEVICE_TYPE_GPU)
+            .unwrap()
+            .first()
+            .expect("no device found in platform");
+
+        let device = Device::new(device_id);
+        let context = Context::from_device(&device).expect("Context::from_device failed");
+
+        let program = Program::create_and_build_from_source(&context, KERNEL_SRC, CL_STD_2_0)
+            .expect("Program::create_and_build_from_source failed");
+
+        let queue =
+            CommandQueue::create_default_with_properties(&context, CL_QUEUE_PROFILING_ENABLE, 0)
+                .expect("CommandQueue::create_default_with_properties failed");
+
+        Self {
+            context,
+            program,
+            queue,
+        }
+    }
+
+    pub fn sum_two_ints32(&self, arr_1: &[i32], arr_2: &[i32], result_vec: &mut Vec<i64>) {
+        let kernel = Kernel::create(&self.program, "add_i").expect("Kernel::create failed");
+
+        let mut arr_1_buf = unsafe {
+            Buffer::<cl_int>::create(
+                &self.context,
+                CL_MEM_READ_ONLY,
+                arr_1.len(),
+                ptr::null_mut(),
+            )
+            .expect("allocation error")
+        };
+        let mut arr_2_buf = unsafe {
+            Buffer::<cl_int>::create(
+                &self.context,
+                CL_MEM_READ_ONLY,
+                arr_2.len(),
+                ptr::null_mut(),
+            )
+            .expect("allocation error")
+        };
+        let result_buf = unsafe {
+            Buffer::<cl_long>::create(
+                &self.context,
+                CL_MEM_WRITE_ONLY,
+                result_vec.len(),
+                ptr::null_mut(),
+            )
+            .expect("allocation error")
+        };
+
+        let _arr_1_buf_write_event = unsafe {
+            self.queue
+                .enqueue_write_buffer(&mut arr_1_buf, CL_NON_BLOCKING, 0, &arr_1, &[])
+                .unwrap()
+        };
+        let _arr_2_buf_write_event = unsafe {
+            self.queue
+                .enqueue_write_buffer(&mut arr_2_buf, CL_NON_BLOCKING, 0, &arr_2, &[])
+                .unwrap()
+        };
+
+        let kernel_event = unsafe {
+            ExecuteKernel::new(&kernel)
+                .set_arg(&arr_1_buf)
+                .set_arg(&arr_2_buf)
+                .set_arg(&result_buf)
+                .set_global_work_size(arr_1.len())
+                .set_wait_event(&_arr_1_buf_write_event)
+                .set_wait_event(&_arr_2_buf_write_event)
+                .enqueue_nd_range(&self.queue)
+                .unwrap()
+        };
+
+        let mut events: Vec<cl_event> = Vec::default();
+        events.push(kernel_event.get());
+
+        let read_event = unsafe {
+            self.queue
+                .enqueue_read_buffer(&result_buf, CL_NON_BLOCKING, 0, result_vec, &events)
+                .unwrap()
+        };
+
+        read_event.wait().unwrap();
     }
 
-    result.read(result_vec).enq().unwrap();
+    pub fn dot_floats32(&self, arr_1: &[f32], arr_2: &[f32]) -> f32 {
+        let kernel = Kernel::create(&self.program, "dot_f").expect("Kernel::create failed");
+
+        let mut arr_1_buf = unsafe {
+            Buffer::<cl_float>::create(
+                &self.context,
+                CL_MEM_READ_ONLY,
+                arr_1.len(),
+                ptr::null_mut(),
+            )
+            .expect("opencl: allocation error")
+        };
+
+        let mut arr_2_buf = unsafe {
+            Buffer::<cl_float>::create(
+                &self.context,
+                CL_MEM_READ_ONLY,
+                arr_2.len(),
+                ptr::null_mut(),
+            )
+            .expect("opencl: allocation error")
+        };
+
+        let local_size = 64;
+        let group_count = (arr_1.len() + local_size - 1) / local_size;
+
+        let partial_buf = unsafe {
+            Buffer::<cl_float>::create(
+                &self.context,
+                CL_MEM_WRITE_ONLY,
+                group_count,
+                ptr::null_mut(),
+            )
+            .unwrap()
+        };
+
+        let _arr_1_buf_write_event = unsafe {
+            self.queue
+                .enqueue_write_buffer(&mut arr_1_buf, CL_NON_BLOCKING, 0, &arr_1, &[])
+                .unwrap()
+        };
+        let _arr_2_buf_write_event = unsafe {
+            self.queue
+                .enqueue_write_buffer(&mut arr_2_buf, CL_NON_BLOCKING, 0, &arr_2, &[])
+                .unwrap()
+        };
+
+        let kernel_event = unsafe {
+            ExecuteKernel::new(&kernel)
+                .set_arg(&arr_1_buf)
+                .set_arg(&arr_2_buf)
+                .set_arg(&partial_buf)
+                .set_global_work_size(arr_1.len())
+                .set_local_work_size(local_size)
+                .set_wait_event(&_arr_1_buf_write_event)
+                .set_wait_event(&_arr_2_buf_write_event)
+                .enqueue_nd_range(&self.queue)
+                .unwrap()
+        };
+
+        let mut events: Vec<cl_event> = Vec::default();
+        events.push(kernel_event.get());
+
+        let mut partial_results = vec![0.0f32; group_count];
+        let read_event = unsafe {
+            self.queue
+                .enqueue_read_buffer(&partial_buf, CL_BLOCKING, 0, &mut partial_results, &[])
+                .unwrap()
+        };
+
+        let result: f32 = partial_results.iter().sum();
+        read_event.wait().unwrap();
+
+        result
+    }
 }