inference-engine/thirdparty/mkl-dnn/src/cpu/ref_eltwise.hpp

   1 /*******************************************************************************
   2 * Copyright 2016-2018 Intel Corporation
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *     http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 *******************************************************************************/
  16
  17 #ifndef CPU_REF_ELTWISE_HPP
  18 #define CPU_REF_ELTWISE_HPP
  19
  20 #include <assert.h>
  21
  22 #include "c_types_map.hpp"
  23 #include "cpu_eltwise_pd.hpp"
  24 #include "cpu_engine.hpp"
  25 #include "type_helpers.hpp"
  26 #include "utils.hpp"
  27
  28 namespace mkldnn {
  29 namespace impl {
  30 namespace cpu {
  31
  32 struct ref_eltwise_scalar_fwd_t {
  33 public:
  34     ref_eltwise_scalar_fwd_t(const alg_kind_t alg, float alpha, float beta);
  35     float compute_scalar(float s);
  36
  37 private:
  38     alg_kind_t alg;
  39     float alpha;
  40     float beta;
  41 };
  42
  43 template <impl::data_type_t data_type>
  44 struct ref_eltwise_fwd_t: public cpu_primitive_t {
  45     struct pd_t: public cpu_eltwise_fwd_pd_t {
  46         pd_t(engine_t *engine, const eltwise_desc_t *adesc,
  47                 const primitive_attr_t *attr,
  48                 const eltwise_fwd_pd_t *hint_fwd_pd)
  49             : cpu_eltwise_fwd_pd_t(engine, adesc, attr, hint_fwd_pd) {}
  50
  51         DECLARE_COMMON_PD_T("ref:any", ref_eltwise_fwd_t);
  52
  53         virtual status_t init() override {
  54             using namespace prop_kind;
  55             using namespace memory_format;
  56             using namespace utils;
  57             assert(engine()->kind() == engine_kind::cpu);
  58
  59             auto src_d = memory_desc_wrapper(src_pd());
  60
  61             use_dense_ = false
  62                 || src_d.is_dense()
  63                 || (src_d.is_dense(true) && is_zero_preserved());
  64
  65             use_nCspBc_padded_ = !use_dense_
  66                 && one_of(desc()->data_desc.format, nChw8c, nChw16c, nCdhw16c)
  67                 && src_d.only_padded_dim(1)
  68                 && src_d.is_dense(true);
  69
  70             const bool use_generic = !use_dense_ && !use_nCspBc_padded_;
  71
  72             bool ok = true
  73                 && one_of(desc()->prop_kind, forward_training,
  74                         forward_inference)
  75                 && everyone_is(data_type, desc()->data_desc.data_type)
  76                 && implication(use_generic, one_of(src_d.ndims(), 4, 5))
  77                 && attr()->has_default_values();
  78             if (!ok) return status::unimplemented;
  79
  80             return status::success;
  81         }
  82
  83         bool use_dense_, use_nCspBc_padded_;
  84     };
  85
  86     ref_eltwise_fwd_t(const pd_t *pd, const input_vector &inputs,
  87             const output_vector &outputs)
  88         : cpu_primitive_t(&conf_, inputs, outputs), conf_(*pd) {}
  89     typedef typename prec_traits<data_type>::type data_t;
  90
  91     virtual void execute(event_t *e) {
  92         if (conf_.use_dense_)
  93             execute_forward_dense();
  94         else if (conf_.use_nCspBc_padded_)
  95             execute_forward_nCspBc_padded();
  96         else
  97             execute_forward_generic();
  98         e->set_state(event_t::ready);
  99     }
 100
 101 private:
 102     void execute_forward_nCspBc_padded();
 103     void execute_forward_dense();
 104     void execute_forward_generic();
 105     pd_t conf_;
 106 };
 107
 108 template <impl::data_type_t data_type>
 109 struct ref_eltwise_bwd_t: public cpu_primitive_t {
 110     struct pd_t: public cpu_eltwise_bwd_pd_t {
 111         pd_t(engine_t *engine, const eltwise_desc_t *adesc,
 112                 const primitive_attr_t *attr,
 113                 const eltwise_fwd_pd_t *hint_fwd_pd)
 114             : cpu_eltwise_bwd_pd_t(engine, adesc, attr, hint_fwd_pd) {}
 115
 116         DECLARE_COMMON_PD_T("ref:any", ref_eltwise_bwd_t);
 117
 118         virtual status_t init() override {
 119             using namespace prop_kind;
 120             using namespace utils;
 121             assert(engine()->kind() == engine_kind::cpu);
 122             bool ok = true && desc()->prop_kind == backward_data
 123                     && everyone_is(data_type, desc()->data_desc.data_type,
 124                             desc()->diff_data_desc.data_type)
 125                     && attr()->has_default_values();
 126             if (!ok) return status::unimplemented;
 127
 128             auto diff_dst_d = memory_desc_wrapper(diff_dst_pd());
 129             const bool same_fmt_ = diff_dst_d == memory_desc_wrapper(src_pd());
 130
 131             use_dense_ = true
 132                 && same_fmt_
 133                 && diff_dst_d.is_dense(true)
 134                 && is_zero_preserved();
 135             const bool use_generic = !use_dense_;
 136
 137             if (use_generic && !one_of(diff_dst_d.ndims(), 4, 5))
 138                 return status::unimplemented;
 139
 140             return status::success;
 141         }
 142
 143         bool use_dense_;
 144     };
 145
 146     ref_eltwise_bwd_t(const pd_t *pd, const input_vector &inputs,
 147             const output_vector &outputs)
 148         : cpu_primitive_t(&conf_, inputs, outputs), conf_(*pd) {}
 149     typedef typename prec_traits<data_type>::type data_t;
 150
 151     virtual void execute(event_t *e) {
 152         if (conf_.use_dense_) execute_backward_dense();
 153         else execute_backward_generic();
 154         e->set_state(event_t::ready);
 155     }
 156
 157 private:
 158     void execute_backward_dense();
 159     void execute_backward_generic();
 160     pd_t conf_;
 161 };
 162
 163 }
 164 }
 165 }
 166
 167 #endif
 168
 169 // vim: et ts=4 sw=4 cindent cino^=l0,\:0,N-s