1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
//! Dynamic bindings to OpenCL //! //! This library provides dynamically-loaded bindings to the system OpenCL //! library, allowing you to add optional OpenCL support to an application //! without requiring it as a linker dependency. Two APIs are available - raw, //! unsafe, one-to-one bindings to the OpenCL C API, and a higher-level, safe(r) //! and more convenient Rust API. //! //! The safe Rust API is only provided with the `safe` feature flag set, which //! is enabled by default. If you prefer only the unsafe raw bindings, you can //! disable the feature flag by setting `default_features = false` for the //! dependency in your project manifest. pub extern crate dlopen; #[macro_use] mod macros; pub mod raw; #[cfg(feature = "safe")] mod safe { pub mod buffer; pub mod context; pub mod device; mod error; pub mod kernel; pub mod platform; pub mod program; pub mod queue; pub mod util; pub use error::*; } #[cfg(feature = "safe")] pub use safe::*; use crate::raw::OpenCLVersion; /// Attempt to load the system OpenCL library, if not already loaded. /// /// This function will search for the OpenCL library using the absolute path or /// library name specified by the `OPENCL_LIBRARY` environment variable if set, /// and from the system library path using a platform-specific version of the /// name `OpenCL` if not set. /// /// Once the library has been found and opened, symbols will be loaded from it /// and bound to the appropriate function pointers in the `raw` module. This /// call will attempt to determine the OpenCL version supported by the library /// based on which symbols are present or missing, which will be returned. Any /// functions for which symbols could not be found will be replaced by a /// shim that simply panics. /// /// Calling any raw function before OpenCL has been loaded with this function /// will implicitly call this function to load OpenCL, panicking on failure. /// /// The result of this call (including implicit calls from raw function shims) /// will be stored in static memory, and future calls will simply return the /// stored result rather than attempting to load the library again. Since raw /// function pointers are replaced by this call, there is no overhead for OpenCL /// library calls once the functions have been bound. pub fn load_opencl() -> std::result::Result<OpenCLVersion, &'static dlopen::Error> { raw::functions::load_opencl() }