| // The MIT License (MIT) |
| // |
| // Copyright (c) 2016 Northeastern University |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| // SOFTWARE. |
| |
| #ifndef CORE_INCLUDE_DNN_WRAPPER_H_ |
| #define CORE_INCLUDE_DNN_WRAPPER_H_ |
| |
| #include <iostream> |
| #include <string> |
| #include "common.h" |
| #include "dnn_utility.h" |
| #include "data_manager.h" |
| #include "timer.h" |
| |
| namespace dnnmark { |
| |
| // |
| // Convolution forward/backward functions |
| // |
| |
| template <typename T> |
| inline void dnnmarkConvolutionForward(const Handle &handle, |
| RunMode mode, int idx, Timer *timer, |
| const void *alpha, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const ConvolutionDesc<T> &conv_desc, |
| const void *w, |
| ConvAlgo<T> *conv_algo, |
| void *workspace, |
| size_t workspace_in_bytes, |
| const void *beta, |
| const DataTensor<T> &top_desc, |
| void *y) { |
| #ifdef NVIDIA_CUDNN |
| ProfilerStart(handle, mode, idx, timer, "ConvFwd"); |
| CUDNN_CALL(cudnnConvolutionForward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| alpha, |
| bottom_desc.Get(), x, |
| conv_desc.GetFilter(), w, |
| conv_desc.GetConv(), |
| conv_algo->GetFwdAlgo(), workspace, workspace_in_bytes, |
| beta, |
| top_desc.Get(), y)); |
| ProfilerStop(handle, mode, idx, timer, "ConvFwd"); |
| #endif |
| #ifdef AMD_MIOPEN |
| |
| conv_algo->FindFwdAlgo(handle, mode, idx, |
| bottom_desc, |
| conv_desc, |
| top_desc, |
| x, w, y, |
| workspace, workspace_in_bytes); |
| ProfilerStart(handle, mode, idx, timer, "ConvFwd"); |
| MIOPEN_CALL(miopenConvolutionForward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| alpha, |
| bottom_desc.Get(), x, |
| conv_desc.GetFilter(), w, |
| conv_desc.GetConv(), |
| conv_algo->GetFwdAlgo(), |
| beta, |
| top_desc.Get(), y, |
| workspace, workspace_in_bytes)); |
| ProfilerStop(handle, mode, idx, timer, "ConvFwd"); |
| #endif |
| |
| } |
| |
| template <typename T> |
| inline void dnnmarkConvolutionBackwardData(const Handle &handle, |
| RunMode mode, int idx, Timer *timer, |
| const void *alpha, |
| const DataTensor<T> &top_desc, |
| const void *dy, |
| const ConvolutionDesc<T> &conv_desc, |
| const void *w, |
| ConvAlgo<T> *conv_algo, |
| void *workspace, |
| size_t workspace_in_bytes, |
| const void *beta, |
| const DataTensor<T> &bottom_desc, |
| void *dx) { |
| #ifdef NVIDIA_CUDNN |
| ProfilerStart(handle, mode, idx, timer, "ConvBwdData"); |
| CUDNN_CALL(cudnnConvolutionBackwardData( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| alpha, |
| conv_desc.GetFilter(), w, |
| top_desc.Get(), dy, |
| conv_desc.GetConv(), |
| conv_algo->GetBwdDataAlgo(), |
| workspace, workspace_in_bytes, |
| beta, |
| bottom_desc.Get(), dx)); |
| ProfilerStop(handle, mode, idx, timer, "ConvBwdData"); |
| #endif |
| #ifdef AMD_MIOPEN |
| conv_algo->FindBwdDataAlgo(handle, mode, idx, |
| bottom_desc, |
| conv_desc, |
| top_desc, |
| dy, w, dx, |
| workspace, workspace_in_bytes); |
| ProfilerStart(handle, mode, idx, timer, "ConvBwdData"); |
| MIOPEN_CALL(miopenConvolutionBackwardData( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| alpha, |
| top_desc.Get(), dy, |
| conv_desc.GetFilter(), w, |
| conv_desc.GetConv(), |
| conv_algo->GetBwdDataAlgo(), |
| beta, |
| bottom_desc.Get(), dx, |
| workspace, workspace_in_bytes)); |
| ProfilerStop(handle, mode, idx, timer, "ConvBwdData"); |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkConvolutionBackwardFilter(const Handle &handle, |
| RunMode mode, int idx, Timer *timer, |
| const void *alpha, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const DataTensor<T> &top_desc, |
| const void *dy, |
| const ConvolutionDesc<T> &conv_desc, |
| ConvAlgo<T> *conv_algo, |
| void *workspace, |
| size_t workspace_in_bytes, |
| const void *beta, |
| void *dw) { |
| #ifdef NVIDIA_CUDNN |
| // std::string conv_algo_param; |
| cudnnFilterDescriptor_t filter_t = conv_desc.GetFilter(); |
| ProfilerStart(handle, mode, idx, timer, "ConvBwdFilter"); |
| // conv_algo_param = conv_algo->GetBwdFilterAlgoParameter(); |
| // // std::cout << "algo_param "<< conv_algo_param <<"\n"; |
| // if (conv_algo_param == "autoex") { |
| // conv_algo->checkAlgo4DataShape(bottom_desc.Get(),top_desc.Get(), filter_t); |
| // // ,workspace_in_bytes); |
| // conv_algo->FindBwdFilterAlgoEx(handle, mode, idx, |
| // bottom_desc, |
| // conv_desc, |
| // top_desc, |
| // x, dy, dw, |
| // workspace, workspace_in_bytes); |
| |
| // LOG(INFO) << "cuDNN AUTO selected conv. bwd filter alg. to " << conv_algo->GetBwdFilterAlgo(); |
| // std::cout << "cuDNN AUTO selected bwd convolution filter algorithm:"<<conv_algo->GetBwdFilterAlgo()<<"\n"; |
| // } |
| CUDNN_CALL(cudnnConvolutionBackwardFilter( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| alpha, |
| bottom_desc.Get(), x, |
| top_desc.Get(), dy, |
| conv_desc.GetConv(), |
| conv_algo->GetBwdFilterAlgo(), |
| workspace, workspace_in_bytes, |
| beta, |
| filter_t, dw)); |
| ProfilerStop(handle, mode, idx, timer, "ConvBwdFilter"); |
| #endif |
| #ifdef AMD_MIOPEN |
| conv_algo->FindBwdFilterAlgo(handle, mode, idx, |
| bottom_desc, |
| conv_desc, |
| top_desc, |
| x, dy, dw, |
| workspace, workspace_in_bytes); |
| ProfilerStart(handle, mode, idx, timer, "ConvBwdFilter"); |
| MIOPEN_CALL(miopenConvolutionBackwardWeights( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| alpha, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), x, |
| conv_desc.GetConv(), |
| conv_algo->GetBwdFilterAlgo(), |
| beta, |
| conv_desc.GetFilter(), dw, |
| workspace, workspace_in_bytes)); |
| ProfilerStop(handle, mode, idx, timer, "ConvBwdFilter"); |
| #endif |
| } |
| |
| // |
| // Pooling forward/backward functions |
| // |
| |
| template <typename T> |
| inline void dnnmarkPoolingForward(const Handle &handle, |
| RunMode mode, int idx, |
| const PoolingDesc<T> &pooling_desc, |
| const void *alpha, |
| const DataTensor<T> &x_desc, |
| const void *x, |
| const void *beta, |
| const DataTensor<T> &y_desc, |
| void * y, |
| Data<T> *workspace, |
| size_t workspace_in_bytes) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnPoolingForward( |
| mode == COMPOSED ? handle.GetCudnn(idx) : handle.GetCudnn(), |
| pooling_desc.Get(), |
| alpha, |
| x_desc.Get(), x, |
| beta, |
| y_desc.Get(), y)); |
| #endif |
| #ifdef AMD_MIOPEN |
| LOG(INFO) << "Before MIOpen call"; |
| MIOPEN_CALL(miopenPoolingForward( |
| mode == COMPOSED ? handle.GetMIOpen(idx):handle.GetMIOpen(), |
| pooling_desc.Get(), |
| alpha, |
| x_desc.Get(), x, |
| beta, |
| y_desc.Get(), y, |
| false, |
| workspace->Get(), workspace_in_bytes)); |
| LOG(INFO) << "Done with MIOpen call"; |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkPoolingBackward(const Handle &handle, |
| RunMode mode, int idx, |
| const PoolingDesc<T> &pooling_desc, |
| const void *alpha, |
| const DataTensor<T> &y_desc, |
| const void *y, |
| const DataTensor<T> &dy_desc, |
| const void *dy, |
| const DataTensor<T> &x_desc, |
| const void *x, |
| const void *beta, |
| const DataTensor<T> &dx_desc, |
| void *dx, |
| Data<T> *workspace) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnPoolingBackward( |
| mode == COMPOSED ? handle.GetCudnn(idx) : handle.GetCudnn(), |
| pooling_desc.Get(), |
| alpha, |
| y_desc.Get(), y, |
| dy_desc.Get(), dy, |
| x_desc.Get(), x, |
| beta, |
| dx_desc.Get(), dx)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenPoolingBackward( |
| mode == COMPOSED ? handle.GetMIOpen() : handle.GetMIOpen(), |
| pooling_desc.Get(), |
| alpha, |
| y_desc.Get(), y, |
| dy_desc.Get(), dy, |
| x_desc.Get(), x, |
| beta, |
| dx_desc.Get(), dx, |
| workspace->Get())); |
| #endif |
| } |
| |
| // |
| // Activation forward/backward functions |
| // |
| |
| template <typename T> |
| inline void dnnmarkActivationForward(const Handle &handle, |
| RunMode mode, int idx, |
| const ActivationDesc<T> &activation_desc, |
| const void *alpha, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const void *beta, |
| const DataTensor<T> &top_desc, |
| void *y) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnActivationForward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| activation_desc.Get(), |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenActivationForward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| activation_desc.Get(), |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y)); |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkActivationBackward(const Handle &handle, |
| RunMode mode, int idx, |
| const ActivationDesc<T> &activation_desc, |
| const void *alpha, |
| const DataTensor<T> &top_desc, |
| const void *y, |
| const void *dy, |
| const void *beta, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| void *dx) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnActivationBackward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| activation_desc.Get(), |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), x, |
| beta, |
| bottom_desc.Get(), dx)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenActivationBackward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| activation_desc.Get(), |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), x, |
| beta, |
| bottom_desc.Get(), dx)); |
| #endif |
| } |
| |
| // |
| // LRN forward/backward functions |
| // |
| |
| template <typename T> |
| inline void dnnmarkLRNForward(const Handle &handle, |
| RunMode mode, int idx, |
| const LRNDesc<T> &lrn_desc, |
| const LRNParam &lrn_param, |
| const void *alpha, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const void *beta, |
| const DataTensor<T> &top_desc, |
| void *y, |
| Data<T> *workspace) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnLRNCrossChannelForward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| lrn_desc.Get(), |
| lrn_param.mode_, |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenLRNForward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| lrn_desc.Get(), |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y, |
| true, workspace->Get())); |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkLRNBackward(const Handle &handle, |
| RunMode mode, int idx, |
| const LRNDesc<T> &lrn_desc, |
| const LRNParam &lrn_param, |
| const void *alpha, |
| const DataTensor<T> &top_desc, |
| const void *y, |
| const void *dy, |
| const void *beta, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| void *dx, |
| Data<T> *workspace) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnLRNCrossChannelBackward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| lrn_desc.Get(), |
| lrn_param.mode_, |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), x, |
| beta, |
| bottom_desc.Get(), dx)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenLRNBackward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| lrn_desc.Get(), |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), x, |
| beta, |
| bottom_desc.Get(), dx, |
| workspace->Get())); |
| #endif |
| } |
| |
| // |
| // Fully Connected forward/backward functions |
| // |
| |
| // |
| // Softmax forward/backward functions |
| // |
| |
| template <typename T> |
| inline void dnnmarkSoftmaxForward(const Handle &handle, |
| RunMode mode, int idx, |
| const SoftmaxParam &softmax_param, |
| const void *alpha, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const void *beta, |
| const DataTensor<T> &top_desc, |
| void *y) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnSoftmaxForward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| softmax_param.algo_, |
| softmax_param.mode_, |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenSoftmaxForward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y)); |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkSoftmaxBackward(const Handle &handle, |
| RunMode mode, int idx, |
| const SoftmaxParam &softmax_param, |
| const void *alpha, |
| const DataTensor<T> &top_desc, |
| const void *y, |
| const void *dy, |
| const void *beta, |
| const DataTensor<T> &bottom_desc, |
| void *dx) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnSoftmaxBackward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| softmax_param.algo_, |
| softmax_param.mode_, |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| beta, |
| bottom_desc.Get(), dx)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenSoftmaxBackward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| beta, |
| bottom_desc.Get(), dx)); |
| |
| #endif |
| } |
| |
| // |
| // Batch Normalization forward/backward functions |
| // |
| |
| template <typename T> |
| inline void dnnmarkBatchNormalizationForwardTraining( |
| const Handle &handle, |
| RunMode mode, int idx, |
| const BatchNormParam &bn_param, |
| void *alpha, |
| void *beta, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const DataTensor<T> &top_desc, |
| void *y, |
| const DataTensor<T> &scale_bias_mean_var_desc, |
| void *bn_scale, |
| void *bn_bias, |
| double exp_avg_factor, |
| void *result_running_mean, |
| void *result_running_var, |
| double epsilon, |
| void *result_save_mean, |
| void *result_save_var) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnBatchNormalizationForwardTraining( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| bn_param.mode_, |
| alpha, |
| beta, |
| bottom_desc.Get(), x, |
| top_desc.Get(), y, |
| scale_bias_mean_var_desc.Get(), |
| bn_scale, bn_bias, |
| exp_avg_factor, |
| result_running_mean, result_running_var, |
| epsilon, |
| result_save_mean, result_save_var)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenBatchNormalizationForwardTraining( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| bn_param.mode_, |
| alpha, |
| beta, |
| bottom_desc.Get(), x, |
| top_desc.Get(), y, |
| scale_bias_mean_var_desc.Get(), |
| bn_scale, bn_bias, |
| exp_avg_factor, |
| result_running_mean, result_running_var, |
| epsilon, |
| result_save_mean, result_save_var)); |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkBatchNormalizationBackward( |
| const Handle &handle, |
| RunMode mode, int idx, |
| const BatchNormParam &bn_param, |
| const void *alpha_data_diff, |
| const void *beta_data_diff, |
| const void *alpha_param_diff, |
| const void *beta_param_diff, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| void *dx, |
| const DataTensor<T> &top_desc, |
| const void *dy, |
| const DataTensor<T> &scale_bias_mean_var_desc, |
| const void *bn_scale, |
| void *result_bn_scale_diff, |
| void *result_bn_bias_diff, |
| double epsilon, |
| const void *saved_mean, |
| const void *saved_var) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnBatchNormalizationBackward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| bn_param.mode_, |
| alpha_data_diff, |
| beta_data_diff, |
| alpha_param_diff, |
| beta_param_diff, |
| bottom_desc.Get(), x, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), dx, |
| scale_bias_mean_var_desc.Get(), |
| bn_scale, |
| result_bn_scale_diff, result_bn_bias_diff, |
| epsilon, |
| saved_mean, saved_var)); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenBatchNormalizationBackward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| bn_param.mode_, |
| alpha_data_diff, |
| beta_data_diff, |
| alpha_param_diff, |
| beta_param_diff, |
| bottom_desc.Get(), x, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), dx, |
| scale_bias_mean_var_desc.Get(), |
| bn_scale, |
| result_bn_scale_diff, result_bn_bias_diff, |
| epsilon, |
| saved_mean, saved_var)); |
| #endif |
| } |
| |
| // |
| // Bypass layer |
| // |
| |
| template <typename T> |
| inline void dnnmarkBypassForward(const Handle &handle, |
| RunMode mode, int idx, |
| const BypassDesc<T> &bypass_desc, |
| const void *alpha, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const void *beta, |
| const DataTensor<T> &top_desc, |
| void *y) { |
| #ifdef NVIDIA_CUDNN |
| CUDA_CALL(cudaMemcpy(y, |
| x, |
| sizeof(T) * bypass_desc.Get().n_ |
| * bypass_desc.Get().c_ |
| * bypass_desc.Get().h_ |
| * bypass_desc.Get().w_, |
| cudaMemcpyDeviceToDevice |
| )); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenActivationForward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| bypass_desc.Get(), |
| alpha, |
| bottom_desc.Get(), x, |
| beta, |
| top_desc.Get(), y)); |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkBypassBackward(const Handle &handle, |
| RunMode mode, int idx, |
| const BypassDesc<T> &bypass_desc, |
| const void *alpha, |
| const DataTensor<T> &top_desc, |
| const void *y, |
| const void *dy, |
| const void *beta, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| void *dx) { |
| #ifdef NVIDIA_CUDNN |
| CUDA_CALL(cudaMemcpy(dx, |
| dy, |
| sizeof(T) * bypass_desc.Get().n_ |
| * bypass_desc.Get().c_ |
| * bypass_desc.Get().h_ |
| * bypass_desc.Get().w_, |
| cudaMemcpyDeviceToDevice |
| )); |
| #endif |
| #ifdef AMD_MIOPEN |
| MIOPEN_CALL(miopenActivationBackward( |
| mode == COMPOSED ? |
| handle.GetMIOpen(idx) : handle.GetMIOpen(), |
| bypass_desc.Get(), |
| alpha, |
| top_desc.Get(), y, |
| top_desc.Get(), dy, |
| bottom_desc.Get(), x, |
| beta, |
| bottom_desc.Get(), dx)); |
| #endif |
| } |
| |
| // |
| // Dropout layer |
| // |
| |
| template <typename T> |
| inline void dnnmarkDropoutForward(const Handle &handle, |
| RunMode mode, int idx, |
| const DropoutDesc<T> &dropout_desc, |
| const DataTensor<T> &bottom_desc, |
| const void *x, |
| const DataTensor<T> &top_desc, |
| void *y, |
| void *reserve_space, size_t reserve_space_size) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnDropoutForward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| dropout_desc.Get(), |
| bottom_desc.Get(), x, |
| top_desc.Get(), y, |
| reserve_space, |
| reserve_space_size |
| )); |
| #endif |
| #ifdef AMD_MIOPEN |
| #endif |
| } |
| |
| template <typename T> |
| inline void dnnmarkDropoutBackward(const Handle &handle, |
| RunMode mode, int idx, |
| const DropoutDesc<T> &dropout_desc, |
| const DataTensor<T> &top_desc, |
| const void *dy, |
| const DataTensor<T> &bottom_desc, |
| void *dx, |
| void *reserve_space, size_t reserve_space_size) { |
| #ifdef NVIDIA_CUDNN |
| CUDNN_CALL(cudnnDropoutBackward( |
| mode == COMPOSED ? |
| handle.GetCudnn(idx) : handle.GetCudnn(), |
| dropout_desc.Get(), |
| top_desc.Get(), dy, |
| bottom_desc.Get(), dx, |
| reserve_space, |
| reserve_space_size |
| )); |
| #endif |
| #ifdef AMD_MIOPEN |
| #endif |
| } |
| |
| } // namespace dnnmark |
| |
| #endif // CORE_INCLUDE_DNN_WRAPPER_H_ |
