Method get_convolution_backward_data_algorithm

crates/cudnn/src/context.rs:686–757

This function serves as a heuristic for obtaining the best suited algorithm for `convolution_backward_data()` for the given layer specifications. It will return the best algorithm according to an internal heuristic. # Arguments `w_desc` - previously initialized filter descriptor. `dy_desc` - previously initialized differential tensor descriptor for the output map. `dx_desc` - previously initi

(
        &self,
        w_desc: &FilterDescriptor<T1, F1, D>,
        dy_desc: &TensorDescriptor<T2, F2, D>,
        dx_desc: &TensorDescriptor<T3, F3, D>,
        conv_desc: &ConvolutionDescriptor<C

    /// math type of the convolution descriptor according to the one of the returned algorithm to
    /// get the best possible performance.
    pub fn get_convolution_backward_data_algorithm<
        T1,
        F1,
        T2,
        F2,
        CompType,
        T3,
        F3,
        const D: usize,
        const N: usize,
    >(
        &self,
        w_desc: &FilterDescriptor<T1, F1, D>,
        dy_desc: &TensorDescriptor<T2, F2, D>,
        dx_desc: &TensorDescriptor<T3, F3, D>,
        conv_desc: &ConvolutionDescriptor<CompType, N>,
    ) -> Result<BestHeuristic<sys::cudnnConvolutionBwdDataAlgo_t>, CudnnError>
    where
        T1: DataType,
        F1: TensorFormat + SupportedType<T1>,
        T2: DataType,
        F2: TensorFormat + SupportedType<T2>,
        CompType: DataType,
        T3: DataType,
        F3: TensorFormat + SupportedType<T3>,
        BestHeuristic<sys::cudnnConvolutionBwdDataAlgo_t>:
            SupportedConvBwdData<T1, F1, T2, F2, CompType, T3, F3, D, N>,
    {
        let mut returned_algo_count = MaybeUninit::uninit();
        let mut perf_results = MaybeUninit::uninit();

        unsafe {
            sys::cudnnGetConvolutionBackwardDataAlgorithm_v7(
                self.raw,
                w_desc.raw,
                dy_desc.raw,
                conv_desc.raw,
                dx_desc.raw,
                1,
                returned_algo_count.as_mut_ptr(),
                perf_results.as_mut_ptr(),
            )
            .into_result()?;

            let returned_algo_count = returned_algo_count.assume_init();

            match returned_algo_count {
                // This is general enough so that in the future it can be expanded to be more
                // complex.
                1 => {
                    let results: Vec<BestHeuristic<sys::cudnnConvolutionBwdDataAlgo_t>> = {
                        let raw_results = std::slice::from_raw_parts(
                            perf_results.as_ptr(),
                            returned_algo_count as usize,
                        );

                        raw_results
                            .iter()