20 #ifndef DOXYGEN_SHOULD_SKIP_THIS 55 template <
typename T,
typename traits=handle_traits<T>>
class handle {
57 std::shared_ptr<typename std::remove_pointer<T>::type> _data;
61 bool operator==(
const T other)
const {
return other == _data.get(); }
62 bool operator!=(
const T other)
const {
return !(*
this == other); }
67 handle(T t = 0,
bool weak =
false): _data(0) {
79 void reset(T t,
bool weak =
false) {
80 auto dummy_destructor = [](T) {
return decltype(traits::destructor(0))(0); };
81 _data.reset(t, weak ? dummy_destructor : traits::destructor);
85 T
get()
const {
return _data.get(); }
87 bool operator==(
const handle &other)
const {
return other._data.get() == _data.get(); }
91 #ifndef DOXYGEN_SHOULD_SKIP_THIS 100 template <>
struct handle_traits<mkldnn_primitive_desc_iterator_t> {
109 friend class primitive_at;
110 using handle::handle;
163 struct error:
public std::exception {
176 mkldnn_primitive_t aerror_primitive = 0)
179 , error_primitive(aerror_primitive, true)
191 const std::string &message,
192 mkldnn_primitive_t *error_primitive = 0)
195 if (
nullptr != error_primitive)
196 throw error(status, message, *error_primitive);
198 throw error(status, message,
nullptr);
207 data.output_index, &output),
208 "could not get an output primitive");
209 return primitive(const_cast<mkldnn_primitive_t>(output),
true);
215 "could not get primitive descriptor by primitive");
365 #ifndef DOXYGEN_SHOULD_SKIP_THIS 373 mkldnn_post_ops_t result;
375 "could not create post operation sequence");
384 "post_ops index is out of range");
391 "could not append sum");
396 "could not get sum params");
403 "could not append eltwise");
407 float &alpha,
float &beta)
const {
410 &scale, &c_alg, &alpha, &beta),
411 "could not get eltwise params");
416 #ifndef DOXYGEN_SHOULD_SKIP_THIS 424 mkldnn_primitive_attr_t result;
426 "could not create a primitive attr");
433 get(), &result),
"could not get int output round mode");
440 "could not set int output round mode");
446 const float *c_scales;
448 &count, &c_mask, &c_scales),
449 "could not get int output scales");
450 scales.resize(count);
453 for (
int c = 0; c < count; ++c)
454 scales[c] = c_scales[c];
460 (
int)scales.size(), mask, &scales[0]),
461 "could not set int output scales");
468 "could not get post operation sequence");
469 result.
reset(const_cast<mkldnn_post_ops_t>(c_result),
true);
475 "could not set post operation sequence");
487 #ifndef DOXYGEN_SHOULD_SKIP_THIS 521 mkldnn_engine_t aengine;
525 "could not create an engine");
529 explicit engine(
const mkldnn_engine_t& aengine)
530 :
handle(aengine, true) {}
533 mkldnn_engine_t engine_q;
537 "could not get engine from primitive_desc");
538 reset(engine_q,
true);
541 template <
class primitive_desc>
543 mkldnn_engine_t engine_q;
547 "could not get engine from primitive_desc");
572 std::shared_ptr<char> _handle;
575 typedef std::vector<std::remove_extent<mkldnn_dims_t>::type>
dims;
580 "invalid dimensions");
725 validate_dims(adims);
728 adims.size() == 0 ? nullptr : &adims[0],
730 "could not initialize a memory descriptor");
748 mkldnn_primitive_desc_t result;
752 "could not initialize a memory primitive descriptor");
769 other.
get())) ? false :
true;
787 mkldnn_primitive_t result;
790 "could not create a memory primitive");
792 auto _malloc = [](
size_t size,
int alignment) {
795 ptr = _aligned_malloc(size, alignment);
796 int rc = ((ptr)? 0 : errno);
798 int rc = ::posix_memalign(&ptr, alignment, size);
800 return (rc == 0) ? (
char*)ptr :
nullptr;
802 auto _free = [](
char* p) {
804 _aligned_free((
void*)p);
809 _handle.reset(_malloc(adesc.
get_size(), 4096), _free);
810 set_data_handle(_handle.get());
814 mkldnn_primitive_t result;
817 "could not create a memory primitive");
819 set_data_handle(ahandle);
828 "could not get primitive descriptor from a memory primitive");
830 adesc.
reset(const_cast<mkldnn_primitive_desc_t>(cdesc),
true);
839 "could not get native handle");
845 "could not set native handle");
869 &aprimitive_desc,
int n_inputs,
int n_outputs,
870 const std::string &prim_name) {
875 if (n_outputs_expected > n_outputs ) {
876 std::string message =
"could not create " + prim_name +
877 " primitive, not enought output parameters";
880 if (n_inputs_expected > n_inputs ) {
881 std::string message =
"could not create " + prim_name +
882 " primitive, not enought input parameters";
894 return ((aprimitive_md !=
nullptr) && (aprimitive_md->
ndims == 0));
935 mkldnn_primitive_desc_t result;
937 &result, input.
get(), output.
get()),
938 "could not create a reorder primitive descriptor");
945 mkldnn_primitive_desc_t result;
947 &result, input.
get(), output.
get(), aattr.
get()),
948 "could not create a reorder primitive descriptor");
957 mkldnn_primitive_t result;
961 aprimitive_desc.
get(), inputs, outputs),
962 "could not create a reorder primitive");
972 mkldnn_primitive_t result;
976 reorder_d.get(), inputs, outputs),
977 "could not create a reorder primitive");
994 mkldnn_primitive_desc_t result;
997 &result, input.
get(), &dims[0], &offsets[0]),
998 "could not create a view primitive descriptor");
1004 mkldnn_primitive_desc_t cdesc;
1010 "could not clone a dst primitive descriptor");
1019 mkldnn_primitive_t result;
1022 view_pd.
get(), inputs,
nullptr),
1023 "could not create a view primitive");
1028 mkldnn_primitive_t result;
1033 view_pd.get(), inputs,
nullptr),
1034 "could not create a view primitive");
1050 std::vector<memory::primitive_desc> inputs) {
1051 std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
1052 c_api_inputs.reserve(inputs.size());
1054 std::transform(inputs.begin(), inputs.end(),
1056 return c_api_inputs;
1060 std::vector<memory::primitive_desc> inputs) {
1061 mkldnn_primitive_desc_t result;
1063 auto c_api_inputs = cpp_to_c(inputs);
1066 &result, &output.
data, (
int)c_api_inputs.size(),
1067 concat_dimension, &c_api_inputs[0]),
1068 "could not create a concat primitive descriptor");
1073 std::vector<memory::primitive_desc> inputs) {
1074 mkldnn_primitive_desc_t result;
1076 auto c_api_inputs = cpp_to_c(inputs);
1079 &result,
nullptr, (
int)c_api_inputs.size(),
1080 concat_dimension, &c_api_inputs[0]),
1081 "could not create a concat primitive descriptor");
1087 mkldnn_primitive_desc_t cdesc;
1092 "could not clone a dst primitive descriptor");
1101 std::vector<primitive::at> &inputs,
const memory &output) {
1102 mkldnn_primitive_t result;
1104 std::vector<mkldnn_primitive_at_t> p_inputs;
1105 for (
size_t i = 0; i < inputs.size(); i++)
1106 p_inputs.push_back(inputs[i].data);
1110 concat_pd.
get(), &p_inputs[0], outputs),
1111 "could not create a concat primitive");
1127 std::vector<memory::primitive_desc> inputs) {
1128 std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
1129 c_api_inputs.reserve(inputs.size());
1131 std::transform(inputs.begin(), inputs.end(),
1133 return c_api_inputs;
1137 const std::vector<float> &scales,
1138 std::vector<memory::primitive_desc> inputs) {
1139 mkldnn_primitive_desc_t result;
1141 auto c_api_inputs = cpp_to_c(inputs);
1146 "number of scales not equal to number of inputs");
1149 &result, &output.
data, (
int)c_api_inputs.size(),
1150 &scales[0], &c_api_inputs[0]),
1151 "could not create a sum primitive descriptor");
1156 std::vector<memory::primitive_desc> inputs) {
1157 mkldnn_primitive_desc_t result;
1159 auto c_api_inputs = cpp_to_c(inputs);
1164 "number of scales not equal to number of inputs");
1167 &result,
nullptr, (
int)c_api_inputs.size(), &scales[0],
1169 "could not create a sum primitive descriptor");
1176 std::vector<memory::primitive_desc> inputs) {
1177 mkldnn_primitive_desc_t result;
1179 auto c_api_inputs = cpp_to_c(inputs);
1180 auto scale_f = scale_to_float(scale);
1183 &result, &output.
data, (
int)c_api_inputs.size(),
1184 &scale_f[0], &c_api_inputs[0]),
1185 "could not create a sum primitive descriptor");
1192 std::vector<memory::primitive_desc> inputs) {
1193 mkldnn_primitive_desc_t result;
1195 auto c_api_inputs = cpp_to_c(inputs);
1196 auto scale_f = scale_to_float(scale);
1199 &result,
nullptr, (
int)c_api_inputs.size(), &scale_f[0],
1201 "could not create a sum primitive descriptor");
1207 mkldnn_primitive_desc_t cdesc;
1213 "could not clone a dst primitive descriptor");
1222 std::vector<primitive::at> &inputs,
const memory &output) {
1223 mkldnn_primitive_t result;
1225 std::vector<mkldnn_primitive_at_t> p_inputs;
1226 for (
size_t i = 0; i < inputs.size(); i++)
1227 p_inputs.push_back(inputs[i].data);
1231 sum_pd.
get(), &p_inputs[0], outputs),
1232 "could not create a sum primitive");
1237 static std::vector<float> scale_to_float(
const std::vector<double> &vd) {
1238 std::vector<float> vf(vd.size());
1239 std::transform(vd.begin(), vd.end(), vf.begin(),
1240 [=](
double x){
return (
float)x;});
1259 mkldnn_primitive_desc_iterator_t iterator =
nullptr;
1261 &iterator, desc, attr ? attr->
get() :
nullptr, e.
get(),
1264 "could not create a primitive descriptor iterator");
1265 pd_iterator.reset(iterator);
1276 "could not query implementation info string");
1300 if (!std::any_of(valid_w.cbegin(), valid_w.cend(),
1301 [=](
query q) {
return what == q; }))
1309 if (const_cdesc ==
nullptr)
1312 mkldnn_primitive_desc_t cdesc;
1314 "could not clone a memory primitive descriptor");
1322 # define REG_QUERY_MPD(name, what, idx) \ 1323 memory::primitive_desc name ## _primitive_desc() const \ 1324 { return query_mpd(what ## _pd, idx); } 1327 handle<mkldnn_primitive_desc_iterator_t> pd_iterator;
1332 "could not fetch a primitive descriptor from the iterator");
1363 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1365 "could not create a convolution forward descriptor");
1380 &src_desc.
data, &weights_desc.
data,
nullptr,
1381 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1383 "could not create a convolution forward descriptor");
1403 &dst_desc.
data, &strides[0], &dilates[0],
1404 &padding_l[0], &padding_r[0],
1406 "could not create a dilated convolution forward descriptor");
1424 &src_desc.
data, &weights_desc.
data,
nullptr,
1425 &dst_desc.
data, &strides[0], &dilates[0],
1426 &padding_l[0], &padding_r[0],
1428 "could not create a dilated convolution forward descriptor");
1448 mkldnn_primitive_t result;
1453 aprimitive_desc.
get(), inputs, outputs),
1454 "could not create a convolution forward bias primitive");
1461 mkldnn_primitive_t result;
1465 "convolution forward");
1467 aprimitive_desc.
get(), inputs, outputs),
1468 "could not create a convolution forward primitive");
1489 &weights_desc.
data, &diff_dst_desc.
data,
1490 &strides[0], &padding_l[0], &padding_r[0],
1492 "could not create a convolution backward data descriptor");
1510 &weights_desc.
data, &diff_dst_desc.
data,
1511 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1513 "could not create a convolution backward data descriptor");
1533 const memory &diff_src) {
1534 mkldnn_primitive_t result;
1538 "convolution backward data");
1540 aprimitive_desc.
get(), inputs, outputs),
1541 "could not create a convolution backward data primitive");
1563 &diff_weights_desc.
data, &diff_bias_desc.
data,
1564 &diff_dst_desc.
data,
1565 &strides[0], &padding_l[0], &padding_r[0],
1567 "could not create a convolution backward weights descriptor");
1582 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1583 &strides[0], &padding_l[0], &padding_r[0],
1585 "could not create a convolution backward weights descriptor");
1603 &diff_weights_desc.
data, &diff_bias_desc.
data,
1604 &diff_dst_desc.
data,
1605 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1607 "could not create a convolution backward weights descriptor");
1624 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1625 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1627 "could not create a convolution backward weights descriptor");
1650 mkldnn_primitive_t result;
1655 "convolution backward weights");
1657 aprimitive_desc.
get(), inputs, outputs),
1658 "could not create a convolution backward weights primitive");
1663 const memory &diff_weights) {
1664 mkldnn_primitive_t result;
1668 "convolution backward weights");
1670 aprimitive_desc.
get(), inputs, outputs),
1671 "could not create a convolution backward weights primitive");
1685 const float negative_slope) {
1687 &conv_desc.
data, negative_slope),
1688 "could not create a convolution_relu_forward descriptor");
1707 mkldnn_primitive_t result;
1712 "convolution relu forward");
1714 aprimitive_desc.
get(), inputs, outputs),
1715 "could not create a convolution relu forward primitive");
1724 mkldnn_primitive_t result;
1728 "convolution relu forward");
1730 aprimitive_desc.
get(), inputs, outputs),
1731 "could not create a convolution relu forward primitive");
1762 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1764 "could not create a deconvolution forward descriptor");
1779 &src_desc.
data, &weights_desc.
data,
nullptr,
1780 &dst_desc.
data, &strides[0], &padding_l[0], &padding_r[0],
1782 "could not create a deconvolution forward descriptor");
1801 &dst_desc.
data, &strides[0], &dilates[0], &padding_l[0],
1803 "could not create a dilated deconvolution forward descriptor");
1820 &src_desc.
data, &weights_desc.
data,
nullptr,
1821 &dst_desc.
data, &strides[0], &dilates[0], &padding_l[0],
1823 "could not create a dilated deconvolution forward descriptor");
1843 mkldnn_primitive_t result;
1848 "deconvolution forward");
1850 aprimitive_desc.
get(), inputs, outputs),
1851 "could not create a deconvolution forward bias primitive");
1858 mkldnn_primitive_t result;
1862 "deconvolution forward");
1864 aprimitive_desc.
get(), inputs, outputs),
1865 "could not create a deconvolution forward primitive");
1886 &weights_desc.
data, &diff_dst_desc.
data,
1887 &strides[0], &padding_l[0], &padding_r[0],
1889 "could not create a deconvolution backward data descriptor");
1906 &weights_desc.
data, &diff_dst_desc.
data,
1907 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
1909 "could not create a dilated deconvolution backward data descriptor");
1929 const memory &diff_src) {
1930 mkldnn_primitive_t result;
1934 "deconvolution backward data");
1936 aprimitive_desc.
get(), inputs, outputs),
1937 "could not create a deconvolution backward data primitive");
1959 &diff_weights_desc.
data, &diff_bias_desc.
data,
1960 &diff_dst_desc.
data,
1961 &strides[0], &padding_l[0], &padding_r[0],
1963 "could not create a deconvolution backward weights descriptor");
1978 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
1979 &strides[0], &padding_l[0], &padding_r[0],
1981 "could not create a deconvolution backward weights descriptor");
1999 &diff_weights_desc.
data, &diff_bias_desc.
data,
2000 &diff_dst_desc.
data,
2001 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
2003 "could not create a dilated deconvolution backward weights descriptor");
2020 &diff_weights_desc.
data,
nullptr, &diff_dst_desc.
data,
2021 &strides[0], &dilates[0], &padding_l[0], &padding_r[0],
2023 "could not create a dilated deconvolution backward weights descriptor");
2045 mkldnn_primitive_t result;
2050 "deconvolution backward weights");
2052 aprimitive_desc.
get(), inputs, outputs),
2053 "could not create a deconvolution backward weights primitive");
2058 const memory &diff_weights) {
2059 mkldnn_primitive_t result;
2063 "deconvolution backward weights");
2065 aprimitive_desc.
get(), inputs, outputs),
2066 "could not create a deconvolution backward weights primitive");
2085 int local_size,
float alpha,
float beta,
float k)
2089 &src_desc.
data, local_size, alpha, beta, k),
2090 "could not create a lrn forward descriptor");
2094 int local_size,
float alpha,
float beta)
2098 &src_desc.
data, local_size, alpha, beta,
float(1.0)),
2099 "could not create a lrn forward descriptor");
2118 mkldnn_primitive_t result;
2124 aprimitive_desc.
get(), inputs, outputs),
2125 "could not create a lrn forward primitive");
2131 mkldnn_primitive_t result;
2136 aprimitive_desc.
get(), inputs, outputs),
2137 "could not create a lrn forward primitive");
2148 int local_size,
float alpha,
float beta,
float k)
2152 &data_desc.
data, local_size, alpha, beta, k),
2153 "could not create a lrn backward descriptor");
2158 int local_size,
float alpha,
float beta)
2162 &data_desc.
data, local_size, alpha, beta,
float(1.0)),
2163 "could not create a lrn backward descriptor");
2184 mkldnn_primitive_t result;
2190 aprimitive_desc.
get(), inputs, outputs),
2191 "could not create a lrn backward primitive");
2197 const memory &diff_src) {
2198 mkldnn_primitive_t result;
2203 aprimitive_desc.
get(), inputs, outputs),
2204 "could not create a lrn backward primitive");
2236 &strides[0], &kernel[0],
2237 &padding_l[0], &padding_r[0],
2239 "could not init a forward pooling descriptor");
2257 mkldnn_primitive_t result;
2262 aprimitive_desc.
get(), inputs, outputs),
2263 "could not create a pooling forward primitive");
2269 mkldnn_primitive_t result;
2274 aprimitive_desc.
get(), inputs, outputs),
2275 "could not create a pooling forward primitive");
2297 &diff_src_desc.
data, &diff_dst_desc.
data,
2298 &strides[0], &kernel[0],
2299 &padding_l[0], &padding_r[0],
2301 "could not init a backward pooling descriptor");
2320 const memory &diff_src) {
2321 mkldnn_primitive_t result;
2326 aprimitive_desc.
get(), inputs, outputs),
2327 "could not create a pooling backward primitive");
2333 mkldnn_primitive_t result;
2338 aprimitive_desc.
get(), inputs, outputs),
2339 "could not create a pooling backward primitive");
2356 template <
typename T>
2358 const memory::desc &src_desc, T alpha = 0, T beta = 0) {
2362 static_cast<float>(alpha), static_cast<float>(beta)),
2363 "could not create a eltwise forward descriptor");
2367 template <
typename T>
2387 mkldnn_primitive_t result;
2392 aprimitive_desc.
get(), inputs, outputs),
2393 "could not create a eltwise forward primitive");
2404 template <
typename T>
2406 const memory::desc &data_desc, T alpha = 0, T beta = 0) {
2409 &data_desc.
data, static_cast<float>(alpha),
2410 static_cast<float>(beta)),
2411 "could not create a eltwise backward descriptor");
2415 template <
typename T>
2438 const memory &diff_src) {
2439 mkldnn_primitive_t result;
2444 aprimitive_desc.
get(), inputs, outputs),
2445 "could not create a eltwise backward primitive");
2468 "could not create a softmax forward descriptor");
2485 mkldnn_primitive_t result;
2490 aprimitive_desc.
get(), inputs, outputs),
2491 "could not create a softmax forward primitive");
2502 &diff_desc.
data, &data_desc.
data, softmax_axis),
2503 "could not init a backward softmax descriptor");
2524 const memory &diff_src) {
2525 mkldnn_primitive_t result;
2529 aprimitive_desc.
get(), inputs, outputs),
2530 "could not create a softmax backward primitive");
2546 template <
typename T>
2552 static_cast<float>(epsilon), flags),
2553 "could not create a batch normalization forward descriptor");
2570 {
return stat_primitive_desc(mean); }
2572 {
return stat_primitive_desc(var); }
2575 enum { mean = 1, var = 2, };
2580 "could not get a batch-normalization descriptor");
2589 mkldnn_primitive_t result;
2594 "batch normalization forward");
2596 aprimitive_desc.
get(), inputs, outputs),
2597 "could not create a batch normalization forward primitive");
2604 mkldnn_primitive_t result;
2609 "batch normalization forward");
2611 aprimitive_desc.
get(), inputs, outputs),
2612 "could not create a batch normalization forward primitive");
2626 mkldnn_primitive_t result;
2629 mean.
get(), variance.
get() };
2631 "batch normalization forward");
2633 aprimitive_desc.
get(), inputs, outputs),
2634 "could not create a batch normalization forward primitive");
2641 const memory &workspace) {
2642 mkldnn_primitive_t result;
2645 mean.
get(), variance.
get(), workspace.
get() };
2647 "batch normalization forward");
2649 aprimitive_desc.
get(), inputs, outputs),
2650 "could not create a batch normalization forward primitive");
2656 const memory &variance) {
2657 mkldnn_primitive_t result;
2660 mean.
get(), variance.
get() };
2662 "batch normalization forward");
2664 aprimitive_desc.
get(), inputs, outputs),
2665 "could not create a batch normalization forward primitive");
2683 mkldnn_primitive_t result;
2686 mean.
get(), variance.
get(), workspace.
get() };
2693 if (n_inputs_expected == 2 && n_outputs_expected == 3) {
2695 auto _weights = dst;
2696 inputs[1] = {_weights.get(), 0};
2698 auto _dst = mean, _mean = variance, _variance = workspace;
2699 outputs[0] = _dst.get();
2700 outputs[1] = _mean.get();
2701 outputs[2] = _variance.get();
2702 outputs[3] =
nullptr;
2706 aprimitive_desc.
get(), inputs, outputs),
2707 "could not create a batch normalization forward primitive");
2714 mkldnn_primitive_t result;
2718 "batch normalization forward");
2720 aprimitive_desc.
get(), inputs, outputs),
2721 "could not create a batch normalization forward primitive");
2727 mkldnn_primitive_t result;
2731 "batch normalization forward");
2733 aprimitive_desc.
get(), inputs, outputs),
2734 "could not create a batch normalization forward primitive");
2742 template <
typename T>
2744 const memory::desc &data_desc, T epsilon,
unsigned flags) {
2748 &diff_data_desc.
data, &data_desc.
data,
2749 static_cast<float>(epsilon), flags),
2750 "could not create a batch normalization backward descriptor");
2780 const memory &diff_weights) {
2781 mkldnn_primitive_t result;
2785 diff_weights.
get() };
2787 "batch normalization backward");
2789 aprimitive_desc.
get(), inputs, outputs),
2790 "could not create a batch normalization backward primitive");
2800 mkldnn_primitive_t result;
2804 diff_weights.
get() };
2806 "batch normalization backward");
2808 aprimitive_desc.
get(), inputs, outputs),
2809 "could not create a batch normalization backward primitive");
2821 mkldnn_primitive_t result;
2823 diff_dst.
data, weights_or_workspace.
data };
2826 "batch normalization backward");
2828 aprimitive_desc.
get(), inputs, outputs),
2829 "could not create a batch normalization backward primitive");
2837 const memory &diff_src) {
2838 mkldnn_primitive_t result;
2843 "batch normalization backward");
2845 aprimitive_desc.
get(), inputs, outputs),
2846 "could not create a batch normalization backward primitive");
2870 "could not create a inner product forward descriptor");
2879 &weights_desc.
data,
nullptr, &dst_desc.
data),
2880 "could not create a inner product forward descriptor");
2900 mkldnn_primitive_t result;
2905 "inner product forward");
2907 aprimitive_desc.
get(), inputs, outputs),
2908 "could not create a inner product forward primitive");
2915 mkldnn_primitive_t result;
2919 "inner product forward");
2921 aprimitive_desc.
get(), inputs, outputs),
2922 "could not create a inner product forward primitive");
2935 &diff_src_desc.
data, &weights_desc.
data,
2936 &diff_dst_desc.
data),
2937 "could not create a inner product backward data descriptor");
2957 const memory &diff_src) {
2958 mkldnn_primitive_t result;
2962 "inner product backward data");
2964 aprimitive_desc.
get(), inputs, outputs),
2965 "could not create a inner product backward data primitive");
2979 &data, &src_desc.
data, &diff_weights_desc.
data,
2980 &diff_bias_desc.
data, &diff_dst_desc.
data),
2981 "could not create a inner product backward weights descriptor");
2988 &data, &src_desc.
data, &diff_weights_desc.
data,
2989 nullptr, &diff_dst_desc.
data),
2990 "could not create a inner product backward weights descriptor");
3011 const memory &diff_weights) {
3012 mkldnn_primitive_t result;
3016 "inner product backward weights");
3018 aprimitive_desc.
get(), inputs, outputs),
3019 "could not create a inner product backward weights primitive");
3026 mkldnn_primitive_t result;
3029 { diff_weights.
get(), diff_bias.
get()};
3031 "inner product backward weights");
3033 aprimitive_desc.
get(), inputs, outputs),
3034 "could not create a inner product backward weights primitive");
3055 "could not init an rnn cell descriptor");
3069 c_rnn_cell_.
alpha = alpha;
3103 &src_layer_desc.
data, &src_iter_desc.
data,
3104 &weights_layer_desc.
data, &weights_iter_desc.
data,
3106 &dst_layer_desc.
data, &dst_iter_desc.
data),
3107 "could not create an RNN forward descriptor");
3134 const memory &workspace) {
3135 mkldnn_primitive_t result;
3139 inputs[idx++] = src_layer.
data;
3141 inputs[idx++] = src_iter.
data;
3142 inputs[idx++] = weights_layer.
data;
3143 inputs[idx++] = weights_iter.
data;
3147 outputs[idx++] = dst_layer.
get();
3152 aprimitive_desc.
get(), inputs, outputs),
3153 "could not create an RNN forward primitive");
3180 &src_layer_desc.
data, &src_iter_desc.
data,
3181 &weights_layer_desc.
data, &weights_iter_desc.
data,
3183 &dst_layer_desc.
data, &dst_iter_desc.
data,
3184 &diff_src_layer_desc.
data, &diff_src_iter_desc.
data,
3185 &diff_weights_layer_desc.
data,
3186 &diff_weights_iter_desc.
data, &diff_bias_desc.
data,
3187 &diff_dst_layer_desc.
data, &diff_dst_iter_desc.
data),
3188 "could not create an RNN backward descriptor");
3233 const memory &diff_src_layer,
3234 const memory &diff_src_iter,
3235 const memory &diff_weights_layer,
3236 const memory &diff_weights_iter,
3241 mkldnn_primitive_t result;
3245 inputs[idx++] = src_layer.
data;
3247 inputs[idx++] = src_iter.
data;
3248 inputs[idx++] = weights_layer.
data;
3249 inputs[idx++] = weights_iter.
data;
3251 inputs[idx++] = bias.
data;
3252 inputs[idx++] = dst_layer.
data;
3254 inputs[idx++] = dst_iter.
data;
3255 inputs[idx++] = diff_dst_layer.
data;
3257 inputs[idx++] = diff_dst_iter.
data;
3258 inputs[idx++] = workspace.
data;
3261 outputs[idx++] = diff_src_layer.
get();
3263 outputs[idx++] = diff_src_iter.
get();
3264 outputs[idx++] = diff_weights_layer.
get();
3265 outputs[idx++] = diff_weights_iter.
get();
3268 aprimitive_desc.
get(), inputs, outputs),
3269 "could not create an RNN backward primitive");
3286 int axis,
int group_size) {
3290 "could not create a shuffle forward descriptor");
3304 mkldnn_primitive_t result;
3309 aprimitive_desc.
get(), inputs, outputs),
3310 "could not create a shuffle forward primitive");
3320 &diff_data_desc.
data, axis, group_size),
3321 "could not create a shuffle backward descriptor");
3336 mkldnn_primitive_t result;
3341 aprimitive_desc.
get(), inputs, outputs),
3342 "could not create a shuffle backward primitive");
3357 #ifndef DOXYGEN_SHOULD_SKIP_THIS 3364 using handle::handle;
3375 mkldnn_stream_t astream;
3378 "could not create a stream");
3389 if (primitives.size() == 0)
return *
this;
3390 std::vector<mkldnn_primitive_t> c_api_primitives;
3391 c_api_primitives.reserve(primitives.size());
3393 std::transform(primitives.begin(), primitives.end(),
3396 mkldnn_primitive_t c_api_error_primitive;
3399 c_api_primitives.size(), &c_api_primitives[0],
3400 &c_api_error_primitive),
3401 "could not submit primitives to a stream",
3402 &c_api_error_primitive);
3414 mkldnn_primitive_t c_api_error_primitive;
3416 block, &c_api_error_primitive);
3420 &c_api_error_primitive);
3425 mkldnn_primitive_t c_api_error_primitive;
3428 "could not rerun a stream", &c_api_error_primitive);
3433 #undef REG_QUERY_MPD void append_sum(float scale=1.)
Definition: mkldnn.hpp:389
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2473
Definition: mkldnn.hpp:2422
LRN within a single channel.
Definition: mkldnn_types.h:474
primitive error_primitive
Definition: mkldnn.hpp:166
A descriptor of a Local Response Normalization (LRN) operation.
Definition: mkldnn_types.h:809
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1494
Definition: mkldnn.hpp:346
blocked weights format
Definition: mkldnn_types.h:300
Definition: mkldnn.hpp:1681
inner_product_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at weights, const memory &dst)
Definition: mkldnn.hpp:2912
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2247
Definition: mkldnn.hpp:270
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1049
blocked weights format
Definition: mkldnn_types.h:303
op descriptor
Definition: mkldnn_types.h:1163
primitive_desc(const memory::desc &output, int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1059
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1637
mkldnn_status_t MKLDNN_API mkldnn_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for backward propagation with respect to weights using...
blocked weights format with additional buffer with size equal to the number of output channels multip...
Definition: mkldnn_types.h:327
Definition: mkldnn.hpp:3158
blocked weights format
Definition: mkldnn_types.h:287
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_destroy(mkldnn_primitive_attr_t attr)
Deletes an attr.
blocked weights format
Definition: mkldnn_types.h:345
mkldnn_status_t MKLDNN_API mkldnn_sum_primitive_desc_create(mkldnn_primitive_desc_t *sum_primitive_desc, const mkldnn_memory_desc_t *output_desc, int n, const float *scales, const_mkldnn_primitive_desc_t *input_pds)
Creates out-of-place sum_primitive_desc for sum of n inputs multiplied by scale with resulting output...
A Softmax primitive.
Definition: mkldnn_types.h:422
number of outputs expected
Definition: mkldnn_types.h:1152
bool operator!=(const handle &other) const
Definition: mkldnn.hpp:88
mkldnn_status_t MKLDNN_API mkldnn_stream_destroy(mkldnn_stream_t stream)
Destroys an execution stream.
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:3116
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:1647
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:2585
stream & submit(std::vector< primitive > primitives)
Submits a vector of primitives to a stream for computations.
Definition: mkldnn.hpp:3386
bool operator==(const primitive_desc &other) const
Definition: mkldnn.hpp:767
A base class for all primitive descriptors.
Definition: mkldnn.hpp:1256
Definition: mkldnn.hpp:2280
mkldnn_status_t
Status values returned by Intel(R) MKL-DNN functions.
Definition: mkldnn_types.h:39
stream & rerun()
Definition: mkldnn.hpp:3424
Definition: mkldnn.hpp:2243
A descriptor of a convolution operation.
Definition: mkldnn_types.h:655
Definition: mkldnn.hpp:302
desc(prop_kind aprop_kind, const memory::desc &data_desc, int axis, int group_size)
Definition: mkldnn.hpp:3285
Definition: mkldnn.hpp:2218
The operation failed and should be retried.
Definition: mkldnn_types.h:45
memory null_memory(engine eng)
Definition: mkldnn.hpp:863
mkldnn_status_t MKLDNN_API mkldnn_memory_primitive_desc_create(mkldnn_primitive_desc_t *memory_primitive_desc, const mkldnn_memory_desc_t *memory_desc, mkldnn_engine_t engine)
Creates a memory_primitive_desc memory primitive descriptor using memory_desc and engine...
MKLDNN_DEPRECATED primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3195
Definition: mkldnn.hpp:2027
blocked weights format
Definition: mkldnn_types.h:259
mkldnn_status_t MKLDNN_API mkldnn_post_ops_create(mkldnn_post_ops_t *post_ops)
Creates an empty sequence of post operations post_ops.
Definition: mkldnn.hpp:331
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_destroy(mkldnn_primitive_desc_t primitive_desc)
Deletes a primitive_desc.
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1587
mkldnn_status_t MKLDNN_API mkldnn_concat_primitive_desc_create(mkldnn_primitive_desc_t *concat_primitive_desc, const mkldnn_memory_desc_t *output_desc, int n, int concat_dimension, const_mkldnn_primitive_desc_t *input_pds)
Creates out-of-place concat_primitive_desc for concatenation of n inputs by concat_dimension with res...
MKLDNN_DEPRECATED convolution_relu_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1721
4D RNN bias tensor in the format (num_layers, num_directions, num_gates, output_channels).
Definition: mkldnn_types.h:239
4D data tensor with the physical layout chwn, used in Neon.
Definition: mkldnn_types.h:163
Definition: mkldnn.hpp:266
padding_kind
Definition: mkldnn.hpp:234
The operation failed because of incorrect function arguments.
Definition: mkldnn_types.h:47
Forward data propagation (alias for mkldnn_forward_inference)
Definition: mkldnn_types.h:381
Definition: mkldnn.hpp:2081
Definition: mkldnn.hpp:1943
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:1549
Definition: mkldnn.hpp:2884
Backward data propagation.
Definition: mkldnn_types.h:387
Definition: mkldnn.hpp:2497
static void validate_dims(std::vector< T > v)
Definition: mkldnn.hpp:577
Definition: mkldnn.hpp:3325
Definition: mkldnn.hpp:3315
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:2463
Definition: mkldnn.hpp:275
blocked weights format
Definition: mkldnn_types.h:283
Undefined memory format, used for empty memory descriptors.
Definition: mkldnn_types.h:137
const_mkldnn_primitive_desc_t get_primitive_desc() const
Returns the descriptor of the underlying C API primitive.
Definition: mkldnn.hpp:212
MKLDNN_DEPRECATED desc(const memory::desc &diff_data_desc, const memory::desc &data_desc, T negative_slope)
Definition: mkldnn.hpp:2417
concat(const primitive_desc &concat_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:1100
memory::desc desc()
Returns the memory primitive descriptor.
Definition: mkldnn.hpp:757
deconvolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights, const memory &diff_bias)
Definition: mkldnn.hpp:2042
mkldnn_status_t MKLDNN_API mkldnn_dilated_convolution_backward_weights_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for backward propagation with respect to weights using...
float alpha
alpha is a negative slope parameter (used only if (flags & mkldnn_rnn_cell_with_relu) != 0) ...
Definition: mkldnn_types.h:925
#define TENSOR_MAX_DIMS
Maximum number of dimensions a tensor can have.
Definition: mkldnn_types.h:552
format
Memory format specification. See mkldnn_memory_format_t for a detailed description.
Definition: mkldnn.hpp:596
Definition: mkldnn.hpp:291
4D weights tensor with physical layout oihw, used in Caffe.
Definition: mkldnn_types.h:184
MKLDNN_DEPRECATED primitive_desc(std::vector< double > scale, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1191
A descriptor of a Softmax operation.
Definition: mkldnn_types.h:759
blocked weights format
Definition: mkldnn_types.h:348
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_clone(mkldnn_primitive_desc_t *primitive_desc, const_mkldnn_primitive_desc_t existing_primitive_desc)
Makes a copy of a primitive_desc.
softmax_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2483
blocked weights format
Definition: mkldnn_types.h:349
blocked data format
Definition: mkldnn_types.h:246
mkldnn_status_t MKLDNN_API mkldnn_memory_get_data_handle(const_mkldnn_primitive_t memory, void **handle)
For a memory primitive, returns the data handle.
Definition: mkldnn.hpp:246
mkldnn_status_t MKLDNN_API mkldnn_convolution_backward_data_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for backward propagation with respect to data using al...
A descriptor of an inner product operation.
Definition: mkldnn_types.h:867
mkldnn_status_t MKLDNN_API mkldnn_post_ops_destroy(mkldnn_post_ops_t post_ops)
Deletes a post_ops sequence.
std::vector< std::remove_extent< mkldnn_dims_t >::type > dims
Definition: mkldnn.hpp:575
3D RNN data tensor in the format (seq_length, batch, input channels).
Definition: mkldnn_types.h:215
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3295
An opaque structure for a chain of post operations.
An opaque structure to describe a primitive descriptor .
batch normalization descriptor
Definition: mkldnn_types.h:1173
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1766
mkldnn_rnn_direction_t
A direction of RNN primitive execution.
Definition: mkldnn_types.h:932
void reset(T t, bool weak=false)
Resets the value of a C handle.
Definition: mkldnn.hpp:79
A convolution primitive.
Definition: mkldnn_types.h:414
primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1914
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:2144
mkldnn_status_t MKLDNN_API mkldnn_memory_set_data_handle(mkldnn_primitive_t memory, void *handle)
For a memory primitive, sets the data handle.
engine(const mkldnn_engine_t &aengine)
Definition: mkldnn.hpp:529
engine(const handle< mkldnn_primitive_desc_t > &pd)
Definition: mkldnn.hpp:532
engine get_engine()
Definition: mkldnn.hpp:1269
desc(dims adims, data_type adata_type, format aformat)
Constructs a memory descriptor.
Definition: mkldnn.hpp:723
blocked data format
Definition: mkldnn_types.h:247
mkldnn_status_t MKLDNN_API mkldnn_batch_normalization_forward_desc_init(mkldnn_batch_normalization_desc_t *bnrm_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *data_desc, float epsilon, unsigned flags)
Initializes a batch normalization descriptor bnrm_desc for forward propagation using prop_kind...
Definition: mkldnn.hpp:227
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2861
sum(const primitive_desc &sum_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:1221
An execution engine.
Definition: mkldnn.hpp:494
memory(const primitive_desc &adesc, void *ahandle)
Definition: mkldnn.hpp:813
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2929
mkldnn_status_t MKLDNN_API mkldnn_post_ops_append_eltwise(mkldnn_post_ops_t post_ops, float scale, mkldnn_alg_kind_t alg, float alpha, float beta)
Appends eltwise post operation to the post_ops with given parameters kind, alpha and beta (...
static void wrap_c_api(mkldnn_status_t status, const std::string &message, mkldnn_primitive_t *error_primitive=0)
A convenience function for wrapping calls to the C API. Checks the return status and throws an error ...
Definition: mkldnn.hpp:190
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:2282
Undefined primitive (XXX: why do we have it?).
Definition: mkldnn_types.h:398
mkldnn_status_t MKLDNN_API mkldnn_deconvolution_backward_data_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a deconvolution descriptor conv_desc for backward propagation with respect to data using ...
An inner product primitive.
Definition: mkldnn_types.h:430
void check_num_parameters(const const_mkldnn_primitive_desc_t &aprimitive_desc, int n_inputs, int n_outputs, const std::string &prim_name)
Definition: mkldnn.hpp:868
Round down.
Definition: mkldnn_types.h:82
Definition: mkldnn_types.h:1175
4D grouped weights tensor with the physical layout goiw.
Definition: mkldnn_types.h:199
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const softmax_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2512
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:1784
Definition: mkldnn.hpp:265
round_mode get_int_output_round_mode() const
Definition: mkldnn.hpp:430
primitive_attr()
Definition: mkldnn.hpp:423
Definition: mkldnn_types.h:470
Definition: mkldnn.hpp:2400
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:2508
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:2498
Definition: mkldnn.hpp:2472
void get_params_sum(int index, float &scale) const
Definition: mkldnn.hpp:394
Definition: mkldnn.hpp:249
32-bit signed integer.
Definition: mkldnn_types.h:68
primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2942
Max pooling.
Definition: mkldnn_types.h:465
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1408
memory::desc zero_md()
Definition: mkldnn.hpp:857
Definition: mkldnn.hpp:340
primitive_desc(const memory::primitive_desc &input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:992
mkldnn_status_t MKLDNN_API mkldnn_softmax_forward_desc_init(mkldnn_softmax_desc_t *softmax_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *data_desc, int softmax_axis)
Initializes a softmax_desc for forward propagation using prop_kind (possible value are mkldnn_forward...
blocked weights format
Definition: mkldnn_types.h:273
const post_ops get_post_ops() const
Definition: mkldnn.hpp:464
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims kernel, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:2220
Definition: mkldnn.hpp:333
execution engine
Definition: mkldnn_types.h:1148
stream(kind akind)
Constructs a stream.
Definition: mkldnn.hpp:3374
Definition: mkldnn.hpp:991
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_next(mkldnn_primitive_desc_iterator_t iterator)
Iterates over primitive descriptors.
Definition: mkldnn.hpp:338
desc(const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2930
mkldnn_status_t MKLDNN_API mkldnn_pooling_backward_desc_init(mkldnn_pooling_desc_t *pool_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t kernel, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a pooling descriptor pool_desc for backward propagation using alg_kind, memory descriptors, and pooling parameters in spatial domain: strides, kernel sizes, padding_l, padding_r, and padding_kind.
Definition: mkldnn.hpp:2217
blocked weights format
Definition: mkldnn_types.h:280
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1693
static mkldnn_memory_format_t convert_to_c(format aformat)
Definition: mkldnn.hpp:852
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const eltwise_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2427
Definition: mkldnn.hpp:2754
Definition: mkldnn.hpp:322
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_create(mkldnn_primitive_attr_t *attr)
Creates an empty (default) attr attribute.
Definition: mkldnn_types.h:910
A descriptor of a convolution followed by relu operation.
Definition: mkldnn_types.h:896
mkldnn_status_t MKLDNN_API mkldnn_stream_submit(mkldnn_stream_t stream, size_t n, mkldnn_primitive_t primitives[], mkldnn_primitive_t *error_primitive)
Submits primitives to an execution stream.
algorithm
Definition: mkldnn.hpp:257
input memory primitive desc
Definition: mkldnn_types.h:1180
blocked weights format
Definition: mkldnn_types.h:294
mkldnn_shuffle_desc_t data
Definition: mkldnn.hpp:3284
5D grouped weights tensor with the physical layout goihw, used in Caffe.
Definition: mkldnn_types.h:203
const_mkldnn_primitive_t primitive
Primitive to specify the output for.
Definition: mkldnn_types.h:1108
Definition: mkldnn.hpp:290
rnn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src_layer, const primitive::at &src_iter, const primitive::at &weights_layer, const primitive::at &weights_iter, const primitive::at &bias, const memory &dst_layer, const memory &dst_iter, const memory &workspace)
Definition: mkldnn.hpp:3129
mkldnn_status_t MKLDNN_API mkldnn_rnn_cell_desc_init(mkldnn_rnn_cell_desc_t *rnn_cell_desc, mkldnn_alg_kind_t kind, mkldnn_alg_kind_t f, unsigned int flags, float alpha, float clipping)
Initializes a recurrent cell descriptor rnn_cell_desc using rnn_cell_desc, kind (possible values are ...
A descriptor of a element-wise operation.
Definition: mkldnn_types.h:717
rnn descriptor
Definition: mkldnn_types.h:1176
memory::primitive_desc variance_primitive_desc() const
Definition: mkldnn.hpp:2571
An element-wise primitive.
Definition: mkldnn_types.h:418
Definition: mkldnn.hpp:2941
Definition: mkldnn.hpp:2496
destination grad.
Definition: mkldnn_types.h:1187
algorithm get_cell_kind() const
Definition: mkldnn.hpp:3061
engine get_engine()
Definition: mkldnn.hpp:1218
Definition: mkldnn.hpp:2401
mkldnn_status_t MKLDNN_API mkldnn_stream_wait(mkldnn_stream_t stream, int block, mkldnn_primitive_t *error_primitive)
Waits for all primitives in the execution stream to finish.
mkldnn_alg_kind_t activation_kind
Activation function used.
Definition: mkldnn_types.h:920
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1205
blocked weights format
Definition: mkldnn_types.h:297
A descriptor for an rnn operation.
Definition: mkldnn_types.h:947
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1385
Definition: mkldnn.hpp:1047
Definition: mkldnn.hpp:278
Definition: mkldnn.hpp:260
eltwise descriptor
Definition: mkldnn_types.h:1168
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &mean, const memory &variance, const memory &workspace)
Definition: mkldnn.hpp:2680
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1433
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:2817
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2129
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:2973
batch_normalization_flag
Definition: mkldnn.hpp:289
A memory primitive.
Definition: mkldnn_types.h:400
float clipping
clipping parameter (used only if (flags & mkldnn_rnn_cell_with_clipping) != 0)
Definition: mkldnn_types.h:928
MKLDNN_DEPRECATED desc(prop_kind aprop_kind, const memory::desc &src_desc, T negative_slope)
Definition: mkldnn.hpp:2369
blocked weights format
Definition: mkldnn_types.h:282
desc(prop_kind aprop_kind, rnn_cell::desc cell, const rnn_direction direction, const memory::desc &src_layer_desc, const memory::desc &src_iter_desc, const memory::desc &weights_layer_desc, const memory::desc &weights_iter_desc, const memory::desc &bias_desc, const memory::desc &dst_layer_desc, const memory::desc &dst_iter_desc, const memory::desc &diff_src_layer_desc, const memory::desc &diff_src_iter_desc, const memory::desc &diff_weights_layer_desc, const memory::desc &diff_weights_iter_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_layer_desc, const memory::desc &diff_dst_iter_desc)
Definition: mkldnn.hpp:3161
Eltwise: soft_relu.
Definition: mkldnn_types.h:461
Definition: mkldnn.hpp:1517
void set_post_ops(post_ops ops)
Definition: mkldnn.hpp:473
inner_product_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at weights, const primitive::at &bias, const memory &dst)
Definition: mkldnn.hpp:2897
Definition: mkldnn.hpp:345
Definition: mkldnn.hpp:262
mkldnn_primitive_kind_t MKLDNN_API mkldnn_post_ops_get_kind(const_mkldnn_post_ops_t post_ops, int index)
Returns the type of post operation with index index in given post_ops.
RNN cell.
Definition: mkldnn_types.h:480
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2244
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:1805
bool is_null_memory(const const_mkldnn_primitive_t &aprimitive)
Definition: mkldnn.hpp:888
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2946
Definition: mkldnn.hpp:371
Definition: mkldnn.hpp:2928
blocked weights format
Definition: mkldnn_types.h:309
bool operator==(const handle &other) const
Definition: mkldnn.hpp:87
Definition: mkldnn.hpp:1345
Backward weights propagation.
Definition: mkldnn_types.h:389
void set_int_output_round_mode(round_mode mode)
Definition: mkldnn.hpp:437
mkldnn_rnn_desc_t data
Definition: mkldnn.hpp:3089
blocked weights format
Definition: mkldnn_types.h:344
eltwise_forward relu_forward
Definition: mkldnn.hpp:2398
32-bit/single-precision floating point.
Definition: mkldnn_types.h:66
blocked weights format
Definition: mkldnn_types.h:256
blocked data format
Definition: mkldnn_types.h:245
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1569
algorithm get_activation() const
Definition: mkldnn.hpp:3063
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2255
2D weights tensor with physical layout oi.
Definition: mkldnn_types.h:172
Just a sentinel, not real memory format.
Definition: mkldnn_types.h:359
Omit statistics.
Definition: mkldnn_types.h:532
Memory descriptor.
Definition: mkldnn_types.h:616
Definition: mkldnn.hpp:2860
Definition: mkldnn.hpp:305
mkldnn_status_t MKLDNN_API mkldnn_inner_product_backward_data_desc_init(mkldnn_inner_product_desc_t *ip_desc, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc)
Initializes an inner product descriptor ip_desc for backward propagation with respect to data using m...
Base class for all computational primitives.
Definition: mkldnn.hpp:106
shuffle_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:3302
mkldnn_batch_normalization_flag_t
Flags for batch-normalization primititve.
Definition: mkldnn_types.h:497
void set_clipping(float clipping)
Definition: mkldnn.hpp:3073
convolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:1661
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:2082
Definition: mkldnn.hpp:2859
desc(prop_kind aprop_kind, const memory::desc &src_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2547
Definition: mkldnn.hpp:281
pooling descriptor
Definition: mkldnn_types.h:1171
Definition: mkldnn.hpp:2281
const mkldnn_memory_desc_t MKLDNN_API * mkldnn_primitive_desc_query_memory_d(const_mkldnn_primitive_desc_t primitive_desc)
Queries primitive descriptor for memory descriptor.
prop_kind
Definition: mkldnn.hpp:242
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:2219
Definition: mkldnn.hpp:268
blocked weights format
Definition: mkldnn_types.h:255
3D weights tensor with physical layout wio.
Definition: mkldnn_types.h:181
blocked weights format
Definition: mkldnn_types.h:308
mkldnn_status_t MKLDNN_API mkldnn_dilated_deconvolution_forward_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated deconvolution descriptor deconv_desc for forward propagation using prop_kind (p...
unsigned int flags
RNN cell flags.
Definition: mkldnn_types.h:922
3D data tensor with the physical layout ncw.
Definition: mkldnn_types.h:151
blocked weights format
Definition: mkldnn_types.h:285
convolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1531
The operation was successful.
Definition: mkldnn_types.h:41
mkldnn_status_t MKLDNN_API mkldnn_engine_create(mkldnn_engine_t *engine, mkldnn_engine_kind_t kind, size_t index)
Creates an engine of particular kind and index.
blocked weights format
Definition: mkldnn_types.h:320
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2999
primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1633
desc(algorithm kind, algorithm activation_f)
Definition: mkldnn.hpp:3051
blocked weights format
Definition: mkldnn_types.h:328
Definition: mkldnn.hpp:328
Definition: mkldnn.hpp:247
primitive_desc(const_mkldnn_op_desc_t desc, const primitive_attr *attr, const engine &e, const_mkldnn_primitive_desc_t hint_fwd_pd)
Definition: mkldnn.hpp:1257
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_get_int_output_round_mode(const_mkldnn_primitive_attr_t attr, mkldnn_round_mode_t *round_mode)
Returns integer output rounding mode round_mode for a given attr, previously set by mkldnn_primitive_...
blocked weights format
Definition: mkldnn_types.h:342
mkldnn_rnn_desc_t data
Definition: mkldnn.hpp:3160
Backward propagation (with respect to all parameters.
Definition: mkldnn_types.h:385
5D data tensor with the physical layout ndhwc, used in TensorFlow.
Definition: mkldnn_types.h:169
inner_product_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at diff_dst, const memory &diff_weights, const memory &diff_bias)
Definition: mkldnn.hpp:3023
softmax descriptor
Definition: mkldnn_types.h:1170
mkldnn_round_mode_t
Rounding mode.
Definition: mkldnn_types.h:78
A deconvolution primitive.
Definition: mkldnn_types.h:416
Definition: mkldnn.hpp:332
Definition: mkldnn.hpp:276
primitive_desc(const desc &adesc, const engine &aengine)
Constructs a memory primitive descriptor.
Definition: mkldnn.hpp:747
Use global statistics.
Definition: mkldnn_types.h:510
Definition: mkldnn.hpp:31
primitive_desc(int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1072
blocked weights format
Definition: mkldnn_types.h:286
no query
Definition: mkldnn_types.h:1146
Definition: mkldnn.hpp:2971
Definition: mkldnn.hpp:1745
blocked weights format
Definition: mkldnn_types.h:335
blocked weights format
Definition: mkldnn_types.h:298
mkldnn_status_t MKLDNN_API mkldnn_convolution_forward_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a convolution descriptor conv_desc for forward propagation using prop_kind (possible valu...
mkldnn_status_t MKLDNN_API mkldnn_view_primitive_desc_create(mkldnn_primitive_desc_t *view_primitive_desc, const_mkldnn_primitive_desc_t memory_primitive_desc, const mkldnn_dims_t dims, const mkldnn_dims_t offsets)
Creates a view_primitive_desc for a given memory_primitive_desc, with dims sizes and offset offsets...
8-bit unsigned integer.
Definition: mkldnn_types.h:74
Definition: mkldnn.hpp:350
Average pooling include padding.
Definition: mkldnn_types.h:467
Unspecified format.
Definition: mkldnn_types.h:140
inner_product_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at weights, const memory &diff_src)
Definition: mkldnn.hpp:2955
Definition: mkldnn.hpp:2103
destination memory primitive desc
Definition: mkldnn_types.h:1186
memory::primitive_desc mean_primitive_desc() const
Definition: mkldnn.hpp:2569
5D RNN weights tensor in the format (num_layers, num_directions, input_channels, num_gates, output_channels).
Definition: mkldnn_types.h:225
GRU cell with linear before reset.
Definition: mkldnn_types.h:493
memory(const primitive_desc &adesc)
Constructs a memory primitive.
Definition: mkldnn.hpp:786
lrn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const primitive::at &workspace, const memory &diff_src)
Definition: mkldnn.hpp:2181
mkldnn_status_t MKLDNN_API mkldnn_shuffle_forward_desc_init(mkldnn_shuffle_desc_t *shuffle_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *data_desc, int axis, int group_size)
Initializes a shuffle_desc for forward propagation using prop_kind, memory descriptor data_desc...
Local response normalization (LRN) across multiple channels.
Definition: mkldnn_types.h:472
blocked weights format
Definition: mkldnn_types.h:270
GRU cell.
Definition: mkldnn_types.h:484
Eager stream.
Definition: mkldnn_types.h:1201
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output, const primitive_attr &aattr)
Definition: mkldnn.hpp:942
void set_output_scales(int mask, const std::vector< float > &scales)
Definition: mkldnn.hpp:457
at(const primitive &aprimitive, size_t at=0)
Constructs a wrapper specifying aprimitive output with index at.
Definition: mkldnn.hpp:145
implementation name
Definition: mkldnn_types.h:1159
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_bias_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1983
Definition: mkldnn.hpp:1346
desc(const memory::desc &diff_data_desc, int axis, int group_size)
Definition: mkldnn.hpp:3318
Definition: mkldnn.hpp:3316
Definition: mkldnn.hpp:258
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2319
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_get_output_scales(const_mkldnn_primitive_attr_t attr, int *count, int *mask, const float **scales)
Returns count, correspondence scale mask, and pointer to a constant floating point array of output sc...
3D weights tensor with physical layout oiw.
Definition: mkldnn_types.h:178
Eltwise: parametric exponential linear unit (elu)
Definition: mkldnn_types.h:449
kind
Kinds of engines.
Definition: mkldnn.hpp:499
Definition: mkldnn.hpp:2143
Definition: mkldnn.hpp:2927
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2476
Intel(R) MKL-DNN exception class.
Definition: mkldnn.hpp:163
round_mode
Definition: mkldnn.hpp:225
bool operator==(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:897
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1872
Eltwise: ReLU.
Definition: mkldnn_types.h:445
Definition: mkldnn.hpp:2460
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1347
Definition: mkldnn.hpp:235
1D data tensor.
Definition: mkldnn_types.h:146
mkldnn_primitive_at_t data
The underlying C API structure.
Definition: mkldnn.hpp:138
memory::primitive_desc query_mpd(query what, int idx=0) const
Queries and returns requested memory primitive descriptor.
Definition: mkldnn.hpp:1297
desc(const convolution_forward::desc conv_desc, const float negative_slope)
Definition: mkldnn.hpp:1684
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2759
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:3202
primitive_desc(const desc &desc, const engine &e, const shuffle_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3326
4D weights tensor with physical layout ihwo.
Definition: mkldnn_types.h:190
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:2402
mkldnn_memory_format_t
Memory format specification.
Definition: mkldnn_types.h:135
Definition: mkldnn.hpp:990
Eltwise: square.
Definition: mkldnn_types.h:451
Definition: mkldnn.hpp:1124
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1367
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1002
Definition: mkldnn.hpp:282
mkldnn_status_t MKLDNN_API mkldnn_eltwise_forward_desc_init(mkldnn_eltwise_desc_t *eltwise_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *data_desc, float alpha, float beta)
Initializes a eltwise_desc for forward propagation using prop_kind (possible values are mkldnn_forwar...
int MKLDNN_API mkldnn_memory_primitive_desc_equal(const_mkldnn_primitive_desc_t lhs, const_mkldnn_primitive_desc_t rhs)
Compares two descriptors of memory primitives.
static mkldnn_data_type_t convert_to_c(data_type adata_type)
Definition: mkldnn.hpp:849
4D data tensor with the physical layout nhwc, used in TensorFlow.
Definition: mkldnn_types.h:160
void set_data_handle(void *handle) const
Definition: mkldnn.hpp:843
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &mean, const memory &variance)
Definition: mkldnn.hpp:2654
Definition: mkldnn.hpp:269
desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, int local_size, float alpha, float beta, float k)
Definition: mkldnn.hpp:2145
Backward bias propagation.
Definition: mkldnn_types.h:391
Definition: mkldnn.hpp:931
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, float alpha, float beta)
Definition: mkldnn.hpp:2092
blocked weights format
Definition: mkldnn_types.h:339
Use scale and shift parameters.
Definition: mkldnn_types.h:523
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1747
mkldnn_status_t MKLDNN_API mkldnn_deconvolution_forward_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a deconvolution descriptor deconv_desc for forward propagation using prop_kind (possible ...
query
Definition: mkldnn.hpp:313
Definition: mkldnn.hpp:280
weights format with additional buffer size equal to the number of output channels multiplied by numbe...
Definition: mkldnn_types.h:319
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_query(const_mkldnn_primitive_desc_t primitive_desc, mkldnn_query_t what, int index, void *result)
Queries primitive descriptor.
float get_alpha() const
Definition: mkldnn.hpp:3066
blocked weights format
Definition: mkldnn_types.h:269
blocked weights format
Definition: mkldnn_types.h:329
A descriptor of a shuffle operation.
Definition: mkldnn_types.h:700
void get_params_eltwise(int index, float &scale, algorithm &alg, float &alpha, float &beta) const
Definition: mkldnn.hpp:406
Definition: mkldnn_types.h:942
mkldnn_status_t MKLDNN_API mkldnn_dilated_deconvolution_backward_weights_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated deconvolution descriptor conv_desc for backward propagation with respect to wei...
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:2355
primitive_desc(const desc &desc, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2028
Definition: mkldnn.hpp:422
blocked weights format
Definition: mkldnn_types.h:337
blocked weights format
Definition: mkldnn_types.h:305
Definition: mkldnn.hpp:1913
int get_gates_count() const
Definition: mkldnn.hpp:3078
int ndims
Number of dimensions.
Definition: mkldnn_types.h:621
reorder(const primitive_desc &aprimitive_desc, const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:955
Definition: mkldnn.hpp:2080
Definition: mkldnn.hpp:1048
kind
A proxy to C primitive kind enum.
Definition: mkldnn.hpp:113
void set_alpha(float alpha)
Definition: mkldnn.hpp:3067
A convolution primitive merged with ReLU.
Definition: mkldnn_types.h:432
mkldnn_status_t MKLDNN_API mkldnn_eltwise_backward_desc_init(mkldnn_eltwise_desc_t *eltwise_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_data_desc, const mkldnn_memory_desc_t *data_desc, float alpha, float beta)
Initializes a eltwise_desc for backward propagation using alg_kind algorithm memory descriptors diff_...
desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, int local_size, float alpha, float beta)
Definition: mkldnn.hpp:2155
5D data tensor with the physical layout ncdhw.
Definition: mkldnn_types.h:166
Definition: mkldnn.hpp:3283
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_destroy(mkldnn_primitive_desc_iterator_t iterator)
Deletes a primitive descriptor iterator.
5D RNN states tensor in the format (num_layers, num_directions, num_states, batch, state channels).
Definition: mkldnn_types.h:218
Definition: mkldnn.hpp:2167
size_t get_size() const
Returns the number of bytes required to allocate the memory described including the padding area...
Definition: mkldnn.hpp:763
mkldnn_status_t MKLDNN_API mkldnn_post_ops_append_sum(mkldnn_post_ops_t post_ops, float scale)
Appends accumulation (sum) post operation to the post_ops.
Definition: mkldnn.hpp:1546
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:1840
A rnn primitive.
Definition: mkldnn_types.h:434
mkldnn_status_t MKLDNN_API mkldnn_primitive_get_output(const_mkldnn_primitive_t primitive, size_t index, const_mkldnn_primitive_t *output)
For a primitive, returns output at the index position.
MKLDNN_DEPRECATED primitive_desc(const memory::desc &output, std::vector< double > scale, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1175
blocked weights format
Definition: mkldnn_types.h:293
mkldnn_status_t MKLDNN_API mkldnn_shuffle_backward_desc_init(mkldnn_shuffle_desc_t *shuffle_desc, const mkldnn_memory_desc_t *diff_data_desc, int axis, int group_size)
Initializes a shuffle_desc for backward propagation using memory descriptor diff_data_desc, axis and group number.
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1944
Definition: mkldnn.hpp:3048
eltwise_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2436
mkldnn_prop_kind_t
Kinds of propagation.
Definition: mkldnn_types.h:369
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn.hpp:136
CPU engine.
Definition: mkldnn_types.h:998
Definition: mkldnn.hpp:293
desc(algorithm alg_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:2405
Eltwise: square root.
Definition: mkldnn_types.h:455
blocked weights format
Definition: mkldnn_types.h:257
mkldnn_stream_kind_t
Kinds of streams.
Definition: mkldnn_types.h:1197
Definition: mkldnn.hpp:272
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_int_output_round_mode(mkldnn_primitive_attr_t attr, mkldnn_round_mode_t round_mode)
Sets output rounding mode round_mode for integer operations for a given attr.
4D weights tensor with physical layout hwio, used in TensorFlow.
Definition: mkldnn_types.h:187
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn_types.h:1106
Winograd convolution.
Definition: mkldnn_types.h:443
Definition: mkldnn.hpp:248
A ReLU primitive.
Definition: mkldnn_types.h:420
Definition: mkldnn.hpp:347
Eltwise: linear.
Definition: mkldnn_types.h:457
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1873
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:1945
reorder(const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:966
Eltwise: logistic.
Definition: mkldnn_types.h:463
Definition: mkldnn.hpp:2739
Direct convolution.
Definition: mkldnn_types.h:441
Primitive iterator passed over last primitive descriptor.
Definition: mkldnn_types.h:54
Definition: mkldnn.hpp:342
Definition: mkldnn.hpp:271
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &workspace, const memory &dst)
Definition: mkldnn.hpp:2115
source gradient memory primitive desc
Definition: mkldnn_types.h:1183
mkldnn_alg_kind_t cell_kind
RNN cell kind.
Definition: mkldnn_types.h:917
Definition: mkldnn.hpp:1474
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2741
Definition: mkldnn_types.h:934
Definition: mkldnn.hpp:314
blocked data format
Definition: mkldnn_types.h:249
mkldnn_status_t MKLDNN_API mkldnn_pooling_forward_desc_init(mkldnn_pooling_desc_t *pool_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t kernel, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a pooling descriptor pool_desc for forward propagation using prop_kind (possible values a...
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, float alpha, float beta, float k)
Definition: mkldnn.hpp:2083
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:2711
mkldnn_rnn_cell_desc_t c_rnn_cell_
Definition: mkldnn.hpp:3049
bool operator!=(const primitive_desc &other) const
Definition: mkldnn.hpp:772
runtime estimation (seconds)
Definition: mkldnn_types.h:1154
blocked weights format
Definition: mkldnn_types.h:336
Definition: mkldnn.hpp:1632
bool operator==(const T other) const
Definition: mkldnn.hpp:61
A (in-place) concat primitive.
Definition: mkldnn_types.h:410
mkldnn_status_t MKLDNN_API mkldnn_stream_create(mkldnn_stream_t *stream, mkldnn_stream_kind_t stream_kind)
Creates an execution stream of stream_kind.
primitive_desc get_primitive_desc() const
Returns the descriptor of the memory primitive.
Definition: mkldnn.hpp:823
blocked weights format
Definition: mkldnn_types.h:271
LSTM cell.
Definition: mkldnn_types.h:482
blocked weights format
Definition: mkldnn_types.h:260
mkldnn_status_t MKLDNN_API mkldnn_batch_normalization_backward_desc_init(mkldnn_batch_normalization_desc_t *bnrm_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_memory_desc_t *diff_data_desc, const mkldnn_memory_desc_t *data_desc, float epsilon, unsigned flags)
Initializes a batch normalization descriptor bnrm_desc for backward propagation with respect to data ...
Definition: mkldnn_types.h:943
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2558
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2885
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2888
Undefined data type, used for empty memory descriptors.
Definition: mkldnn_types.h:64
Definition: mkldnn.hpp:1870
16-bit signed integer.
Definition: mkldnn_types.h:70
Definition: mkldnn.hpp:2354
A shuffle primitive.
Definition: mkldnn_types.h:406
blocked weights format with additional buffer with size equal to the number of output channels and co...
Definition: mkldnn_types.h:278
mkldnn_shuffle_desc_t data
Definition: mkldnn.hpp:3317
primitive_desc()
Definition: mkldnn.hpp:744
int len() const
Definition: mkldnn.hpp:379
mkldnn_status_t MKLDNN_API mkldnn_primitive_get_primitive_desc(const_mkldnn_primitive_t primitive, const_mkldnn_primitive_desc_t *primitive_desc)
Retrieves a reference to the primitive_desc descriptor of given primitive.
primitive_desc(const memory::desc &output, const std::vector< float > &scales, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1136
desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc)
Definition: mkldnn.hpp:2873
mkldnn_status_t MKLDNN_API mkldnn_post_ops_get_params_eltwise(const_mkldnn_post_ops_t post_ops, int index, float *scale, mkldnn_alg_kind_t *alg, float *alpha, float *beta)
Gets the eltwise parameters of the post operation with index index in the sequence of post_ops...
Definition: mkldnn.hpp:1827
Definition: mkldnn.hpp:244
blocked weights format
Definition: mkldnn_types.h:299
Definition: mkldnn.hpp:2994
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:1475
blocked weights format
Definition: mkldnn_types.h:292
A (out-of-place) concat primitive.
Definition: mkldnn_types.h:408
blocked weights format
Definition: mkldnn_types.h:306
Fuse with ReLU.
Definition: mkldnn_types.h:541
Definition: mkldnn.hpp:261
Definition: mkldnn.hpp:279
static size_t get_count(kind akind)
Returns the number of engines of a certain kind.
Definition: mkldnn.hpp:510
mkldnn_query_t
Primitive descriptor query specification.
Definition: mkldnn_types.h:1145
A descriptor of a Batch Normalization operation.
Definition: mkldnn_types.h:836
static engine query(const primitive_desc &pd)
Definition: mkldnn.hpp:542
Definition: mkldnn.hpp:3087
deconvolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:2056
Definition: mkldnn.hpp:292
blocked data format
Definition: mkldnn_types.h:248
A sum primitive.
Definition: mkldnn_types.h:412
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2834
Definition: mkldnn.hpp:304
blocked weights format
Definition: mkldnn_types.h:333
eltwise_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2385
unsigned flags
Definition: mkldnn_types.h:863
mkldnn_status_t MKLDNN_API mkldnn_reorder_primitive_desc_create_v2(mkldnn_primitive_desc_t *reorder_primitive_desc, const_mkldnn_primitive_desc_t input, const_mkldnn_primitive_desc_t output, const_mkldnn_primitive_attr_t attr)
Initializes a reorder_primitive_desc using an attr attribute and descriptors of input and output memo...
blocked weights format
Definition: mkldnn_types.h:261
blocked weights format
Definition: mkldnn_types.h:310
Definition: mkldnn.hpp:3047
softmax_backward(const primitive_desc &aprimitive_desc, const primitive::at &dst, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2522
blocked weights format
Definition: mkldnn_types.h:252
Definition: mkldnn.hpp:3088
Definition: mkldnn.hpp:259
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2375
mkldnn_status_t MKLDNN_API mkldnn_dilated_deconvolution_backward_data_desc_init(mkldnn_deconvolution_desc_t *conv_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *diff_dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated deconvolution descriptor conv_desc for backward propagation with respect to dat...
blocked weights format
Definition: mkldnn_types.h:338
mkldnn_status_t MKLDNN_API mkldnn_stream_rerun(mkldnn_stream_t stream, mkldnn_primitive_t *error_primitive)
Reruns all the primitives within the stream.
2D weights tensor with physical layout io.
Definition: mkldnn_types.h:175
memory consumption – extra (scratch) memory, additional to all inputs and outputs memory (bytes) ...
Definition: mkldnn_types.h:1155
An batch normalization primitive.
Definition: mkldnn_types.h:428
A class for wrapping an Intel(R) MKL-DNN handle. It is used as the base class for primitive (mkldnn_p...
Definition: mkldnn.hpp:55
Definition: mkldnn_types.h:439
engine(kind akind, size_t index)
Constructs an engine.
Definition: mkldnn.hpp:520
Definition: mkldnn.hpp:2353
A descriptor of a pooling operation.
Definition: mkldnn_types.h:775
Definition: mkldnn.hpp:3363
Definition: mkldnn.hpp:273
Definition: mkldnn.hpp:274
engine get_engine()
Definition: mkldnn.hpp:776
MKLDNN_DEPRECATED convolution_relu_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const primitive::at &bias, const memory &dst)
Definition: mkldnn.hpp:1704
error(mkldnn_status_t astatus, std::string amessage, mkldnn_primitive_t aerror_primitive=0)
Constructs an error instance.
Definition: mkldnn.hpp:175
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2032
const char * impl_info_str() const
Returns implementation name.
Definition: mkldnn.hpp:1272
deconvolution descriptor
Definition: mkldnn_types.h:1166
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1126
blocked weights format
Definition: mkldnn_types.h:312
shuffle_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:3334
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output)
Definition: mkldnn.hpp:933
primitive_desc(const desc &desc, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2306
mkldnn_memory_desc_t data
The underlying C API data structure.
Definition: mkldnn.hpp:716
mkldnn_primitive_desc_t MKLDNN_API mkldnn_primitive_desc_iterator_fetch(const_mkldnn_primitive_desc_iterator_t iterator)
Fetches current primitive descriptor.
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:1436
engine get_engine()
Definition: mkldnn.hpp:952
int MKLDNN_API mkldnn_primitive_desc_query_s32(const_mkldnn_primitive_desc_t primitive_desc, mkldnn_query_t what, int index)
Queries primitive descriptor for signed 32bit int.
8-bit signed integer.
Definition: mkldnn_types.h:72
mkldnn_status_t MKLDNN_API mkldnn_reorder_primitive_desc_create(mkldnn_primitive_desc_t *reorder_primitive_desc, const_mkldnn_primitive_desc_t input, const_mkldnn_primitive_desc_t output)
Initializes a reorder_primitive_desc using descriptors of input and output memory primitives...
The data in padding regions is zero.
Definition: mkldnn_types.h:365
int MKLDNN_API mkldnn_rnn_cell_get_states_count(const mkldnn_rnn_cell_desc_t *rnn_cell_desc)
Returns the number of states of a particular rnn_cell_desc.
Definition: mkldnn.hpp:2374
desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2983
source memory primitive desc
Definition: mkldnn_types.h:1182
mkldnn_primitive_kind_t
Kinds of primitives.
Definition: mkldnn_types.h:396
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const deconvolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1918
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:2005
RNN packed weights (unused)
Definition: mkldnn_types.h:354
Definition: mkldnn.hpp:3294
Winograd deconvolution.
Definition: mkldnn_types.h:478
Definition: mkldnn.hpp:250
number of inputs expected
Definition: mkldnn_types.h:1151
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:2462
Definition: mkldnn.hpp:349
Definition: mkldnn.hpp:3112
Definition: mkldnn.hpp:2740
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2561
Definition: mkldnn.hpp:2544
desc(prop_kind aprop_kind, algorithm alg_kind, const memory::desc &src_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:2357
An unspecified engine.
Definition: mkldnn_types.h:1199
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:1828
void * get_data_handle() const
Returns a handle of the data contained in the memory primitive. On the CPU engine, this is a pointer to the allocated memory.
Definition: mkldnn.hpp:836
A view primitive.
Definition: mkldnn_types.h:402
size_t MKLDNN_API mkldnn_memory_primitive_desc_get_size(const_mkldnn_primitive_desc_t memory_primitive_desc)
Returns the size (in bytes) that is required for given memory_primitive_desc.
Definition: mkldnn.hpp:3159
Definition: mkldnn.hpp:263
Definition: mkldnn.hpp:330
Definition: mkldnn.hpp:3193
blocked weights format
Definition: mkldnn_types.h:284
Definition: mkldnn.hpp:339
mkldnn_primitive_kind_t convert_to_c(primitive::kind akind)
Definition: mkldnn.hpp:156
Definition: mkldnn.hpp:1547
Definition: mkldnn.hpp:344
Definition: mkldnn.hpp:334
Definition: mkldnn.hpp:325
Definition: mkldnn.hpp:336
Average pooling exclude padding.
Definition: mkldnn_types.h:469
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_get_post_ops(const_mkldnn_primitive_attr_t attr, const_mkldnn_post_ops_t *post_ops)
Returns post_ops for given attr.
mkldnn_status_t MKLDNN_API mkldnn_primitive_create(mkldnn_primitive_t *primitive, const_mkldnn_primitive_desc_t primitive_desc, const mkldnn_primitive_at_t *inputs, const_mkldnn_primitive_t *outputs)
Creates a primitive using a primitive_desc descriptor and arrays of inputs and outputs.
primitive::kind kind(int index) const
Definition: mkldnn.hpp:381
Definition: mkldnn_types.h:913
Forward data propagation (inference mode).
Definition: mkldnn_types.h:379
6D grouped weights tensor with the physical layout goidhw, used in Caffe.
Definition: mkldnn_types.h:211
5D weights tensor with physical layout iodhw, used in Caffe.
Definition: mkldnn_types.h:193
A class that provides the destructor for an Intel(R) MKL-DNN C handle.
Definition: mkldnn.hpp:40
data_type
Data type specification. See mkldnn_data_type_t for a detailed description.
Definition: mkldnn.hpp:585
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const memory &dst)
Definition: mkldnn.hpp:2601
Direct deconvolution.
Definition: mkldnn_types.h:476
Eltwise: abs.
Definition: mkldnn_types.h:453
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst, const memory &mean, const memory &variance)
Definition: mkldnn.hpp:2623
blocked weights format
Definition: mkldnn_types.h:322
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &workspace, const memory &diff_src)
Definition: mkldnn.hpp:2331
blocked weights format
Definition: mkldnn_types.h:272
A memory descriptor.
Definition: mkldnn.hpp:713
deconvolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1927
5D grouped weights tensor with the physical layout hwigo, used in TensorFlow.
Definition: mkldnn_types.h:207
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2378
blocked weights format
Definition: mkldnn_types.h:330
bool operator!=(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:900
handle(T t=0, bool weak=false)
Constructs a C handle wrapper.
Definition: mkldnn.hpp:67
mkldnn_status_t MKLDNN_API mkldnn_dilated_convolution_forward_desc_init(mkldnn_convolution_desc_t *conv_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *weights_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_desc, const mkldnn_dims_t strides, const mkldnn_dims_t dilates, const mkldnn_dims_t padding_l, const mkldnn_dims_t padding_r, mkldnn_padding_kind_t padding_kind)
Initializes a dilated convolution descriptor conv_desc for forward propagation using prop_kind (possi...
Eltwise: hyperbolic tangent non-linearity (tanh)
Definition: mkldnn_types.h:447
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2972
mkldnn_status_t status
Definition: mkldnn.hpp:164
deconvolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1855
eltwise_backward relu_backward
Definition: mkldnn.hpp:2450
T get() const
Returns the value of the underlying C handle.
Definition: mkldnn.hpp:85
mkldnn_status_t MKLDNN_API mkldnn_engine_destroy(mkldnn_engine_t engine)
Destroys an engine.
view(const primitive_desc &view_pd, primitive::at input)
Definition: mkldnn.hpp:1018
desc(algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1965
blocked weights format
Definition: mkldnn_types.h:311
2D data tensor.
Definition: mkldnn_types.h:148
primitive_desc(const desc &desc, const engine &e, const batch_normalization_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2755
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:2862
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:3413
mkldnn_status_t MKLDNN_API mkldnn_lrn_backward_desc_init(mkldnn_lrn_desc_t *lrn_desc, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *diff_data_desc, const mkldnn_memory_desc_t *data_desc, int local_size, float alpha, float beta, float k)
Initializes an lrn_desc for backward propagation using alg_kind, memory descriptors data_desc...
Primitive or engine failed on execution.
Definition: mkldnn_types.h:56
memory descriptor for memory and view
Definition: mkldnn_types.h:1164
view(memory input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:1027
Definition: mkldnn.hpp:1432
Definition: mkldnn.hpp:267
An LRN primitive.
Definition: mkldnn_types.h:426
Definition: mkldnn_types.h:939
mkldnn_padding_kind_t
Kinds of padding.
Definition: mkldnn_types.h:363
rnn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src_layer, const primitive::at &src_iter, const primitive::at &weights_layer, const primitive::at &weights_iter, const primitive::at &bias, const primitive::at &dst_layer, const primitive::at &dst_iter, const memory &diff_src_layer, const memory &diff_src_iter, const memory &diff_weights_layer, const memory &diff_weights_iter, const memory &diff_bias, const primitive::at &diff_dst_layer, const primitive::at &diff_dst_iter, const primitive::at &workspace)
Definition: mkldnn.hpp:3225
Lazy stream.
Definition: mkldnn_types.h:1203
Definition: mkldnn.hpp:335
desc(const memory::desc &diff_desc, const memory::desc &data_desc, int softmax_axis)
Definition: mkldnn.hpp:2499
blocked weights format
Definition: mkldnn_types.h:334
Definition: mkldnn.hpp:306
void get_output_scales(int &mask, std::vector< float > &scales) const
Definition: mkldnn.hpp:443
blocked weights format
Definition: mkldnn_types.h:254
desc(algorithm kind)
Definition: mkldnn.hpp:3057
primitive_desc(const desc &desc, const engine &e, const rnn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:3198
Definition: mkldnn.hpp:1871
5D RNN weights tensor in the format (num_layers, num_directions, num_gates, output_channels, input_channels).
Definition: mkldnn_types.h:232
blocked weights format
Definition: mkldnn_types.h:304
const_mkldnn_primitive_desc_t MKLDNN_API mkldnn_primitive_desc_query_pd(const_mkldnn_primitive_desc_t primitive_desc, mkldnn_query_t what, int index)
Queries primitive descriptor for primitive descriptor.
Definition: mkldnn.hpp:2970
shuffle descriptor
Definition: mkldnn_types.h:1167
Forward data propagation (training mode).
Definition: mkldnn_types.h:375
Definition: mkldnn.hpp:348
primitive_desc(const desc &desc, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2168
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:3009
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1548
memory(const primitive &aprimitive)
Constructs a memory primitive from a generic primitive.
Definition: mkldnn.hpp:782
3D data tensor with the physical layout nwc.
Definition: mkldnn_types.h:154
engine get_engine()
Definition: mkldnn.hpp:1097
post_ops()
Definition: mkldnn.hpp:372
An opaque structure to describe a primitive.
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const primitive::at &weights, const primitive::at &workspace, const memory &diff_src, const memory &diff_weights)
Definition: mkldnn.hpp:2795
A tensor in a generic format described by the stride and blocking values in each dimension.
Definition: mkldnn_types.h:144
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &bias_desc, const memory::desc &dst_desc, const memory::dims strides, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1348
mkldnn_data_type_t
Data type specification.
Definition: mkldnn_types.h:62
Definition: mkldnn.hpp:1473
Definition: mkldnn.hpp:327
Definition: mkldnn.hpp:320
convolution descriptor
Definition: mkldnn_types.h:1165
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1522
A memory primitive descriptor.
Definition: mkldnn.hpp:740
Definition: mkldnn.hpp:316
Definition: mkldnn.hpp:2507
mkldnn_status_t MKLDNN_API mkldnn_lrn_forward_desc_init(mkldnn_lrn_desc_t *lrn_desc, mkldnn_prop_kind_t prop_kind, mkldnn_alg_kind_t alg_kind, const mkldnn_memory_desc_t *data_desc, int local_size, float alpha, float beta, float k)
Initializes an lrn_desc for forward propagation using prop_kind (possible values are mkldnn_forward_t...
blocked weights format
Definition: mkldnn_types.h:295
primitive_desc(const desc &desc, const engine &e, const convolution_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:1518
blocked weights format
Definition: mkldnn_types.h:288
handle & operator=(const handle &other)
Definition: mkldnn.hpp:72
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2725
Eltwise: bounded_relu.
Definition: mkldnn_types.h:459
Definition: mkldnn.hpp:2461
#define REG_QUERY_MPD(name, what, idx)
Definition: mkldnn.hpp:1322
Definition: mkldnn_types.h:936
convolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1458
mkldnn_engine_kind_t
Kinds of engines.
Definition: mkldnn_types.h:994
Definition: mkldnn_types.h:909
int MKLDNN_API mkldnn_rnn_cell_get_gates_count(const mkldnn_rnn_cell_desc_t *rnn_cell_desc)
Returns the number of gates of a particular rnn_cell_desc.
Queried element is not required for given primitive.
Definition: mkldnn_types.h:58
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:3113
blocked weights format
Definition: mkldnn_types.h:347
bool operator!=(const T other) const
Definition: mkldnn.hpp:62
Memory primitive that describes the data.
Definition: mkldnn.hpp:570
Weights format used in 8bit Winograd convolution.
Definition: mkldnn_types.h:351
Definition: mkldnn.hpp:329
primitive_desc(const desc &desc, const engine &e)
Definition: mkldnn.hpp:2104
Definition: mkldnn.hpp:2142
Definition: mkldnn.hpp:303
Round nearest.
Definition: mkldnn_types.h:80
blocked weights format
Definition: mkldnn_types.h:346
Definition: mkldnn.hpp:245
batch_normalization_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &mean, const primitive::at &variance, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src, const memory &diff_weights)
Definition: mkldnn.hpp:2776
Definition: mkldnn.hpp:1744
const void * const_mkldnn_op_desc_t
A pointer to any of the operation descriptors (constant variant).
Definition: mkldnn_types.h:610
static mkldnn_stream_kind_t convert_to_c(kind akind)
Definition: mkldnn.hpp:3370
blocked weights format
Definition: mkldnn_types.h:253
blocked weights format
Definition: mkldnn_types.h:343
Definition: mkldnn.hpp:1942
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1085
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_iterator_create_v2(mkldnn_primitive_desc_iterator_t *iterator, const_mkldnn_op_desc_t op_desc, const_mkldnn_primitive_attr_t attr, mkldnn_engine_t engine, const_mkldnn_primitive_desc_t hint_forward_primitive_desc)
Creates a primitive descriptor iterator for given op_desc, attr, engine, and optionally a hint primit...
Definition: mkldnn.hpp:2543
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &workspace)
Definition: mkldnn.hpp:2267
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:1445
A reorder primitive.
Definition: mkldnn_types.h:404
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:1831
mkldnn_status_t MKLDNN_API mkldnn_convolution_relu_desc_init(mkldnn_convolution_relu_desc_t *conv_relu_desc, const mkldnn_convolution_desc_t *conv_desc, float negative_slope)
Initializes a merged convolution-relu descriptor conv_relu_desc for forward propagation (supported in...
rnn_direction
Definition: mkldnn.hpp:301
primitive_desc(const std::vector< float > &scales, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:1155
blocked weights format
Definition: mkldnn_types.h:331
blocked weights format
Definition: mkldnn_types.h:291
An unspecified engine.
Definition: mkldnn_types.h:996
desc(const mkldnn_memory_desc_t &adata)
Constructs a memory descriptor from a C API data structure.
Definition: mkldnn.hpp:736
Definition: mkldnn.hpp:1692
blocked weights format
Definition: mkldnn_types.h:307
Definition: mkldnn.hpp:1125
int MKLDNN_API mkldnn_post_ops_len(const_mkldnn_post_ops_t post_ops)
Returns the length of post operations for given post_ops.
engine get_engine()
Definition: mkldnn.hpp:1015
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const pooling_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2310
mkldnn_convolution_relu_desc_t data
Definition: mkldnn.hpp:1682
blocked weights format
Definition: mkldnn_types.h:332
blocked weights format
Definition: mkldnn_types.h:321
mkldnn_alg_kind_t
Kinds of algorithms.
Definition: mkldnn_types.h:438
primitive_desc(const desc &desc, const engine &e, const inner_product_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2995
Definition: mkldnn.hpp:264
inner product descriptor
Definition: mkldnn_types.h:1174
A pooling primitive.
Definition: mkldnn_types.h:424
weights memory primitive descriptor desc
Definition: mkldnn_types.h:1184
output memory primitive desc
Definition: mkldnn_types.h:1181
Definition: mkldnn.hpp:2305
5D weights tensor with physical layout dhwio, used in TensorFlow.
Definition: mkldnn_types.h:196
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e)
Definition: mkldnn.hpp:2107
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2545
Definition: mkldnn.hpp:932
mkldnn_status_t MKLDNN_API mkldnn_primitive_destroy(mkldnn_primitive_t primitive)
Deletes a primitive.
Definition: mkldnn.hpp:337
std::string message
Definition: mkldnn.hpp:165
Definition: mkldnn.hpp:3282
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:2423
Definition: mkldnn.hpp:2557
Definition: mkldnn.hpp:317
blocked weights format
Definition: mkldnn_types.h:281
handle(const handle &other)
Definition: mkldnn.hpp:71
Forward data propagation (alias for mkldnn_forward_training)
Definition: mkldnn_types.h:383
3D RNN data tensor in the format (batch, seq_length, input channels).
Definition: mkldnn_types.h:213
mkldnn_status_t MKLDNN_API mkldnn_primitive_attr_set_output_scales(mkldnn_primitive_attr_t attr, int count, int mask, const float *scales)
Sets output scales for primitive operations.
Definition: mkldnn.hpp:243
lrn descriptor
Definition: mkldnn_types.h:1172
workspace memory primitive desc
Definition: mkldnn_types.h:1188
lrn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:2195
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:1609
bool next_impl()
Advances the next implementation for the given op descriptor.
Definition: mkldnn.hpp:1286
mkldnn_status_t MKLDNN_API mkldnn_inner_product_backward_weights_desc_init(mkldnn_inner_product_desc_t *ip_desc, const mkldnn_memory_desc_t *src_desc, const mkldnn_memory_desc_t *diff_weights_desc, const mkldnn_memory_desc_t *diff_bias_desc, const mkldnn_memory_desc_t *diff_dst_desc)
Initializes an inner product descriptor ip_desc for backward propagation with respect to weights usin...
blocked weights format
Definition: mkldnn_types.h:258
mkldnn_deconvolution_desc_t data
Definition: mkldnn.hpp:1746
desc(prop_kind aprop_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2743
blocked weights format
Definition: mkldnn_types.h:296
Definition: mkldnn.hpp:226
weights format with additional buffer size equal to the number of output channels and containing the ...
Definition: mkldnn_types.h:268
Definition: mkldnn_types.h:1169
primitive_desc(const desc &desc, const primitive_attr &attr, const engine &e, const lrn_forward::primitive_desc &hint_fwd_pd)
Definition: mkldnn.hpp:2172
float get_clipping() const
Definition: mkldnn.hpp:3072
weights grad.
Definition: mkldnn_types.h:1185
4D data tensor with the physical layout nchw, used in Caffe.
Definition: mkldnn_types.h:157
Definition: mkldnn.hpp:323
mkldnn_status_t MKLDNN_API mkldnn_rnn_forward_desc_init(mkldnn_rnn_desc_t *rnn_desc, mkldnn_prop_kind_t prop_kind, const mkldnn_rnn_cell_desc_t *rnn_cell_desc, const mkldnn_rnn_direction_t direction, const mkldnn_memory_desc_t *src_layer_desc, const mkldnn_memory_desc_t *src_iter_desc, const mkldnn_memory_desc_t *weights_layer_desc, const mkldnn_memory_desc_t *weights_iter_desc, const mkldnn_memory_desc_t *bias_desc, const mkldnn_memory_desc_t *dst_layer_desc, const mkldnn_memory_desc_t *dst_iter_desc)
Initializes a rnn descriptor rnn_desc for forward propagation using prop_kind, rnn_cell_desc, direction, and memory descriptors.
void append_eltwise(float scale, algorithm alg, float alpha, float beta)
Definition: mkldnn.hpp:399
primitive kind
Definition: mkldnn_types.h:1149
blocked data format
Definition: mkldnn_types.h:244
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc, const memory::dims strides, const memory::dims dilates, const memory::dims padding_l, const memory::dims padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:1891
RNN packed weights (unused)
Definition: mkldnn_types.h:355
int get_state_count() const
Definition: mkldnn.hpp:3081
blocked weights format
Definition: mkldnn_types.h:279
Definition: mkldnn.hpp:319
desc(algorithm aalgorithm, const memory::desc &diff_src_desc, const memory::desc &diff_dst_desc, const memory::dims &strides, const memory::dims &kernel, const memory::dims &padding_l, const memory::dims &padding_r, const padding_kind apadding_kind)
Definition: mkldnn.hpp:2283
A merged convolution-relu primitive for inference mode only.
Definition: mkldnn.hpp:1680
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:2638
kind
Definition: mkldnn.hpp:3366
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:1476
Definition: mkldnn.hpp:343
desc(prop_kind aprop_kind, rnn_cell::desc cell, const rnn_direction direction, const memory::desc &src_layer_desc, const memory::desc &src_iter_desc, const memory::desc &weights_layer_desc, const memory::desc &weights_iter_desc, const memory::desc &bias_desc, const memory::desc &dst_layer_desc, const memory::desc &dst_iter_desc)
Definition: mkldnn.hpp:3090
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...