20 #ifndef DOXYGEN_SHOULD_SKIP_THIS 55 template <
typename T,
typename traits=handle_traits<T>>
class handle {
57 std::shared_ptr<typename std::remove_pointer<T>::type> _data;
61 bool operator==(
const T other)
const {
return other == _data.get(); }
62 bool operator!=(
const T other)
const {
return !(*
this == other); }
67 handle(T t = 0,
bool weak =
false): _data(0) {
79 void reset(T t,
bool weak =
false) {
80 auto dummy_destructor = [](T) {
return decltype(traits::destructor(0))(0); };
81 _data.reset(t, weak ? dummy_destructor : traits::destructor);
85 T
get()
const {
return _data.get(); }
87 bool operator==(
const handle &other)
const {
return other._data.get() == _data.get(); }
91 #ifndef DOXYGEN_SHOULD_SKIP_THIS 100 template <>
struct handle_traits<mkldnn_primitive_desc_iterator_t> {
109 friend class primitive_at;
110 using handle::handle;
163 struct error:
public std::exception {
176 mkldnn_primitive_t aerror_primitive = 0)
179 , error_primitive(aerror_primitive, true)
191 const std::string &message,
192 mkldnn_primitive_t *error_primitive = 0)
195 if (
nullptr != error_primitive)
196 throw error(status, message, *error_primitive);
198 throw error(status, message,
nullptr);
207 data.output_index, &output),
208 "could not get an output primitive");
209 return primitive(const_cast<mkldnn_primitive_t>(output),
true);
215 "could not get primitive descriptor by primitive");
365 #ifndef DOXYGEN_SHOULD_SKIP_THIS 373 mkldnn_post_ops_t result;
375 "could not create post operation sequence");
384 "post_ops index is out of range");
391 "could not append sum");
396 "could not get sum params");
403 "could not append eltwise");
407 float &alpha,
float &beta)
const {
410 &scale, &c_alg, &alpha, &beta),
411 "could not get eltwise params");
416 #ifndef DOXYGEN_SHOULD_SKIP_THIS 424 mkldnn_primitive_attr_t result;
426 "could not create a primitive attr");
433 get(), &result),
"could not get int output round mode");
440 "could not set int output round mode");
446 const float *c_scales;
448 &count, &c_mask, &c_scales),
449 "could not get int output scales");
450 scales.resize(count);
453 for (
int c = 0; c < count; ++c)
454 scales[c] = c_scales[c];
460 (
int)scales.size(), mask, &scales[0]),
461 "could not set int output scales");
468 "could not get post operation sequence");
469 result.
reset(const_cast<mkldnn_post_ops_t>(c_result),
true);
475 "could not set post operation sequence");
487 #ifndef DOXYGEN_SHOULD_SKIP_THIS 521 mkldnn_engine_t aengine;
525 "could not create an engine");
529 explicit engine(
const mkldnn_engine_t& aengine)
530 :
handle(aengine, true) {}
533 mkldnn_engine_t engine_q;
537 "could not get engine from primitive_desc");
538 reset(engine_q,
true);
541 template <
class primitive_desc>
543 mkldnn_engine_t engine_q;
547 "could not get engine from primitive_desc");
572 std::shared_ptr<char> _handle;
575 typedef std::vector<std::remove_extent<mkldnn_dims_t>::type>
dims;
580 "invalid dimensions");
725 validate_dims(adims);
728 adims.size() == 0 ? nullptr : &adims[0],
730 "could not initialize a memory descriptor");
748 mkldnn_primitive_desc_t result;
752 "could not initialize a memory primitive descriptor");
769 other.
get())) ? false :
true;
787 mkldnn_primitive_t result;
790 "could not create a memory primitive");
792 auto _malloc = [](
size_t size,
int alignment) {
795 ptr = _aligned_malloc(size, alignment);
796 int rc = ((ptr)? 0 : errno);
798 int rc = ::posix_memalign(&ptr, alignment, size);
800 return (rc == 0) ? (
char*)ptr :
nullptr;
802 auto _free = [](
char* p) {
804 _aligned_free((
void*)p);
809 _handle.reset(_malloc(adesc.
get_size(), 4096), _free);
810 set_data_handle(_handle.get());
814 mkldnn_primitive_t result;
817 "could not create a memory primitive");
819 set_data_handle(ahandle);
828 "could not get primitive descriptor from a memory primitive");
830 adesc.
reset(const_cast<mkldnn_primitive_desc_t>(cdesc),
true);
839 "could not get native handle");
845 "could not set native handle");
869 &aprimitive_desc,
int n_inputs,
int n_outputs,
870 const std::string &prim_name) {
875 if (n_outputs_expected > n_outputs ) {
876 std::string message =
"could not create " + prim_name +
877 " primitive, not enought output parameters";
880 if (n_inputs_expected > n_inputs ) {
881 std::string message =
"could not create " + prim_name +
882 " primitive, not enought input parameters";
894 return ((aprimitive_md !=
nullptr) && (aprimitive_md->
ndims == 0));
935 mkldnn_primitive_desc_t result;
937 &result, input.
get(), output.
get()),
938 "could not create a reorder primitive descriptor");
945 mkldnn_primitive_desc_t result;
947 &result, input.
get(), output.
get(), aattr.
get()),
948 "could not create a reorder primitive descriptor");
957 mkldnn_primitive_t result;
961 aprimitive_desc.
get(), inputs, outputs),
962 "could not create a reorder primitive");
972 mkldnn_primitive_t result;
976 reorder_d.get(), inputs, outputs),
977 "could not create a reorder primitive");
994 mkldnn_primitive_desc_t result;
997 &result, input.
get(), &dims[0], &offsets[0]),
998 "could not create a view primitive descriptor");
1004 mkldnn_primitive_desc_t cdesc;
1010 "could not clone a dst primitive descriptor");
1019 mkldnn_primitive_t result;
1022 view_pd.
get(), inputs,
nullptr),
1023 "could not create a view primitive");
1028 mkldnn_primitive_t result;
1033 view_pd.get(), inputs,
nullptr),
1034 "could not create a view primitive");
1050 std::vector<memory::primitive_desc> inputs) {
1051 std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
1052 c_api_inputs.reserve(inputs.size());
1054 std::transform(inputs.begin(), inputs.end(),
1056 return c_api_inputs;
1060 std::vector<memory::primitive_desc> inputs) {
1061 mkldnn_primitive_desc_t result;
1063 auto c_api_inputs = cpp_to_c(inputs);
1066 &result, &output.
data, (
int)c_api_inputs.size(),
1067 concat_dimension, &c_api_inputs[0]),
1068 "could not create a concat primitive descriptor");
1073 std::vector<memory::primitive_desc> inputs) {
1074 mkldnn_primitive_desc_t result;
1076 auto c_api_inputs = cpp_to_c(inputs);
1079 &result,
nullptr, (
int)c_api_inputs.size(),
1080 concat_dimension, &c_api_inputs[0]),
1081 "could not create a concat primitive descriptor");
1087 mkldnn_primitive_desc_t cdesc;
1092 "could not clone a dst primitive descriptor");
1101 std::vector<primitive::at> &inputs,
const memory &output) {
1102 mkldnn_primitive_t result;
1104 std::vector<mkldnn_primitive_at_t> p_inputs;
1105 for (
size_t i = 0; i < inputs.size(); i++)
1106 p_inputs.push_back(inputs[i].data);
1110 concat_pd.
get(), &p_inputs[0], outputs),
1111 "could not create a concat primitive");
1127 std::vector<memory::primitive_desc> inputs) {
1128 std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
1129 c_api_inputs.reserve(inputs.size());
1131 std::transform(inputs.begin(), inputs.end(),
1133 return c_api_inputs;
1137 const std::vector<float> &scales,
1138 std::vector<memory::primitive_desc> inputs) {
1139 mkldnn_primitive_desc_t result;
1141 auto c_api_inputs = cpp_to_c(inputs);
1146 "number of scales not equal to number of inputs");
1149 &result, &output.
data, (
int)c_api_inputs.size(),
1150 &scales[0], &c_api_inputs[0]),
1151 "could not create a sum primitive descriptor");
1156 std::vector<memory::primitive_desc> inputs) {
1157 mkldnn_primitive_desc_t result;
1159 auto c_api_inputs = cpp_to_c(inputs);
1164 "number of scales not equal to number of inputs");
1167 &result,
nullptr, (
int)c_api_inputs.size(), &scales[0],
1169 "could not create a sum primitive descriptor");
1176 std::vector<memory::primitive_desc> inputs) {
1177 mkldnn_primitive_desc_t result;
1179 auto c_api_inputs = cpp_to_c(inputs);
1180 auto scale_f = scale_to_float(scale);
1183 &result, &output.
data, (
int)c_api_inputs.size(),
1184 &scale_f[0], &c_api_inputs[0]),
1185 "could not create a sum primitive descriptor");
1192 std::vector<memory::primitive_desc> inputs) {
1193 mkldnn_primitive_desc_t result;
1195 auto c_api_inputs = cpp_to_c(inputs);
1196 auto scale_f = scale_to_float(scale);
1199 &result,
nullptr, (
int)c_api_inputs.size(), &scale_f[0],
1201 "could not create a sum primitive descriptor");
1207 mkldnn_primitive_desc_t cdesc;
1213 "could not clone a dst primitive descriptor");
1222 std::vector<primitive::at> &inputs,
const memory &output) {
1223 mkldnn_primitive_t result;
1225 std::vector<mkldnn_primitive_at_t> p_inputs;
1226 for (
size_t i = 0; i < inputs.size(); i++)
1227 p_inputs.push_back(inputs[i].data);
1231 sum_pd.
get(), &p_inputs[0], outputs),
1232 "could not create a sum primitive");
1237 static std::vector<float> scale_to_float(
const std::vector<double> &vd) {
1238 std::vector<float> vf(vd.size());
1239 std::transform(vd.begin(), vd.end(), vf.begin(),
1240 [=](
double x){
return (
float)x;});
1259 mkldnn_primitive_desc_iterator_t iterator =
nullptr;
1261 &iterator, desc, attr ? attr->
get() :
nullptr, e.
get(),
1264 "could not create a primitive descriptor iterator");
1265 pd_iterator.reset(iterator);
1274 "could not get attributes");
1275 mkldnn_primitive_attr_t cattr;
1277 "could not clone attributes");
1289 "could not query implementation info string");
1313 if (!std::any_of(valid_w.cbegin(), valid_w.cend(),
1314 [=](
query q) {
return what == q; }))
1322 if (const_cdesc ==
nullptr)
1325 mkldnn_primitive_desc_t cdesc;
1327 "could not clone a memory primitive descriptor");
1335 # define REG_QUERY_MPD(name, what, idx) \ 1336 memory::primitive_desc name ## _primitive_desc() const \ 1337 { return query_mpd(what ## _pd, idx); } 1340 handle<mkldnn_primitive_desc_iterator_t> pd_iterator;
1345 "could not fetch a primitive descriptor from the iterator");
1376 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1378 "could not create a convolution forward descriptor");
1393 &src_desc.
data, &weights_desc.
data,
nullptr,
1394 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1396 "could not create a convolution forward descriptor");
1416 &dst_desc.
data, &strides[0], &dilates[0],
1417 &padding_l[0], &padding_r[0],
1419 "could not create a dilated convolution forward descriptor");
1437 &src_desc.
data, &weights_desc.
data,
nullptr,
1438 &dst_desc.
data, &strides[0], &dilates[0],
1439 &padding_l[0], &padding_r[0],
1441 "could not create a dilated convolution forward descriptor");
1461 mkldnn_primitive_t result;
1466 aprimitive_desc.
get(), inputs, outputs),
1467 "could not create a convolution forward bias primitive");
1474 mkldnn_primitive_t result;
1478 "convolution forward");
1480 aprimitive_desc.
get(), inputs, outputs),
1481 "could not create a convolution forward primitive");
1502 &weights_desc.
data, &diff_dst_desc.
data,
1503 &strides[0], &padding_l[0], &padding_r[0],
1505 "could not create a convolution backward data descriptor");
1523 &weights_desc.
data, &diff_dst_desc.
data,
1524 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1526 "could not create a convolution backward data descriptor");
1546 const memory &diff_src) {
1547 mkldnn_primitive_t result;
1551 "convolution backward data");
1553 aprimitive_desc.
get(), inputs, outputs),
1554 "could not create a convolution backward data primitive");
1576 &diff_weights_desc.
data, &diff_bias_desc.
data,
1577 &diff_dst_desc.
data,
1578 &strides[0], &padding_l[0], &padding_r[0],
1580 "could not create a convolution backward weights descriptor");
1595 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1596 &strides[0], &padding_l[0], &padding_r[0],
1598 "could not create a convolution backward weights descriptor");
1616 &diff_weights_desc.
data, &diff_bias_desc.
data,
1617 &diff_dst_desc.
data,
1618 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1620 "could not create a convolution backward weights descriptor");
1637 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1638 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1640 "could not create a convolution backward weights descriptor");
1663 mkldnn_primitive_t result;
1668 "convolution backward weights");
1670 aprimitive_desc.
get(), inputs, outputs),
1671 "could not create a convolution backward weights primitive");
1676 const memory &diff_weights) {
1677 mkldnn_primitive_t result;
1681 "convolution backward weights");
1683 aprimitive_desc.
get(), inputs, outputs),
1684 "could not create a convolution backward weights primitive");
1698 const float negative_slope) {
1700 &conv_desc.
data, negative_slope),
1701 "could not create a convolution_relu_forward descriptor");
1720 mkldnn_primitive_t result;
1725 "convolution relu forward");
1727 aprimitive_desc.
get(), inputs, outputs),
1728 "could not create a convolution relu forward primitive");
1737 mkldnn_primitive_t result;
1741 "convolution relu forward");
1743 aprimitive_desc.
get(), inputs, outputs),
1744 "could not create a convolution relu forward primitive");
1775 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1777 "could not create a deconvolution forward descriptor");
1792 &src_desc.
data, &weights_desc.
data,
nullptr,
1793 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1795 "could not create a deconvolution forward descriptor");
1814 &dst_desc.
data, &strides[0], &dilates[0], &padding_l[0],
1816 "could not create a dilated deconvolution forward descriptor");
1833 &src_desc.
data, &weights_desc.
data,
nullptr,
1834 &dst_desc.
data, &strides[0], &dilates[0], &padding_l[0],
1836 "could not create a dilated deconvolution forward descriptor");
1856 mkldnn_primitive_t result;
1861 "deconvolution forward");
1863 aprimitive_desc.
get(), inputs, outputs),
1864 "could not create a deconvolution forward bias primitive");
1871 mkldnn_primitive_t result;
1875 "deconvolution forward");
1877 aprimitive_desc.
get(), inputs, outputs),
1878 "could not create a deconvolution forward primitive");
1899 &weights_desc.
data, &diff_dst_desc.
data,
1900 &strides[0], &padding_l[0], &padding_r[0],
1902 "could not create a deconvolution backward data descriptor");
1919 &weights_desc.
data, &diff_dst_desc.
data,
1920 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1922 "could not create a dilated deconvolution backward data descriptor");
1942 const memory &diff_src) {
1943 mkldnn_primitive_t result;
1947 "deconvolution backward data");
1949 aprimitive_desc.
get(), inputs, outputs),
1950 "could not create a deconvolution backward data primitive");
1972 &diff_weights_desc.
data, &diff_bias_desc.
data,
1973 &diff_dst_desc.
data,
1974 &strides[0], &padding_l[0], &padding_r[0],
1976 "could not create a deconvolution backward weights descriptor");
1991 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1992 &strides[0], &padding_l[0], &padding_r[0],
1994 "could not create a deconvolution backward weights descriptor");
2012 &diff_weights_desc.
data, &diff_bias_desc.
data,
2013 &diff_dst_desc.
data,
2014 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
2016 "could not create a dilated deconvolution backward weights descriptor");
2033 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
2034 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
2036 "could not create a dilated deconvolution backward weights descriptor");
2058 mkldnn_primitive_t result;
2063 "deconvolution backward weights");
2065 aprimitive_desc.
get(), inputs, outputs),
2066 "could not create a deconvolution backward weights primitive");
2071 const memory &diff_weights) {
2072 mkldnn_primitive_t result;
2076 "deconvolution backward weights");
2078 aprimitive_desc.
get(), inputs, outputs),
2079 "could not create a deconvolution backward weights primitive");
2098 int local_size,
float alpha,
float beta,
float k)
2102 &src_desc.
data, local_size, alpha, beta, k),
2103 "could not create a lrn forward descriptor");
2107 int local_size,
float alpha,
float beta)
2111 &src_desc.
data, local_size, alpha, beta,
float(1.0)),
2112 "could not create a lrn forward descriptor");
2131 mkldnn_primitive_t result;
2137 aprimitive_desc.
get(), inputs, outputs),
2138 "could not create a lrn forward primitive");
2144 mkldnn_primitive_t result;
2149 aprimitive_desc.
get(), inputs, outputs),
2150 "could not create a lrn forward primitive");
2161 int local_size,
float alpha,
float beta,
float k)
2165 &data_desc.
data, local_size, alpha, beta, k),
2166 "could not create a lrn backward descriptor");
2171 int local_size,
float alpha,
float beta)
2175 &data_desc.
data, local_size, alpha, beta,
float(1.0)),
2176 "could not create a lrn backward descriptor");
2197 mkldnn_primitive_t result;
2203 aprimitive_desc.
get(), inputs, outputs),
2204 "could not create a lrn backward primitive");
2210 const memory &diff_src) {
2211 mkldnn_primitive_t result;
2216 aprimitive_desc.
get(), inputs, outputs),
2217 "could not create a lrn backward primitive");
2249 &strides[0], &kernel[0],
2250 &padding_l[0], &padding_r[0],
2252 "could not init a forward pooling descriptor");
2270 mkldnn_primitive_t result;
2275 aprimitive_desc.
get(), inputs, outputs),
2276 "could not create a pooling forward primitive");
2282 mkldnn_primitive_t result;
2287 aprimitive_desc.
get(), inputs, outputs),
2288 "could not create a pooling forward primitive");
2310 &diff_src_desc.
data, &diff_dst_desc.
data,
2311 &strides[0], &kernel[0],
2312 &padding_l[0], &padding_r[0],
2314 "could not init a backward pooling descriptor");
2333 const memory &diff_src) {
2334 mkldnn_primitive_t result;
2339 aprimitive_desc.
get(), inputs, outputs),
2340 "could not create a pooling backward primitive");
2346 mkldnn_primitive_t result;
2351 aprimitive_desc.
get(), inputs, outputs),
2352 "could not create a pooling backward primitive");
2369 template <
typename T>
2371 const memory::desc &src_desc, T alpha = 0, T beta = 0) {
2375 static_cast<float>(alpha), static_cast<float>(beta)),
2376 "could not create a eltwise forward descriptor");
2380 template <
typename T>
2400 mkldnn_primitive_t result;
2405 aprimitive_desc.
get(), inputs, outputs),
2406 "could not create a eltwise forward primitive");
2417 template <
typename T>
2419 const memory::desc &data_desc, T alpha = 0, T beta = 0) {
2422 &data_desc.
data, static_cast<float>(alpha),
2423 static_cast<float>(beta)),
2424 "could not create a eltwise backward descriptor");
2428 template <
typename T>
2451 const memory &diff_src) {
2452 mkldnn_primitive_t result;
2457 aprimitive_desc.
get(), inputs, outputs),
2458 "could not create a eltwise backward primitive");
2481 "could not create a softmax forward descriptor");
2498 mkldnn_primitive_t result;
2503 aprimitive_desc.
get(), inputs, outputs),
2504 "could not create a softmax forward primitive");
2515 &diff_desc.
data, &data_desc.
data, softmax_axis),
2516 "could not init a backward softmax descriptor");
2537 const memory &diff_src) {
2538 mkldnn_primitive_t result;
2542 aprimitive_desc.
get(), inputs, outputs),
2543 "could not create a softmax backward primitive");
2559 template <
typename T>
2565 static_cast<float>(epsilon), flags),
2566 "could not create a batch normalization forward descriptor");
2583 {
return stat_primitive_desc(mean); }
2585 {
return stat_primitive_desc(var); }
2588 enum { mean = 1, var = 2, };
2593 "could not get a batch-normalization descriptor");
2602 mkldnn_primitive_t result;
2607 "batch normalization forward");
2609 aprimitive_desc.
get(), inputs, outputs),
2610 "could not create a batch normalization forward primitive");
2617 mkldnn_primitive_t result;
2622 "batch normalization forward");
2624 aprimitive_desc.
get(), inputs, outputs),
2625 "could not create a batch normalization forward primitive");
2639 mkldnn_primitive_t result;
2642 mean.
get(), variance.
get() };
2644 "batch normalization forward");
2646 aprimitive_desc.
get(), inputs, outputs),
2647 "could not create a batch normalization forward primitive");
2654 const memory &workspace) {
2655 mkldnn_primitive_t result;
2658 mean.
get(), variance.
get(), workspace.
get() };
2660 "batch normalization forward");
2662 aprimitive_desc.
get(), inputs, outputs),
2663 "could not create a batch normalization forward primitive");
2669 const memory &variance) {
2670 mkldnn_primitive_t result;
2673 mean.
get(), variance.
get() };
2675 "batch normalization forward");
2677 aprimitive_desc.
get(), inputs, outputs),
2678 "could not create a batch normalization forward primitive");
2696 mkldnn_primitive_t result;
2699 mean.
get(), variance.
get(), workspace.
get() };
2706 if (n_inputs_expected == 2 && n_outputs_expected == 3) {
2708 auto _weights = dst;
2709 inputs[1] = {_weights.get(), 0};
2711 auto _dst = mean, _mean = variance, _variance = workspace;
2712 outputs[0] = _dst.get();
2713 outputs[1] = _mean.get();
2714 outputs[2] = _variance.get();
2715 outputs[3] =
nullptr;
2719 aprimitive_desc.
get(), inputs, outputs),
2720 "could not create a batch normalization forward primitive");
2727 mkldnn_primitive_t result;
2731 "batch normalization forward");
2733 aprimitive_desc.
get(), inputs, outputs),
2734 "could not create a batch normalization forward primitive");
2740 mkldnn_primitive_t result;
2744 "batch normalization forward");
2746 aprimitive_desc.
get(), inputs, outputs),
2747 "could not create a batch normalization forward primitive");
2755 template <
typename T>
2757 const memory::desc &data_desc, T epsilon,
unsigned flags) {
2761 &diff_data_desc.
data, &data_desc.
data,
2762 static_cast<float>(epsilon), flags),
2763 "could not create a batch normalization backward descriptor");
2793 const memory &diff_weights) {
2794 mkldnn_primitive_t result;
2798 diff_weights.
get() };
2800 "batch normalization backward");
2802 aprimitive_desc.
get(), inputs, outputs),
2803 "could not create a batch normalization backward primitive");
2813 mkldnn_primitive_t result;
2817 diff_weights.
get() };
2819 "batch normalization backward");
2821 aprimitive_desc.
get(), inputs, outputs),
2822 "could not create a batch normalization backward primitive");
2834 mkldnn_primitive_t result;
2836 diff_dst.
data, weights_or_workspace.
data };
2839 "batch normalization backward");
2841 aprimitive_desc.
get(), inputs, outputs),
2842 "could not create a batch normalization backward primitive");
2850 const memory &diff_src) {
2851 mkldnn_primitive_t result;
2856 "batch normalization backward");
2858 aprimitive_desc.
get(), inputs, outputs),
2859 "could not create a batch normalization backward primitive");
2883 "could not create a inner product forward descriptor");
2892 &weights_desc.
data,
nullptr, &dst_desc.
data),
2893 "could not create a inner product forward descriptor");
2913 mkldnn_primitive_t result;
2918 "inner product forward");
2920 aprimitive_desc.
get(), inputs, outputs),
2921 "could not create a inner product forward primitive");
2928 mkldnn_primitive_t result;
2932 "inner product forward");
2934 aprimitive_desc.
get(), inputs, outputs),
2935 "could not create a inner product forward primitive");
2948 &diff_src_desc.
data, &weights_desc.
data,
2949 &diff_dst_desc.
data),
2950 "could not create a inner product backward data descriptor");
2970 const memory &diff_src) {
2971 mkldnn_primitive_t result;
2975 "inner product backward data");
2977 aprimitive_desc.
get(), inputs, outputs),
2978 "could not create a inner product backward data primitive");
2992 &data, &src_desc.
data, &diff_weights_desc.
data,
2993 &diff_bias_desc.
data, &diff_dst_desc.
data),
2994 "could not create a inner product backward weights descriptor");
3001 &data, &src_desc.
data, &diff_weights_desc.
data,
3002 nullptr, &diff_dst_desc.
data),
3003 "could not create a inner product backward weights descriptor");
3024 const memory &diff_weights) {
3025 mkldnn_primitive_t result;
3029 "inner product backward weights");
3031 aprimitive_desc.
get(), inputs, outputs),
3032 "could not create a inner product backward weights primitive");
3039 mkldnn_primitive_t result;
3042 { diff_weights.
get(), diff_bias.
get()};
3044 "inner product backward weights");
3046 aprimitive_desc.
get(), inputs, outputs),
3047 "could not create a inner product backward weights primitive");
3068 "could not init an rnn cell descriptor");
3082 c_rnn_cell_.
alpha = alpha;
3116 &src_layer_desc.
data, &src_iter_desc.
data,
3117 &weights_layer_desc.
data, &weights_iter_desc.
data,
3119 &dst_layer_desc.
data, &dst_iter_desc.
data),
3120 "could not create an RNN forward descriptor");
3147 const memory &workspace) {
3148 mkldnn_primitive_t result;
3152 inputs[idx++] = src_layer.
data;
3154 inputs[idx++] = src_iter.
data;
3155 inputs[idx++] = weights_layer.
data;
3156 inputs[idx++] = weights_iter.
data;
3160 outputs[idx++] = dst_layer.
get();
3165 aprimitive_desc.
get(), inputs, outputs),
3166 "could not create an RNN forward primitive");
3193 &src_layer_desc.
data, &src_iter_desc.
data,
3194 &weights_layer_desc.
data, &weights_iter_desc.
data,
3196 &dst_layer_desc.
data, &dst_iter_desc.
data,
3197 &diff_src_layer_desc.
data, &diff_src_iter_desc.
data,
3198 &diff_weights_layer_desc.
data,
3199 &diff_weights_iter_desc.
data, &diff_bias_desc.
data,
3200 &diff_dst_layer_desc.
data, &diff_dst_iter_desc.
data),
3201 "could not create an RNN backward descriptor");
3246 const memory &diff_src_layer,
3247 const memory &diff_src_iter,
3248 const memory &diff_weights_layer,
3249 const memory &diff_weights_iter,
3254 mkldnn_primitive_t result;
3258 inputs[idx++] = src_layer.
data;
3260 inputs[idx++] = src_iter.
data;
3261 inputs[idx++] = weights_layer.
data;
3262 inputs[idx++] = weights_iter.
data;
3264 inputs[idx++] = bias.
data;
3265 inputs[idx++] = dst_layer.
data;
3267 inputs[idx++] = dst_iter.
data;
3268 inputs[idx++] = diff_dst_layer.
data;
3270 inputs[idx++] = diff_dst_iter.
data;
3271 inputs[idx++] = workspace.
data;
3274 outputs[idx++] = diff_src_layer.
get();
3276 outputs[idx++] = diff_src_iter.
get();
3277 outputs[idx++] = diff_weights_layer.
get();
3278 outputs[idx++] = diff_weights_iter.
get();
3281 aprimitive_desc.
get(), inputs, outputs),
3282 "could not create an RNN backward primitive");
3299 int axis,
int group_size) {
3303 "could not create a shuffle forward descriptor");
3317 mkldnn_primitive_t result;
3322 aprimitive_desc.
get(), inputs, outputs),
3323 "could not create a shuffle forward primitive");
3333 &diff_data_desc.
data, axis, group_size),
3334 "could not create a shuffle backward descriptor");
3349 mkldnn_primitive_t result;
3354 aprimitive_desc.
get(), inputs, outputs),
3355 "could not create a shuffle backward primitive");
3370 #ifndef DOXYGEN_SHOULD_SKIP_THIS 3377 using handle::handle;
3388 mkldnn_stream_t astream;
3391 "could not create a stream");
3402 if (primitives.size() == 0)
return *
this;
3403 std::vector<mkldnn_primitive_t> c_api_primitives;
3404 c_api_primitives.reserve(primitives.size());
3406 std::transform(primitives.begin(), primitives.end(),
3409 mkldnn_primitive_t c_api_error_primitive;
3412 c_api_primitives.size(), &c_api_primitives[0],
3413 &c_api_error_primitive),
3414 "could not submit primitives to a stream",
3415 &c_api_error_primitive);
3427 mkldnn_primitive_t c_api_error_primitive;
3429 block, &c_api_error_primitive);
3433 &c_api_error_primitive);
3438 mkldnn_primitive_t c_api_error_primitive;
3441 "could not rerun a stream", &c_api_error_primitive);
3446 #undef REG_QUERY_MPD void append_sum(float scale=1.)
Definition: mkldnn.hpp:389
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2486
Definition: mkldnn.hpp:2435
LRN within a single channel.
Definition: mkldnn_types.h:474
primitive error_primitive
Definition: mkldnn.hpp:166
A descriptor of a Local Response Normalization (LRN) operation.
Definition: mkldnn_types.h:809
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1507
Definition: mkldnn.hpp:346
blocked weights format
Definition: mkldnn_types.h:300
Definition: mkldnn.hpp:1694
inner_product_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at weights, const memory &dst)
Definition: mkldnn.hpp:2925
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2260
Definition: mkldnn.hpp:270
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1049
blocked weights format
Definition: mkldnn_types.h:303
op descriptor
Definition: mkldnn_types.h:1163
primitive_desc(const memory::desc &output, int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1059
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1650
mkldnn_status_t MKLDNN_API mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for backward propagation with respect to weights using...
blocked weights format with additional buffer with size equal to the number of output channels multip...
Definition: mkldnn_types.h:327
Definition: mkldnn.hpp:3171
blocked weights format
Definition: mkldnn_types.h:287
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_destroy(mkldnn_primitive_attr_t attr)
Deletes an attr.
blocked weights format
Definition: mkldnn_types.h:345
mkldnn_status_t MKLDNN_API mkldnn_sum_primitive_desc_create(mkldnn_primitive_desc_t *sum_primitive_desc, const mkldnn_memory_desc_t *output_desc, int n, const float *scales, const_mkldnn_primitive_desc_t *input_pds)
Creates out-of-place sum_primitive_desc for sum of n inputs multiplied by scale with resulting output...
A Softmax primitive.
Definition: mkldnn_types.h:422
number of outputs expected
Definition: mkldnn_types.h:1152
bool operator!=(const handle &other) const
Definition: mkldnn.hpp:88
mkldnn_status_t MKLDNN_API mkldnn_stream_destroy(mkldnn_stream_t stream)
Destroys an execution stream.
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:3129
convolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights, const memory &diff_bias)
Definition: mkldnn.hpp:1660
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:2598
stream & submit(std::vector< primitive > primitives)
Submits a vector of primitives to a stream for computations.
Definition: mkldnn.hpp:3399
bool operator==(const primitive_desc &other) const
Definition: mkldnn.hpp:767
A base class for all primitive descriptors.
Definition: mkldnn.hpp:1256
Definition: mkldnn.hpp:2293
mkldnn_status_t
Status values returned by Intel(R) MKL-DNN functions.
Definition: mkldnn_types.h:39
stream & rerun()
Definition: mkldnn.hpp:3437
Definition: mkldnn.hpp:2256
A descriptor of a convolution operation.
Definition: mkldnn_types.h:655
Definition: mkldnn.hpp:302
desc(prop_kind aprop_kind, const memory::desc &data_desc, int axis, int group_size)
Definition: mkldnn.hpp:3298
Definition: mkldnn.hpp:2231
The operation failed and should be retried.
Definition: mkldnn_types.h:45
memory null_memory(engine eng)
Definition: mkldnn.hpp:863
mkldnn_status_t MKLDNN_API mkldnn_memory_primitive_desc_create(mkldnn_primitive_desc_t *memory_primitive_desc, const mkldnn_memory_desc_t *memory_desc, mkldnn_engine_t engine)
Creates a memory_primitive_desc memory primitive descriptor using memory_desc and engine...
MKLDNN_DEPRECATED primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3208
Definition: mkldnn.hpp:2040
blocked weights format
Definition: mkldnn_types.h:259
mkldnn_status_t MKLDNN_API mkldnn_post_ops_create(mkldnn_post_ops_t *post_ops)
Creates an empty sequence of post operations post_ops.
Definition: mkldnn.hpp:331
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_destroy(mkldnn_primitive_desc_t primitive_desc)
Deletes a primitive_desc.
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1600
mkldnn_status_t MKLDNN_API mkldnn_concat_primitive_desc_create(mkldnn_primitive_desc_t *concat_primitive_desc, const mkldnn_memory_desc_t *output_desc, int n, int concat_dimension, const_mkldnn_primitive_desc_t *input_pds)
Creates out-of-place concat_primitive_desc for concatenation of n inputs by concat_dimension with res...
MKLDNN_DEPRECATED convolution_relu_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1734
4D RNN bias tensor in the format (num_layers, num_directions, num_gates, output_channels).
Definition: mkldnn_types.h:239
4D data tensor with the physical layout chwn, used in Neon.
Definition: mkldnn_types.h:163
Definition: mkldnn.hpp:266
padding_kind
Definition: mkldnn.hpp:234
The operation failed because of incorrect function arguments.
Definition: mkldnn_types.h:47
Forward data propagation (alias for mkldnn_forward_inference)
Definition: mkldnn_types.h:381
Definition: mkldnn.hpp:2094
Definition: mkldnn.hpp:1956
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1562
Definition: mkldnn.hpp:2897
Backward data propagation.
Definition: mkldnn_types.h:387
Definition: mkldnn.hpp:2510
static void validate_dims(std::vector< T > v)
Definition: mkldnn.hpp:577
Definition: mkldnn.hpp:3338
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_get_attr(const_mkldnn_primitive_desc_t primitive_desc, const_mkldnn_primitive_attr_t *attr)
Returns a constant reference to the attribute of a primitive_desc.
Definition: mkldnn.hpp:3328
mkldnn_status_t MKLDNN_API mkldnn_memory_desc_init(mkldnn_memory_desc_t *memory_desc, int ndims, const mkldnn_dims_t dims, mkldnn_data_type_t data_type, mkldnn_memory_format_t format)
Initializes a memory_desc memory descriptor using ndims, dims, data_type, and data format...
desc(prop_kind aprop_kind, const memory::desc &data_desc, int softmax_axis)
Definition: mkldnn.hpp:2476
Definition: mkldnn.hpp:275
blocked weights format
Definition: mkldnn_types.h:283
Undefined memory format, used for empty memory descriptors.
Definition: mkldnn_types.h:137
const_mkldnn_primitive_desc_t get_primitive_desc() const
Returns the descriptor of the underlying C API primitive.
Definition: mkldnn.hpp:212
MKLDNN_DEPRECATED desc(const memory::desc &diff_data_desc, const memory::desc &data_desc, T negative_slope)
Definition: mkldnn.hpp:2430
concat(const primitive_desc &concat_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:1100
memory::desc desc()
Returns the memory primitive descriptor.
Definition: mkldnn.hpp:757
deconvolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights, const memory &diff_bias)
Definition: mkldnn.hpp:2055
mkldnn_status_t MKLDNN_API mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for backward propagation with respect to weights using...
float alpha
alpha is a negative slope parameter (used only if (flags & mkldnn_rnn_cell_with_relu) != 0) ...
Definition: mkldnn_types.h:925
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_clone(mkldnn_primitive_attr_t *attr, const_mkldnn_primitive_attr_t existing_attr)
Makes a copy of an existing_attr.
#define TENSOR_MAX_DIMS
Maximum number of dimensions a tensor can have.
Definition: mkldnn_types.h:552
format
Memory format specification. See mkldnn_memory_format_t for a detailed description.
Definition: mkldnn.hpp:596
Definition: mkldnn.hpp:291
4D weights tensor with physical layout oihw, used in Caffe.
Definition: mkldnn_types.h:184
MKLDNN_DEPRECATED primitive_desc(std::vector< double > scale, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1191
A descriptor of a Softmax operation.
Definition: mkldnn_types.h:759
blocked weights format
Definition: mkldnn_types.h:348
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_clone(mkldnn_primitive_desc_t *primitive_desc, const_mkldnn_primitive_desc_t existing_primitive_desc)
Makes a copy of a primitive_desc.
softmax_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2496
blocked weights format
Definition: mkldnn_types.h:349
blocked data format
Definition: mkldnn_types.h:246
mkldnn_status_t MKLDNN_API mkldnn_memory_get_data_handle(const_mkldnn_primitive_t memory, void **handle)
For a memory primitive, returns the data handle.
Definition: mkldnn.hpp:246
mkldnn_status_t MKLDNN_API mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for backward propagation with respect to data using al...
A descriptor of an inner product operation.
Definition: mkldnn_types.h:867
mkldnn_status_t MKLDNN_API mkldnn_post_ops_destroy(mkldnn_post_ops_t post_ops)
Deletes a post_ops sequence.
std::vector< std::remove_extent< mkldnn_dims_t >::type > dims
Definition: mkldnn.hpp:575
3D RNN data tensor in the format (seq_length, batch, input channels).
Definition: mkldnn_types.h:215
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3308
An opaque structure for a chain of post operations.
An opaque structure to describe a primitive descriptor .
batch normalization descriptor
Definition: mkldnn_types.h:1173
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1779
mkldnn_rnn_direction_t
A direction of RNN primitive execution.
Definition: mkldnn_types.h:932
void reset(T t, bool weak=false)
Resets the value of a C handle.
Definition: mkldnn.hpp:79
A convolution primitive.
Definition: mkldnn_types.h:414
primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1927
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:2157
mkldnn_status_t MKLDNN_API mkldnn_memory_set_data_handle(mkldnn_primitive_t memory, void *handle)
For a memory primitive, sets the data handle.
engine(const mkldnn_engine_t &aengine)
Definition: mkldnn.hpp:529
engine(const handle< mkldnn_primitive_desc_t > &pd)
Definition: mkldnn.hpp:532
engine get_engine()
Definition: mkldnn.hpp:1269
desc(dims adims, data_type adata_type, format aformat)
Constructs a memory descriptor.
Definition: mkldnn.hpp:723
blocked data format
Definition: mkldnn_types.h:247
mkldnn_status_t MKLDNN_API mkldnn_batch_normalization_forward_desc_init(mkldnn_batch_normalization_desc_t *bnrm_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *data_desc, float epsilon, unsigned flags)
Initializes a batch normalization descriptor bnrm_desc for forward propagation using prop_kind...
Definition: mkldnn.hpp:227
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2874
sum(const primitive_desc &sum_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:1221
An execution engine.
Definition: mkldnn.hpp:494
memory(const primitive_desc &adesc, void *ahandle)
Definition: mkldnn.hpp:813
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2942
mkldnn_status_t MKLDNN_API mkldnn_post_ops_append_eltwise(mkldnn_post_ops_t post_ops, float scale, mkldnn_alg_kind_t alg, float alpha, float beta)
Appends eltwise post operation to the post_ops with given parameters kind, alpha and beta (...
static void wrap_c_api(mkldnn_status_t status, const std::string &message, mkldnn_primitive_t *error_primitive=0)
A convenience function for wrapping calls to the C API. Checks the return status and throws an error ...
Definition: mkldnn.hpp:190
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:2295
Undefined primitive (XXX: why do we have it?).
Definition: mkldnn_types.h:398
mkldnn_status_t MKLDNN_API mkldnn_deconvolution_backward_data_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a deconvolution descriptor conv_desc for backward propagation with respect to data using ...
An inner product primitive.
Definition: mkldnn_types.h:430
void check_num_parameters(const const_mkldnn_primitive_desc_t &aprimitive_desc, int n_inputs, int n_outputs, const std::string &prim_name)
Definition: mkldnn.hpp:868
Round down.
Definition: mkldnn_types.h:82
Definition: mkldnn_types.h:1175
4D grouped weights tensor with the physical layout goiw.
Definition: mkldnn_types.h:199
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const softmax_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2525
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1797
Definition: mkldnn.hpp:265
round_mode get_int_output_round_mode() const
Definition: mkldnn.hpp:430
primitive_attr()
Definition: mkldnn.hpp:423
Definition: mkldnn_types.h:470
Definition: mkldnn.hpp:2413
mkldnn_primitive_at_t MKLDNN_API mkldnn_primitive_at(const_mkldnn_primitive_t primitive, size_t output_index)
Creates an mkldnn_primitive_at_t structure from a primitive and output_index.
primitive_desc(const desc &desc, const engine &e, const softmax_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2521
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:2511
Definition: mkldnn.hpp:2485
void get_params_sum(int index, float &scale) const
Definition: mkldnn.hpp:394
Definition: mkldnn.hpp:249
32-bit signed integer.
Definition: mkldnn_types.h:68
primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2955
Max pooling.
Definition: mkldnn_types.h:465
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1421
memory::desc zero_md()
Definition: mkldnn.hpp:857
Definition: mkldnn.hpp:340
primitive_desc(const memory::primitive_desc &input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:992
mkldnn_status_t MKLDNN_API mkldnn_softmax_forward_desc_init(mkldnn_softmax_desc_t *softmax_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *data_desc, int softmax_axis)
Initializes a softmax_desc for forward propagation using prop_kind (possible value are mkldnn_forward...
blocked weights format
Definition: mkldnn_types.h:273
const post_ops get_post_ops() const
Definition: mkldnn.hpp:464
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims kernel, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:2233
Definition: mkldnn.hpp:333
execution engine
Definition: mkldnn_types.h:1148
stream(kind akind)
Constructs a stream.
Definition: mkldnn.hpp:3387
Definition: mkldnn.hpp:991
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_next(mkldnn_primitive_desc_iterator_t iterator)
Iterates over primitive descriptors.
Definition: mkldnn.hpp:338
desc(const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2943
mkldnn_status_t MKLDNN_API mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t *pool_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t kernel, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a pooling descriptor pool_desc for backward propagation using alg_kind, memory descriptors, and pooling parameters in spatial domain: strides, kernel sizes, padding_l, padding_r, and padding_kind.
Definition: mkldnn.hpp:2230
blocked weights format
Definition: mkldnn_types.h:280
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1706
static mkldnn_memory_format_t convert_to_c(format aformat)
Definition: mkldnn.hpp:852
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const eltwise_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2440
Definition: mkldnn.hpp:2767
Definition: mkldnn.hpp:322
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_create(mkldnn_primitive_attr_t *attr)
Creates an empty (default) attr attribute.
Definition: mkldnn_types.h:910
A descriptor of a convolution followed by relu operation.
Definition: mkldnn_types.h:896
mkldnn_status_t MKLDNN_API mkldnn_stream_submit(mkldnn_stream_t stream, size_t n, mkldnn_primitive_t primitives[], mkldnn_primitive_t *error_primitive)
Submits primitives to an execution stream.
algorithm
Definition: mkldnn.hpp:257
input memory primitive desc
Definition: mkldnn_types.h:1180
blocked weights format
Definition: mkldnn_types.h:294
mkldnn_shuffle_desc_t data
Definition: mkldnn.hpp:3297
5D grouped weights tensor with the physical layout goihw, used in Caffe.
Definition: mkldnn_types.h:203
const_mkldnn_primitive_t primitive
Primitive to specify the output for.
Definition: mkldnn_types.h:1108
Definition: mkldnn.hpp:290
rnn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src_layer, const primitive::at &src_iter, const primitive::at &weights_layer, const primitive::at &weights_iter, const primitive::at &bias, const memory &dst_layer, const memory &dst_iter, const memory &workspace)
Definition: mkldnn.hpp:3142
mkldnn_status_t MKLDNN_API mkldnn_rnn_cell_desc_init(mkldnn_rnn_cell_desc_t *rnn_cell_desc, mkldnn_alg_kind_t kind, mkldnn_alg_kind_t f, unsigned int flags, float alpha, float clipping)
Initializes a recurrent cell descriptor rnn_cell_desc using rnn_cell_desc, kind (possible values are ...
A descriptor of a element-wise operation.
Definition: mkldnn_types.h:717
rnn descriptor
Definition: mkldnn_types.h:1176
memory::primitive_desc variance_primitive_desc() const
Definition: mkldnn.hpp:2584
An element-wise primitive.
Definition: mkldnn_types.h:418
Definition: mkldnn.hpp:2954
Definition: mkldnn.hpp:2509
destination grad.
Definition: mkldnn_types.h:1187
algorithm get_cell_kind() const
Definition: mkldnn.hpp:3074
engine get_engine()
Definition: mkldnn.hpp:1218
Definition: mkldnn.hpp:2414
mkldnn_status_t MKLDNN_API mkldnn_stream_wait(mkldnn_stream_t stream, int block, mkldnn_primitive_t *error_primitive)
Waits for all primitives in the execution stream to finish.
mkldnn_alg_kind_t activation_kind
Activation function used.
Definition: mkldnn_types.h:920
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1205
blocked weights format
Definition: mkldnn_types.h:297
A descriptor for an rnn operation.
Definition: mkldnn_types.h:947
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1398
Definition: mkldnn.hpp:1047
Definition: mkldnn.hpp:278
Definition: mkldnn.hpp:260
eltwise descriptor
Definition: mkldnn_types.h:1168
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &mean, const memory &variance, const memory &workspace)
Definition: mkldnn.hpp:2693
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1446
Definition: mkldnn.hpp:277
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const primitive::at &weights_or_workspace, const memory &diff_src)
Definition: mkldnn.hpp:2830
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2142
size_t MKLDNN_API mkldnn_engine_get_count(mkldnn_engine_kind_t kind)
Returns the number of engines of a particular kind.
desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2986
batch_normalization_flag
Definition: mkldnn.hpp:289
A memory primitive.
Definition: mkldnn_types.h:400
float clipping
clipping parameter (used only if (flags & mkldnn_rnn_cell_with_clipping) != 0)
Definition: mkldnn_types.h:928
MKLDNN_DEPRECATED desc(prop_kind aprop_kind, const memory::desc &src_desc, T negative_slope)
Definition: mkldnn.hpp:2382
blocked weights format
Definition: mkldnn_types.h:282
desc(prop_kind aprop_kind, rnn_cell::desc cell, const rnn_direction direction, const memory::desc &src_layer_desc, const memory::desc &src_iter_desc, const memory::desc &weights_layer_desc, const memory::desc &weights_iter_desc, const memory::desc &bias_desc, const memory::desc &dst_layer_desc, const memory::desc &dst_iter_desc, const memory::desc &diff_src_layer_desc, const memory::desc &diff_src_iter_desc, const memory::desc &diff_weights_layer_desc, const memory::desc &diff_weights_iter_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_layer_desc, const memory::desc &diff_dst_iter_desc)
Definition: mkldnn.hpp:3174
Eltwise: soft_relu.
Definition: mkldnn_types.h:461
Definition: mkldnn.hpp:1530
void set_post_ops(post_ops ops)
Definition: mkldnn.hpp:473
inner_product_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at weights, const primitive::at &bias, const memory &dst)
Definition: mkldnn.hpp:2910
Definition: mkldnn.hpp:345
Definition: mkldnn.hpp:262
mkldnn_primitive_kind_t MKLDNN_API mkldnn_post_ops_get_kind(const_mkldnn_post_ops_t post_ops, int index)
Returns the type of post operation with index index in given post_ops.
RNN cell.
Definition: mkldnn_types.h:480
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2257
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1818
bool is_null_memory(const const_mkldnn_primitive_t &aprimitive)
Definition: mkldnn.hpp:888
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2959
Definition: mkldnn.hpp:371
Definition: mkldnn.hpp:2941
blocked weights format
Definition: mkldnn_types.h:309
bool operator==(const handle &other) const
Definition: mkldnn.hpp:87
Definition: mkldnn.hpp:1358
Backward weights propagation.
Definition: mkldnn_types.h:389
void set_int_output_round_mode(round_mode mode)
Definition: mkldnn.hpp:437
mkldnn_rnn_desc_t data
Definition: mkldnn.hpp:3102
blocked weights format
Definition: mkldnn_types.h:344
eltwise_forward relu_forward
Definition: mkldnn.hpp:2411
32-bit/single-precision floating point.
Definition: mkldnn_types.h:66
blocked weights format
Definition: mkldnn_types.h:256
blocked data format
Definition: mkldnn_types.h:245
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1582
algorithm get_activation() const
Definition: mkldnn.hpp:3076
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2268
2D weights tensor with physical layout oi.
Definition: mkldnn_types.h:172
Just a sentinel, not real memory format.
Definition: mkldnn_types.h:359
Omit statistics.
Definition: mkldnn_types.h:532
Memory descriptor.
Definition: mkldnn_types.h:616
Definition: mkldnn.hpp:2873
Definition: mkldnn.hpp:305
mkldnn_status_t MKLDNN_API mkldnn_inner_product_backward_data_desc_init(mkldnn_inner_product_desc_t *ip_desc, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc)
Initializes an inner product descriptor ip_desc for backward propagation with respect to data using m...
Base class for all computational primitives.
Definition: mkldnn.hpp:106
shuffle_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:3315
mkldnn_batch_normalization_flag_t
Flags for batch-normalization primititve.
Definition: mkldnn_types.h:497
void set_clipping(float clipping)
Definition: mkldnn.hpp:3086
convolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:1674
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:2095
Definition: mkldnn.hpp:2872
desc(prop_kind aprop_kind, const memory::desc &src_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2560
Definition: mkldnn.hpp:281
pooling descriptor
Definition: mkldnn_types.h:1171
Definition: mkldnn.hpp:2294
const mkldnn_memory_desc_t MKLDNN_API * mkldnn_primitive_desc_query_memory_d(const_mkldnn_primitive_desc_t primitive_desc)
Queries primitive descriptor for memory descriptor.
prop_kind
Definition: mkldnn.hpp:242
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:2232
Definition: mkldnn.hpp:268
blocked weights format
Definition: mkldnn_types.h:255
3D weights tensor with physical layout wio.
Definition: mkldnn_types.h:181
blocked weights format
Definition: mkldnn_types.h:308
mkldnn_status_t MKLDNN_API mkldnn_dilated_deconvolution_forward_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated deconvolution descriptor deconv_desc for forward propagation using prop_kind (p...
unsigned int flags
RNN cell flags.
Definition: mkldnn_types.h:922
3D data tensor with the physical layout ncw.
Definition: mkldnn_types.h:151
blocked weights format
Definition: mkldnn_types.h:285
convolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1544
The operation was successful.
Definition: mkldnn_types.h:41
mkldnn_status_t MKLDNN_API mkldnn_engine_create(mkldnn_engine_t *engine, mkldnn_engine_kind_t kind, size_t index)
Creates an engine of particular kind and index.
blocked weights format
Definition: mkldnn_types.h:320
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3012
primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1646
desc(algorithm kind, algorithm activation_f)
Definition: mkldnn.hpp:3064
blocked weights format
Definition: mkldnn_types.h:328
Definition: mkldnn.hpp:328
Definition: mkldnn.hpp:247
primitive_desc(const_mkldnn_op_desc_t desc, const primitive_attr *attr, const engine &e, const_mkldnn_primitive_desc_t hint_fwd_pd)
Definition: mkldnn.hpp:1257
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_get_int_output_round_mode(const_mkldnn_primitive_attr_t attr, mkldnn_round_mode_t *round_mode)
Returns integer output rounding mode round_mode for a given attr, previously set by mkldnn_primitive_...
blocked weights format
Definition: mkldnn_types.h:342
mkldnn_rnn_desc_t data
Definition: mkldnn.hpp:3173
Backward propagation (with respect to all parameters.
Definition: mkldnn_types.h:385
5D data tensor with the physical layout ndhwc, used in TensorFlow.
Definition: mkldnn_types.h:169
inner_product_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at diff_dst, const memory &diff_weights, const memory &diff_bias)
Definition: mkldnn.hpp:3036
softmax descriptor
Definition: mkldnn_types.h:1170
mkldnn_round_mode_t
Rounding mode.
Definition: mkldnn_types.h:78
A deconvolution primitive.
Definition: mkldnn_types.h:416
Definition: mkldnn.hpp:332
Definition: mkldnn.hpp:276
primitive_desc(const desc &adesc, const engine &aengine)
Constructs a memory primitive descriptor.
Definition: mkldnn.hpp:747
Use global statistics.
Definition: mkldnn_types.h:510
Definition: mkldnn.hpp:31
primitive_desc(int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1072
blocked weights format
Definition: mkldnn_types.h:286
no query
Definition: mkldnn_types.h:1146
Definition: mkldnn.hpp:2984
Definition: mkldnn.hpp:1758
blocked weights format
Definition: mkldnn_types.h:335
blocked weights format
Definition: mkldnn_types.h:298
mkldnn_status_t MKLDNN_API mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for forward propagation using prop_kind (possible valu...
mkldnn_status_t MKLDNN_API mkldnn_view_primitive_desc_create(mkldnn_primitive_desc_t *view_primitive_desc, const_mkldnn_primitive_desc_t memory_primitive_desc, const mkldnn_dims_t dims, const mkldnn_dims_t offsets)
Creates a view_primitive_desc for a given memory_primitive_desc, with dims sizes and offset offsets...
8-bit unsigned integer.
Definition: mkldnn_types.h:74
Definition: mkldnn.hpp:350
Average pooling include padding.
Definition: mkldnn_types.h:467
Unspecified format.
Definition: mkldnn_types.h:140
inner_product_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at weights, const memory &diff_src)
Definition: mkldnn.hpp:2968
Definition: mkldnn.hpp:2116
destination memory primitive desc
Definition: mkldnn_types.h:1186
memory::primitive_desc mean_primitive_desc() const
Definition: mkldnn.hpp:2582
5D RNN weights tensor in the format (num_layers, num_directions, input_channels, num_gates, output_channels).
Definition: mkldnn_types.h:225
GRU cell with linear before reset.
Definition: mkldnn_types.h:493
memory(const primitive_desc &adesc)
Constructs a memory primitive.
Definition: mkldnn.hpp:786
lrn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const primitive::at &workspace, const memory &diff_src)
Definition: mkldnn.hpp:2194
mkldnn_status_t MKLDNN_API mkldnn_shuffle_forward_desc_init(mkldnn_shuffle_desc_t *shuffle_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *data_desc, int axis, int group_size)
Initializes a shuffle_desc for forward propagation using prop_kind, memory descriptor data_desc...
Local response normalization (LRN) across multiple channels.
Definition: mkldnn_types.h:472
blocked weights format
Definition: mkldnn_types.h:270
GRU cell.
Definition: mkldnn_types.h:484
Eager stream.
Definition: mkldnn_types.h:1201
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output, const primitive_attr &aattr)
Definition: mkldnn.hpp:942
void set_output_scales(int mask, const std::vector< float > &scales)
Definition: mkldnn.hpp:457
at(const primitive &aprimitive, size_t at=0)
Constructs a wrapper specifying aprimitive output with index at.
Definition: mkldnn.hpp:145
implementation name
Definition: mkldnn_types.h:1159
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1996
Definition: mkldnn.hpp:1359
desc(const memory::desc &diff_data_desc, int axis, int group_size)
Definition: mkldnn.hpp:3331
Definition: mkldnn.hpp:3329
Definition: mkldnn.hpp:258
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2332
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_get_output_scales(const_mkldnn_primitive_attr_t attr, int *count, int *mask, const float **scales)
Returns count, correspondence scale mask, and pointer to a constant floating point array of output sc...
3D weights tensor with physical layout oiw.
Definition: mkldnn_types.h:178
Eltwise: parametric exponential linear unit (elu)
Definition: mkldnn_types.h:449
kind
Kinds of engines.
Definition: mkldnn.hpp:499
Definition: mkldnn.hpp:2156
Definition: mkldnn.hpp:2940
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2489
Intel(R) MKL-DNN exception class.
Definition: mkldnn.hpp:163
round_mode
Definition: mkldnn.hpp:225
bool operator==(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:897
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1885
Eltwise: ReLU.
Definition: mkldnn_types.h:445
Definition: mkldnn.hpp:2473
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1360
Definition: mkldnn.hpp:235
1D data tensor.
Definition: mkldnn_types.h:146
mkldnn_primitive_at_t data
The underlying C API structure.
Definition: mkldnn.hpp:138
memory::primitive_desc query_mpd(query what, int idx=0) const
Queries and returns requested memory primitive descriptor.
Definition: mkldnn.hpp:1310
desc(const convolution_forward::desc conv_desc, const float negative_slope)
Definition: mkldnn.hpp:1697
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2772
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_post_ops(mkldnn_primitive_attr_t attr, const_mkldnn_post_ops_t post_ops)
Sets configured post_ops to an attribute attr for future use (when primitive descriptor is being crea...
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const rnn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3215
primitive_desc(const desc &desc, const engine &e, const shuffle_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3339
4D weights tensor with physical layout ihwo.
Definition: mkldnn_types.h:190
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:2415
mkldnn_memory_format_t
Memory format specification.
Definition: mkldnn_types.h:135
Definition: mkldnn.hpp:990
Eltwise: square.
Definition: mkldnn_types.h:451
Definition: mkldnn.hpp:1124
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1380
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1002
Definition: mkldnn.hpp:282
mkldnn_status_t MKLDNN_API mkldnn_eltwise_forward_desc_init(mkldnn_eltwise_desc_t *eltwise_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *data_desc, float alpha, float beta)
Initializes a eltwise_desc for forward propagation using prop_kind (possible values are mkldnn_forwar...
int MKLDNN_API mkldnn_memory_primitive_desc_equal(const_mkldnn_primitive_desc_t lhs, const_mkldnn_primitive_desc_t rhs)
Compares two descriptors of memory primitives.
static mkldnn_data_type_t convert_to_c(data_type adata_type)
Definition: mkldnn.hpp:849
4D data tensor with the physical layout nhwc, used in TensorFlow.
Definition: mkldnn_types.h:160
void set_data_handle(void *handle) const
Definition: mkldnn.hpp:843
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &mean, const memory &variance)
Definition: mkldnn.hpp:2667
Definition: mkldnn.hpp:269
desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, int local_size, float alpha, float beta, float k)
Definition: mkldnn.hpp:2158
Backward bias propagation.
Definition: mkldnn_types.h:391
Definition: mkldnn.hpp:931
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, float alpha, float beta)
Definition: mkldnn.hpp:2105
blocked weights format
Definition: mkldnn_types.h:339
Use scale and shift parameters.
Definition: mkldnn_types.h:523
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1760
mkldnn_status_t MKLDNN_API mkldnn_deconvolution_forward_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a deconvolution descriptor deconv_desc for forward propagation using prop_kind (possible ...
query
Definition: mkldnn.hpp:313
Definition: mkldnn.hpp:280
weights format with additional buffer size equal to the number of output channels multiplied by numbe...
Definition: mkldnn_types.h:319
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_query(const_mkldnn_primitive_desc_t primitive_desc, mkldnn_query_t what, int index, void *result)
Queries primitive descriptor.
float get_alpha() const
Definition: mkldnn.hpp:3079
blocked weights format
Definition: mkldnn_types.h:269
blocked weights format
Definition: mkldnn_types.h:329
A descriptor of a shuffle operation.
Definition: mkldnn_types.h:700
void get_params_eltwise(int index, float &scale, algorithm &alg, float &alpha, float &beta) const
Definition: mkldnn.hpp:406
Definition: mkldnn_types.h:942
mkldnn_status_t MKLDNN_API mkldnn_dilated_deconvolution_backward_weights_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated deconvolution descriptor conv_desc for backward propagation with respect to wei...
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:2368
primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2041
Definition: mkldnn.hpp:422
blocked weights format
Definition: mkldnn_types.h:337
blocked weights format
Definition: mkldnn_types.h:305
Definition: mkldnn.hpp:1926
int get_gates_count() const
Definition: mkldnn.hpp:3091
int ndims
Number of dimensions.
Definition: mkldnn_types.h:621
reorder(const primitive_desc &aprimitive_desc, const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:955
Definition: mkldnn.hpp:2093
Definition: mkldnn.hpp:1048
kind
A proxy to C primitive kind enum.
Definition: mkldnn.hpp:113
void set_alpha(float alpha)
Definition: mkldnn.hpp:3080
A convolution primitive merged with ReLU.
Definition: mkldnn_types.h:432
mkldnn_status_t MKLDNN_API mkldnn_eltwise_backward_desc_init(mkldnn_eltwise_desc_t *eltwise_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_data_desc, const mkldnn_memory_desc_t *data_desc, float alpha, float beta)
Initializes a eltwise_desc for backward propagation using alg_kind algorithm memory descriptors diff_...
desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, int local_size, float alpha, float beta)
Definition: mkldnn.hpp:2168
5D data tensor with the physical layout ncdhw.
Definition: mkldnn_types.h:166
Definition: mkldnn.hpp:3296
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_destroy(mkldnn_primitive_desc_iterator_t iterator)
Deletes a primitive descriptor iterator.
5D RNN states tensor in the format (num_layers, num_directions, num_states, batch, state channels).
Definition: mkldnn_types.h:218
Definition: mkldnn.hpp:2180
size_t get_size() const
Returns the number of bytes required to allocate the memory described including the padding area...
Definition: mkldnn.hpp:763
mkldnn_status_t MKLDNN_API mkldnn_post_ops_append_sum(mkldnn_post_ops_t post_ops, float scale)
Appends accumulation (sum) post operation to the post_ops.
Definition: mkldnn.hpp:1559
deconvolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const primitive::at &bias, const memory &dst)
Definition: mkldnn.hpp:1853
A rnn primitive.
Definition: mkldnn_types.h:434
mkldnn_status_t MKLDNN_API mkldnn_primitive_get_output(const_mkldnn_primitive_t primitive, size_t index, const_mkldnn_primitive_t *output)
For a primitive, returns output at the index position.
MKLDNN_DEPRECATED primitive_desc(const memory::desc &output, std::vector< double > scale, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1175
blocked weights format
Definition: mkldnn_types.h:293
mkldnn_status_t MKLDNN_API mkldnn_shuffle_backward_desc_init(mkldnn_shuffle_desc_t *shuffle_desc, const mkldnn_memory_desc_t *diff_data_desc, int axis, int group_size)
Initializes a shuffle_desc for backward propagation using memory descriptor diff_data_desc, axis and group number.
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1957
Definition: mkldnn.hpp:3061
eltwise_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2449
mkldnn_prop_kind_t
Kinds of propagation.
Definition: mkldnn_types.h:369
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn.hpp:136
CPU engine.
Definition: mkldnn_types.h:998
Definition: mkldnn.hpp:293
desc(algorithm alg_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:2418
Eltwise: square root.
Definition: mkldnn_types.h:455
blocked weights format
Definition: mkldnn_types.h:257
mkldnn_stream_kind_t
Kinds of streams.
Definition: mkldnn_types.h:1197
Definition: mkldnn.hpp:272
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_int_output_round_mode(mkldnn_primitive_attr_t attr, mkldnn_round_mode_t round_mode)
Sets output rounding mode round_mode for integer operations for a given attr.
4D weights tensor with physical layout hwio, used in TensorFlow.
Definition: mkldnn_types.h:187
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn_types.h:1106
Winograd convolution.
Definition: mkldnn_types.h:443
Definition: mkldnn.hpp:248
A ReLU primitive.
Definition: mkldnn_types.h:420
Definition: mkldnn.hpp:347
Eltwise: linear.
Definition: mkldnn_types.h:457
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1886
mkldnn_status_t MKLDNN_API mkldnn_softmax_backward_desc_init(mkldnn_softmax_desc_t *softmax_desc, const mkldnn_memory_desc_t *diff_desc, const mkldnn_memory_desc_t *data_desc, int softmax_axis)
Initializes a softmax_desc for backward propagation using memory descriptors diff_desc and data_desc...
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1958
reorder(const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:966
Eltwise: logistic.
Definition: mkldnn_types.h:463
Definition: mkldnn.hpp:2752
Direct convolution.
Definition: mkldnn_types.h:441
Primitive iterator passed over last primitive descriptor.
Definition: mkldnn_types.h:54
Definition: mkldnn.hpp:342
Definition: mkldnn.hpp:271
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &workspace, const memory &dst)
Definition: mkldnn.hpp:2128
source gradient memory primitive desc
Definition: mkldnn_types.h:1183
mkldnn_alg_kind_t cell_kind
RNN cell kind.
Definition: mkldnn_types.h:917
Definition: mkldnn.hpp:1487
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2754
Definition: mkldnn_types.h:934
An opaque structure for primitive descriptor attributes.
Definition: mkldnn.hpp:314
blocked data format
Definition: mkldnn_types.h:249
mkldnn_status_t MKLDNN_API mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t *pool_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t kernel, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a pooling descriptor pool_desc for forward propagation using prop_kind (possible values a...
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, float alpha, float beta, float k)
Definition: mkldnn.hpp:2096
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:2724
mkldnn_rnn_cell_desc_t c_rnn_cell_
Definition: mkldnn.hpp:3062
bool operator!=(const primitive_desc &other) const
Definition: mkldnn.hpp:772
runtime estimation (seconds)
Definition: mkldnn_types.h:1154
blocked weights format
Definition: mkldnn_types.h:336
Definition: mkldnn.hpp:1645
bool operator==(const T other) const
Definition: mkldnn.hpp:61
A (in-place) concat primitive.
Definition: mkldnn_types.h:410
mkldnn_status_t MKLDNN_API mkldnn_stream_create(mkldnn_stream_t *stream, mkldnn_stream_kind_t stream_kind)
Creates an execution stream of stream_kind.
primitive_desc get_primitive_desc() const
Returns the descriptor of the memory primitive.
Definition: mkldnn.hpp:823
blocked weights format
Definition: mkldnn_types.h:271
LSTM cell.
Definition: mkldnn_types.h:482
blocked weights format
Definition: mkldnn_types.h:260
mkldnn_status_t MKLDNN_API mkldnn_batch_normalization_backward_desc_init(mkldnn_batch_normalization_desc_t *bnrm_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *diff_data_desc, const mkldnn_memory_desc_t *data_desc, float epsilon, unsigned flags)
Initializes a batch normalization descriptor bnrm_desc for backward propagation with respect to data ...
Definition: mkldnn_types.h:943
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2571
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2898
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2901
Undefined data type, used for empty memory descriptors.
Definition: mkldnn_types.h:64
Definition: mkldnn.hpp:1883
16-bit signed integer.
Definition: mkldnn_types.h:70
Definition: mkldnn.hpp:2367
A shuffle primitive.
Definition: mkldnn_types.h:406
blocked weights format with additional buffer with size equal to the number of output channels and co...
Definition: mkldnn_types.h:278
mkldnn_shuffle_desc_t data
Definition: mkldnn.hpp:3330
primitive_desc()
Definition: mkldnn.hpp:744
int len() const
Definition: mkldnn.hpp:379
mkldnn_status_t MKLDNN_API mkldnn_primitive_get_primitive_desc(const_mkldnn_primitive_t primitive, const_mkldnn_primitive_desc_t *primitive_desc)
Retrieves a reference to the primitive_desc descriptor of given primitive.
primitive_desc(const memory::desc &output, const std::vector< float > &scales, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1136
desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc)
Definition: mkldnn.hpp:2886
mkldnn_status_t MKLDNN_API mkldnn_post_ops_get_params_eltwise(const_mkldnn_post_ops_t post_ops, int index, float *scale, mkldnn_alg_kind_t *alg, float *alpha, float *beta)
Gets the eltwise parameters of the post operation with index index in the sequence of post_ops...
Definition: mkldnn.hpp:1840
Definition: mkldnn.hpp:244
blocked weights format
Definition: mkldnn_types.h:299
Definition: mkldnn.hpp:3007
mkldnn_status_t MKLDNN_API mkldnn_post_ops_get_params_sum(const_mkldnn_post_ops_t post_ops, int index, float *scale)
Gets the parameters of the accumulation (sum) post operation with index index in the sequence of post...
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1488
blocked weights format
Definition: mkldnn_types.h:292
A (out-of-place) concat primitive.
Definition: mkldnn_types.h:408
blocked weights format
Definition: mkldnn_types.h:306
Fuse with ReLU.
Definition: mkldnn_types.h:541
Definition: mkldnn.hpp:261
Definition: mkldnn.hpp:279
static size_t get_count(kind akind)
Returns the number of engines of a certain kind.
Definition: mkldnn.hpp:510
mkldnn_query_t
Primitive descriptor query specification.
Definition: mkldnn_types.h:1145
A descriptor of a Batch Normalization operation.
Definition: mkldnn_types.h:836
static engine query(const primitive_desc &pd)
Definition: mkldnn.hpp:542
Definition: mkldnn.hpp:3100
deconvolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:2069
Definition: mkldnn.hpp:292
blocked data format
Definition: mkldnn_types.h:248
A sum primitive.
Definition: mkldnn_types.h:412
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2847
Definition: mkldnn.hpp:304
blocked weights format
Definition: mkldnn_types.h:333
eltwise_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2398
unsigned flags
Definition: mkldnn_types.h:863
mkldnn_status_t MKLDNN_API mkldnn_reorder_primitive_desc_create_v2(mkldnn_primitive_desc_t *reorder_primitive_desc, const_mkldnn_primitive_desc_t input, const_mkldnn_primitive_desc_t output, const_mkldnn_primitive_attr_t attr)
Initializes a reorder_primitive_desc using an attr attribute and descriptors of input and output memo...
blocked weights format
Definition: mkldnn_types.h:261
blocked weights format
Definition: mkldnn_types.h:310
Definition: mkldnn.hpp:3060
softmax_backward(const primitive_desc &aprimitive_desc, const primitive::at &dst, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2535
blocked weights format
Definition: mkldnn_types.h:252
Definition: mkldnn.hpp:3101
Definition: mkldnn.hpp:259
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2388
mkldnn_status_t MKLDNN_API mkldnn_dilated_deconvolution_backward_data_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated deconvolution descriptor conv_desc for backward propagation with respect to dat...
blocked weights format
Definition: mkldnn_types.h:338
mkldnn_status_t MKLDNN_API mkldnn_stream_rerun(mkldnn_stream_t stream, mkldnn_primitive_t *error_primitive)
Reruns all the primitives within the stream.
2D weights tensor with physical layout io.
Definition: mkldnn_types.h:175
memory consumption – extra (scratch) memory, additional to all inputs and outputs memory (bytes) ...
Definition: mkldnn_types.h:1155
An batch normalization primitive.
Definition: mkldnn_types.h:428
A class for wrapping an Intel(R) MKL-DNN handle. It is used as the base class for primitive (mkldnn_p...
Definition: mkldnn.hpp:55
Definition: mkldnn_types.h:439
engine(kind akind, size_t index)
Constructs an engine.
Definition: mkldnn.hpp:520
Definition: mkldnn.hpp:2366
A descriptor of a pooling operation.
Definition: mkldnn_types.h:775
Definition: mkldnn.hpp:3376
Definition: mkldnn.hpp:273
Definition: mkldnn.hpp:274
engine get_engine()
Definition: mkldnn.hpp:776
MKLDNN_DEPRECATED convolution_relu_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const primitive::at &bias, const memory &dst)
Definition: mkldnn.hpp:1717
error(mkldnn_status_t astatus, std::string amessage, mkldnn_primitive_t aerror_primitive=0)
Constructs an error instance.
Definition: mkldnn.hpp:175
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2045
const char * impl_info_str() const
Returns implementation name.
Definition: mkldnn.hpp:1285
deconvolution descriptor
Definition: mkldnn_types.h:1166
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1126
blocked weights format
Definition: mkldnn_types.h:312
shuffle_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:3347
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output)
Definition: mkldnn.hpp:933
primitive_desc(const desc &desc, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2319
mkldnn_memory_desc_t data
The underlying C API data structure.
Definition: mkldnn.hpp:716
mkldnn_primitive_desc_t MKLDNN_API mkldnn_primitive_desc_iterator_fetch(const_mkldnn_primitive_desc_iterator_t iterator)
Fetches current primitive descriptor.
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:1449
engine get_engine()
Definition: mkldnn.hpp:952
int MKLDNN_API mkldnn_primitive_desc_query_s32(const_mkldnn_primitive_desc_t primitive_desc, mkldnn_query_t what, int index)
Queries primitive descriptor for signed 32bit int.
8-bit signed integer.
Definition: mkldnn_types.h:72
mkldnn_status_t MKLDNN_API mkldnn_reorder_primitive_desc_create(mkldnn_primitive_desc_t *reorder_primitive_desc, const_mkldnn_primitive_desc_t input, const_mkldnn_primitive_desc_t output)
Initializes a reorder_primitive_desc using descriptors of input and output memory primitives...
The data in padding regions is zero.
Definition: mkldnn_types.h:365
int MKLDNN_API mkldnn_rnn_cell_get_states_count(const mkldnn_rnn_cell_desc_t *rnn_cell_desc)
Returns the number of states of a particular rnn_cell_desc.
Definition: mkldnn.hpp:2387
desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2996
source memory primitive desc
Definition: mkldnn_types.h:1182
mkldnn_primitive_kind_t
Kinds of primitives.
Definition: mkldnn_types.h:396
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1931
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:2018
RNN packed weights (unused)
Definition: mkldnn_types.h:354
Definition: mkldnn.hpp:3307
Winograd deconvolution.
Definition: mkldnn_types.h:478
Definition: mkldnn.hpp:250
number of inputs expected
Definition: mkldnn_types.h:1151
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:2475
Definition: mkldnn.hpp:349
Definition: mkldnn.hpp:3125
Definition: mkldnn.hpp:2753
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2574
Definition: mkldnn.hpp:2557
desc(prop_kind aprop_kind, algorithm alg_kind, const memory::desc &src_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:2370
An unspecified engine.
Definition: mkldnn_types.h:1199
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1841
void * get_data_handle() const
Returns a handle of the data contained in the memory primitive. On the CPU engine, this is a pointer to the allocated memory.
Definition: mkldnn.hpp:836
A view primitive.
Definition: mkldnn_types.h:402
size_t MKLDNN_API mkldnn_memory_primitive_desc_get_size(const_mkldnn_primitive_desc_t memory_primitive_desc)
Returns the size (in bytes) that is required for given memory_primitive_desc.
Definition: mkldnn.hpp:3172
Definition: mkldnn.hpp:263
Definition: mkldnn.hpp:330
Definition: mkldnn.hpp:3206
blocked weights format
Definition: mkldnn_types.h:284
Definition: mkldnn.hpp:339
mkldnn_primitive_kind_t convert_to_c(primitive::kind akind)
Definition: mkldnn.hpp:156
Definition: mkldnn.hpp:1560
Definition: mkldnn.hpp:344
Definition: mkldnn.hpp:334
Definition: mkldnn.hpp:325
Definition: mkldnn.hpp:336
Average pooling exclude padding.
Definition: mkldnn_types.h:469
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_get_post_ops(const_mkldnn_primitive_attr_t attr, const_mkldnn_post_ops_t *post_ops)
Returns post_ops for given attr.
mkldnn_status_t MKLDNN_API mkldnn_primitive_create(mkldnn_primitive_t *primitive, const_mkldnn_primitive_desc_t primitive_desc, const mkldnn_primitive_at_t *inputs, const_mkldnn_primitive_t *outputs)
Creates a primitive using a primitive_desc descriptor and arrays of inputs and outputs.
primitive::kind kind(int index) const
Definition: mkldnn.hpp:381
Definition: mkldnn_types.h:913
Forward data propagation (inference mode).
Definition: mkldnn_types.h:379
primitive_attr get_primitive_attr() const
Definition: mkldnn.hpp:1271
6D grouped weights tensor with the physical layout goidhw, used in Caffe.
Definition: mkldnn_types.h:211
5D weights tensor with physical layout iodhw, used in Caffe.
Definition: mkldnn_types.h:193
A class that provides the destructor for an Intel(R) MKL-DNN C handle.
Definition: mkldnn.hpp:40
data_type
Data type specification. See mkldnn_data_type_t for a detailed description.
Definition: mkldnn.hpp:585
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const memory &dst)
Definition: mkldnn.hpp:2614
Direct deconvolution.
Definition: mkldnn_types.h:476
Eltwise: abs.
Definition: mkldnn_types.h:453
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst, const memory &mean, const memory &variance)
Definition: mkldnn.hpp:2636
blocked weights format
Definition: mkldnn_types.h:322
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &workspace, const memory &diff_src)
Definition: mkldnn.hpp:2344
blocked weights format
Definition: mkldnn_types.h:272
A memory descriptor.
Definition: mkldnn.hpp:713
deconvolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1940
5D grouped weights tensor with the physical layout hwigo, used in TensorFlow.
Definition: mkldnn_types.h:207
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2391
blocked weights format
Definition: mkldnn_types.h:330
bool operator!=(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:900
handle(T t=0, bool weak=false)
Constructs a C handle wrapper.
Definition: mkldnn.hpp:67
mkldnn_status_t MKLDNN_API mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated convolution descriptor conv_desc for forward propagation using prop_kind (possi...
Eltwise: hyperbolic tangent non-linearity (tanh)
Definition: mkldnn_types.h:447
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2985
mkldnn_status_t status
Definition: mkldnn.hpp:164
deconvolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1868
eltwise_backward relu_backward
Definition: mkldnn.hpp:2463
T get() const
Returns the value of the underlying C handle.
Definition: mkldnn.hpp:85
mkldnn_status_t MKLDNN_API mkldnn_engine_destroy(mkldnn_engine_t engine)
Destroys an engine.
view(const primitive_desc &view_pd, primitive::at input)
Definition: mkldnn.hpp:1018
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1978
blocked weights format
Definition: mkldnn_types.h:311
2D data tensor.
Definition: mkldnn_types.h:148
primitive_desc(const desc &desc, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2768
desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc)
Definition: mkldnn.hpp:2875
mkldnn_status_t MKLDNN_API mkldnn_dilated_convolution_backward_data_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated convolution descriptor conv_desc for backward propagation with respect to data ...
bool wait(bool block=true)
Waits for all computations submitted to the stream to complete.
Definition: mkldnn.hpp:3426
mkldnn_status_t MKLDNN_API mkldnn_lrn_backward_desc_init(mkldnn_lrn_desc_t *lrn_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_data_desc, const mkldnn_memory_desc_t *data_desc, int local_size, float alpha, float beta, float k)
Initializes an lrn_desc for backward propagation using alg_kind, memory descriptors data_desc...
Primitive or engine failed on execution.
Definition: mkldnn_types.h:56
memory descriptor for memory and view
Definition: mkldnn_types.h:1164
view(memory input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:1027
Definition: mkldnn.hpp:1445
Definition: mkldnn.hpp:267
An LRN primitive.
Definition: mkldnn_types.h:426
Definition: mkldnn_types.h:939
mkldnn_padding_kind_t
Kinds of padding.
Definition: mkldnn_types.h:363
rnn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src_layer, const primitive::at &src_iter, const primitive::at &weights_layer, const primitive::at &weights_iter, const primitive::at &bias, const primitive::at &dst_layer, const primitive::at &dst_iter, const memory &diff_src_layer, const memory &diff_src_iter, const memory &diff_weights_layer, const memory &diff_weights_iter, const memory &diff_bias, const primitive::at &diff_dst_layer, const primitive::at &diff_dst_iter, const primitive::at &workspace)
Definition: mkldnn.hpp:3238
Lazy stream.
Definition: mkldnn_types.h:1203
Definition: mkldnn.hpp:335
desc(const memory::desc &diff_desc, const memory::desc &data_desc, int softmax_axis)
Definition: mkldnn.hpp:2512
blocked weights format
Definition: mkldnn_types.h:334
Definition: mkldnn.hpp:306
void get_output_scales(int &mask, std::vector< float > &scales) const
Definition: mkldnn.hpp:443
blocked weights format
Definition: mkldnn_types.h:254
desc(algorithm kind)
Definition: mkldnn.hpp:3070
primitive_desc(const desc &desc, const engine &e, const rnn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3211
Definition: mkldnn.hpp:1884
5D RNN weights tensor in the format (num_layers, num_directions, num_gates, output_channels, input_channels).
Definition: mkldnn_types.h:232
blocked weights format
Definition: mkldnn_types.h:304
const_mkldnn_primitive_desc_t MKLDNN_API mkldnn_primitive_desc_query_pd(const_mkldnn_primitive_desc_t primitive_desc, mkldnn_query_t what, int index)
Queries primitive descriptor for primitive descriptor.
Definition: mkldnn.hpp:2983
shuffle descriptor
Definition: mkldnn_types.h:1167
Forward data propagation (training mode).
Definition: mkldnn_types.h:375
Definition: mkldnn.hpp:348
primitive_desc(const desc &desc, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2181
inner_product_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:3022
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1561
memory(const primitive &aprimitive)
Constructs a memory primitive from a generic primitive.
Definition: mkldnn.hpp:782
3D data tensor with the physical layout nwc.
Definition: mkldnn_types.h:154
engine get_engine()
Definition: mkldnn.hpp:1097
post_ops()
Definition: mkldnn.hpp:372
An opaque structure to describe a primitive.
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const primitive::at &weights, const primitive::at &workspace, const memory &diff_src, const memory &diff_weights)
Definition: mkldnn.hpp:2808
A tensor in a generic format described by the stride and blocking values in each dimension.
Definition: mkldnn_types.h:144
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1361
mkldnn_data_type_t
Data type specification.
Definition: mkldnn_types.h:62
Definition: mkldnn.hpp:1486
Definition: mkldnn.hpp:327
Definition: mkldnn.hpp:320
convolution descriptor
Definition: mkldnn_types.h:1165
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1535
A memory primitive descriptor.
Definition: mkldnn.hpp:740
Definition: mkldnn.hpp:316
Definition: mkldnn.hpp:2520
mkldnn_status_t MKLDNN_API mkldnn_lrn_forward_desc_init(mkldnn_lrn_desc_t *lrn_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *data_desc, int local_size, float alpha, float beta, float k)
Initializes an lrn_desc for forward propagation using prop_kind (possible values are mkldnn_forward_t...
blocked weights format
Definition: mkldnn_types.h:295
primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1531
blocked weights format
Definition: mkldnn_types.h:288
handle & operator=(const handle &other)
Definition: mkldnn.hpp:72
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2738
Eltwise: bounded_relu.
Definition: mkldnn_types.h:459
Definition: mkldnn.hpp:2474
#define REG_QUERY_MPD(name, what, idx)
Definition: mkldnn.hpp:1335
Definition: mkldnn_types.h:936
convolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1471
mkldnn_engine_kind_t
Kinds of engines.
Definition: mkldnn_types.h:994
Definition: mkldnn_types.h:909
int MKLDNN_API mkldnn_rnn_cell_get_gates_count(const mkldnn_rnn_cell_desc_t *rnn_cell_desc)
Returns the number of gates of a particular rnn_cell_desc.
Queried element is not required for given primitive.
Definition: mkldnn_types.h:58
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3126
blocked weights format
Definition: mkldnn_types.h:347
bool operator!=(const T other) const
Definition: mkldnn.hpp:62
Memory primitive that describes the data.
Definition: mkldnn.hpp:570
Weights format used in 8bit Winograd convolution.
Definition: mkldnn_types.h:351
Definition: mkldnn.hpp:329
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2117
Definition: mkldnn.hpp:2155
Definition: mkldnn.hpp:303
Round nearest.
Definition: mkldnn_types.h:80
blocked weights format
Definition: mkldnn_types.h:346
Definition: mkldnn.hpp:245
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src, const memory &diff_weights)
Definition: mkldnn.hpp:2789
Definition: mkldnn.hpp:1757
const void * const_mkldnn_op_desc_t
A pointer to any of the operation descriptors (constant variant).
Definition: mkldnn_types.h:610
static mkldnn_stream_kind_t convert_to_c(kind akind)
Definition: mkldnn.hpp:3383
blocked weights format
Definition: mkldnn_types.h:253
blocked weights format
Definition: mkldnn_types.h:343
Definition: mkldnn.hpp:1955
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1085
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_create_v2(mkldnn_primitive_desc_iterator_t *iterator, const_mkldnn_op_desc_t op_desc, const_mkldnn_primitive_attr_t attr, mkldnn_engine_t engine, const_mkldnn_primitive_desc_t hint_forward_primitive_desc)
Creates a primitive descriptor iterator for given op_desc, attr, engine, and optionally a hint primit...
Definition: mkldnn.hpp:2556
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &workspace)
Definition: mkldnn.hpp:2280
convolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const primitive::at &bias, const memory &dst)
Definition: mkldnn.hpp:1458
A reorder primitive.
Definition: mkldnn_types.h:404
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:1844
mkldnn_status_t MKLDNN_API mkldnn_convolution_relu_desc_init(mkldnn_convolution_relu_desc_t *conv_relu_desc, const mkldnn_convolution_desc_t *conv_desc, float negative_slope)
Initializes a merged convolution-relu descriptor conv_relu_desc for forward propagation (supported in...
rnn_direction
Definition: mkldnn.hpp:301
primitive_desc(const std::vector< float > &scales, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1155
blocked weights format
Definition: mkldnn_types.h:331
blocked weights format
Definition: mkldnn_types.h:291
An unspecified engine.
Definition: mkldnn_types.h:996
desc(const mkldnn_memory_desc_t &adata)
Constructs a memory descriptor from a C API data structure.
Definition: mkldnn.hpp:736
Definition: mkldnn.hpp:1705
blocked weights format
Definition: mkldnn_types.h:307
Definition: mkldnn.hpp:1125
int MKLDNN_API mkldnn_post_ops_len(const_mkldnn_post_ops_t post_ops)
Returns the length of post operations for given post_ops.
engine get_engine()
Definition: mkldnn.hpp:1015
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2323
mkldnn_convolution_relu_desc_t data
Definition: mkldnn.hpp:1695
blocked weights format
Definition: mkldnn_types.h:332
blocked weights format
Definition: mkldnn_types.h:321
mkldnn_alg_kind_t
Kinds of algorithms.
Definition: mkldnn_types.h:438
primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3008
Definition: mkldnn.hpp:264
inner product descriptor
Definition: mkldnn_types.h:1174
A pooling primitive.
Definition: mkldnn_types.h:424
weights memory primitive descriptor desc
Definition: mkldnn_types.h:1184
output memory primitive desc
Definition: mkldnn_types.h:1181
Definition: mkldnn.hpp:2318
5D weights tensor with physical layout dhwio, used in TensorFlow.
Definition: mkldnn_types.h:196
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2120
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2558
Definition: mkldnn.hpp:932
mkldnn_status_t MKLDNN_API mkldnn_primitive_destroy(mkldnn_primitive_t primitive)
Deletes a primitive.
Definition: mkldnn.hpp:337
std::string message
Definition: mkldnn.hpp:165
Definition: mkldnn.hpp:3295
mkldnn_status_t MKLDNN_API mkldnn_deconvolution_backward_weights_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a deconvolution descriptor conv_desc for backward propagation with respect to weights usi...
mkldnn_status_t MKLDNN_API mkldnn_rnn_backward_desc_init(mkldnn_rnn_desc_t *rnn_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_rnn_cell_desc_t *rnn_cell_desc, const mkldnn_rnn_direction_t direction, const mkldnn_memory_desc_t *src_layer_desc, const mkldnn_memory_desc_t *src_iter_desc, const mkldnn_memory_desc_t *weights_layer_desc, const mkldnn_memory_desc_t *weights_iter_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_layer_desc, const mkldnn_memory_desc_t *dst_iter_desc, const mkldnn_memory_desc_t *diff_src_layer_desc, const mkldnn_memory_desc_t *diff_src_iter_desc, const mkldnn_memory_desc_t *diff_weights_layer_desc, const mkldnn_memory_desc_t *diff_weights_iter_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_layer, const mkldnn_memory_desc_t *diff_dst_iter_desc)
Initializes a rnn descriptor rnn_desc for backward propagation using prop_kind, rnn_cell_desc, direction, and memory descriptors.
primitive_desc(const desc &desc, const engine &e, const eltwise_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2436
Definition: mkldnn.hpp:2570
Definition: mkldnn.hpp:317
blocked weights format
Definition: mkldnn_types.h:281
handle(const handle &other)
Definition: mkldnn.hpp:71
Forward data propagation (alias for mkldnn_forward_training)
Definition: mkldnn_types.h:383
3D RNN data tensor in the format (batch, seq_length, input channels).
Definition: mkldnn_types.h:213
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr_t attr, int count, int mask, const float *scales)
Sets output scales for primitive operations.
Definition: mkldnn.hpp:243
lrn descriptor
Definition: mkldnn_types.h:1172
workspace memory primitive desc
Definition: mkldnn_types.h:1188
lrn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2208
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1622
bool next_impl()
Advances the next implementation for the given op descriptor.
Definition: mkldnn.hpp:1299
mkldnn_status_t MKLDNN_API mkldnn_inner_product_backward_weights_desc_init(mkldnn_inner_product_desc_t *ip_desc, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc)
Initializes an inner product descriptor ip_desc for backward propagation with respect to weights usin...
blocked weights format
Definition: mkldnn_types.h:258
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1759
desc(prop_kind aprop_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2756
blocked weights format
Definition: mkldnn_types.h:296
Definition: mkldnn.hpp:226
weights format with additional buffer size equal to the number of output channels and containing the ...
Definition: mkldnn_types.h:268
Definition: mkldnn_types.h:1169
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2185
float get_clipping() const
Definition: mkldnn.hpp:3085
weights grad.
Definition: mkldnn_types.h:1185
4D data tensor with the physical layout nchw, used in Caffe.
Definition: mkldnn_types.h:157
Definition: mkldnn.hpp:323
mkldnn_status_t MKLDNN_API mkldnn_rnn_forward_desc_init(mkldnn_rnn_desc_t *rnn_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_rnn_cell_desc_t *rnn_cell_desc, const mkldnn_rnn_direction_t direction, const mkldnn_memory_desc_t *src_layer_desc, const mkldnn_memory_desc_t *src_iter_desc, const mkldnn_memory_desc_t *weights_layer_desc, const mkldnn_memory_desc_t *weights_iter_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_layer_desc, const mkldnn_memory_desc_t *dst_iter_desc)
Initializes a rnn descriptor rnn_desc for forward propagation using prop_kind, rnn_cell_desc, direction, and memory descriptors.
void append_eltwise(float scale, algorithm alg, float alpha, float beta)
Definition: mkldnn.hpp:399
primitive kind
Definition: mkldnn_types.h:1149
blocked data format
Definition: mkldnn_types.h:244
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1904
RNN packed weights (unused)
Definition: mkldnn_types.h:355
int get_state_count() const
Definition: mkldnn.hpp:3094
blocked weights format
Definition: mkldnn_types.h:279
Definition: mkldnn.hpp:319
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &diff_dst_desc, const memory::dims &strides, const memory::dims &kernel, const memory::dims &padding_l, const memory::dims &padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:2296
A merged convolution-relu primitive for inference mode only.
Definition: mkldnn.hpp:1693
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst, const memory &mean, const memory &variance, const memory &workspace)
Definition: mkldnn.hpp:2651
kind
Definition: mkldnn.hpp:3379
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1489
Definition: mkldnn.hpp:343
desc(prop_kind aprop_kind, rnn_cell::desc cell, const rnn_direction direction, const memory::desc &src_layer_desc, const memory::desc &src_iter_desc, const memory::desc &weights_layer_desc, const memory::desc &weights_iter_desc, const memory::desc &bias_desc, const memory::desc &dst_layer_desc, const memory::desc &dst_iter_desc)
Definition: mkldnn.hpp:3103
mkldnn_status_t MKLDNN_API mkldnn_inner_product_forward_desc_init(mkldnn_inner_product_desc_t *ip_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc)
Initializes an inner product descriptor ip_desc for forward propagation using prop_kind (possible val...