{"@context":"https://schema.org","@type":"QAPage","mainEntity":{"@type":"Question","name":"Arrayfire -> glium interaction possible?","text":"
Hi, I'm trying to get arrayfire and glium to cooperate; Is that currently possible with both libraries as they are? or is there some lower level work that needs to be done?
\n
Basically trying to figure out how to do this:
\n
let arr: Array<f32>\nglium::VertexBuffer::new_raw(display as &Facade, arr.device_ptr() ,bindings, arr.elements() * std::mem::size_of::<f32>()).unwrap()\n//or\nglium::buffer::Buffer::new<f32>(display as &Facade, arr.device_ptr(), BufferType::TextureBuffer, glium::buffer::BufferMode::Default)
\n
while keeping everything on the gpu and avoiding expensive gpu->cpu->gpu operations.
\n
Is this even possible? And if so, what steps need to be taken?
\nThanks!
","upvoteCount":2,"answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"
@nodeSpace Yes, I believe it is completely possible to do that. However, it would require some additional helper code apart from using the libraries glium and arrayfire. arrayfire/forge essentially handles the same workflow(avoids via CPU data transfers) which is ArrayFire's graphics(OpenGL based) functionality provider.
\n
Let's say you are using CUDA backend of ArrayFire.  Have a look at the functions from forge helper header: createGLBuffer, copyToGLBuffer, releaseGLBuffer for an idea on C++ code does it. You would need similar functions in rust that are written with glium as target. I think the following steps should essentially let you handle the OpenGL interop successfully.
\n
\n
Create a shared resource handle cudaGraphicsResource in rust using vertex buffer resource id returned by glium. Note that this vertex buffer's size in bytes should match the array you want to display. Matching data type is also important - Essentially what createGLBuffer does in forge project
\n
Copy data from CUDA device pointer to shared resource created in step (1). Note that this is also a device buffer sitting on GPU. So, you are essentially only doing a device-to-device memcopy which is many times faster than host-to-device/device-to-host copy. - Essentially what copyToGLBuffer does in forge project.
\n
Release the shared resource handle during program exit or when you are done using it.
\n
\n
This workflow would need CUDA rust API. You can take a look at arrayfire's CUDA/OpenCL interop crates to see what we use in those projects. Any crate exposes CUDA API will do the job of creating/copying/releasing the shared CUDA-OpenGL resource.
\n
\n
ArrayFire-CUDA Interop Crate
\n
ArrayFire-OpenCL Interop Crate
\n
\n
The entire process remains the same if you use OpenCL backend with OpenCL APIs replacing their respective CUDA APIs.
\n
Updated
\n
My mistake, I didn't mention one additional detail regarding OpenCL, you would need to some additional modifications to your code.
\n
Firstly, use ArrayFire's OpenCL interop crate - https://github.com/arrayfire/arrayfire-rust/tree/master/opencl-interop
\n
You need to use some crate that enables you use OpenCL API in rust, you can use the OpenCL crate that af-opencl-interop crate uses for easy integration.
\n
The following are the additional steps:
\n
\n
create an OpenCL context using OpenGL context handle
\n
Now add the device on which context from step (1) is created and the context itself to ArrayFire device manager - Please look at the documentation of af_opencl_interop for relevant functions.
\n
Set device to this newly added device in ArrayFire and use that for computations.
\n
\n
With the above setup done before any devices are used by OpenCL in ArrayFire. You should be able to share the OpenCL-OpenGL context. There are some examples in af-opencl-interop crate, please have a look - they might help with figuring out the opencl context creation etc.
","upvoteCount":2,"url":"https://github.com/arrayfire/arrayfire-rust/discussions/278#discussioncomment-348321"}}}