Method convolution_forward

crates/cudnn/src/context.rs:1148–1217

This function executes convolutions or cross-correlations over `x` using a filter specified with `w`, returning results in `y`. # Arguments `alpha` - scaling parameter. `x` - input map. `w` - filter. `conv_desc` - convolution descriptor. `algo` - convolution algorithm that should be used to compute the result. `work_space` - a buffer to GPU memory to a workspace needed to be able to execut

(
        &self,
        alpha: CompType,
        x: &Tensor<T1, F1, impl GpuBuffer<T1>, D>,
        w: &Filter<T2, F2, impl GpuBuffer<T2>, D>,
        conv_desc: &ConvolutionDescriptor<CompType, N>,

    /// are supported by cuDNN. Refer to the following link for the
    /// [complete list](https://docs.nvidia.com/deeplearning/cudnn/api/index.html#cudnnConvolutionForward).
    pub fn convolution_forward<
        T1,
        F1,
        T2,
        F2,
        CompType,
        T3,
        F3,
        A,
        W,
        const D: usize,
        const N: usize,
    >(
        &self,
        alpha: CompType,
        x: &Tensor<T1, F1, impl GpuBuffer<T1>, D>,
        w: &Filter<T2, F2, impl GpuBuffer<T2>, D>,
        conv_desc: &ConvolutionDescriptor<CompType, N>,
        algo: &A,
        work_space: Option<&mut W>,
        beta: CompType,
        y: &mut Tensor<T3, F3, impl GpuBuffer<T3>, D>,
    ) -> Result<(), CudnnError>
    where
        T1: DataType,
        F1: TensorFormat + SupportedType<T1>,
        T2: DataType,
        F2: TensorFormat + SupportedType<T2>,
        CompType: DataType,
        T3: DataType,
        F3: TensorFormat + SupportedType<T3>,
        A: ConvolutionFwdAlgo + SupportedConvFwd<T1, F1, T2, F2, CompType, T3, F3, D, N>,
        W: GpuBuffer<u8>,
    {
        let x_data = x.data().as_device_ptr().as_raw();
        let x_desc = x.descriptor();

        let w_data = w.data().as_device_ptr().as_raw();
        let w_desc = w.descriptor();

        let y_data = y.data().as_device_ptr().as_ptr();
        let y_desc = y.descriptor();

        // If the _ size is 0 then the algorithm can work in-place and cuDNN expects a null
        // pointer.
        let (work_space_ptr, work_space_size): (*mut u8, usize) = {
            work_space.map_or((std::ptr::null_mut(), 0), |work_space| {
                (work_space.as_device_ptr().as_mut_ptr(), work_space.len())
            })
        };

        unsafe {
            sys::cudnnConvolutionForward(
                self.raw,
                &alpha as *const CompType as *const std::ffi::c_void,
                x_desc.raw,
                x_data as *const std::ffi::c_void,
                w_desc.raw,