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;
161 struct error:
public std::exception {
174 mkldnn_primitive_t aerror_primitive = 0)
177 , error_primitive(aerror_primitive, true)
189 const std::string &message,
190 mkldnn_primitive_t *error_primitive = 0)
193 if (
nullptr != error_primitive)
194 throw error(status, message, *error_primitive);
196 throw error(status, message,
nullptr);
205 data.output_index, &output),
206 "could not get an output primitive");
207 return primitive(const_cast<mkldnn_primitive_t>(output),
true);
213 "could not get primitive descriptor by primitive");
362 #ifndef DOXYGEN_SHOULD_SKIP_THIS 370 mkldnn_post_ops_t result;
372 "could not create post operation sequence");
381 "post_ops index is out of range");
388 "could not append sum");
393 "could not get sum params");
400 "could not append eltwise");
404 float &alpha,
float &beta)
const {
407 &scale, &c_alg, &alpha, &beta),
408 "could not get eltwise params");
413 #ifndef DOXYGEN_SHOULD_SKIP_THIS 421 mkldnn_primitive_attr_t result;
423 "could not create a primitive attr");
430 get(), &result),
"could not get int output round mode");
437 "could not set int output round mode");
443 const float *c_scales;
445 &count, &c_mask, &c_scales),
446 "could not get int output scales");
447 scales.resize(count);
450 for (
int c = 0; c < count; ++c)
451 scales[c] = c_scales[c];
457 (
int)scales.size(), mask, &scales[0]),
458 "could not set int output scales");
465 "could not get post operation sequence");
466 result.
reset(const_cast<mkldnn_post_ops_t>(c_result),
true);
472 "could not set post operation sequence");
478 scale, shift),
"could not set rnn data int scale/shift");
484 (
int)scales.size(), mask, &scales[0]),
485 "could not set rnn weights int scales");
497 #ifndef DOXYGEN_SHOULD_SKIP_THIS 531 mkldnn_engine_t aengine;
535 "could not create an engine");
539 explicit engine(
const mkldnn_engine_t& aengine)
540 :
handle(aengine, true) {}
543 mkldnn_engine_t engine_q;
547 "could not get engine from primitive_desc");
548 reset(engine_q,
true);
551 template <
class primitive_desc>
553 mkldnn_engine_t engine_q;
557 "could not get engine from primitive_desc");
582 std::shared_ptr<char> _handle;
585 typedef std::vector<std::remove_extent<mkldnn_dims_t>::type>
dims;
590 "invalid dimensions");
779 validate_dims(adims);
782 adims.size() == 0 ? nullptr : &adims[0],
784 "could not initialize a memory descriptor");
802 mkldnn_primitive_desc_t result;
806 "could not initialize a memory primitive descriptor");
823 other.
get())) ? false :
true;
841 mkldnn_primitive_t result;
844 "could not create a memory primitive");
846 auto _malloc = [](
size_t size,
int alignment) {
849 ptr = _aligned_malloc(size, alignment);
850 int rc = ((ptr)? 0 : errno);
852 int rc = ::posix_memalign(&ptr, alignment, size);
854 return (rc == 0) ? (
char*)ptr :
nullptr;
856 auto _free = [](
char* p) {
858 _aligned_free((
void*)p);
863 _handle.reset(_malloc(adesc.
get_size(), 4096), _free);
864 set_data_handle(_handle.get());
868 mkldnn_primitive_t result;
871 "could not create a memory primitive");
873 set_data_handle(ahandle);
882 "could not get primitive descriptor from a memory primitive");
884 adesc.
reset(const_cast<mkldnn_primitive_desc_t>(cdesc),
true);
893 "could not get native handle");
899 "could not set native handle");
923 &aprimitive_desc,
int n_inputs,
int n_outputs,
924 const std::string &prim_name) {
929 if (n_outputs_expected > n_outputs ) {
930 std::string message =
"could not create " + prim_name +
931 " primitive, not enought output parameters";
934 if (n_inputs_expected > n_inputs ) {
935 std::string message =
"could not create " + prim_name +
936 " primitive, not enought input parameters";
948 return ((aprimitive_md !=
nullptr) && (aprimitive_md->
ndims == 0));
989 mkldnn_primitive_desc_t result;
991 &result, input.
get(), output.
get()),
992 "could not create a reorder primitive descriptor");
999 mkldnn_primitive_desc_t result;
1001 &result, input.
get(), output.
get(), aattr.
get()),
1002 "could not create a reorder primitive descriptor");
1011 mkldnn_primitive_t result;
1015 aprimitive_desc.
get(), inputs, outputs),
1016 "could not create a reorder primitive");
1026 mkldnn_primitive_t result;
1030 reorder_d.get(), inputs, outputs),
1031 "could not create a reorder primitive");
1048 mkldnn_primitive_desc_t result;
1051 &result, input.
get(), &dims[0], &offsets[0]),
1052 "could not create a view primitive descriptor");
1058 mkldnn_primitive_desc_t cdesc;
1064 "could not clone a dst primitive descriptor");
1073 mkldnn_primitive_t result;
1076 view_pd.
get(), inputs,
nullptr),
1077 "could not create a view primitive");
1082 mkldnn_primitive_t result;
1087 view_pd.get(), inputs,
nullptr),
1088 "could not create a view primitive");
1104 std::vector<memory::primitive_desc> inputs) {
1105 std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
1106 c_api_inputs.reserve(inputs.size());
1108 std::transform(inputs.begin(), inputs.end(),
1110 return c_api_inputs;
1114 std::vector<memory::primitive_desc> inputs) {
1115 mkldnn_primitive_desc_t result;
1117 auto c_api_inputs = cpp_to_c(inputs);
1120 &result, &output.
data, (
int)c_api_inputs.size(),
1121 concat_dimension, &c_api_inputs[0]),
1122 "could not create a concat primitive descriptor");
1127 std::vector<memory::primitive_desc> inputs) {
1128 mkldnn_primitive_desc_t result;
1130 auto c_api_inputs = cpp_to_c(inputs);
1133 &result,
nullptr, (
int)c_api_inputs.size(),
1134 concat_dimension, &c_api_inputs[0]),
1135 "could not create a concat primitive descriptor");
1141 mkldnn_primitive_desc_t cdesc;
1146 "could not clone a dst primitive descriptor");
1155 std::vector<primitive::at> &inputs,
const memory &output) {
1156 mkldnn_primitive_t result;
1158 std::vector<mkldnn_primitive_at_t> p_inputs;
1159 for (
size_t i = 0; i < inputs.size(); i++)
1160 p_inputs.push_back(inputs[i].data);
1164 concat_pd.
get(), &p_inputs[0], outputs),
1165 "could not create a concat primitive");
1181 std::vector<memory::primitive_desc> inputs) {
1182 std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
1183 c_api_inputs.reserve(inputs.size());
1185 std::transform(inputs.begin(), inputs.end(),
1187 return c_api_inputs;
1191 const std::vector<float> &scales,
1192 std::vector<memory::primitive_desc> inputs) {
1193 mkldnn_primitive_desc_t result;
1195 auto c_api_inputs = cpp_to_c(inputs);
1200 "number of scales not equal to number of inputs");
1203 &result, &output.
data, (
int)c_api_inputs.size(),
1204 &scales[0], &c_api_inputs[0]),
1205 "could not create a sum primitive descriptor");
1210 std::vector<memory::primitive_desc> inputs) {
1211 mkldnn_primitive_desc_t result;
1213 auto c_api_inputs = cpp_to_c(inputs);
1218 "number of scales not equal to number of inputs");
1221 &result,
nullptr, (
int)c_api_inputs.size(), &scales[0],
1223 "could not create a sum primitive descriptor");
1229 mkldnn_primitive_desc_t cdesc;
1235 "could not clone a dst primitive descriptor");
1244 std::vector<primitive::at> &inputs,
const memory &output) {
1245 mkldnn_primitive_t result;
1247 std::vector<mkldnn_primitive_at_t> p_inputs;
1248 for (
size_t i = 0; i < inputs.size(); i++)
1249 p_inputs.push_back(inputs[i].data);
1253 sum_pd.
get(), &p_inputs[0], outputs),
1254 "could not create a sum primitive");
1273 mkldnn_primitive_desc_iterator_t iterator =
nullptr;
1275 &iterator, desc, attr ? attr->
get() :
nullptr, e.
get(),
1278 "could not create a primitive descriptor iterator");
1279 pd_iterator.reset(iterator);
1288 "could not get attributes");
1289 mkldnn_primitive_attr_t cattr;
1291 "could not clone attributes");
1303 "could not query implementation info string");
1327 if (!std::any_of(valid_w.cbegin(), valid_w.cend(),
1328 [=](
query q) {
return what == q; }))
1336 if (const_cdesc ==
nullptr)
1339 mkldnn_primitive_desc_t cdesc;
1341 "could not clone a memory primitive descriptor");
1349 # define REG_QUERY_MPD(name, what, idx) \ 1350 memory::primitive_desc name ## _primitive_desc() const \ 1351 { return query_mpd(what ## _pd, idx); } 1354 handle<mkldnn_primitive_desc_iterator_t> pd_iterator;
1359 "could not fetch a primitive descriptor from the iterator");
1390 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1392 "could not create a convolution forward descriptor");
1407 &src_desc.
data, &weights_desc.
data,
nullptr,
1408 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1410 "could not create a convolution forward descriptor");
1430 &dst_desc.
data, &strides[0], &dilates[0],
1431 &padding_l[0], &padding_r[0],
1433 "could not create a dilated convolution forward descriptor");
1451 &src_desc.
data, &weights_desc.
data,
nullptr,
1452 &dst_desc.
data, &strides[0], &dilates[0],
1453 &padding_l[0], &padding_r[0],
1455 "could not create a dilated convolution forward descriptor");
1475 mkldnn_primitive_t result;
1480 aprimitive_desc.
get(), inputs, outputs),
1481 "could not create a convolution forward bias primitive");
1488 mkldnn_primitive_t result;
1492 "convolution forward");
1494 aprimitive_desc.
get(), inputs, outputs),
1495 "could not create a convolution forward primitive");
1516 &weights_desc.
data, &diff_dst_desc.
data,
1517 &strides[0], &padding_l[0], &padding_r[0],
1519 "could not create a convolution backward data descriptor");
1537 &weights_desc.
data, &diff_dst_desc.
data,
1538 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1540 "could not create a convolution backward data descriptor");
1560 const memory &diff_src) {
1561 mkldnn_primitive_t result;
1565 "convolution backward data");
1567 aprimitive_desc.
get(), inputs, outputs),
1568 "could not create a convolution backward data primitive");
1590 &diff_weights_desc.
data, &diff_bias_desc.
data,
1591 &diff_dst_desc.
data,
1592 &strides[0], &padding_l[0], &padding_r[0],
1594 "could not create a convolution backward weights descriptor");
1609 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1610 &strides[0], &padding_l[0], &padding_r[0],
1612 "could not create a convolution backward weights descriptor");
1630 &diff_weights_desc.
data, &diff_bias_desc.
data,
1631 &diff_dst_desc.
data,
1632 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1634 "could not create a convolution backward weights descriptor");
1651 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1652 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1654 "could not create a convolution backward weights descriptor");
1677 mkldnn_primitive_t result;
1682 "convolution backward weights");
1684 aprimitive_desc.
get(), inputs, outputs),
1685 "could not create a convolution backward weights primitive");
1690 const memory &diff_weights) {
1691 mkldnn_primitive_t result;
1695 "convolution backward weights");
1697 aprimitive_desc.
get(), inputs, outputs),
1698 "could not create a convolution backward weights primitive");
1729 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1731 "could not create a deconvolution forward descriptor");
1746 &src_desc.
data, &weights_desc.
data,
nullptr,
1747 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1749 "could not create a deconvolution forward descriptor");
1768 &dst_desc.
data, &strides[0], &dilates[0], &padding_l[0],
1770 "could not create a dilated deconvolution forward descriptor");
1787 &src_desc.
data, &weights_desc.
data,
nullptr,
1788 &dst_desc.
data, &strides[0], &dilates[0], &padding_l[0],
1790 "could not create a dilated deconvolution forward descriptor");
1810 mkldnn_primitive_t result;
1815 "deconvolution forward");
1817 aprimitive_desc.
get(), inputs, outputs),
1818 "could not create a deconvolution forward bias primitive");
1825 mkldnn_primitive_t result;
1829 "deconvolution forward");
1831 aprimitive_desc.
get(), inputs, outputs),
1832 "could not create a deconvolution forward primitive");
1853 &weights_desc.
data, &diff_dst_desc.
data,
1854 &strides[0], &padding_l[0], &padding_r[0],
1856 "could not create a deconvolution backward data descriptor");
1873 &weights_desc.
data, &diff_dst_desc.
data,
1874 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1876 "could not create a dilated deconvolution backward data descriptor");
1896 const memory &diff_src) {
1897 mkldnn_primitive_t result;
1901 "deconvolution backward data");
1903 aprimitive_desc.
get(), inputs, outputs),
1904 "could not create a deconvolution backward data primitive");
1926 &diff_weights_desc.
data, &diff_bias_desc.
data,
1927 &diff_dst_desc.
data,
1928 &strides[0], &padding_l[0], &padding_r[0],
1930 "could not create a deconvolution backward weights descriptor");
1945 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1946 &strides[0], &padding_l[0], &padding_r[0],
1948 "could not create a deconvolution backward weights descriptor");
1966 &diff_weights_desc.
data, &diff_bias_desc.
data,
1967 &diff_dst_desc.
data,
1968 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1970 "could not create a dilated deconvolution backward weights descriptor");
1987 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1988 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1990 "could not create a dilated deconvolution backward weights descriptor");
2012 mkldnn_primitive_t result;
2017 "deconvolution backward weights");
2019 aprimitive_desc.
get(), inputs, outputs),
2020 "could not create a deconvolution backward weights primitive");
2025 const memory &diff_weights) {
2026 mkldnn_primitive_t result;
2030 "deconvolution backward weights");
2032 aprimitive_desc.
get(), inputs, outputs),
2033 "could not create a deconvolution backward weights primitive");
2052 int local_size,
float alpha,
float beta,
float k)
2056 &src_desc.
data, local_size, alpha, beta, k),
2057 "could not create a lrn forward descriptor");
2061 int local_size,
float alpha,
float beta)
2065 &src_desc.
data, local_size, alpha, beta,
float(1.0)),
2066 "could not create a lrn forward descriptor");
2085 mkldnn_primitive_t result;
2091 aprimitive_desc.
get(), inputs, outputs),
2092 "could not create a lrn forward primitive");
2098 mkldnn_primitive_t result;
2103 aprimitive_desc.
get(), inputs, outputs),
2104 "could not create a lrn forward primitive");
2115 int local_size,
float alpha,
float beta,
float k)
2119 &data_desc.
data, local_size, alpha, beta, k),
2120 "could not create a lrn backward descriptor");
2125 int local_size,
float alpha,
float beta)
2129 &data_desc.
data, local_size, alpha, beta,
float(1.0)),
2130 "could not create a lrn backward descriptor");
2151 mkldnn_primitive_t result;
2157 aprimitive_desc.
get(), inputs, outputs),
2158 "could not create a lrn backward primitive");
2164 const memory &diff_src) {
2165 mkldnn_primitive_t result;
2170 aprimitive_desc.
get(), inputs, outputs),
2171 "could not create a lrn backward primitive");
2203 &strides[0], &kernel[0],
2204 &padding_l[0], &padding_r[0],
2206 "could not init a forward pooling descriptor");
2224 mkldnn_primitive_t result;
2229 aprimitive_desc.
get(), inputs, outputs),
2230 "could not create a pooling forward primitive");
2236 mkldnn_primitive_t result;
2241 aprimitive_desc.
get(), inputs, outputs),
2242 "could not create a pooling forward primitive");
2264 &diff_src_desc.
data, &diff_dst_desc.
data,
2265 &strides[0], &kernel[0],
2266 &padding_l[0], &padding_r[0],
2268 "could not init a backward pooling descriptor");
2287 const memory &diff_src) {
2288 mkldnn_primitive_t result;
2293 aprimitive_desc.
get(), inputs, outputs),
2294 "could not create a pooling backward primitive");
2300 mkldnn_primitive_t result;
2305 aprimitive_desc.
get(), inputs, outputs),
2306 "could not create a pooling backward primitive");
2323 template <
typename T>
2325 const memory::desc &src_desc, T alpha = 0, T beta = 0) {
2329 static_cast<float>(alpha), static_cast<float>(beta)),
2330 "could not create a eltwise forward descriptor");
2347 mkldnn_primitive_t result;
2352 aprimitive_desc.
get(), inputs, outputs),
2353 "could not create a eltwise forward primitive");
2362 template <
typename T>
2364 const memory::desc &data_desc, T alpha = 0, T beta = 0) {
2367 &data_desc.
data, static_cast<float>(alpha),
2368 static_cast<float>(beta)),
2369 "could not create a eltwise backward descriptor");
2389 const memory &diff_src) {
2390 mkldnn_primitive_t result;
2395 aprimitive_desc.
get(), inputs, outputs),
2396 "could not create a eltwise backward primitive");
2417 "could not create a softmax forward descriptor");
2434 mkldnn_primitive_t result;
2439 aprimitive_desc.
get(), inputs, outputs),
2440 "could not create a softmax forward primitive");
2451 &diff_desc.
data, &data_desc.
data, softmax_axis),
2452 "could not init a backward softmax descriptor");
2473 const memory &diff_src) {
2474 mkldnn_primitive_t result;
2478 aprimitive_desc.
get(), inputs, outputs),
2479 "could not create a softmax backward primitive");
2495 template <
typename T>
2501 static_cast<float>(epsilon), flags),
2502 "could not create a batch normalization forward descriptor");
2519 {
return stat_primitive_desc(mean); }
2521 {
return stat_primitive_desc(var); }
2524 enum { mean = 1, var = 2, };
2529 "could not get a batch-normalization descriptor");
2538 mkldnn_primitive_t result;
2543 "batch normalization forward");
2545 aprimitive_desc.
get(), inputs, outputs),
2546 "could not create a batch normalization forward primitive");
2553 mkldnn_primitive_t result;
2558 "batch normalization forward");
2560 aprimitive_desc.
get(), inputs, outputs),
2561 "could not create a batch normalization forward primitive");
2575 mkldnn_primitive_t result;
2578 mean.
get(), variance.
get() };
2580 "batch normalization forward");
2582 aprimitive_desc.
get(), inputs, outputs),
2583 "could not create a batch normalization forward primitive");
2590 const memory &workspace) {
2591 mkldnn_primitive_t result;
2594 mean.
get(), variance.
get(), workspace.
get() };
2596 "batch normalization forward");
2598 aprimitive_desc.
get(), inputs, outputs),
2599 "could not create a batch normalization forward primitive");
2605 const memory &variance) {
2606 mkldnn_primitive_t result;
2609 mean.
get(), variance.
get() };
2611 "batch normalization forward");
2613 aprimitive_desc.
get(), inputs, outputs),
2614 "could not create a batch normalization forward primitive");
2631 mkldnn_primitive_t result;
2634 mean.
get(), variance.
get(), workspace.
get() };
2641 if (n_inputs_expected == 2 && n_outputs_expected == 3) {
2643 auto _weights = dst;
2644 inputs[1] = {_weights.get(), 0};
2646 auto _dst = mean, _mean = variance, _variance = workspace;
2647 outputs[0] = _dst.get();
2648 outputs[1] = _mean.get();
2649 outputs[2] = _variance.get();
2650 outputs[3] =
nullptr;
2654 aprimitive_desc.
get(), inputs, outputs),
2655 "could not create a batch normalization forward primitive");
2662 mkldnn_primitive_t result;
2666 "batch normalization forward");
2668 aprimitive_desc.
get(), inputs, outputs),
2669 "could not create a batch normalization forward primitive");
2675 mkldnn_primitive_t result;
2679 "batch normalization forward");
2681 aprimitive_desc.
get(), inputs, outputs),
2682 "could not create a batch normalization forward primitive");
2690 template <
typename T>
2692 const memory::desc &data_desc, T epsilon,
unsigned flags) {
2696 &diff_data_desc.
data, &data_desc.
data,
2697 static_cast<float>(epsilon), flags),
2698 "could not create a batch normalization backward descriptor");
2728 const memory &diff_weights) {
2729 mkldnn_primitive_t result;
2733 diff_weights.
get() };
2735 "batch normalization backward");
2737 aprimitive_desc.
get(), inputs, outputs),
2738 "could not create a batch normalization backward primitive");
2748 mkldnn_primitive_t result;
2752 diff_weights.
get() };
2754 "batch normalization backward");
2756 aprimitive_desc.
get(), inputs, outputs),
2757 "could not create a batch normalization backward primitive");
2769 mkldnn_primitive_t result;
2771 diff_dst.
data, weights_or_workspace.
data };
2774 "batch normalization backward");
2776 aprimitive_desc.
get(), inputs, outputs),
2777 "could not create a batch normalization backward primitive");
2785 const memory &diff_src) {
2786 mkldnn_primitive_t result;
2791 "batch normalization backward");
2793 aprimitive_desc.
get(), inputs, outputs),
2794 "could not create a batch normalization backward primitive");
2818 "could not create a inner product forward descriptor");
2827 &weights_desc.
data,
nullptr, &dst_desc.
data),
2828 "could not create a inner product forward descriptor");
2848 mkldnn_primitive_t result;
2853 "inner product forward");
2855 aprimitive_desc.
get(), inputs, outputs),
2856 "could not create a inner product forward primitive");
2863 mkldnn_primitive_t result;
2867 "inner product forward");
2869 aprimitive_desc.
get(), inputs, outputs),
2870 "could not create a inner product forward primitive");
2883 &diff_src_desc.
data, &weights_desc.
data,
2884 &diff_dst_desc.
data),
2885 "could not create a inner product backward data descriptor");
2905 const memory &diff_src) {
2906 mkldnn_primitive_t result;
2910 "inner product backward data");
2912 aprimitive_desc.
get(), inputs, outputs),
2913 "could not create a inner product backward data primitive");
2927 &data, &src_desc.
data, &diff_weights_desc.
data,
2928 &diff_bias_desc.
data, &diff_dst_desc.
data),
2929 "could not create a inner product backward weights descriptor");
2936 &data, &src_desc.
data, &diff_weights_desc.
data,
2937 nullptr, &diff_dst_desc.
data),
2938 "could not create a inner product backward weights descriptor");
2959 const memory &diff_weights) {
2960 mkldnn_primitive_t result;
2964 "inner product backward weights");
2966 aprimitive_desc.
get(), inputs, outputs),
2967 "could not create a inner product backward weights primitive");
2974 mkldnn_primitive_t result;
2977 { diff_weights.
get(), diff_bias.
get()};
2979 "inner product backward weights");
2981 aprimitive_desc.
get(), inputs, outputs),
2982 "could not create a inner product backward weights primitive");
3003 "could not init an rnn cell descriptor");
3017 c_rnn_cell_.
alpha = alpha;
3051 &src_layer_desc.
data, &src_iter_desc.
data,
3052 &weights_layer_desc.
data, &weights_iter_desc.
data,
3054 &dst_layer_desc.
data, &dst_iter_desc.
data),
3055 "could not create an RNN forward descriptor");
3082 const memory &workspace) {
3083 mkldnn_primitive_t result;
3087 inputs[idx++] = src_layer.
data;
3089 inputs[idx++] = src_iter.
data;
3090 inputs[idx++] = weights_layer.
data;
3091 inputs[idx++] = weights_iter.
data;
3095 outputs[idx++] = dst_layer.
get();
3100 aprimitive_desc.
get(), inputs, outputs),
3101 "could not create an RNN forward primitive");
3128 &src_layer_desc.
data, &src_iter_desc.
data,
3129 &weights_layer_desc.
data, &weights_iter_desc.
data,
3131 &dst_layer_desc.
data, &dst_iter_desc.
data,
3132 &diff_src_layer_desc.
data, &diff_src_iter_desc.
data,
3133 &diff_weights_layer_desc.
data,
3134 &diff_weights_iter_desc.
data, &diff_bias_desc.
data,
3135 &diff_dst_layer_desc.
data, &diff_dst_iter_desc.
data),
3136 "could not create an RNN backward descriptor");
3177 const memory &diff_src_layer,
3178 const memory &diff_src_iter,
3179 const memory &diff_weights_layer,
3180 const memory &diff_weights_iter,
3185 mkldnn_primitive_t result;
3189 inputs[idx++] = src_layer.
data;
3191 inputs[idx++] = src_iter.
data;
3192 inputs[idx++] = weights_layer.
data;
3193 inputs[idx++] = weights_iter.
data;
3195 inputs[idx++] = bias.
data;
3196 inputs[idx++] = dst_layer.
data;
3198 inputs[idx++] = dst_iter.
data;
3199 inputs[idx++] = diff_dst_layer.
data;
3201 inputs[idx++] = diff_dst_iter.
data;
3202 inputs[idx++] = workspace.
data;
3205 outputs[idx++] = diff_src_layer.
get();
3207 outputs[idx++] = diff_src_iter.
get();
3208 outputs[idx++] = diff_weights_layer.
get();
3209 outputs[idx++] = diff_weights_iter.
get();
3212 aprimitive_desc.
get(), inputs, outputs),
3213 "could not create an RNN backward primitive");
3230 int axis,
int group_size) {
3234 "could not create a shuffle forward descriptor");
3248 mkldnn_primitive_t result;
3253 aprimitive_desc.
get(), inputs, outputs),
3254 "could not create a shuffle forward primitive");
3264 &diff_data_desc.
data, axis, group_size),
3265 "could not create a shuffle backward descriptor");
3280 mkldnn_primitive_t result;
3285 aprimitive_desc.
get(), inputs, outputs),
3286 "could not create a shuffle backward primitive");
3301 #ifndef DOXYGEN_SHOULD_SKIP_THIS 3308 using handle::handle;
3319 mkldnn_stream_t astream;
3322 "could not create a stream");
3333 if (primitives.size() == 0)
return *
this;
3334 std::vector<mkldnn_primitive_t> c_api_primitives;
3335 c_api_primitives.reserve(primitives.size());
3337 std::transform(primitives.begin(), primitives.end(),
3340 mkldnn_primitive_t c_api_error_primitive;
3343 c_api_primitives.size(), &c_api_primitives[0],
3344 &c_api_error_primitive),
3345 "could not submit primitives to a stream",
3346 &c_api_error_primitive);
3358 mkldnn_primitive_t c_api_error_primitive;
3360 block, &c_api_error_primitive);
3364 &c_api_error_primitive);
3369 mkldnn_primitive_t c_api_error_primitive;
3372 "could not rerun a stream", &c_api_error_primitive);
3377 #undef REG_QUERY_MPD void append_sum(float scale=1.)
Definition: mkldnn.hpp:386
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2422
Definition: mkldnn.hpp:2373
LRN within a single channel.
Definition: mkldnn_types.h:567
primitive error_primitive
Definition: mkldnn.hpp:164
A descriptor of a Local Response Normalization (LRN) operation.
Definition: mkldnn_types.h:906
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:1521
Definition: mkldnn.hpp:343
blocked weights format
Definition: mkldnn_types.h:348
inner_product_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at weights, const memory &dst)
Definition: mkldnn.hpp:2860
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2214
Definition: mkldnn.hpp:269
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1103
blocked weights format
Definition: mkldnn_types.h:355
op descriptor
Definition: mkldnn_types.h:1248
primitive_desc(const memory::desc &output, int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1113
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1664
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:393
Definition: mkldnn.hpp:3106
blocked weights format
Definition: mkldnn_types.h:332
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_destroy(mkldnn_primitive_attr_t attr)
Deletes an attr.
blocked weights format
Definition: mkldnn_types.h:433
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...
Definition: mkldnn.hpp:257
A Softmax primitive.
Definition: mkldnn_types.h:509
number of outputs expected
Definition: mkldnn_types.h:1237
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:3064
blocked weights format
Definition: mkldnn_types.h:438
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:1674
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:2534
stream & submit(std::vector< primitive > primitives)
Submits a vector of primitives to a stream for computations.
Definition: mkldnn.hpp:3330
bool operator==(const primitive_desc &other) const
Definition: mkldnn.hpp:821
A base class for all primitive descriptors.
Definition: mkldnn.hpp:1270
Definition: mkldnn.hpp:2247
mkldnn_status_t
Status values returned by Intel(R) MKL-DNN functions.
Definition: mkldnn_types.h:49
stream & rerun()
Definition: mkldnn.hpp:3368
Definition: mkldnn.hpp:2210
A descriptor of a convolution operation.
Definition: mkldnn_types.h:758
Definition: mkldnn.hpp:301
desc(prop_kind aprop_kind, const memory::desc &data_desc, int axis, int group_size)
Definition: mkldnn.hpp:3229
Definition: mkldnn.hpp:2185
The operation failed and should be retried.
Definition: mkldnn_types.h:55
memory null_memory(engine eng)
Definition: mkldnn.hpp:917
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...
Definition: mkldnn.hpp:1994
blocked weights format
Definition: mkldnn_types.h:292
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:330
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:1614
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...
4D RNN bias tensor in the format (num_layers, num_directions, num_gates, output_channels).
Definition: mkldnn_types.h:266
4D data tensor with the physical layout chwn, used in Neon.
Definition: mkldnn_types.h:175
Definition: mkldnn.hpp:265
padding_kind
Definition: mkldnn.hpp:232
The operation failed because of incorrect function arguments.
Definition: mkldnn_types.h:57
Eltwise: exponent.
Definition: mkldnn_types.h:556
Forward data propagation (alias for mkldnn_forward_inference)
Definition: mkldnn_types.h:470
Definition: mkldnn.hpp:2048
Definition: mkldnn.hpp:1910
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:1576
Definition: mkldnn.hpp:2832
Backward data propagation.
Definition: mkldnn_types.h:476
Definition: mkldnn.hpp:2446
static void validate_dims(std::vector< T > v)
Definition: mkldnn.hpp:587
Definition: mkldnn.hpp:3269
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:3259
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:2412
Definition: mkldnn.hpp:275
blocked weights format
Definition: mkldnn_types.h:326
blocked weights format
Definition: mkldnn_types.h:404
Undefined memory format, used for empty memory descriptors.
Definition: mkldnn_types.h:149
const_mkldnn_primitive_desc_t get_primitive_desc() const
Returns the descriptor of the underlying C API primitive.
Definition: mkldnn.hpp:210
concat(const primitive_desc &concat_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:1154
memory::desc desc()
Returns the memory primitive descriptor.
Definition: mkldnn.hpp:811
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:2009
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:1010
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:632
format
Memory format specification. See mkldnn_memory_format_t for a detailed description.
Definition: mkldnn.hpp:607
Definition: mkldnn.hpp:291
4D weights tensor with physical layout oihw, used in Caffe.
Definition: mkldnn_types.h:199
A descriptor of a Softmax operation.
Definition: mkldnn_types.h:856
blocked weights format
Definition: mkldnn_types.h:439
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:2432
blocked weights format
Definition: mkldnn_types.h:440
blocked weights format
Definition: mkldnn_types.h:403
Definition: mkldnn.hpp:272
blocked data format
Definition: mkldnn_types.h:275
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:244
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:964
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:585
3D RNN data tensor in the format (seq_length, batch, input channels).
Definition: mkldnn_types.h:242
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3239
An opaque structure for a chain of post operations.
An opaque structure to describe a primitive descriptor.
batch normalization descriptor
Definition: mkldnn_types.h:1257
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:1733
mkldnn_rnn_direction_t
A direction of RNN primitive execution.
Definition: mkldnn_types.h:1017
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:503
primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1881
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:2111
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:539
blocked weights format with additional buffer with size equal to the number of output channels and co...
Definition: mkldnn_types.h:301
engine(const handle< mkldnn_primitive_desc_t > &pd)
Definition: mkldnn.hpp:542
engine get_engine()
Definition: mkldnn.hpp:1283
desc(dims adims, data_type adata_type, format aformat)
Constructs a memory descriptor.
Definition: mkldnn.hpp:777
blocked data format
Definition: mkldnn_types.h:276
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 (possi...
Definition: mkldnn.hpp:225
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2809
sum(const primitive_desc &sum_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:1243
An execution engine.
Definition: mkldnn.hpp:504
memory(const primitive_desc &adesc, void *ahandle)
Definition: mkldnn.hpp:867
blocked weights format
Definition: mkldnn_types.h:429
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2877
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:188
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:2249
blocked weights format
Definition: mkldnn_types.h:339
Undefined primitive (XXX: why do we have it?).
Definition: mkldnn_types.h:487
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:517
Packed weights format used in RNN.
Definition: mkldnn_types.h:444
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:922
Round down.
Definition: mkldnn_types.h:94
4D grouped weights tensor with the physical layout goiw.
Definition: mkldnn_types.h:223
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const softmax_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2461
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:1751
Definition: mkldnn.hpp:264
round_mode get_int_output_round_mode() const
Definition: mkldnn.hpp:427
blocked weights format
Definition: mkldnn_types.h:435
blocked weights format
Definition: mkldnn_types.h:294
primitive_attr()
Definition: mkldnn.hpp:420
Definition: mkldnn_types.h:563
Definition: mkldnn.hpp:2358
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_rnn_weights_qparams(mkldnn_primitive_attr_t attr, int count, int mask, const float *weights_scales)
Sets quantization scales weights_scales for RNN weights tensors.
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:2457
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:2447
Definition: mkldnn.hpp:2421
void get_params_sum(int index, float &scale) const
Definition: mkldnn.hpp:391
Definition: mkldnn.hpp:247
32-bit signed integer.
Definition: mkldnn_types.h:78
primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2890
Max pooling.
Definition: mkldnn_types.h:558
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:1435
memory::desc zero_md()
Definition: mkldnn.hpp:911
Definition: mkldnn.hpp:337
primitive_desc(const memory::primitive_desc &input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:1046
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 values are mkldnn_forwar...
blocked weights format
Definition: mkldnn_types.h:314
blocked weights format
Definition: mkldnn_types.h:338
const post_ops get_post_ops() const
Definition: mkldnn.hpp:461
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:2187
execution engine
Definition: mkldnn_types.h:1233
stream(kind akind)
Constructs a stream.
Definition: mkldnn.hpp:3318
Definition: mkldnn.hpp:1045
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_next(mkldnn_primitive_desc_iterator_t iterator)
Iterates over primitive descriptors.
Definition: mkldnn.hpp:336
desc(const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2878
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 the spatial domain: strides, kernel sizes, padding_l, padding_r, and padding_kind.
Definition: mkldnn.hpp:2184
blocked weights format
Definition: mkldnn_types.h:322
static mkldnn_memory_format_t convert_to_c(format aformat)
Definition: mkldnn.hpp:906
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const eltwise_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2378
Definition: mkldnn.hpp:2702
Definition: mkldnn.hpp:321
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_create(mkldnn_primitive_attr_t *attr)
Creates an empty (default) attr attribute.
Definition: mkldnn_types.h:995
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:255
input memory primitive desc
Definition: mkldnn_types.h:1263
blocked weights format
Definition: mkldnn_types.h:341
mkldnn_shuffle_desc_t data
Definition: mkldnn.hpp:3228
5D grouped weights tensor with the physical layout goihw, used in Caffe.
Definition: mkldnn_types.h:227
const_mkldnn_primitive_t primitive
Primitive to specify the output for.
Definition: mkldnn_types.h:1193
Definition: mkldnn.hpp:290
blocked weights format
Definition: mkldnn_types.h:354
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:3077
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:820
rnn descriptor
Definition: mkldnn_types.h:1259
memory::primitive_desc variance_primitive_desc() const
Definition: mkldnn.hpp:2520
An element-wise primitive.
Definition: mkldnn_types.h:507
Definition: mkldnn.hpp:2889
Definition: mkldnn.hpp:2445
blocked weights format
Definition: mkldnn_types.h:331
destination grad.
Definition: mkldnn_types.h:1270
algorithm get_cell_kind() const
Definition: mkldnn.hpp:3009
engine get_engine()
Definition: mkldnn.hpp:1240
Definition: mkldnn.hpp:2359
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:1005
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1227
blocked weights format
Definition: mkldnn_types.h:344
A descriptor for an RNN operation.
Definition: mkldnn_types.h:1032
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:1412
Definition: mkldnn.hpp:1101
Definition: mkldnn.hpp:278
Definition: mkldnn.hpp:259
eltwise descriptor
Definition: mkldnn_types.h:1253
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:2628
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1460
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_rnn_data_qparams(mkldnn_primitive_attr_t attr, const float scale, const float shift)
Sets quantization scale and shift for RNN data tensors.
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:2765
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2096
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:2921
batch_normalization_flag
Definition: mkldnn.hpp:289
A memory primitive.
Definition: mkldnn_types.h:489
float clipping
clipping parameter (used only if (flags & mkldnn_rnn_cell_with_clipping) != 0)
Definition: mkldnn_types.h:1013
blocked weights format
Definition: mkldnn_types.h:311
blocked weights format
Definition: mkldnn_types.h:325
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:3109
Eltwise: soft_relu.
Definition: mkldnn_types.h:552
Definition: mkldnn.hpp:1544
void set_post_ops(post_ops ops)
Definition: mkldnn.hpp:470
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:2845
Definition: mkldnn.hpp:342
Definition: mkldnn.hpp:261
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:569
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2211
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:1772
bool is_null_memory(const const_mkldnn_primitive_t &aprimitive)
Definition: mkldnn.hpp:942
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2894
Definition: mkldnn.hpp:368
Definition: mkldnn.hpp:2876
blocked weights format
Definition: mkldnn_types.h:362
bool operator==(const handle &other) const
Definition: mkldnn.hpp:87
Definition: mkldnn.hpp:1372
Backward weights propagation.
Definition: mkldnn_types.h:478
void set_int_output_round_mode(round_mode mode)
Definition: mkldnn.hpp:434
mkldnn_rnn_desc_t data
Definition: mkldnn.hpp:3037
blocked weights format
Definition: mkldnn_types.h:432
32-bit/single-precision floating point.
Definition: mkldnn_types.h:76
blocked weights format
Definition: mkldnn_types.h:288
blocked data format
Definition: mkldnn_types.h:273
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:1596
algorithm get_activation() const
Definition: mkldnn.hpp:3011
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2222
2D weights tensor with physical layout oi.
Definition: mkldnn_types.h:184
Just a sentinel, not real memory format.
Definition: mkldnn_types.h:448
Memory descriptor.
Definition: mkldnn_types.h:717
Definition: mkldnn.hpp:2808
Definition: mkldnn.hpp:304
blocked weights format
Definition: mkldnn_types.h:350
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:3246
mkldnn_batch_normalization_flag_t
Flags for batch-normalization primititve.
Definition: mkldnn_types.h:586
void set_clipping(float clipping)
Definition: mkldnn.hpp:3021
convolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:1688
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:2049
Definition: mkldnn.hpp:2807
desc(prop_kind aprop_kind, const memory::desc &src_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2496
Definition: mkldnn.hpp:281
pooling descriptor
Definition: mkldnn_types.h:1255
Definition: mkldnn.hpp:2248
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:240
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:2186
Definition: mkldnn.hpp:267
blocked weights format
Definition: mkldnn_types.h:287
blocked data format
Definition: mkldnn_types.h:277
3D weights tensor with physical layout wio.
Definition: mkldnn_types.h:196
blocked weights format
Definition: mkldnn_types.h:414
blocked weights format
Definition: mkldnn_types.h:361
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:1007
3D data tensor with the physical layout ncw.
Definition: mkldnn_types.h:163
blocked weights format
Definition: mkldnn_types.h:329
convolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1558
The operation was successful.
Definition: mkldnn_types.h:51
blocked weights format with additional buffer with size equal to the number of groups and containing ...
Definition: mkldnn_types.h:424
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:386
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2947
primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1660
desc(algorithm kind, algorithm activation_f)
Definition: mkldnn.hpp:2999
blocked weights format
Definition: mkldnn_types.h:400
Definition: mkldnn.hpp:327
Definition: mkldnn.hpp:245
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:1271
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:430
mkldnn_rnn_desc_t data
Definition: mkldnn.hpp:3108
Backward propagation (with respect to all parameters.
Definition: mkldnn_types.h:474
5D data tensor with the physical layout ndhwc, used in TensorFlow.
Definition: mkldnn_types.h:181
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:2971
softmax descriptor
Definition: mkldnn_types.h:1254
mkldnn_round_mode_t
Rounding mode.
Definition: mkldnn_types.h:90
A deconvolution primitive.
Definition: mkldnn_types.h:505
Definition: mkldnn.hpp:331
Definition: mkldnn.hpp:276
primitive_desc(const desc &adesc, const engine &aengine)
Constructs a memory primitive descriptor.
Definition: mkldnn.hpp:801
Use global statistics.
Definition: mkldnn_types.h:599
Definition: mkldnn.hpp:31
primitive_desc(int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1126
blocked weights format
Definition: mkldnn_types.h:330
no query
Definition: mkldnn_types.h:1231
Definition: mkldnn.hpp:2919
Definition: mkldnn.hpp:1712
blocked weights format
Definition: mkldnn_types.h:416
blocked weights format
Definition: mkldnn_types.h:346
blocked weights format
Definition: mkldnn_types.h:365
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 offsets offsets...
8-bit unsigned integer.
Definition: mkldnn_types.h:84
blocked weights format
Definition: mkldnn_types.h:428
Definition: mkldnn.hpp:347
Average pooling include padding.
Definition: mkldnn_types.h:560
Unspecified format.
Definition: mkldnn_types.h:152
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:2903
Definition: mkldnn.hpp:2070
destination memory primitive desc
Definition: mkldnn_types.h:1269
memory::primitive_desc mean_primitive_desc() const
Definition: mkldnn.hpp:2518
5D RNN weights tensor in the format (num_layers, num_directions, input_channels, num_gates, output_channels).
Definition: mkldnn_types.h:252
GRU cell with linear before reset.
Definition: mkldnn_types.h:582
memory(const primitive_desc &adesc)
Constructs a memory primitive.
Definition: mkldnn.hpp:840
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:2148
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:565
blocked weights format
Definition: mkldnn_types.h:310
GRU cell.
Definition: mkldnn_types.h:573
Eager stream.
Definition: mkldnn_types.h:1284
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output, const primitive_attr &aattr)
Definition: mkldnn.hpp:996
void set_output_scales(int mask, const std::vector< float > &scales)
Definition: mkldnn.hpp:454
at(const primitive &aprimitive, size_t at=0)
Constructs a wrapper specifying aprimitive output with index at.
Definition: mkldnn.hpp:143
implementation name
Definition: mkldnn_types.h:1244
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:1950
Definition: mkldnn.hpp:1373
desc(const memory::desc &diff_data_desc, int axis, int group_size)
Definition: mkldnn.hpp:3262
Definition: mkldnn.hpp:3260
Definition: mkldnn.hpp:256
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2286
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 a pointer to a constant floating point array of output ...
3D weights tensor with physical layout oiw.
Definition: mkldnn_types.h:190
Eltwise: parametric exponential linear unit (elu)
Definition: mkldnn_types.h:540
kind
Kinds of engines.
Definition: mkldnn.hpp:509
Definition: mkldnn.hpp:2110
Definition: mkldnn.hpp:2875
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2425
Intel(R) MKL-DNN exception class.
Definition: mkldnn.hpp:161
round_mode
Definition: mkldnn.hpp:223
bool operator==(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:951
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1839
Eltwise: ReLU.
Definition: mkldnn_types.h:536
Definition: mkldnn.hpp:2409
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1374
Definition: mkldnn.hpp:233
1D data tensor.
Definition: mkldnn_types.h:158
mkldnn_primitive_at_t data
The underlying C API structure.
Definition: mkldnn.hpp:136
memory::primitive_desc query_mpd(query what, int idx=0) const
Queries and returns requested memory primitive descriptor.
Definition: mkldnn.hpp:1324
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2707
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:3146
primitive_desc(const desc &desc, const engine &e, const shuffle_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3270
4D weights tensor with physical layout ihwo.
Definition: mkldnn_types.h:208
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:2360
mkldnn_memory_format_t
Memory format specification.
Definition: mkldnn_types.h:147
Definition: mkldnn.hpp:1044
Eltwise: square.
Definition: mkldnn_types.h:542
blocked weights format
Definition: mkldnn_types.h:323
Definition: mkldnn.hpp:1178
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:1394
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1056
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 an eltwise_desc for forward propagation using prop_kind (possible values are mkldnn_forwa...
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.
void set_rnn_data_qparams(const float scale, const float shift)
Definition: mkldnn.hpp:475
static mkldnn_data_type_t convert_to_c(data_type adata_type)
Definition: mkldnn.hpp:903
4D data tensor with the physical layout nhwc, used in TensorFlow.
Definition: mkldnn_types.h:172
void set_data_handle(void *handle) const
Definition: mkldnn.hpp:897
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &mean, const memory &variance)
Definition: mkldnn.hpp:2603
Definition: mkldnn.hpp:268
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:2112
Backward bias propagation.
Definition: mkldnn_types.h:480
Definition: mkldnn.hpp:985
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, float alpha, float beta)
Definition: mkldnn.hpp:2059
blocked weights format
Definition: mkldnn_types.h:425
Use scale and shift parameters.
Definition: mkldnn_types.h:612
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:1714
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:312
Definition: mkldnn.hpp:280
weights format with additional buffer size equal to the number of output channels multiplied by numbe...
Definition: mkldnn_types.h:384
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:3014
blocked weights format
Definition: mkldnn_types.h:309
blocked weights format
Definition: mkldnn_types.h:402
A descriptor of a shuffle operation.
Definition: mkldnn_types.h:803
void get_params_eltwise(int index, float &scale, algorithm &alg, float &alpha, float &beta) const
Definition: mkldnn.hpp:403
Definition: mkldnn_types.h:1027
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:2322
primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1995
Definition: mkldnn.hpp:419
blocked weights format
Definition: mkldnn_types.h:419
blocked weights format
Definition: mkldnn_types.h:357
Definition: mkldnn.hpp:1880
int get_gates_count() const
Definition: mkldnn.hpp:3026
int ndims
Number of dimensions.
Definition: mkldnn_types.h:722
reorder(const primitive_desc &aprimitive_desc, const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:1009
Definition: mkldnn.hpp:2047
Definition: mkldnn.hpp:1102
kind
A proxy to C primitive kind enum.
Definition: mkldnn.hpp:113
blocked weights format with additional buffer with size equal to the number of groups and containing ...
Definition: mkldnn_types.h:377
5D grouped weights tensor with the physical layout giohw.
Definition: mkldnn_types.h:234
void set_alpha(float alpha)
Definition: mkldnn.hpp:3015
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 an 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:2122
5D data tensor with the physical layout ncdhw.
Definition: mkldnn_types.h:178
Definition: mkldnn.hpp:3227
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:245
Definition: mkldnn.hpp:2134
size_t get_size() const
Returns the number of bytes required to allocate the memory described including the padding area...
Definition: mkldnn.hpp:817
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:1573
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:1807
A rnn primitive.
Definition: mkldnn_types.h:519
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.
blocked weights format
Definition: mkldnn_types.h:340
blocked weights format
Definition: mkldnn_types.h:283
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_size.
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1911
Definition: mkldnn.hpp:2996
eltwise_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2387
mkldnn_prop_kind_t
Kinds of propagation.
Definition: mkldnn_types.h:458
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn.hpp:134
CPU engine.
Definition: mkldnn_types.h:1083
Definition: mkldnn.hpp:292
desc(algorithm alg_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:2363
Eltwise: square root.
Definition: mkldnn_types.h:546
blocked weights format
Definition: mkldnn_types.h:434
blocked weights format
Definition: mkldnn_types.h:290
mkldnn_stream_kind_t
Kinds of streams.
Definition: mkldnn_types.h:1280
Definition: mkldnn.hpp:271
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:202
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn_types.h:1191
Winograd convolution.
Definition: mkldnn_types.h:528
Definition: mkldnn.hpp:246
Definition: mkldnn.hpp:344
Eltwise: linear.
Definition: mkldnn_types.h:548
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:1840
bfloat 16-bit.
Definition: mkldnn_types.h:86
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:1912
reorder(const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:1020
Eltwise: logistic.
Definition: mkldnn_types.h:554
Definition: mkldnn.hpp:2687
Direct convolution.
Definition: mkldnn_types.h:526
Primitive iterator passed over last primitive descriptor.
Definition: mkldnn_types.h:64
Definition: mkldnn.hpp:339
Definition: mkldnn.hpp:270
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &workspace, const memory &dst)
Definition: mkldnn.hpp:2082
source gradient memory primitive desc
Definition: mkldnn_types.h:1266
mkldnn_alg_kind_t cell_kind
RNN cell kind.
Definition: mkldnn_types.h:1002
Definition: mkldnn.hpp:1501
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2689
Definition: mkldnn_types.h:1019
An opaque structure for primitive descriptor attributes.
Definition: mkldnn.hpp:313
blocked data format
Definition: mkldnn_types.h:279
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...
blocked weights format
Definition: mkldnn_types.h:345
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, float alpha, float beta, float k)
Definition: mkldnn.hpp:2050
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:2659
mkldnn_rnn_cell_desc_t c_rnn_cell_
Definition: mkldnn.hpp:2997
bool operator!=(const primitive_desc &other) const
Definition: mkldnn.hpp:826
runtime estimation (seconds)
Definition: mkldnn_types.h:1239
blocked weights format
Definition: mkldnn_types.h:418
Definition: mkldnn.hpp:1659
bool operator==(const T other) const
Definition: mkldnn.hpp:61
A (in-place) concat primitive.
Definition: mkldnn_types.h:499
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:877
blocked weights format
Definition: mkldnn_types.h:312
LSTM cell.
Definition: mkldnn_types.h:571
blocked weights format
Definition: mkldnn_types.h:293
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:1028
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2507
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2833
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2836
Undefined data type, used for empty memory descriptors.
Definition: mkldnn_types.h:74
blocked weights format with additional buffer with size equal to the number of output channels multip...
Definition: mkldnn_types.h:372
Definition: mkldnn.hpp:1837
16-bit signed integer.
Definition: mkldnn_types.h:80
Definition: mkldnn.hpp:2321
A shuffle primitive.
Definition: mkldnn_types.h:495
blocked weights format with additional buffer with size equal to the number of output channels and co...
Definition: mkldnn_types.h:319
mkldnn_shuffle_desc_t data
Definition: mkldnn.hpp:3261
primitive_desc()
Definition: mkldnn.hpp:798
int len() const
Definition: mkldnn.hpp:376
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.
blocked weights format
Definition: mkldnn_types.h:328
primitive_desc(const memory::desc &output, const std::vector< float > &scales, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1190
desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc)
Definition: mkldnn.hpp:2821
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...
blocked data format
Definition: mkldnn_types.h:271
Definition: mkldnn.hpp:1794
Definition: mkldnn.hpp:242
blocked weights format
Definition: mkldnn_types.h:347
Definition: mkldnn.hpp:2942
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:1502
blocked weights format
Definition: mkldnn_types.h:337
A (out-of-place) concat primitive.
Definition: mkldnn_types.h:497
blocked weights format
Definition: mkldnn_types.h:358
Fuse with ReLU.
Definition: mkldnn_types.h:621
Definition: mkldnn.hpp:260
Definition: mkldnn.hpp:279
static size_t get_count(kind akind)
Returns the number of engines of a certain kind.
Definition: mkldnn.hpp:520
mkldnn_query_t
Primitive descriptor query specification.
Definition: mkldnn_types.h:1230
A descriptor of a Batch Normalization operation.
Definition: mkldnn_types.h:933
static engine query(const primitive_desc &pd)
Definition: mkldnn.hpp:552
Definition: mkldnn.hpp:3035
blocked weights format
Definition: mkldnn_types.h:373
deconvolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:2023
blocked data format
Definition: mkldnn_types.h:278
blocked weights format
Definition: mkldnn_types.h:289
A sum primitive.
Definition: mkldnn_types.h:501
blocked weights format
Definition: mkldnn_types.h:360
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:2782
Definition: mkldnn.hpp:303
blocked weights format
Definition: mkldnn_types.h:413
eltwise_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2345
blocked weights format
Definition: mkldnn_types.h:296
unsigned flags
Definition: mkldnn_types.h:960
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:295
blocked weights format
Definition: mkldnn_types.h:363
Definition: mkldnn.hpp:2995
Convolution algorithm(either direct or Winograd) is chosen just in time.
Definition: mkldnn_types.h:530
softmax_backward(const primitive_desc &aprimitive_desc, const primitive::at &dst, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2471
blocked weights format
Definition: mkldnn_types.h:284
Definition: mkldnn.hpp:3036
Definition: mkldnn.hpp:258
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2335
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:420
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:187
memory consumption – extra (scratch) memory, additional to all inputs and outputs memory (bytes) ...
Definition: mkldnn_types.h:1240
blocked weights format
Definition: mkldnn_types.h:353
An batch normalization primitive.
Definition: mkldnn_types.h:515
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:524
engine(kind akind, size_t index)
Constructs an engine.
Definition: mkldnn.hpp:530
Definition: mkldnn.hpp:2320
A descriptor of a pooling operation.
Definition: mkldnn_types.h:872
Definition: mkldnn.hpp:3307
Definition: mkldnn.hpp:273
Definition: mkldnn.hpp:274
engine get_engine()
Definition: mkldnn.hpp:830
error(mkldnn_status_t astatus, std::string amessage, mkldnn_primitive_t aerror_primitive=0)
Constructs an error instance.
Definition: mkldnn.hpp:173
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1999
const char * impl_info_str() const
Returns implementation name.
Definition: mkldnn.hpp:1299
deconvolution descriptor
Definition: mkldnn_types.h:1251
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1180
blocked weights format
Definition: mkldnn_types.h:366
shuffle_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:3278
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output)
Definition: mkldnn.hpp:987
primitive_desc(const desc &desc, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2273
mkldnn_memory_desc_t data
The underlying C API data structure.
Definition: mkldnn.hpp:770
mkldnn_primitive_desc_t MKLDNN_API mkldnn_primitive_desc_iterator_fetch(const_mkldnn_primitive_desc_iterator_t iterator)
Fetches the current primitive descriptor.
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:1463
engine get_engine()
Definition: mkldnn.hpp:1006
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:82
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:454
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:2334
desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2931
source memory primitive desc
Definition: mkldnn_types.h:1265
mkldnn_primitive_kind_t
Kinds of primitives.
Definition: mkldnn_types.h:485
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1885
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:1972
Definition: mkldnn.hpp:3238
Winograd deconvolution.
Definition: mkldnn_types.h:534
Definition: mkldnn.hpp:248
number of inputs expected
Definition: mkldnn_types.h:1236
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:2411
Definition: mkldnn.hpp:346
Definition: mkldnn.hpp:3060
Definition: mkldnn.hpp:2688
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2510
Definition: mkldnn.hpp:2493
desc(prop_kind aprop_kind, algorithm alg_kind, const memory::desc &src_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:2324
An unspecified engine.
Definition: mkldnn_types.h:1282
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1795
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:890
A view primitive.
Definition: mkldnn_types.h:491
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:3107
Definition: mkldnn.hpp:262
Definition: mkldnn.hpp:329
Definition: mkldnn.hpp:3141
blocked weights format
Definition: mkldnn_types.h:327
mkldnn_primitive_kind_t convert_to_c(primitive::kind akind)
Definition: mkldnn.hpp:154
Definition: mkldnn.hpp:1574
blocked data format
Definition: mkldnn_types.h:274
Definition: mkldnn.hpp:341
Definition: mkldnn.hpp:332
Definition: mkldnn.hpp:324
Definition: mkldnn.hpp:334
Average pooling exclude padding.
Definition: mkldnn_types.h:562
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:378
Definition: mkldnn_types.h:998
Forward data propagation (inference mode).
Definition: mkldnn_types.h:468
primitive_attr get_primitive_attr() const
Definition: mkldnn.hpp:1285
6D grouped weights tensor with the physical layout goidhw, used in Caffe.
Definition: mkldnn_types.h:238
5D weights tensor with physical layout iodhw, used in Caffe.
Definition: mkldnn_types.h:214
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:595
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:2550
Direct deconvolution.
Definition: mkldnn_types.h:532
Eltwise: abs.
Definition: mkldnn_types.h:544
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:2572
blocked weights format
Definition: mkldnn_types.h:388
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &workspace, const memory &diff_src)
Definition: mkldnn.hpp:2298
blocked weights format
Definition: mkldnn_types.h:313
A memory descriptor.
Definition: mkldnn.hpp:767
deconvolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1894
5D grouped weights tensor with the physical layout hwigo, used in TensorFlow.
Definition: mkldnn_types.h:231
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2338
blocked weights format
Definition: mkldnn_types.h:410
bool operator!=(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:954
void set_rnn_weights_qparams(int mask, const std::vector< float > &scales)
Definition: mkldnn.hpp:481
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:538
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2920
mkldnn_status_t status
Definition: mkldnn.hpp:162
deconvolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1822
blocked weights format with additional buffer with size equal to the number of output channels and co...
Definition: mkldnn_types.h:409
T get() const
Returns the value of the underlying C handle.
Definition: mkldnn.hpp:85
blocked weights format
Definition: mkldnn_types.h:401
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:1072
blocked weights format
Definition: mkldnn_types.h:367
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:1932
blocked weights format
Definition: mkldnn_types.h:364
2D data tensor.
Definition: mkldnn_types.h:160
primitive_desc(const desc &desc, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2703
blocked weights format
Definition: mkldnn_types.h:321
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:2810
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:3357
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 and dif...
Primitive or engine failed on execution.
Definition: mkldnn_types.h:66
memory descriptor for memory and view
Definition: mkldnn_types.h:1249
view(memory input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:1081
Definition: mkldnn.hpp:1459
Definition: mkldnn.hpp:266
An LRN primitive.
Definition: mkldnn_types.h:513
Definition: mkldnn_types.h:1024
mkldnn_padding_kind_t
Kinds of padding.
Definition: mkldnn_types.h:452
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:3169
Lazy stream.
Definition: mkldnn_types.h:1286
Definition: mkldnn.hpp:333
desc(const memory::desc &diff_desc, const memory::desc &data_desc, int softmax_axis)
Definition: mkldnn.hpp:2448
blocked weights format
Definition: mkldnn_types.h:415
Definition: mkldnn.hpp:305
void get_output_scales(int &mask, std::vector< float > &scales) const
Definition: mkldnn.hpp:440
blocked weights format
Definition: mkldnn_types.h:286
desc(algorithm kind)
Definition: mkldnn.hpp:3005
primitive_desc(const desc &desc, const engine &e, const rnn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3142
Definition: mkldnn.hpp:1838
5D RNN weights tensor in the format (num_layers, num_directions, num_gates, output_channels, input_channels).
Definition: mkldnn_types.h:259
blocked weights format
Definition: mkldnn_types.h:356
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:2918
shuffle descriptor
Definition: mkldnn_types.h:1252
Forward data propagation (training mode).
Definition: mkldnn_types.h:464
Definition: mkldnn.hpp:345
primitive_desc(const desc &desc, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2135
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:2957
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1575
memory(const primitive &aprimitive)
Constructs a memory primitive from a generic primitive.
Definition: mkldnn.hpp:836
3D data tensor with the physical layout nwc.
Definition: mkldnn_types.h:166
engine get_engine()
Definition: mkldnn.hpp:1151
post_ops()
Definition: mkldnn.hpp:369
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:2743
A tensor in a generic format described by the stride and blocking values in each dimension.
Definition: mkldnn_types.h:156
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:1375
mkldnn_data_type_t
Data type specification.
Definition: mkldnn_types.h:72
Definition: mkldnn.hpp:1500
Definition: mkldnn.hpp:326
Definition: mkldnn.hpp:319
convolution descriptor
Definition: mkldnn_types.h:1250
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1549
A memory primitive descriptor.
Definition: mkldnn.hpp:794
Definition: mkldnn.hpp:315
Definition: mkldnn.hpp:2456
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:342
primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1545
blocked weights format
Definition: mkldnn_types.h:333
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:2673
Eltwise: bounded_relu.
Definition: mkldnn_types.h:550
Definition: mkldnn.hpp:2410
#define REG_QUERY_MPD(name, what, idx)
Definition: mkldnn.hpp:1349
Definition: mkldnn_types.h:1021
convolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1485
mkldnn_engine_kind_t
Kinds of engines.
Definition: mkldnn_types.h:1079
Definition: mkldnn_types.h:994
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:68
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3061
blocked weights format
Definition: mkldnn_types.h:437
bool operator!=(const T other) const
Definition: mkldnn.hpp:62
blocked weights format
Definition: mkldnn_types.h:385
Memory primitive that describes the data.
Definition: mkldnn.hpp:580
Weights format used in 8bit Winograd convolution.
Definition: mkldnn_types.h:442
Definition: mkldnn.hpp:328
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2071
Definition: mkldnn.hpp:2109
Definition: mkldnn.hpp:302
Round nearest.
Definition: mkldnn_types.h:92
blocked weights format
Definition: mkldnn_types.h:436
Definition: mkldnn.hpp:243
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:2724
Definition: mkldnn.hpp:1711
const void * const_mkldnn_op_desc_t
A pointer to any of the operation descriptors (constant variant).
Definition: mkldnn_types.h:711
static mkldnn_stream_kind_t convert_to_c(kind akind)
Definition: mkldnn.hpp:3314
blocked weights format
Definition: mkldnn_types.h:285
blocked weights format
Definition: mkldnn_types.h:431
Definition: mkldnn.hpp:1909
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1139
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:2492
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &workspace)
Definition: mkldnn.hpp:2234
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:1472
4D weights tensor with physical layout iohw.
Definition: mkldnn_types.h:211
A reorder primitive.
Definition: mkldnn_types.h:493
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:1798
rnn_direction
Definition: mkldnn.hpp:300
primitive_desc(const std::vector< float > &scales, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1209
blocked weights format
Definition: mkldnn_types.h:411
blocked weights format with additional buffer with size equal to the number of output channels multip...
Definition: mkldnn_types.h:399
blocked weights format
Definition: mkldnn_types.h:336
An unspecified engine.
Definition: mkldnn_types.h:1081
desc(const mkldnn_memory_desc_t &adata)
Constructs a memory descriptor from a C API data structure.
Definition: mkldnn.hpp:790
blocked weights format
Definition: mkldnn_types.h:359
Definition: mkldnn.hpp:1179
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:1069
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2277
blocked weights format
Definition: mkldnn_types.h:412
blocked weights format
Definition: mkldnn_types.h:387
mkldnn_alg_kind_t
Kinds of algorithms.
Definition: mkldnn_types.h:523
primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2943
Definition: mkldnn.hpp:263
inner product descriptor
Definition: mkldnn_types.h:1258
blocked weights format
Definition: mkldnn_types.h:394
A pooling primitive.
Definition: mkldnn_types.h:511
weights memory primitive descriptor desc
Definition: mkldnn_types.h:1267
output memory primitive desc
Definition: mkldnn_types.h:1264
Definition: mkldnn.hpp:2272
blocked weights format
Definition: mkldnn_types.h:417
blocked weights format
Definition: mkldnn_types.h:349
5D weights tensor with physical layout dhwio, used in TensorFlow.
Definition: mkldnn_types.h:217
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2074
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2494
Definition: mkldnn.hpp:986
mkldnn_status_t MKLDNN_API mkldnn_primitive_destroy(mkldnn_primitive_t primitive)
Deletes a primitive.
Definition: mkldnn.hpp:335
std::string message
Definition: mkldnn.hpp:163
Definition: mkldnn.hpp:3226
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:2374
Definition: mkldnn.hpp:2506
Definition: mkldnn.hpp:316
blocked weights format
Definition: mkldnn_types.h:324
handle(const handle &other)
Definition: mkldnn.hpp:71
Forward data propagation (alias for mkldnn_forward_training)
Definition: mkldnn_types.h:472
3D RNN data tensor in the format (batch, seq_length, input channels).
Definition: mkldnn_types.h:240
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:241
lrn descriptor
Definition: mkldnn_types.h:1256
workspace memory primitive desc
Definition: mkldnn_types.h:1271
lrn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2162
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:1636
bool next_impl()
Advances the next implementation for the given op descriptor.
Definition: mkldnn.hpp:1313
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:282
blocked weights format
Definition: mkldnn_types.h:291
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1713
desc(prop_kind aprop_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2691
blocked weights format
Definition: mkldnn_types.h:343
Definition: mkldnn.hpp:224
weights format with additional buffer size equal to the number of output channels and containing the ...
Definition: mkldnn_types.h:308
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2139
float get_clipping() const
Definition: mkldnn.hpp:3020
weights grad.
Definition: mkldnn_types.h:1268
4D data tensor with the physical layout nchw, used in Caffe.
Definition: mkldnn_types.h:169
Definition: mkldnn.hpp:322
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:396
primitive kind
Definition: mkldnn_types.h:1234
blocked data format
Definition: mkldnn_types.h:272
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:1858
int get_state_count() const
Definition: mkldnn.hpp:3029
blocked weights format
Definition: mkldnn_types.h:320
Definition: mkldnn.hpp:318
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:2250
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:2587
kind
Definition: mkldnn.hpp:3310
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:1503
Definition: mkldnn.hpp:340
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:3038
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...