namespace impl {
namespace cpu {
-template <bool with_relu>
-struct _jit_sse42_convolution_fwd_t: public cpu_primitive_t {
- struct pd_t: public _cpu_convolution_fwd_pd_t<with_relu> {
+struct jit_sse42_convolution_fwd_t: public cpu_primitive_t {
+ struct pd_t: public cpu_convolution_fwd_pd_t {
pd_t(engine_t *engine,
- const typename pd_t::base_desc_t *adesc,
+ const convolution_desc_t *adesc,
const primitive_attr_t *attr,
const typename pd_t::base_class *hint_fwd_pd)
- : _cpu_convolution_fwd_pd_t<with_relu>(engine, adesc, attr,
- hint_fwd_pd)
- , jcp_(), jcp_dw() {}
+ : cpu_convolution_fwd_pd_t(engine, adesc, attr, hint_fwd_pd)
+ , jcp_(), jcp_dw_() {}
DECLARE_COMMON_PD_T(
JIT_IMPL_NAME_HELPER("jit:", sse42, ""),
- _jit_sse42_convolution_fwd_t<with_relu>);
+ jit_sse42_convolution_fwd_t);
virtual status_t init() override {
using namespace prop_kind;
assert(this->engine()->kind() == engine_kind::cpu);
bool ok = true
&& this->set_default_params() == status::success
- && utils::one_of(this->cdesc_().prop_kind, forward_training,
+ && utils::one_of(this->desc()->prop_kind, forward_training,
forward_inference)
- && this->cdesc_().alg_kind == alg_kind::convolution_direct
+ && utils::one_of(this->desc()->alg_kind,
+ alg_kind::convolution_auto,
+ alg_kind::convolution_direct)
&& !this->has_zero_dim_memory()
&& utils::everyone_is(data_type::f32,
- this->cdesc_().src_desc.data_type,
- this->cdesc_().weights_desc.data_type,
- this->cdesc_().dst_desc.data_type)
+ this->desc()->src_desc.data_type,
+ this->desc()->weights_desc.data_type,
+ this->desc()->dst_desc.data_type)
&& IMPLICATION(this->with_bias(),
- data_type::f32 == this->cdesc_().bias_desc.data_type);
+ data_type::f32 == this->desc()->bias_desc.data_type);
if (!ok) return status::unimplemented;
- status_t sts = jit_sse42_conv_fwd_kernel_f32::init_conf(jcp_, this->cdesc_(),
+ status_t status = jit_sse42_conv_fwd_kernel_f32::init_conf(jcp_, *this->desc(),
*this->src_pd_.desc(), *this->weights_pd_.desc(),
- *this->dst_pd_.desc(), *this->attr(), with_relu,
- this->negative_slope());
- if (sts != status::success) return sts;
+ *this->dst_pd_.desc(), *this->attr());
+ if (status != status::success) return status;
if (jcp_.with_dw_conv) {
- int dw_conv_oh = (jcp_.oh - ((jcp_.dw_conv_ker_h - 1) + 1) + 2) / jcp_.dw_conv_str_h + 1;
- int dw_conv_ow = (jcp_.ow - ((jcp_.dw_conv_ker_w - 1) + 1) + 2) / jcp_.dw_conv_str_w + 1;
-
- status_t sts_dw = jit_uni_dw_conv_row_f32<sse42>::init_conf(jcp_dw,
- jcp_.oc, jcp_.oh, jcp_.ow, dw_conv_oh, dw_conv_ow,
- jcp_.dw_conv_ker_h, jcp_.dw_conv_ker_w,
- jcp_.dw_conv_str_h, jcp_.dw_conv_str_w,
- jcp_.dw_conv_eltwise_alg, jcp_.dw_conv_eltwise_alpha,
- jcp_.dw_conv_eltwise_beta, jcp_.dw_conv_with_sum);
+ status_t sts_dw = jit_uni_dw_conv_row_f32<sse42>::init_conf(jcp_, jcp_dw_, *this->attr());
if (sts_dw != status::success) return sts_dw;
}
+ auto scratchpad = scratchpad_registry().registrar();
+ jit_sse42_conv_fwd_kernel_f32::init_scratchpad(scratchpad, jcp_, jcp_dw_);
+
return status::success;
}
jit_conv_conf_t jcp_;
- jit_conv_conf_t jcp_dw;
+ jit_conv_conf_t jcp_dw_;
protected:
virtual status_t set_default_params() override {
OIhw8i8o, Ohwi8o)));
if (this->bias_pd_.desc()->format == any)
CHECK(this->bias_pd_.set_format(x));
+ if (this->desc()->alg_kind == alg_kind::convolution_auto)
+ CHECK(this->set_alg_kind(alg_kind::convolution_direct));
return status::success;
}
};
- _jit_sse42_convolution_fwd_t(const pd_t *pd, const input_vector &inputs,
+ jit_sse42_convolution_fwd_t(const pd_t *apd, const input_vector &inputs,
const output_vector &outputs)
- : cpu_primitive_t(&conf_, inputs, outputs), conf_(*pd),
- dw_conv_buffer_size_(0), dw_conv_buffer_(nullptr), padded_bias_(nullptr), dw_padded_bias_(nullptr)
+ : cpu_primitive_t(apd, inputs, outputs)
{
- kernel_ = new jit_sse42_conv_fwd_kernel_f32(conf_.jcp_, *conf_.attr());
- if (conf_.jcp_.with_dw_conv) {
- kernel_dw_ = new jit_uni_dw_conv_row_f32<sse42>(conf_.jcp_dw);
- }
-
- if (conf_.jcp_.with_dw_conv) {
- const int nthreads = mkldnn_get_max_threads();
- dw_conv_buffer_size_ = (size_t)conf_.jcp_dw.kh * conf_.jcp_dw.iw * conf_.jcp_dw.ch_block *
- conf_.jcp_.nb_oc_blocking;
- dw_conv_buffer_ = (float *)malloc(nthreads * dw_conv_buffer_size_ * sizeof(float), 64);
- }
-
- if (conf_.want_padded_bias()) {
- const auto &j = conf_.jcp_;
- assert(j.ngroups == 1);
- padded_bias_ = (data_t *)malloc(sizeof(data_t) * j.oc, 64);
- for (int oc = j.oc_without_padding; oc < j.oc; ++oc)
- padded_bias_[oc] = 0;
+ kernel_ = new jit_sse42_conv_fwd_kernel_f32(pd()->jcp_, pd()->jcp_dw_, *pd()->attr());
- dw_padded_bias_ = (data_t *)malloc(sizeof(data_t) * j.oc, 64);
- for (int oc = j.oc_without_padding; oc < j.oc; ++oc)
- dw_padded_bias_[oc] = 0;
+ if (pd()->jcp_.with_dw_conv) {
+ kernel_dw_ = new jit_uni_dw_conv_row_f32<sse42>(pd()->jcp_dw_, *pd()->attr(), pd()->jcp_dw_.ch_block);
}
}
- ~_jit_sse42_convolution_fwd_t() {
+ ~jit_sse42_convolution_fwd_t() {
delete kernel_;
- if (conf_.jcp_.with_dw_conv) {
+ if (pd()->jcp_.with_dw_conv) {
delete kernel_dw_;
- free(dw_conv_buffer_);
- free(dw_padded_bias_);
}
-
- free(padded_bias_);
};
typedef typename prec_traits<data_type::f32>::type data_t;
- virtual void execute(event_t *e) {
- if (conf_.jcp_.with_dw_conv)
- execute_forward_fusing();
+ virtual void execute(event_t *e) const {
+ if (pd()->jcp_.with_dw_conv)
+ execute_forward_with_dw_conv();
else
execute_forward();
}
private:
- void execute_forward();
- void execute_forward_fusing();
+ void execute_forward() const;
+ void execute_forward_with_dw_conv() const;
+ const pd_t *pd() const { return (const pd_t *)primitive_t::pd(); }
- pd_t conf_;
jit_sse42_conv_fwd_kernel_f32 *kernel_;
jit_uni_dw_conv_row_f32<sse42> *kernel_dw_;
-
- /* fuse with dw conv */
- size_t dw_conv_buffer_size_;
- data_t *dw_conv_buffer_;
-
- data_t *padded_bias_;
- data_t *dw_padded_bias_;
};
-using jit_sse42_convolution_fwd_t = _jit_sse42_convolution_fwd_t<false>;
-using jit_sse42_convolution_relu_t = _jit_sse42_convolution_fwd_t<true>;
-
}
}
}
projects / platform / upstream / dldt.git / blobdiff