Intel(R) Math Kernel Library for Deep Neural Networks (Intel(R) MKL-DNN)  0.10
Performance library for Deep Learning
mkldnn.hpp
Go to the documentation of this file.
1 /*******************************************************************************
2 * Copyright 2016-2017 Intel Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *******************************************************************************/
16 
17 #ifndef MKLDNN_HPP
18 #define MKLDNN_HPP
19 
20 #ifndef DOXYGEN_SHOULD_SKIP_THIS
21 #include <assert.h>
22 #include <stdlib.h>
23 #include <memory>
24 #include <vector>
25 #include <algorithm>
26 #include <iterator>
27 
28 #include "mkldnn.h"
29 #endif
30 
31 namespace mkldnn {
32 
35 
38 
40 template <typename T> class handle_traits {};
41 
55 template <typename T, typename traits=handle_traits<T>> class handle {
56 private:
57  std::shared_ptr<typename std::remove_pointer<T>::type> _data;
58  handle(const handle &&) {}
59  handle &operator=(const handle &&other) = delete;
60 protected:
64  handle(T t = 0, bool weak = false): _data(0) {
65  reset(t, weak);
66  }
67 
68  bool operator==(const T other) const { return other == _data.get(); }
69  bool operator!=(const T other) const { return !(*this == other); }
70 public:
71  handle(const handle &other): _data(other._data) {}
72  handle &operator=(const handle &other) {
73  _data = other._data;
74  return *this;
75  }
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);
82  }
83 
85  T get() const { return _data.get(); }
86 
87  bool operator==(const handle &other) const { return other._data.get() == _data.get(); }
88  bool operator!=(const handle &other) const { return !(*this == other); }
89 };
90 
91 template <> struct handle_traits<mkldnn_primitive_t> {
92  static constexpr auto destructor = &mkldnn_primitive_destroy;
93 };
94 
96 class primitive: public handle<mkldnn_primitive_t> {
97  friend struct error;
98  friend struct stream;
99  friend class primitive_at;
100  using handle::handle;
101 public:
103  struct at {
111 
112  at(const primitive &aprimitive, size_t at = 0)
113  : data(mkldnn_primitive_at(aprimitive.get(), at)) {}
115  inline operator primitive() const;
116  };
117 
119  inline const_mkldnn_primitive_desc_t get_primitive_desc() const;
120  // TODO: use the C++ API wrapper structure.
121 };
122 
127 struct error: public std::exception {
129  std::string message;
131 
138 
139  error(mkldnn_status_t astatus, std::string amessage,
140  mkldnn_primitive_t aerror_primitive = 0)
141  : status(astatus)
142  , message(amessage)
143  , error_primitive(aerror_primitive, true)
144  {}
145 
153 
154  static void wrap_c_api(mkldnn_status_t status,
155  std::string message,
156  mkldnn_primitive_t *error_primitive = 0)
157  {
158  if (status != mkldnn_success) {
159  if (nullptr != error_primitive)
160  throw error(status, message, *error_primitive);
161  else
162  throw error(status, message, nullptr);
163  }
164  }
165 };
166 
167 inline primitive::at::operator primitive() const {
170  mkldnn_primitive_get_output(data.primitive,
171  data.output_index, &output),
172  "could not get an output primitive");
173  return primitive(const_cast<mkldnn_primitive_t>(output), true);
174 }
175 
179  "could not get primitive descriptor by primitive");
180  return pd;
181 }
183 
186 
187 #ifndef DOXYGEN_SHOULD_SKIP_THIS
188 template <> struct handle_traits<mkldnn_engine_t> {
189  static constexpr auto destructor = &mkldnn_engine_destroy;
190 };
191 #endif
192 
193 enum query {
195 
198 
201 
204 
206 
217 
227 };
229  return static_cast<mkldnn_query_t>(aquery);
230 }
231 
233 struct engine: public handle<mkldnn_engine_t> {
234  friend class primitive;
235  // gcc bug??? using handle::handle;
236 
238  enum kind {
242  cpu = mkldnn_cpu,
243  };
244 
248 
249  static size_t get_count(kind akind) {
250  return mkldnn_engine_get_count(convert_to_c(akind));
251  }
252 
258 
259  engine(kind akind, size_t index) {
260  mkldnn_engine_t aengine;
262  mkldnn_engine_create(&aengine,
263  convert_to_c(akind), index),
264  "could not create an engine");
265  reset(aengine);
266  }
267 
268  explicit engine(const mkldnn_engine_t& aengine)
269  : handle(aengine, true) {}
270 
272  mkldnn_engine_t engine_q;
275  mkldnn::convert_to_c(eengine), 0, &engine_q),
276  "could not get engine from primitive_desc");
277  reset(engine_q, true);
278  }
279 
280  template <class primitive_desc>
281  static engine query(const primitive_desc &pd) {
282  mkldnn_engine_t engine_q;
285  mkldnn::convert_to_c(eengine), 0, &engine_q),
286  "could not get engine from primitive_desc");
287 
288  return engine(engine_q);
289  }
290 
291 private:
292  static mkldnn_engine_kind_t convert_to_c(kind akind) {
293  return static_cast<mkldnn_engine_kind_t>(akind);
294  }
295 };
296 
298 
301 
303  static constexpr auto destructor = &mkldnn_primitive_desc_destroy;
304 };
305 
307 struct memory: public primitive {
308  private:
309  std::shared_ptr<char> _handle;
310 
311  public:
312  typedef std::vector<std::remove_extent<mkldnn_dims_t>::type> dims;
313 
314  template <typename T> static void validate_dims(std::vector<T> v) {
315  if (v.size() > TENSOR_MAX_DIMS)
317  "invalid dimensions");
318  }
319 
322  enum data_type {
324  f32 = mkldnn_f32,
325  s32 = mkldnn_s32,
326  s16 = mkldnn_s16,
327  s8 = mkldnn_s8,
328  u8 = mkldnn_u8,
329  };
330 
333  enum format {
334  format_undef = mkldnn_format_undef,
335  any = mkldnn_any,
336  blocked = mkldnn_blocked,
337  x = mkldnn_x,
338  nc = mkldnn_nc,
339  nchw = mkldnn_nchw,
340  nhwc = mkldnn_nhwc,
341  chwn = mkldnn_chwn,
342  nChw8c = mkldnn_nChw8c,
343  nChw16c = mkldnn_nChw16c,
344  oi = mkldnn_oi,
345  io = mkldnn_io,
346  oihw = mkldnn_oihw,
347  ihwo = mkldnn_ihwo,
348  hwio = mkldnn_hwio,
349  oIhw8i = mkldnn_oIhw8i,
350  oIhw16i = mkldnn_oIhw16i,
351  OIhw8i8o = mkldnn_OIhw8i8o,
352  OIhw16i16o = mkldnn_OIhw16i16o,
353  OIhw8o8i = mkldnn_OIhw8o8i,
354  OIhw16o16i = mkldnn_OIhw16o16i,
355  OIhw8i16o2i = mkldnn_OIhw8i16o2i,
356  OIhw8o16i2o = mkldnn_OIhw8o16i2o,
357  Oihw8o = mkldnn_Oihw8o,
358  Oihw16o = mkldnn_Oihw16o,
359  Ohwi8o = mkldnn_Ohwi8o,
360  Ohwi16o = mkldnn_Ohwi16o,
361  OhIw16o4i = mkldnn_OhIw16o4i,
362  goihw = mkldnn_goihw,
363  gOIhw8i8o = mkldnn_gOIhw8i8o,
364  gOIhw16i16o = mkldnn_gOIhw16i16o,
365  gOIhw8i16o2i = mkldnn_gOIhw8i16o2i,
366  gOIhw8o16i2o = mkldnn_gOIhw8o16i2o,
367  gOihw8o = mkldnn_gOihw8o,
368  gOihw16o = mkldnn_gOihw16o,
369  gOhwi8o = mkldnn_gOhwi8o,
370  gOhwi16o = mkldnn_gOhwi16o,
371  gOIhw8o8i = mkldnn_gOIhw8o8i,
372  gOIhw16o16i = mkldnn_gOIhw16o16i,
373  gOhIw16o4i = mkldnn_gOhIw16o4i,
374  };
375 
377  struct desc {
378  friend struct memory;
381 
387  desc(dims adims, data_type adata_type,
388  format aformat) {
389  validate_dims(adims);
391  mkldnn_memory_desc_init(&data, (int)adims.size(),
392  adims.size() == 0 ? nullptr : &adims[0],
393  convert_to_c(adata_type), convert_to_c(aformat)),
394  "could not initialize a memory descriptor");
395  }
396 
400  desc(const mkldnn_memory_desc_t &adata): data(adata) {}
401  };
402 
404  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
405  friend struct memory;
406 
407  // TODO: make private
409 
411  primitive_desc(const desc &adesc, const engine &aengine) {
415  &adesc.data, aengine.get()),
416  "could not initialize a memory primitive descriptor");
417  reset(result);
418  }
419 
423  return memory::desc(*memory_d); }
424 
429  size_t get_size() const {
431  }
432 
433  bool operator==(const primitive_desc &other) const {
434  return mkldnn_memory_primitive_desc_equal(get(), other.get());
435  }
436 
437  bool operator!=(const primitive_desc &other) const {
438  return !operator==(other);
439  }
440 
441  engine get_engine() { return engine::query(*this); }
442  };
443 
447  memory(const primitive &aprimitive): primitive(aprimitive) {}
451  memory(const primitive_desc &adesc) {
452  mkldnn_primitive_t result;
454  mkldnn_primitive_create(&result, adesc.get(), nullptr, nullptr),
455  "could not create a memory primitive");
456  reset(result);
457  auto _malloc = [](size_t size, int alignment) {
458  void *ptr;
459 #ifdef _WIN32
460  ptr = _aligned_malloc(size, alignment);
461  int rc = ((ptr)? 0 : errno);
462 #else
463  int rc = ::posix_memalign(&ptr, alignment, size);
464 #endif /* _WIN32 */
465  return (rc == 0) ? (char*)ptr : nullptr;
466  };
467  auto _free = [](char* p) {
468 #ifdef _WIN32
469  _aligned_free((void*)p);
470 #else
471  ::free((void*)p);
472 #endif /* _WIN32 */
473  };
474  _handle.reset(_malloc(adesc.get_size(), 4096), _free);
475  set_data_handle(_handle.get());
476  }
477 
478  memory(const primitive_desc &adesc, void *ahandle) {
479  mkldnn_primitive_t result;
481  mkldnn_primitive_create(&result, adesc.get(), nullptr, nullptr),
482  "could not create a memory primitive");
483  reset(result);
484  set_data_handle(ahandle);
485  }
486 
489  primitive_desc adesc;
492  &cdesc),
493  "could not get primitive descriptor from a memory primitive");
494  /* FIXME: no const_cast should be here */
495  adesc.reset(const_cast<mkldnn_primitive_desc_t>(cdesc), true);
496  return adesc;
497  }
498 
501  inline void *get_data_handle() const {
502  void *handle;
504  "could not get native handle");
505  return handle;
506  }
507 
508  inline void set_data_handle(void *handle) const {
510  "could not set native handle");
511  }
512 
513  // Must go away or be private:
515  return static_cast<mkldnn_data_type_t>(adata_type);
516  }
518  return static_cast<mkldnn_memory_format_t>(aformat);
519  }
520 
521 };
522 
524  return a == memory::convert_to_c(b);
525 }
527  return !(a == b);
528 }
530  return b == a;
531 }
533  return !(a == b);
534 }
535 
537  return a == memory::convert_to_c(b);
538 }
540  return !(a == b);
541 }
543  return b == a;
544 }
546  return !(a == b);
547 }
548 
551 };
553  return static_cast<mkldnn_padding_kind_t>(kind);
554 }
555 
556 enum prop_kind {
565 };
567  return static_cast<mkldnn_prop_kind_t>(kind);
568 }
569 
570 enum algorithm {
582 };
583 
588 };
589 
590 static mkldnn_alg_kind_t convert_to_c(algorithm aalgorithm) {
591  return static_cast<mkldnn_alg_kind_t>(aalgorithm);
592 }
593 
594 struct reorder : public primitive {
595  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
597  const memory::primitive_desc &output) {
600  &result, input.get(), output.get()),
601  "could not create a reorder primitive descriptor");
602  reset(result);
603  }
604 
605  engine get_engine() { return engine::query(*this); }
606  };
607 
608  reorder(const primitive_desc &aprimitive_desc,
609  const primitive::at &input, const memory &output) {
610  mkldnn_primitive_t result;
611  mkldnn_primitive_at_t inputs[] = { input.data };
612  const_mkldnn_primitive_t outputs[] = { output.get() };
614  aprimitive_desc.get(), inputs, outputs),
615  "could not create a reorder primitive");
616  reset(result);
617  }
618 
619  reorder(const primitive::at &input, const memory &output) {
620  auto input_mpd = memory(input).get_primitive_desc();
621  auto output_mpd = output.get_primitive_desc();
622 
623  auto reorder_d = primitive_desc(input_mpd, output_mpd);
624 
625  mkldnn_primitive_t result;
626  mkldnn_primitive_at_t inputs[] = { input.data };
627  const_mkldnn_primitive_t outputs[] = { output.get() };
629  reorder_d.get(), inputs, outputs),
630  "could not create a reorder primitive");
631  reset(result);
632  }
633 };
634 
635 struct view : public primitive {
636  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
638  memory::dims offsets) {
640 
642  &result, input.get(), &dims[0], &offsets[0]),
643  "could not create a view primitive descriptor");
644  reset(result);
645  }
646 
650  const_mkldnn_primitive_desc_t const_cdesc =
654  const_cdesc),
655  "could not clone a dst primitive descriptor");
656  adesc.reset(cdesc);
657  return adesc;
658  }
659 
660  engine get_engine() { return engine::query(*this); }
661  };
662 
663  view(const primitive_desc &view_pd, primitive::at input) {
664  mkldnn_primitive_t result;
665  mkldnn_primitive_at_t inputs[] = { input.data };
667  view_pd.get(), inputs, nullptr),
668  "could not create a view primitive");
669  reset(result);
670  }
671 
672  view(memory input, memory::dims dims, memory::dims offsets) {
673  mkldnn_primitive_t result;
674  primitive_desc view_pd(input.get_primitive_desc(), dims,
675  offsets);
676  mkldnn_primitive_at_t inputs[] = { {input.get(), 0} };
678  view_pd.get(), inputs, nullptr),
679  "could not create a view primitive");
680  reset(result);
681  }
682 };
683 
684 struct concat : public primitive {
685  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
686  std::vector<const_mkldnn_primitive_desc_t> cpp_to_c(
687  std::vector<memory::primitive_desc> inputs) {
688  std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
689  c_api_inputs.reserve(inputs.size());
690  auto convert_to_c = [](memory::primitive_desc d) { return d.get(); };
691  std::transform(inputs.begin(), inputs.end(),
692  std::back_inserter(c_api_inputs), convert_to_c);
693  return c_api_inputs;
694  }
695 
696  primitive_desc(const memory::desc &output, int concat_dimension,
697  std::vector<memory::primitive_desc> inputs) {
699 
700  auto c_api_inputs = cpp_to_c(inputs);
701 
703  &result, &output.data, (int)c_api_inputs.size(),
704  concat_dimension, &c_api_inputs[0]),
705  "could not create a concat primitive descriptor");
706  reset(result);
707  }
708 
709  primitive_desc(int concat_dimension,
710  std::vector<memory::primitive_desc> inputs) {
712 
713  auto c_api_inputs = cpp_to_c(inputs);
714 
716  &result, nullptr, (int)c_api_inputs.size(),
717  concat_dimension, &c_api_inputs[0]),
718  "could not create a concat primitive descriptor");
719  reset(result);
720  }
721 
725  const_mkldnn_primitive_desc_t const_cdesc =
728  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
729  "could not clone a dst primitive descriptor");
730  adesc.reset(cdesc);
731  return adesc;
732  }
733 
734  engine get_engine() { return engine::query(*this); }
735  };
736 
737  concat(const primitive_desc &concat_pd,
738  std::vector<primitive::at> &inputs, const memory &output) {
739  mkldnn_primitive_t result;
740 
741  std::vector<mkldnn_primitive_at_t> p_inputs;
742  for (size_t i = 0; i < inputs.size(); i++)
743  p_inputs.push_back(inputs[i].data);
744  const_mkldnn_primitive_t outputs[] = { output.get() };
745 
747  concat_pd.get(), &p_inputs[0], outputs),
748  "could not create a concat primitive");
749  reset(result);
750  }
751 };
752 
753 struct sum : public primitive {
754  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
755  std::vector<const_mkldnn_primitive_desc_t> cpp_to_c(
756  std::vector<memory::primitive_desc> inputs) {
757  std::vector<const_mkldnn_primitive_desc_t> c_api_inputs;
758  c_api_inputs.reserve(inputs.size());
759  auto convert_to_c = [](memory::primitive_desc d) { return d.get();};
760  std::transform(inputs.begin(), inputs.end(),
761  std::back_inserter(c_api_inputs), convert_to_c);
762  return c_api_inputs;
763  }
764 
765  primitive_desc(const memory::desc &output, std::vector<double> scale,
766  std::vector<memory::primitive_desc> inputs) {
768 
769  auto c_api_inputs = cpp_to_c(inputs);
770 
772  &result, &output.data, (int)c_api_inputs.size(),
773  &scale[0], &c_api_inputs[0]),
774  "could not create a sum primitive descriptor");
775  reset(result);
776  }
777 
778  primitive_desc(std::vector<double> scale,
779  std::vector<memory::primitive_desc> inputs) {
781 
782  auto c_api_inputs = cpp_to_c(inputs);
783 
785  &result, nullptr, (int)c_api_inputs.size(), &scale[0],
786  &c_api_inputs[0]),
787  "could not create a sum primitive descriptor");
788  reset(result);
789  }
790 
794  const_mkldnn_primitive_desc_t const_cdesc =
798  const_cdesc),
799  "could not clone a dst primitive descriptor");
800  adesc.reset(cdesc);
801  return adesc;
802  }
803 
804  engine get_engine() { return engine::query(*this); }
805  };
806 
807  sum(const primitive_desc &sum_pd,
808  std::vector<primitive::at> &inputs, const memory &output) {
809  mkldnn_primitive_t result;
810 
811  std::vector<mkldnn_primitive_at_t> p_inputs;
812  for (size_t i = 0; i < inputs.size(); i++)
813  p_inputs.push_back(inputs[i].data);
814  const_mkldnn_primitive_t outputs[] = { output.get() };
815 
817  sum_pd.get(), &p_inputs[0], outputs),
818  "could not create a sum primitive");
819  reset(result);
820  }
821 };
822 #ifndef DOXYGEN_SHOULD_SKIP_THIS
823 template <> struct handle_traits<mkldnn_stream_t> {
824  static constexpr auto destructor = &mkldnn_stream_destroy;
825 };
826 #endif
827 
828 struct stream: public handle<mkldnn_stream_t> {
829  using handle::handle;
830 
834 
836  return static_cast<mkldnn_stream_kind_t>(akind);
837  }
839  stream(kind akind) {
840  mkldnn_stream_t astream;
842  convert_to_c(akind)),
843  "could not create a stream");
844  reset(astream);
845  }
846 
851  stream &submit(std::vector<primitive> primitives) {
852  // TODO: find a proper way to convert vector<primitive> to
853  // vector<mkldnn_primitive_t>
854  if (primitives.size() == 0) return *this;
855  std::vector<mkldnn_primitive_t> c_api_primitives;
856  c_api_primitives.reserve(primitives.size());
857  auto convert_to_c = [](primitive p) { return p.get(); };
858  std::transform(primitives.begin(), primitives.end(),
859  std::back_inserter(c_api_primitives), convert_to_c);
860 
861  mkldnn_primitive_t c_api_error_primitive;
863  mkldnn_stream_submit(get(),
864  c_api_primitives.size(), &c_api_primitives[0],
865  &c_api_error_primitive),
866  "could not submit primitives to a stream",
867  &c_api_error_primitive);
868 
869  return *this;
870  }
871 
878  bool wait(bool block = true) {
879  mkldnn_primitive_t c_api_error_primitive;
880  mkldnn_status_t status = mkldnn_stream_wait(get(),
881  block, &c_api_error_primitive);
882  if (status != mkldnn_success
883  && status != mkldnn_try_again)
884  error::wrap_c_api(status, "could not wait on a stream",
885  &c_api_error_primitive);
886  return (status == mkldnn_success);
887  }
888 
890  mkldnn_primitive_t c_api_error_primitive;
892  mkldnn_stream_rerun(get(), &c_api_error_primitive),
893  "could not rerun a stream", &c_api_error_primitive);
894  return *this;
895  }
896 };
897 
899  struct desc {
901  desc(prop_kind aprop_kind, algorithm aalgorithm,
902  const memory::desc &src_desc,
903  const memory::desc &weights_desc,
904  const memory::desc &bias_desc,
905  const memory::desc &dst_desc,
906  const memory::dims strides,
907  const memory::dims padding_l,
908  const memory::dims padding_r,
909  const padding_kind apadding_kind) {
910  memory::validate_dims(strides);
911  memory::validate_dims(padding_l);
912  memory::validate_dims(padding_r);
914  mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm),
915  &src_desc.data, &weights_desc.data, &bias_desc.data,
916  &dst_desc.data, &strides[0], &padding_l[0], &padding_r[0],
917  mkldnn::convert_to_c(apadding_kind)),
918  "could not create a convolution forward descriptor");
919  }
920  desc(prop_kind aprop_kind, algorithm aalgorithm,
921  const memory::desc &src_desc,
922  const memory::desc &weights_desc,
923  const memory::desc &dst_desc,
924  const memory::dims strides,
925  const memory::dims padding_l,
926  const memory::dims padding_r,
927  const padding_kind apadding_kind) {
928  memory::validate_dims(strides);
929  memory::validate_dims(padding_l);
930  memory::validate_dims(padding_r);
932  mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm),
933  &src_desc.data, &weights_desc.data, nullptr,
934  &dst_desc.data, &strides[0], &padding_l[0], &padding_r[0],
935  mkldnn::convert_to_c(apadding_kind)),
936  "could not create a convolution forward descriptor");
937  }
938  desc(prop_kind aprop_kind, algorithm aalgorithm,
939  const memory::desc &src_desc,
940  const memory::desc &weights_desc,
941  const memory::desc &bias_desc,
942  const memory::desc &dst_desc,
943  const memory::dims strides,
944  const memory::dims dilates,
945  const memory::dims padding_l,
946  const memory::dims padding_r,
947  const padding_kind apadding_kind) {
948  memory::validate_dims(strides);
949  memory::validate_dims(dilates);
950  memory::validate_dims(padding_l);
951  memory::validate_dims(padding_r);
954  mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm),
955  &src_desc.data, &weights_desc.data, &bias_desc.data,
956  &dst_desc.data, &strides[0], &dilates[0],
957  &padding_l[0], &padding_r[0],
958  mkldnn::convert_to_c(apadding_kind)),
959  "could not create a dilated convolution forward descriptor");
960  }
961  desc(prop_kind aprop_kind, algorithm aalgorithm,
962  const memory::desc &src_desc,
963  const memory::desc &weights_desc,
964  const memory::desc &dst_desc,
965  const memory::dims strides,
966  const memory::dims dilates,
967  const memory::dims padding_l,
968  const memory::dims padding_r,
969  const padding_kind apadding_kind) {
970  memory::validate_dims(strides);
971  memory::validate_dims(dilates);
972  memory::validate_dims(padding_l);
973  memory::validate_dims(padding_r);
976  mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm),
977  &src_desc.data, &weights_desc.data, nullptr,
978  &dst_desc.data, &strides[0], &dilates[0],
979  &padding_l[0], &padding_r[0],
980  mkldnn::convert_to_c(apadding_kind)),
981  "could not create a dilated convolution forward descriptor");
982  }
983  };
984  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
985  primitive_desc(const desc &adesc, const engine &aengine) {
988  &result, &adesc.data, aengine.get(), nullptr),
989  "could not create a convolution forward primitive descriptor");
990  reset(result);
991  }
992 
996  const_mkldnn_primitive_desc_t const_cdesc =
999  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1000  "could not clone a src primititve descriptor");
1001  adesc.reset(cdesc);
1002  return adesc;
1003  }
1004 
1006  memory::primitive_desc adesc;
1008  const_mkldnn_primitive_desc_t const_cdesc =
1011  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1012  "could not clone a weights primitive descriptor");
1013  adesc.reset(cdesc);
1014  return adesc;
1015  }
1016 
1018  memory::primitive_desc adesc;
1020  const_mkldnn_primitive_desc_t const_cdesc =
1023  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1024  "could not clone a bias primitive descriptor");
1025  adesc.reset(cdesc);
1026  return adesc;
1027  }
1028 
1030  memory::primitive_desc adesc;
1032  const_mkldnn_primitive_desc_t const_cdesc =
1035  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1036  "could not clone a dst primitive descriptor");
1037  adesc.reset(cdesc);
1038  return adesc;
1039  }
1040 
1041  engine get_engine() { return engine::query(*this); }
1042  };
1043 
1044  convolution_forward(const primitive_desc &aprimitive_desc,
1045  const primitive::at &src, const primitive::at &weights,
1046  const primitive::at &bias, const memory &dst) {
1047  mkldnn_primitive_t result;
1048  mkldnn_primitive_at_t inputs[] = { src.data, weights.data,
1049  bias.data };
1050  const_mkldnn_primitive_t outputs[] = { dst.get() };
1052  aprimitive_desc.get(), inputs, outputs),
1053  "could not create a convolution forward bias primitive");
1054  reset(result);
1055  }
1056 
1057  convolution_forward(const primitive_desc &aprimitive_desc,
1058  const primitive::at &src, const primitive::at &weights,
1059  const memory &dst) {
1060  mkldnn_primitive_t result;
1061  mkldnn_primitive_at_t inputs[] = { src.data, weights.data };
1062  const_mkldnn_primitive_t outputs[] = { dst.get() };
1064  aprimitive_desc.get(), inputs, outputs),
1065  "could not create a convolution forward primitive");
1066  reset(result);
1067  }
1068 };
1069 
1071  struct desc {
1073  desc(algorithm aalgorithm,
1074  const memory::desc &diff_src_desc,
1075  const memory::desc &weights_desc,
1076  const memory::desc &diff_dst_desc,
1077  const memory::dims strides,
1078  const memory::dims padding_l,
1079  const memory::dims padding_r,
1080  const padding_kind apadding_kind) {
1081  memory::validate_dims(strides);
1082  memory::validate_dims(padding_l);
1083  memory::validate_dims(padding_r);
1085  &data, convert_to_c(aalgorithm), &diff_src_desc.data,
1086  &weights_desc.data, &diff_dst_desc.data,
1087  &strides[0], &padding_l[0], &padding_r[0],
1088  mkldnn::convert_to_c(apadding_kind)),
1089  "could not create a convolution backward data descriptor");
1090  }
1091  };
1092  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1093  primitive_desc(const desc &adesc, const engine &aengine,
1095  &hint_fwd_primitive_desc) {
1096  mkldnn_primitive_desc_t result;
1098  &result, &adesc.data, aengine.get(),
1099  hint_fwd_primitive_desc.get()),
1100  "could not create a convolution backward data primitive descriptor");
1101  reset(result);
1102  }
1104  memory::primitive_desc adesc;
1106  const_mkldnn_primitive_desc_t const_cdesc =
1109  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1110  "could not clone a diff_src primititve descriptor");
1111  adesc.reset(cdesc);
1112  return adesc;
1113  }
1114 
1116  memory::primitive_desc adesc;
1118  const_mkldnn_primitive_desc_t const_cdesc =
1121  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1122  "could not clone a weights primitive descriptor");
1123  adesc.reset(cdesc);
1124  return adesc;
1125  }
1126 
1128  memory::primitive_desc adesc;
1130  const_mkldnn_primitive_desc_t const_cdesc =
1133  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1134  "could not clone a diff_dst primitive descriptor");
1135  adesc.reset(cdesc);
1136  return adesc;
1137  }
1138 
1139  engine get_engine() { return engine::query(*this); }
1140  };
1141 
1143  const primitive::at &diff_dst, const primitive::at &weights,
1144  const memory &diff_src) {
1145  mkldnn_primitive_t result;
1146  mkldnn_primitive_at_t inputs[] = { diff_dst.data, weights.data };
1147  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
1149  aprimitive_desc.get(), inputs, outputs),
1150  "could not create a convolution backward data primitive");
1151  reset(result);
1152  }
1153 };
1154 
1156  struct desc {
1158  desc(algorithm aalgorithm,
1159  const memory::desc &src_desc,
1160  const memory::desc &diff_weights_desc,
1161  const memory::desc &diff_bias_desc,
1162  const memory::desc &diff_dst_desc,
1163  const memory::dims strides,
1164  const memory::dims padding_l,
1165  const memory::dims padding_r,
1166  const padding_kind apadding_kind) {
1167  memory::validate_dims(strides);
1168  memory::validate_dims(padding_l);
1169  memory::validate_dims(padding_r);
1171  &data, convert_to_c(aalgorithm), &src_desc.data,
1172  &diff_weights_desc.data, &diff_bias_desc.data,
1173  &diff_dst_desc.data,
1174  &strides[0], &padding_l[0], &padding_r[0],
1175  mkldnn::convert_to_c(apadding_kind)),
1176  "could not create a convolution backward weights descriptor");
1177  }
1178  desc(algorithm aalgorithm,
1179  const memory::desc &src_desc,
1180  const memory::desc &diff_weights_desc,
1181  const memory::desc &diff_dst_desc,
1182  const memory::dims strides,
1183  const memory::dims padding_l,
1184  const memory::dims padding_r,
1185  const padding_kind apadding_kind) {
1186  memory::validate_dims(strides);
1187  memory::validate_dims(padding_l);
1188  memory::validate_dims(padding_r);
1190  &data, convert_to_c(aalgorithm), &src_desc.data,
1191  &diff_weights_desc.data, nullptr, &diff_dst_desc.data,
1192  &strides[0], &padding_l[0], &padding_r[0],
1193  mkldnn::convert_to_c(apadding_kind)),
1194  "could not create a convolution backward weights descriptor");
1195  }
1196  };
1197 
1198  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1199  primitive_desc(const desc &adesc, const engine &aengine,
1201  &hint_fwd_primitive_desc) {
1202  mkldnn_primitive_desc_t result;
1204  &result, &adesc.data, aengine.get(),
1205  hint_fwd_primitive_desc.get()),
1206  "could not create a convolution backward weights primitive descriptor");
1207  reset(result);
1208  }
1210  memory::primitive_desc adesc;
1212  const_mkldnn_primitive_desc_t const_cdesc =
1215  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1216  "could not clone a src primititve descriptor");
1217  adesc.reset(cdesc);
1218  return adesc;
1219  }
1220 
1222  memory::primitive_desc adesc;
1224  const_mkldnn_primitive_desc_t const_cdesc =
1227  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1228  "could not clone a diff_weights primitive descriptor");
1229  adesc.reset(cdesc);
1230  return adesc;
1231  }
1232 
1234  memory::primitive_desc adesc;
1236  const_mkldnn_primitive_desc_t const_cdesc =
1239  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1240  "could not clone a diff_bias primitive descriptor");
1241  adesc.reset(cdesc);
1242  return adesc;
1243  }
1244 
1246  memory::primitive_desc adesc;
1248  const_mkldnn_primitive_desc_t const_cdesc =
1251  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1252  "could not clone a diff_dst primitive descriptor");
1253  adesc.reset(cdesc);
1254  return adesc;
1255  }
1256 
1257  engine get_engine() { return engine::query(*this); }
1258  };
1259 
1261  const primitive::at &src, const primitive::at &diff_dst,
1262  const memory &diff_weights, const memory &diff_bias) {
1263  mkldnn_primitive_t result;
1264  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data };
1265  const_mkldnn_primitive_t outputs[] = { diff_weights.get(),
1266  diff_bias.get() };
1268  aprimitive_desc.get(), inputs, outputs),
1269  "could not create a convolution backward weights primitive");
1270  reset(result);
1271  }
1273  const primitive::at &src, const primitive::at &diff_dst,
1274  const memory &diff_weights) {
1275  mkldnn_primitive_t result;
1276  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data };
1277  const_mkldnn_primitive_t outputs[] = { diff_weights.get() };
1279  aprimitive_desc.get(), inputs, outputs),
1280  "could not create a convolution backward weights primitive");
1281  reset(result);
1282  }
1283 };
1284 
1286  struct desc {
1289  const double negative_slope)
1290  {
1292  &conv_desc.data, negative_slope),
1293  "could not create a convolution_relu_forward descriptor");
1294  }
1295  };
1296 
1297  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1298  primitive_desc(const desc &adesc, const engine &aengine) {
1299  mkldnn_primitive_desc_t result;
1301  &result, &adesc.data, aengine.get(), nullptr),
1302  "could not create a convolution relu forward descriptor");
1303  reset(result);
1304  }
1305 
1306  engine get_engine() { return engine::query(*this); }
1307  };
1308 
1310  const primitive::at &src, const primitive::at &weights,
1311  const primitive::at &bias, const memory &dst) {
1312  mkldnn_primitive_t result;
1313  mkldnn_primitive_at_t inputs[] = { src.data, weights.data,
1314  bias.data };
1315  const_mkldnn_primitive_t outputs[] = { dst.get() };
1317  aprimitive_desc.get(), inputs, outputs),
1318  "could not create a convolution relu forward primitive");
1319  reset(result);
1320  }
1321 
1323  const primitive::at &src, const primitive::at &weights,
1324  const memory &dst) {
1325  mkldnn_primitive_t result;
1326  mkldnn_primitive_at_t inputs[] = { src.data, weights.data };
1327  const_mkldnn_primitive_t outputs[] = { dst.get() };
1329  aprimitive_desc.get(), inputs, outputs),
1330  "could not create a convolution relu forward primitive");
1331  reset(result);
1332  }
1333 };
1334 struct lrn_forward : public primitive {
1335  struct desc {
1337  desc(prop_kind aprop_kind, algorithm aalgorithm,
1338  const memory::desc &src_desc,
1339  int local_size, double alpha, double beta, double k)
1340  {
1342  mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm),
1343  &src_desc.data, local_size, alpha, beta, k),
1344  "could not create a lrn forward descriptor");
1345  }
1346  desc(prop_kind aprop_kind, algorithm aalgorithm,
1347  const memory::desc &src_desc,
1348  int local_size, double alpha, double beta)
1349  {
1351  mkldnn::convert_to_c(aprop_kind), convert_to_c(aalgorithm),
1352  &src_desc.data, local_size, alpha, beta, double(1.0)),
1353  "could not create a lrn forward descriptor");
1354  }
1355  };
1356 
1357  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1358  primitive_desc(const desc &adesc, const engine &aengine) {
1359  mkldnn_primitive_desc_t result;
1361  &result, &adesc.data, aengine.get(), nullptr),
1362  "could not create a lrn forward primitive descriptor");
1363  reset(result);
1364  }
1365 
1367  memory::primitive_desc adesc;
1369  const_mkldnn_primitive_desc_t const_cdesc =
1372  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1373  "could not clone a src primitive descriptor");
1374  adesc.reset(cdesc);
1375  return adesc;
1376  }
1377 
1379  memory::primitive_desc adesc;
1381  const_mkldnn_primitive_desc_t const_ldesc =
1384  error::wrap_c_api(mkldnn_primitive_desc_clone(&ldesc, const_ldesc),
1385  "could not clone a workspace primitive descriptor");
1386  adesc.reset(ldesc);
1387  return adesc;
1388  }
1389 
1391  memory::primitive_desc adesc;
1393  const_mkldnn_primitive_desc_t const_cdesc =
1396  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1397  "could not clone a dst primitive descriptor");
1398  adesc.reset(cdesc);
1399  return adesc;
1400  }
1401 
1402  engine get_engine() { return engine::query(*this); }
1403  };
1404 
1405  lrn_forward(const primitive_desc &aprimitive_desc,
1406  const primitive::at &src, const memory &workspace,
1407  const memory &dst) {
1408  mkldnn_primitive_t result;
1409  mkldnn_primitive_at_t inputs[] = { src.data };
1410  const_mkldnn_primitive_t outputs[] = { dst.get(),
1411  workspace.get() };
1413  aprimitive_desc.get(), inputs, outputs),
1414  "could not create a lrn forward primitive");
1415  reset(result);
1416  }
1417 
1418  lrn_forward(const primitive_desc &aprimitive_desc,
1419  const primitive::at &src, const memory &dst) {
1420  mkldnn_primitive_t result;
1421  mkldnn_primitive_at_t inputs[] = { src.data };
1422  const_mkldnn_primitive_t outputs[] = { dst.get() };
1424  aprimitive_desc.get(), inputs, outputs),
1425  "could not create a lrn forward primitive");
1426  reset(result);
1427  }
1428 };
1429 
1430 struct lrn_backward : public primitive {
1431  struct desc {
1433  desc(algorithm aalgorithm,
1434  const memory::desc &data_desc,
1435  const memory::desc &diff_data_desc,
1436  int local_size, double alpha, double beta, double k)
1437  {
1439  convert_to_c(aalgorithm), &diff_data_desc.data,
1440  &data_desc.data, local_size, alpha, beta, k),
1441  "could not create a lrn backward descriptor");
1442  }
1443  desc(algorithm aalgorithm,
1444  const memory::desc &data_desc,
1445  const memory::desc &diff_data_desc,
1446  int local_size, double alpha, double beta)
1447  {
1449  convert_to_c(aalgorithm), &diff_data_desc.data,
1450  &data_desc.data, local_size, alpha, beta, double(1.0)),
1451  "could not create a lrn backward descriptor");
1452  }
1453  };
1454 
1455  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1456  primitive_desc(const desc &adesc, const engine &aengine,
1457  const lrn_forward::primitive_desc &hint_fwd_primitive_desc) {
1458  mkldnn_primitive_desc_t result;
1460  &result, &adesc.data, aengine.get(),
1461  hint_fwd_primitive_desc.get()),
1462  "could not create a backward lrn primitive descriptor");
1463  reset(result);
1464  }
1465 
1467  memory::primitive_desc adesc;
1469  const_mkldnn_primitive_desc_t const_cdesc =
1472  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1473  "could not clone a diff_src primitive descriptor");
1474  adesc.reset(cdesc);
1475  return adesc;
1476  }
1477 
1479  memory::primitive_desc adesc;
1481  const_mkldnn_primitive_desc_t const_ldesc =
1484  error::wrap_c_api(mkldnn_primitive_desc_clone(&ldesc, const_ldesc),
1485  "could not clone a workspace primitive descriptor");
1486  adesc.reset(ldesc);
1487  return adesc;
1488  }
1489 
1491  memory::primitive_desc adesc;
1493  const_mkldnn_primitive_desc_t const_cdesc =
1496  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1497  "could not clone a diff_dst primitive descriptor");
1498  adesc.reset(cdesc);
1499  return adesc;
1500  }
1501 
1502  engine get_engine() { return engine::query(*this); }
1503  };
1504 
1505  lrn_backward(const primitive_desc &aprimitive_desc,
1506  const primitive::at &src, const primitive::at &diff_dst,
1507  const primitive::at &workspace, const memory &diff_src) {
1508  mkldnn_primitive_t result;
1509  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data,
1510  workspace.data };
1511  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
1513  aprimitive_desc.get(), inputs, outputs),
1514  "could not create a lrn backward primitive");
1515  reset(result);
1516  }
1517 
1518  lrn_backward(const primitive_desc &aprimitive_desc,
1519  const primitive::at &src, const primitive::at &diff_dst,
1520  const memory &diff_src) {
1521  mkldnn_primitive_t result;
1522  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data };
1523  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
1525  aprimitive_desc.get(), inputs, outputs),
1526  "could not create a lrn backward primitive");
1527  reset(result);
1528  }
1529 };
1530 
1531 struct pooling_forward : public primitive {
1532  struct desc {
1534  desc(prop_kind aprop_kind, algorithm aalgorithm,
1535  const memory::desc &src_desc,
1536  const memory::desc &dst_desc,
1537  const memory::dims strides,
1538  const memory::dims kernel,
1539  const memory::dims padding_l,
1540  const memory::dims padding_r,
1541  const padding_kind apadding_kind) {
1542  memory::validate_dims(strides);
1543  memory::validate_dims(kernel);
1544  memory::validate_dims(padding_l);
1545  memory::validate_dims(padding_r);
1547  mkldnn::convert_to_c(aprop_kind),
1548  convert_to_c(aalgorithm),
1549  &src_desc.data, &dst_desc.data,
1550  &strides[0], &kernel[0],
1551  &padding_l[0], &padding_r[0],
1552  mkldnn::convert_to_c(apadding_kind)),
1553  "could not init a forward pooling descriptor");
1554  }
1555  };
1556 
1557  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1558  primitive_desc(const desc &adesc, const engine &aengine) {
1559  mkldnn_primitive_desc_t result;
1561  &result, &adesc.data, aengine.get(), nullptr),
1562  "could not create a forward pooling primitive descriptor");
1563  reset(result);
1564  }
1565 
1567  memory::primitive_desc adesc;
1569  const_mkldnn_primitive_desc_t const_cdesc =
1572  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1573  "could not clone a workspace primititve descriptor");
1574  adesc.reset(cdesc);
1575  return adesc;
1576  }
1577 
1579  memory::primitive_desc adesc;
1581  const_mkldnn_primitive_desc_t const_cdesc =
1584  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1585  "could not clone a dst primitive descriptor");
1586  adesc.reset(cdesc);
1587  return adesc;
1588  }
1589 
1590  engine get_engine() { return engine::query(*this); }
1591  };
1592 
1593  pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src,
1594  const memory &dst) {
1595  mkldnn_primitive_t result;
1596  mkldnn_primitive_at_t inputs[] = { src.data };
1597  const_mkldnn_primitive_t outputs[] = { dst.get(), nullptr };
1599  aprimitive_desc.get(), inputs, outputs),
1600  "could not create a pooling forward primitive");
1601  reset(result);
1602  }
1603 
1604  pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src,
1605  const memory &dst, const memory &workspace) {
1606  mkldnn_primitive_t result;
1607  mkldnn_primitive_at_t inputs[] = { src.data };
1608  const_mkldnn_primitive_t outputs[] = { dst.get(), workspace.get() };
1610  aprimitive_desc.get(), inputs, outputs),
1611  "could not create a pooling forward primitive");
1612  reset(result);
1613  }
1614 };
1615 
1616 struct pooling_backward : public primitive {
1617  struct desc {
1619  desc(algorithm aalgorithm,
1620  const memory::desc &diff_src_desc,
1621  const memory::desc &diff_dst_desc,
1622  const memory::dims &strides,
1623  const memory::dims &kernel,
1624  const memory::dims &padding_l,
1625  const memory::dims &padding_r,
1626  const padding_kind apadding_kind) {
1627  memory::validate_dims(strides);
1628  memory::validate_dims(kernel);
1629  memory::validate_dims(padding_l);
1630  memory::validate_dims(padding_r);
1632  convert_to_c(aalgorithm),
1633  &diff_src_desc.data, &diff_dst_desc.data,
1634  &strides[0], &kernel[0],
1635  &padding_l[0], &padding_r[0],
1636  mkldnn::convert_to_c(apadding_kind)),
1637  "could not init a backward pooling descriptor");
1638  }
1639  };
1640 
1641  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1642  primitive_desc(const desc &adesc, const engine &aengine,
1643  const pooling_forward::primitive_desc &hint_fwd_primitive_desc) {
1644  mkldnn_primitive_desc_t result;
1646  &result, &adesc.data, aengine.get(),
1647  hint_fwd_primitive_desc.get()),
1648  "could not create a backward pooling primitive descriptor");
1649  reset(result);
1650  }
1651 
1653  memory::primitive_desc adesc;
1655  const_mkldnn_primitive_desc_t const_cdesc =
1658  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1659  "could not clone a diff src primitive descriptor");
1660  adesc.reset(cdesc);
1661  return adesc;
1662  }
1663 
1664  engine get_engine() { return engine::query(*this); }
1665  };
1666 
1667  pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst,
1668  const memory &diff_src) {
1669  mkldnn_primitive_t result;
1670  mkldnn_primitive_at_t inputs[] = { diff_dst.data };
1671  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
1673  aprimitive_desc.get(), inputs, outputs),
1674  "could not create a pooling backward primitive");
1675  reset(result);
1676  }
1677 
1678  pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst,
1679  const primitive::at &workspace, const memory &diff_src) {
1680  mkldnn_primitive_t result;
1681  mkldnn_primitive_at_t inputs[] = { diff_dst.data, workspace.data };
1682  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
1684  aprimitive_desc.get(), inputs, outputs),
1685  "could not create a pooling backward primitive");
1686  reset(result);
1687  }
1688 };
1689 
1690 struct eltwise_forward : public primitive {
1691  struct desc {
1693  template <typename T>
1694  desc(prop_kind aprop_kind, algorithm alg_kind,
1695  const memory::desc &src_desc, T alpha = 0, T beta = 0) {
1697  mkldnn::convert_to_c(aprop_kind),
1698  mkldnn::convert_to_c(alg_kind), &src_desc.data,
1699  static_cast<double>(alpha), static_cast<double>(beta)),
1700  "could not create a eltwise forward descriptor");
1701  }
1702 
1704  template <typename T>
1705  MKLDNN_DEPRECATED
1706  desc(prop_kind aprop_kind, const memory::desc &src_desc,
1707  T negative_slope)
1708  : desc(aprop_kind, eltwise_relu, src_desc, negative_slope) {}
1709  };
1710 
1711  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1712  primitive_desc(const desc &adesc, const engine &aengine) {
1713  mkldnn_primitive_desc_t result;
1715  &result, &adesc.data, aengine.get(), nullptr),
1716  "could not create a eltwise forward primitive descriptor");
1717  reset(result);
1718  }
1719 
1721  memory::primitive_desc adesc;
1723  const_mkldnn_primitive_desc_t const_cdesc =
1727  mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1728  "could not clone a dst primitive descriptor");
1729  adesc.reset(cdesc);
1730  return adesc;
1731  }
1732 
1733  engine get_engine() { return engine::query(*this); }
1734  };
1735 
1736  eltwise_forward(const primitive_desc &aprimitive_desc,
1737  const primitive::at &src, const memory &dst) {
1738  mkldnn_primitive_t result;
1739  mkldnn_primitive_at_t inputs[] = { src.data };
1740  const_mkldnn_primitive_t outputs[] = { dst.get() };
1742  aprimitive_desc.get(), inputs, outputs),
1743  "could not create a eltwise forward primitive");
1744  reset(result);
1745  }
1746 };
1747 
1749 
1750 struct eltwise_backward : public primitive {
1751  struct desc {
1753 
1754  template <typename T>
1755  desc(algorithm alg_kind, const memory::desc &diff_data_desc,
1756  const memory::desc &data_desc, T alpha = 0, T beta = 0) {
1758  mkldnn::convert_to_c(alg_kind), &diff_data_desc.data,
1759  &data_desc.data, static_cast<double>(alpha),
1760  static_cast<double>(beta)),
1761  "could not create a eltwise backward descriptor");
1762  }
1763 
1765  template <typename T>
1766  MKLDNN_DEPRECATED
1767  desc(const memory::desc &diff_data_desc, const memory::desc &data_desc,
1768  T negative_slope): desc(eltwise_relu, diff_data_desc, data_desc,
1769  negative_slope) {}
1770  };
1771 
1772  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1773  primitive_desc(const desc &adesc, const engine &aengine,
1774  const eltwise_forward::primitive_desc &hint_fwd_primitive_desc) {
1775  mkldnn_primitive_desc_t result;
1777  &result, &adesc.data, aengine.get(),
1778  hint_fwd_primitive_desc.get()),
1779  "could not create a eltwise backward primitive descriptor");
1780  reset(result);
1781  }
1782 
1784  memory::primitive_desc adesc;
1786  const_mkldnn_primitive_desc_t const_cdesc =
1789  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
1790  "could not clone a diff src primitive descriptor");
1791  adesc.reset(cdesc);
1792  return adesc;
1793  }
1794 
1795  engine get_engine() { return engine::query(*this); }
1796  };
1797 
1798  eltwise_backward(const primitive_desc &aprimitive_desc,
1799  const primitive::at &src, const primitive::at &diff_dst,
1800  const memory &diff_src) {
1801  mkldnn_primitive_t result;
1802  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data };
1803  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
1805  aprimitive_desc.get(), inputs, outputs),
1806  "could not create a eltwise backward primitive");
1807  reset(result);
1808  }
1809 };
1810 
1812 
1813 struct softmax_forward : public primitive {
1814  struct desc {
1816  desc(prop_kind aprop_kind, const memory::desc &data_desc,
1817  int softmax_axis) {
1819  mkldnn::convert_to_c(aprop_kind), &data_desc.data,
1820  softmax_axis),
1821  "could not create a softmax forward descriptor");
1822  }
1823  };
1824 
1825  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1826  primitive_desc(const desc &adesc, const engine &aengine) {
1827  mkldnn_primitive_desc_t result;
1829  &result, &adesc.data, aengine.get(), nullptr),
1830  "could not create a softmax forward primitive descriptor");
1831  reset(result);
1832  }
1833 
1834  engine get_engine() { return engine::query(*this); }
1835  };
1836 
1837  softmax_forward(const primitive_desc &aprimitive_desc,
1838  const primitive::at &src, const memory &dst) {
1839  mkldnn_primitive_t result;
1840  mkldnn_primitive_at_t inputs[] = { src.data };
1841  const_mkldnn_primitive_t outputs[] = { dst.get() };
1843  aprimitive_desc.get(), inputs, outputs),
1844  "could not create a softmax forward primitive");
1845  reset(result);
1846  }
1847 };
1848 
1850  struct desc {
1852  template <typename T>
1853  desc(prop_kind aprop_kind, const memory::desc &src_desc, T epsilon,
1854  unsigned flags) {
1857  mkldnn::convert_to_c(aprop_kind), &src_desc.data,
1858  static_cast<double>(epsilon), flags),
1859  "could not create a batch normalization forward descriptor");
1860  }
1861  };
1862 
1863  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
1864  primitive_desc(const desc &adesc, const engine &aengine) {
1865  mkldnn_primitive_desc_t result;
1867  &result, &adesc.data, aengine.get(), nullptr),
1868  "could not create a batch normalization forward primitive descriptor");
1869  reset(result);
1870  }
1871 
1873  memory::primitive_desc adesc;
1874  mkldnn_primitive_desc_t bndesc;
1875  const_mkldnn_primitive_desc_t const_bndesc =
1879  const_bndesc),
1880  "could not clone a weights primitive descriptor");
1881  adesc.reset(bndesc);
1882  return adesc;
1883  }
1884 
1886  memory::primitive_desc aprimitive_desc;
1887  mkldnn_primitive_desc_t bndesc;
1891  "could not get a batch-normalization descriptor");
1892  const_mkldnn_primitive_desc_t const_bndesc =
1893  (p->flags & use_global_stats) ?
1899  const_bndesc),
1900  "could not clone a mean primitive descriptor");
1901  aprimitive_desc.reset(bndesc);
1902  return aprimitive_desc;
1903  }
1904 
1906  memory::primitive_desc aprimitive_desc;
1907  mkldnn_primitive_desc_t bndesc;
1911  "could not get a batch-normalization descriptor");
1912  const_mkldnn_primitive_desc_t const_bndesc =
1913  (p->flags & use_global_stats) ?
1919  const_bndesc),
1920  "could not clone a variance primitive descriptor");
1921  aprimitive_desc.reset(bndesc);
1922  return aprimitive_desc;
1923  }
1924 
1926  memory::primitive_desc adesc;
1928  const_mkldnn_primitive_desc_t const_cdesc =
1932  const_cdesc),
1933  "could not clone a dst primitive descriptor");
1934  adesc.reset(cdesc);
1935  return adesc;
1936  }
1937 
1938  engine get_engine() { return engine::query(*this); }
1939  };
1940 
1942  const primitive::at &src, const primitive::at &mean,
1943  const primitive::at &variance, const primitive::at &weights,
1944  const memory &dst) {
1945  mkldnn_primitive_t result;
1946  mkldnn_primitive_at_t inputs[] = { src.data,
1947  mean.data, variance.data, weights.data };
1948  const_mkldnn_primitive_t outputs[] = { dst.get() };
1950  aprimitive_desc.get(), inputs, outputs),
1951  "could not create a batch normalization forward primitive");
1952  reset(result);
1953  }
1954 
1956  const primitive::at &src, const primitive::at &mean,
1957  const primitive::at &variance, const memory &dst) {
1958  mkldnn_primitive_t result;
1959  mkldnn_primitive_at_t inputs[] = { src.data,
1960  mean.data, variance.data };
1961  const_mkldnn_primitive_t outputs[] = { dst.get() };
1963  aprimitive_desc.get(), inputs, outputs),
1964  "could not create a batch normalization forward primitive");
1965  reset(result);
1966  }
1967 
1969  const primitive::at &src, const primitive::at &weights,
1970  const memory &dst, const memory &mean, const memory &variance) {
1971  mkldnn_primitive_t result;
1972  mkldnn_primitive_at_t inputs[] = { src.data, weights.data };
1973  const_mkldnn_primitive_t outputs[] = { dst.get(),
1974  mean.get(), variance.get() };
1976  aprimitive_desc.get(), inputs, outputs),
1977  "could not create a batch normalization forward primitive");
1978  reset(result);
1979  }
1980 
1982  const primitive::at &src, const memory &dst, const memory &mean,
1983  const memory &variance) {
1984  mkldnn_primitive_t result;
1985  mkldnn_primitive_at_t inputs[] = { src.data };
1986  const_mkldnn_primitive_t outputs[] = { dst.get(),
1987  mean.get(), variance.get() };
1989  aprimitive_desc.get(), inputs, outputs),
1990  "could not create a batch normalization forward primitive");
1991  reset(result);
1992  }
1993 
1995  const primitive::at &src, const primitive::at &weights,
1996  const memory &dst) {
1997  mkldnn_primitive_t result;
1998  mkldnn_primitive_at_t inputs[] = { src.data, weights.data };
1999  const_mkldnn_primitive_t outputs[] = { dst.get() };
2001  aprimitive_desc.get(), inputs, outputs),
2002  "could not create a batch normalization forward primitive");
2003  reset(result);
2004  }
2005 
2007  const primitive::at &src, const memory &dst) {
2008  mkldnn_primitive_t result;
2009  mkldnn_primitive_at_t inputs[] = { src.data };
2010  const_mkldnn_primitive_t outputs[] = { dst.get() };
2012  aprimitive_desc.get(), inputs, outputs),
2013  "could not create a batch normalization forward primitive");
2014  reset(result);
2015  }
2016 };
2017 
2019  struct desc {
2021  template <typename T>
2022  desc(prop_kind aprop_kind, const memory::desc &diff_data_desc,
2023  const memory::desc &data_desc, T epsilon, unsigned flags) {
2026  mkldnn::convert_to_c(aprop_kind),
2027  &diff_data_desc.data, &data_desc.data,
2028  static_cast<double>(epsilon), flags),
2029  "could not create a batch normalization backward descriptor");
2030  }
2031  };
2032 
2033  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
2034  primitive_desc(const desc &adesc, const engine &aengine,
2036  &hint_fwd_primitive_desc) {
2037  mkldnn_primitive_desc_t result;
2039  &result, &adesc.data, aengine.get(),
2040  hint_fwd_primitive_desc.get()),
2041  "could not create a batch normalization backward primitive descriptor");
2042  reset(result);
2043  }
2044 
2046  memory::primitive_desc adesc;
2047  mkldnn_primitive_desc_t bndesc;
2048  const_mkldnn_primitive_desc_t const_bndesc =
2052  const_bndesc),
2053  "could not clone a weights primitive descriptor");
2054  adesc.reset(bndesc);
2055  return adesc;
2056  }
2057 
2059  memory::primitive_desc adesc;
2060  mkldnn_primitive_desc_t bndesc;
2061  const_mkldnn_primitive_desc_t const_bndesc =
2065  const_bndesc),
2066  "could not clone a diff_weights primitive descriptor");
2067  adesc.reset(bndesc);
2068  return adesc;
2069  }
2070 
2072  memory::primitive_desc adesc;
2073  mkldnn_primitive_desc_t bndesc;
2074  const_mkldnn_primitive_desc_t const_bndesc =
2078  const_bndesc),
2079  "could not clone a mean primitive descriptor");
2080  adesc.reset(bndesc);
2081  return adesc;
2082  }
2083 
2085  memory::primitive_desc adesc;
2086  mkldnn_primitive_desc_t bndesc;
2087  const_mkldnn_primitive_desc_t const_bndesc =
2091  const_bndesc),
2092  "could not clone a variance primitive descriptor");
2093  adesc.reset(bndesc);
2094  return adesc;
2095  }
2096 
2098  memory::primitive_desc adesc;
2100  const_mkldnn_primitive_desc_t const_cdesc =
2104  const_cdesc),
2105  "could not clone a dst primitive descriptor");
2106  adesc.reset(cdesc);
2107  return adesc;
2108  }
2109 
2110  engine get_engine() { return engine::query(*this); }
2111  };
2112 
2113  // Prop_kind == backward
2115  const primitive::at &src, const primitive::at &mean,
2116  const primitive::at &variance, const primitive::at &diff_dst,
2117  const primitive::at &weights, const memory &diff_src,
2118  const memory &diff_weights) {
2119  mkldnn_primitive_t result;
2120  mkldnn_primitive_at_t inputs[] = { src.data,
2121  mean.data, variance.data, diff_dst.data, weights.data };
2122  const_mkldnn_primitive_t outputs[] = { diff_src.get(),
2123  diff_weights.get() };
2125  aprimitive_desc.get(), inputs, outputs),
2126  "could not create a batch normalization backward primitive");
2127  reset(result);
2128  }
2129 
2130  // Prop_kind == backward_data
2132  const primitive::at &src, const primitive::at &mean,
2133  const primitive::at &variance,const primitive::at &diff_dst,
2134  const primitive::at &weights, const memory &diff_src) {
2135  mkldnn_primitive_t result;
2136  mkldnn_primitive_at_t inputs[] = { src.data,
2137  mean.data, variance.data, diff_dst.data, weights.data };
2138  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
2140  aprimitive_desc.get(), inputs, outputs),
2141  "could not create a batch normalization backward primitive");
2142  reset(result);
2143  }
2144 
2145  // Prop_kind == backward_data
2147  const primitive::at &src, const primitive::at &mean,
2148  const primitive::at &variance, const primitive::at &diff_dst,
2149  const memory &diff_src) {
2150  mkldnn_primitive_t result;
2151  mkldnn_primitive_at_t inputs[] = { src.data,
2152  mean.data, variance.data, diff_dst.data };
2153  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
2155  aprimitive_desc.get(), inputs, outputs),
2156  "could not create a batch normalization backward primitive");
2157  reset(result);
2158  }
2159 };
2160 
2162  struct desc {
2164  desc(prop_kind aprop_kind, const memory::desc &src_desc,
2165  const memory::desc &weights_desc,
2166  const memory::desc &bias_desc,
2167  const memory::desc &dst_desc) {
2170  mkldnn::convert_to_c(aprop_kind), &src_desc.data,
2171  &weights_desc.data, &bias_desc.data, &dst_desc.data),
2172  "could not create a inner product forward descriptor");
2173  }
2174 
2175  desc(prop_kind aprop_kind, const memory::desc &src_desc,
2176  const memory::desc &weights_desc,
2177  const memory::desc &dst_desc) {
2180  mkldnn::convert_to_c(aprop_kind), &src_desc.data,
2181  &weights_desc.data, nullptr, &dst_desc.data),
2182  "could not create a inner product forward descriptor");
2183  }
2184  };
2185 
2186  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
2187  primitive_desc(const desc &adesc, const engine &aengine) {
2188  mkldnn_primitive_desc_t result;
2190  &result, &adesc.data, aengine.get(), nullptr),
2191  "could not create a inner product forward primitive descriptor");
2192  reset(result);
2193  }
2194 
2196  memory::primitive_desc adesc;
2198  const_mkldnn_primitive_desc_t const_cdesc =
2201  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2202  "could not clone a src primititve descriptor");
2203  adesc.reset(cdesc);
2204  return adesc;
2205  }
2206 
2208  memory::primitive_desc adesc;
2210  const_mkldnn_primitive_desc_t const_cdesc =
2213  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2214  "could not clone a weights primitive descriptor");
2215  adesc.reset(cdesc);
2216  return adesc;
2217  }
2218 
2220  memory::primitive_desc adesc;
2222  const_mkldnn_primitive_desc_t const_cdesc =
2225  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2226  "could not clone a bias primitive descriptor");
2227  adesc.reset(cdesc);
2228  return adesc;
2229  }
2230 
2232  memory::primitive_desc adesc;
2234  const_mkldnn_primitive_desc_t const_cdesc =
2237  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2238  "could not clone a dst primitive descriptor");
2239  adesc.reset(cdesc);
2240  return adesc;
2241  }
2242 
2243  engine get_engine() { return engine::query(*this); }
2244  };
2245 
2246  inner_product_forward(const primitive_desc &aprimitive_desc,
2247  const primitive::at &src, const primitive::at weights,
2248  const primitive::at &bias, const memory &dst) {
2249  mkldnn_primitive_t result;
2250  mkldnn_primitive_at_t inputs[] = { src.data, weights.data,
2251  bias.data };
2252  const_mkldnn_primitive_t outputs[] = { dst.get() };
2254  aprimitive_desc.get(), inputs, outputs),
2255  "could not create a inner product forward primitive");
2256  reset(result);
2257  }
2258 
2259  inner_product_forward(const primitive_desc &aprimitive_desc,
2260  const primitive::at &src, const primitive::at weights,
2261  const memory &dst) {
2262  mkldnn_primitive_t result;
2263  mkldnn_primitive_at_t inputs[] = { src.data, weights.data };
2264  const_mkldnn_primitive_t outputs[] = { dst.get() };
2266  aprimitive_desc.get(), inputs, outputs),
2267  "could not create a inner product forward primitive");
2268  reset(result);
2269  }
2270 };
2271 
2273  struct desc {
2275  desc(const memory::desc &diff_src_desc,
2276  const memory::desc &weights_desc,
2277  const memory::desc &diff_dst_desc) {
2280  &diff_src_desc.data, &weights_desc.data,
2281  &diff_dst_desc.data),
2282  "could not create a inner product backward data descriptor");
2283  }
2284  };
2285 
2286  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
2287  primitive_desc(const desc &adesc, const engine &aengine,
2289  &hint_fwd_primitive_desc) {
2290  mkldnn_primitive_desc_t result;
2292  &adesc.data, aengine.get(), hint_fwd_primitive_desc.get()),
2293  "could not create a inner product backward data primitive descriptor");
2294  reset(result);
2295  }
2296 
2298  memory::primitive_desc adesc;
2300  const_mkldnn_primitive_desc_t const_cdesc =
2303  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2304  "could not clone a diff dst primititve descriptor");
2305  adesc.reset(cdesc);
2306  return adesc;
2307  }
2308 
2310  memory::primitive_desc adesc;
2312  const_mkldnn_primitive_desc_t const_cdesc =
2315  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2316  "could not clone a weights primitive descriptor");
2317  adesc.reset(cdesc);
2318  return adesc;
2319  }
2320 
2322  memory::primitive_desc adesc;
2324  const_mkldnn_primitive_desc_t const_cdesc =
2327  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2328  "could not clone a diff src primitive descriptor");
2329  adesc.reset(cdesc);
2330  return adesc;
2331  }
2332 
2333  engine get_engine() { return engine::query(*this); }
2334  };
2335 
2337  const primitive::at &diff_dst, const primitive::at weights,
2338  const memory &diff_src) {
2339  mkldnn_primitive_t result;
2340  mkldnn_primitive_at_t inputs[] = { diff_dst.data, weights.data };
2341  const_mkldnn_primitive_t outputs[] = { diff_src.get() };
2343  aprimitive_desc.get(), inputs, outputs),
2344  "could not create a inner product backward data primitive");
2345  reset(result);
2346  }
2347 };
2348 
2350  struct desc {
2352  desc(const memory::desc &src_desc,
2353  const memory::desc &diff_weights_desc,
2354  const memory::desc &diff_bias_desc,
2355  const memory::desc &diff_dst_desc) {
2358  &data, &src_desc.data, &diff_weights_desc.data,
2359  &diff_bias_desc.data, &diff_dst_desc.data),
2360  "could not create a inner product backward weights descriptor");
2361  }
2362  desc(const memory::desc &src_desc,
2363  const memory::desc &diff_weights_desc,
2364  const memory::desc &diff_dst_desc) {
2367  &data, &src_desc.data, &diff_weights_desc.data,
2368  nullptr, &diff_dst_desc.data),
2369  "could not create a inner product backward weights descriptor");
2370  }
2371  };
2372 
2373  struct primitive_desc : public handle<mkldnn_primitive_desc_t> {
2374  primitive_desc(const desc &adesc, const engine &aengine,
2376  &hint_fwd_primitive_desc) {
2377  mkldnn_primitive_desc_t result;
2379  &adesc.data, aengine.get(), hint_fwd_primitive_desc.get()),
2380  "could not create a inner product backward weights primitive descriptor");
2381  reset(result);
2382  }
2383 
2385  memory::primitive_desc adesc;
2387  const_mkldnn_primitive_desc_t const_cdesc =
2390  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2391  "could not clone a diff dst primititve descriptor");
2392  adesc.reset(cdesc);
2393  return adesc;
2394  }
2395 
2397  memory::primitive_desc adesc;
2399  const_mkldnn_primitive_desc_t const_cdesc =
2402  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2403  "could not clone a diff weights primitive descriptor");
2404  adesc.reset(cdesc);
2405  return adesc;
2406  }
2407 
2409  memory::primitive_desc adesc;
2411  const_mkldnn_primitive_desc_t const_cdesc =
2414  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2415  "could not clone a diff bias primitive descriptor");
2416  adesc.reset(cdesc);
2417  return adesc;
2418  }
2419 
2421  memory::primitive_desc adesc;
2423  const_mkldnn_primitive_desc_t const_cdesc =
2426  error::wrap_c_api(mkldnn_primitive_desc_clone(&cdesc, const_cdesc),
2427  "could not clone a src primitive descriptor");
2428  adesc.reset(cdesc);
2429  return adesc;
2430  }
2431 
2432  engine get_engine() { return engine::query(*this); }
2433  };
2434 
2436  const primitive::at &src, const primitive::at diff_dst,
2437  const memory &diff_weights) {
2438  mkldnn_primitive_t result;
2439  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data };
2440  const_mkldnn_primitive_t outputs[] = { diff_weights.get() };
2442  aprimitive_desc.get(), inputs, outputs),
2443  "could not create a inner product backward weights primitive");
2444  reset(result);
2445  }
2446 
2448  const primitive::at &src, const primitive::at diff_dst,
2449  const memory &diff_weights, const memory &diff_bias) {
2450  mkldnn_primitive_t result;
2451  mkldnn_primitive_at_t inputs[] = { src.data, diff_dst.data };
2452  const_mkldnn_primitive_t outputs[] =
2453  { diff_weights.get(), diff_bias.get()};
2455  aprimitive_desc.get(), inputs, outputs),
2456  "could not create a inner product backward weights primitive");
2457  reset(result);
2458  }
2459 };
2460 } // namespace mkldnn
2461 
2462 #endif
memory::primitive_desc weights_primitive_desc() const
Definition: mkldnn.hpp:1005
Definition: mkldnn.hpp:1772
LRN within a single channel.
Definition: mkldnn_types.h:318
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:1298
A descriptor of a Local Response Normalization (LRN) operation.
Definition: mkldnn_types.h:551
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1029
Definition: mkldnn.hpp:1286
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2274
Definition: mkldnn.hpp:216
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...
memory::primitive_desc weights_primitive_desc() const
Definition: mkldnn.hpp:1872
4D weights tensor in the format (output channels, width, height, input channels) with output channels...
Definition: mkldnn_types.h:173
number of outputs expected
Definition: mkldnn_types.h:764
mkldnn_status_t MKLDNN_API mkldnn_stream_destroy(mkldnn_stream_t stream)
Destroys an execution stream.
T get() const
Returns the value of the underlying C handle.
Definition: mkldnn.hpp:85
Definition: mkldnn.hpp:1616
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:1619
mkldnn_status_t
Status values returned by Intel(R) MKL-DNN functions.
Definition: mkldnn_types.h:39
concat(const primitive_desc &concat_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:737
Definition: mkldnn.hpp:1557
A descriptor of a convolution operation.
Definition: mkldnn_types.h:428
Definition: mkldnn.hpp:1532
engine(kind akind, size_t index)
Constructs an engine.
Definition: mkldnn.hpp:259
Definition: mkldnn.hpp:578
Definition: mkldnn.hpp:573
The operation failed and should be retried.
Definition: mkldnn_types.h:45
mkldnn_status_t MKLDNN_API mkldnn_memory_primitive_desc_create(mkldnn_primitive_desc_t *memory_primitive_desc, const mkldnn_memory_desc_t *memory_desc, mkldnn_engine_t engine)
Creates a memory_primitive_desc memory primitive descriptor using memory_desc and engine...
Definition: mkldnn.hpp:215
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, double negative_slope)
Initializes a merged convolution-relu descriptor conv_relu_desc for forward propagation (supported in...
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_destroy(mkldnn_primitive_desc_t primitive_desc)
Deletes a primitive_desc.
handle & operator=(const handle &other)
Definition: mkldnn.hpp:72
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...
Definition: mkldnn.hpp:585
kind
Definition: mkldnn.hpp:831
4D data tensor in the chwn format typically used in Neon.
Definition: mkldnn_types.h:118
MKLDNN_DEPRECATED desc(const memory::desc &diff_data_desc, const memory::desc &data_desc, T negative_slope)
Definition: mkldnn.hpp:1767
The operation failed because of incorrect function arguments.
Definition: mkldnn_types.h:47
bool operator!=(const handle &other) const
Definition: mkldnn.hpp:88
Forward data propagation (alias for mkldnn_forward_inference)
Definition: mkldnn_types.h:246
Definition: mkldnn.hpp:1335
desc(dims adims, data_type adata_type, format aformat)
Constructs a memory descriptor.
Definition: mkldnn.hpp:387
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:2164
Definition: mkldnn.hpp:200
Backward data propagation.
Definition: mkldnn_types.h:252
Definition: mkldnn.hpp:220
handle(const handle &other)
Definition: mkldnn.hpp:71
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...
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:722
eltwise_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:1736
Undefined memory format, used for empty memory descriptors.
Definition: mkldnn_types.h:101
Definition: mkldnn.hpp:208
primitive_desc(const desc &adesc, const engine &aengine, const pooling_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:1642
#define TENSOR_MAX_DIMS
Maximum number of dimensions a tensor can have.
Definition: mkldnn_types.h:368
algorithm
Definition: mkldnn.hpp:570
4D weights tensor in the format (input channels, output channels, width, height). ...
Definition: mkldnn_types.h:131
memory::primitive_desc diff_src_primitive_desc() const
Definition: mkldnn.hpp:1783
A descriptor of a Softmax operation.
Definition: mkldnn_types.h:503
Definition: mkldnn.hpp:558
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:2020
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.
Definition: mkldnn.hpp:581
4D data tensor in the nchw format with channels data laid out in memory in 8-element blocks...
Definition: mkldnn_types.h:121
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.
engine get_engine()
Definition: mkldnn.hpp:804
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:609
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:2352
An opaque structure to describe a primitive descriptor .
batch normalization descriptor
Definition: mkldnn_types.h:782
mkldnn_status_t status
Definition: mkldnn.hpp:128
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:2114
static size_t get_count(kind akind)
Returns the number of engines of a certain kind.
Definition: mkldnn.hpp:249
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:938
padding_kind
Definition: mkldnn.hpp:549
mkldnn_status_t MKLDNN_API mkldnn_memory_set_data_handle(mkldnn_primitive_t memory, void *handle)
For a memory primitive, sets the data handle.
static void wrap_c_api(mkldnn_status_t status, 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:154
4D data tensor in the nchw format with channels data laid out in memory in 16-element blocks...
Definition: mkldnn_types.h:124
memory::primitive_desc diff_src_primitive_desc() const
Definition: mkldnn.hpp:2321
An execution engine.
Definition: mkldnn.hpp:233
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1390
Definition: mkldnn.hpp:579
engine get_engine()
Definition: mkldnn.hpp:1834
view(const primitive_desc &view_pd, primitive::at input)
Definition: mkldnn.hpp:663
primitive_desc(const memory::desc &output, int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:696
engine(const handle< mkldnn_primitive_desc_t > &pd)
Definition: mkldnn.hpp:271
convolution-relu descriptor
Definition: mkldnn_types.h:784
engine get_engine()
Definition: mkldnn.hpp:1257
batch_normalization_flag
Definition: mkldnn.hpp:584
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, double alpha, double beta, double k)
Initializes an lrn_desc for backward propagation using alg_kind, memory descriptors data_desc...
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1157
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:791
Definition: mkldnn.hpp:574
Definition: mkldnn_types.h:314
Definition: mkldnn.hpp:1750
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.
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)
Definition: mkldnn.hpp:2131
engine get_engine()
Definition: mkldnn.hpp:2110
void reset(T t, bool weak=false)
Resets the value of a C handle.
Definition: mkldnn.hpp:79
Definition: mkldnn.hpp:1825
32-bit signed integer.
Definition: mkldnn_types.h:68
Max pooling.
Definition: mkldnn_types.h:309
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:2146
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...
Definition: mkldnn.hpp:580
execution engine
Definition: mkldnn_types.h:760
Definition: mkldnn.hpp:636
Definition: mkldnn.hpp:576
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:1531
4D weights tensor in the oihw format with input channels data laid out in memory in 16-element blocks...
Definition: mkldnn_types.h:151
engine get_engine()
Definition: mkldnn.hpp:441
A descriptor of a convolution followed by relu operation.
Definition: mkldnn_types.h:638
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.
input memory primitive desc
Definition: mkldnn_types.h:788
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1578
5D weights tensor in the oihw format with extra outer dimension for groups.
Definition: mkldnn_types.h:179
memory::primitive_desc diff_weights_primitive_desc() const
Definition: mkldnn.hpp:2396
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, double epsilon, unsigned flags)
Initializes a batch normalization descriptor bnrm_desc for backward propagation with respect to data ...
static engine query(const primitive_desc &pd)
Definition: mkldnn.hpp:281
A descriptor of a element-wise operation.
Definition: mkldnn_types.h:470
softmax_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:1837
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:1358
primitive error_primitive
Definition: mkldnn.hpp:130
memory::primitive_desc weights_primitive_desc() const
Definition: mkldnn.hpp:2045
memory::primitive_desc diff_dst_primitive_desc() const
Definition: mkldnn.hpp:2297
destination grad.
Definition: mkldnn_types.h:795
Definition: mkldnn.hpp:1751
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.
desc(prop_kind aprop_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:2022
primitive_desc(int concat_dimension, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:709
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:1533
Definition: mkldnn.hpp:684
eltwise descriptor
Definition: mkldnn_types.h:777
const_mkldnn_primitive_desc_t get_primitive_desc() const
Returns the descriptor of the underlying C API primitive.
Definition: mkldnn.hpp:176
size_t MKLDNN_API mkldnn_engine_get_count(mkldnn_engine_kind_t kind)
Returns the number of engines of a particular kind.
memory::primitive_desc diff_weights_primitive_desc() const
Definition: mkldnn.hpp:2058
4D weights tensor in the oihw format with both input and output channels data laid out in memory in 1...
Definition: mkldnn_types.h:157
memory::primitive_desc variance_primitive_desc() const
Definition: mkldnn.hpp:1905
inner_product_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at weights, const memory &dst)
Definition: mkldnn.hpp:2259
engine get_engine()
Definition: mkldnn.hpp:2432
convolution_relu_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1322
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:1558
static mkldnn_memory_format_t convert_to_c(format aformat)
Definition: mkldnn.hpp:517
Definition: mkldnn.hpp:898
Backward weights propagation.
Definition: mkldnn_types.h:254
Definition: mkldnn.hpp:218
32-bit/single-precision floating point.
Definition: mkldnn_types.h:66
memory::primitive_desc diff_dst_primitive_desc() const
Definition: mkldnn.hpp:1490
2D weights tensor in the format (input channels, output channels).
Definition: mkldnn_types.h:126
Omit statistics.
Definition: mkldnn_types.h:357
Memory descriptor.
Definition: mkldnn_types.h:404
Definition: mkldnn.hpp:199
Definition: mkldnn.hpp:2162
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:96
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:1432
engine get_engine()
Definition: mkldnn.hpp:605
static void validate_dims(std::vector< T > v)
Definition: mkldnn.hpp:314
Definition: mkldnn.hpp:2161
memory::primitive_desc weights_primitive_desc() const
Definition: mkldnn.hpp:2207
pooling descriptor
Definition: mkldnn_types.h:780
Definition: mkldnn.hpp:1617
primitive_desc(const memory::desc &output, std::vector< double > scale, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:765
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.
memory::primitive_desc src_primitive_desc() const
Definition: mkldnn.hpp:1366
desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, int local_size, double alpha, double beta)
Definition: mkldnn.hpp:1443
MKLDNN_DEPRECATED desc(prop_kind aprop_kind, const memory::desc &src_desc, T negative_slope)
Definition: mkldnn.hpp:1706
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:901
memory::primitive_desc src_primitive_desc() const
Definition: mkldnn.hpp:2420
std::vector< std::remove_extent< mkldnn_dims_t >::type > dims
Definition: mkldnn.hpp:312
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:1158
4D weights tensor in the format (output channels, input channels, height, width) with output channels...
Definition: mkldnn_types.h:165
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.
5D weights tensor in the blocked version of goihw format with both input and output channels data lai...
Definition: mkldnn_types.h:183
5D weights tensor in the oihw format with output channels data laid out in memory in 16-element block...
Definition: mkldnn_types.h:191
stream(kind akind)
Constructs a stream.
Definition: mkldnn.hpp:839
Backward propagation (with respect to all parameters.
Definition: mkldnn_types.h:250
softmax descriptor
Definition: mkldnn_types.h:779
query
Definition: mkldnn.hpp:193
engine get_engine()
Definition: mkldnn.hpp:1041
Use global statistics.
Definition: mkldnn_types.h:335
Definition: mkldnn.hpp:31
4D weights tensor in the format (output channels, width, height, input channels) with output channels...
Definition: mkldnn_types.h:169
no query
Definition: mkldnn_types.h:758
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:1418
5D weights tensor in the blocked version of goihw format with output channels data laid out in memory...
Definition: mkldnn_types.h:212
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
size_t get_size() const
Returns the number of data elements in the memory described.
Definition: mkldnn.hpp:429
memory::primitive_desc diff_bias_primitive_desc() const
Definition: mkldnn.hpp:2408
Average pooling include padding.
Definition: mkldnn_types.h:311
Unspecified format.
Definition: mkldnn_types.h:104
Definition: mkldnn.hpp:1357
destination memory primitive desc
Definition: mkldnn_types.h:794
memory::primitive_desc diff_dst_primitive_desc() const
Definition: mkldnn.hpp:1245
engine get_engine()
Definition: mkldnn.hpp:1664
convolution_backward_weights(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_weights)
Definition: mkldnn.hpp:1272
convolution_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1057
Local response normalization (LRN) across multiple channels.
Definition: mkldnn_types.h:316
4D weights tensor in the oihw format with input channels data laid out in memory in 16-element blocks...
Definition: mkldnn_types.h:224
Eager stream.
Definition: mkldnn_types.h:809
engine get_engine()
Definition: mkldnn.hpp:1938
implementation name
Definition: mkldnn_types.h:771
Definition: mkldnn.hpp:899
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:1260
engine get_engine()
Definition: mkldnn.hpp:1502
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1925
memory(const primitive_desc &adesc, void *ahandle)
Definition: mkldnn.hpp:478
Definition: mkldnn.hpp:213
Eltwise: parametric exponential linear unit (elu)
Definition: mkldnn_types.h:307
memory::primitive_desc diff_weights_primitive_desc() const
Definition: mkldnn.hpp:1221
Definition: mkldnn.hpp:1431
Definition: mkldnn.hpp:2272
Intel(R) MKL-DNN exception class.
Definition: mkldnn.hpp:127
bool operator==(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:523
Eltwise: ReLU.
Definition: mkldnn_types.h:303
memory::primitive_desc variance_primitive_desc() const
Definition: mkldnn.hpp:2084
Definition: mkldnn.hpp:1813
1D data tensor.
Definition: mkldnn_types.h:110
Definition: mkldnn.hpp:202
Definition: mkldnn.hpp:222
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:686
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:1072
4D weights tensor in the format (input channels, height, width, output channels). ...
Definition: mkldnn_types.h:134
mkldnn_memory_format_t
Memory format specification.
Definition: mkldnn_types.h:99
Definition: mkldnn.hpp:635
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:2006
primitive_desc(const desc &adesc, const engine &aengine, const eltwise_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:1773
engine get_engine()
Definition: mkldnn.hpp:1306
engine get_engine()
Definition: mkldnn.hpp:2333
Definition: mkldnn.hpp:753
Definition: mkldnn.hpp:223
kind
Kinds of engines.
Definition: mkldnn.hpp:238
sum(const primitive_desc &sum_pd, std::vector< primitive::at > &inputs, const memory &output)
Definition: mkldnn.hpp:807
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:1667
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.
bool operator==(const T other) const
Definition: mkldnn.hpp:68
stream & rerun()
Definition: mkldnn.hpp:889
Definition: mkldnn.hpp:209
4D data tensor in the nhwc format typically used in TensorFlow.
Definition: mkldnn_types.h:116
static mkldnn_stream_kind_t convert_to_c(kind akind)
Definition: mkldnn.hpp:835
desc(const convolution_forward::desc conv_desc, const double negative_slope)
Definition: mkldnn.hpp:1288
static mkldnn_data_type_t convert_to_c(data_type adata_type)
Definition: mkldnn.hpp:514
Backward bias propagation.
Definition: mkldnn_types.h:256
Definition: mkldnn.hpp:594
5D weights tensor in the goihw format with both input and output channels data laid out in memory in ...
Definition: mkldnn_types.h:218
Use scale and shift parameters.
Definition: mkldnn_types.h:348
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:647
Definition: mkldnn.hpp:197
engine get_engine()
Definition: mkldnn.hpp:1733
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.
Definition: mkldnn.hpp:577
4D weights tensor in the oihw format with input channels data laid out in memory in 8-element blocks...
Definition: mkldnn_types.h:221
5D weights tensor in the oihw format with input channels data laid out in memory in 16-element blocks...
Definition: mkldnn_types.h:195
mkldnn_primitive_at_t data
The underlying C API structure.
Definition: mkldnn.hpp:105
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:1826
Definition: mkldnn.hpp:1334
Definition: mkldnn.hpp:685
mkldnn_convolution_desc_t data
Definition: mkldnn.hpp:900
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:1968
memory::primitive_desc workspace_primitive_desc() const
Definition: mkldnn.hpp:1378
primitive_desc(const desc &adesc, const engine &aengine, const batch_normalization_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:2034
Definition: mkldnn.hpp:1455
Definition: mkldnn.hpp:1155
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.
Definition: mkldnn.hpp:219
Definition: mkldnn.hpp:207
Definition: mkldnn.hpp:563
mkldnn_prop_kind_t
Kinds of propagation.
Definition: mkldnn_types.h:234
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn.hpp:103
CPU engine.
Definition: mkldnn_types.h:659
mkldnn_stream_kind_t
Kinds of streams.
Definition: mkldnn_types.h:805
desc(algorithm aalgorithm, const memory::desc &data_desc, const memory::desc &diff_data_desc, int local_size, double alpha, double beta, double k)
Definition: mkldnn.hpp:1433
memory::primitive_desc diff_src_primitive_desc() const
Definition: mkldnn.hpp:1652
4D weights tensor in the format (height, width, input channels, output channels). ...
Definition: mkldnn_types.h:137
A wrapper structure to specify a particular output of a primitive.
Definition: mkldnn_types.h:719
Winograd convolution.
Definition: mkldnn_types.h:301
view(memory input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:672
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, double alpha, double beta, double k)
Initializes an lrn_desc for forward propagation using prop_kind (possible values are mkldnn_forward_t...
bool wait(bool block=true)
Waits for all computations submitted to the stream to complete.
Definition: mkldnn.hpp:878
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:1534
memory::primitive_desc diff_src_primitive_desc() const
Definition: mkldnn.hpp:1103
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:2447
Definition: mkldnn.hpp:2018
Direct convolution.
Definition: mkldnn_types.h:299
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:2246
source gradient memory primitive desc
Definition: mkldnn_types.h:791
convolution_backward_data(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &weights, const memory &diff_src)
Definition: mkldnn.hpp:1142
Definition: mkldnn.hpp:1071
primitive_desc(const desc &adesc, const engine &aengine)
Constructs a memory primitive descriptor.
Definition: mkldnn.hpp:411
engine(const mkldnn_engine_t &aengine)
Definition: mkldnn.hpp:268
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...
runtime estimation (seconds)
Definition: mkldnn_types.h:766
5D weights tensor in the blocked version of goihw format with output channels data laid out in memory...
Definition: mkldnn_types.h:215
primitive_desc get_primitive_desc() const
Returns the descriptor of the memory primitive.
Definition: mkldnn.hpp:488
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.
eltwise_forward relu_forward
Definition: mkldnn.hpp:1748
4D weights tensor in the oihw format with both input and output channels data laid out in memory in 8...
Definition: mkldnn_types.h:140
Definition: mkldnn.hpp:587
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:501
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2163
Undefined data type, used for empty memory descriptors.
Definition: mkldnn_types.h:64
engine get_engine()
Definition: mkldnn.hpp:734
memory::primitive_desc src_primitive_desc() const
Definition: mkldnn.hpp:1209
16-bit signed integer.
Definition: mkldnn_types.h:70
Definition: mkldnn.hpp:1691
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &weights, const memory &dst)
Definition: mkldnn.hpp:1994
memory::primitive_desc diff_dst_primitive_desc() const
Definition: mkldnn.hpp:2384
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.
engine get_engine()
Definition: mkldnn.hpp:2243
mkldnn_memory_desc_t data
The underlying C API data structure.
Definition: mkldnn.hpp:380
memory::primitive_desc src_primitive_desc() const
Definition: mkldnn.hpp:993
eltwise_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:1798
Definition: mkldnn.hpp:562
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst)
Definition: mkldnn.hpp:1593
mkldnn_query_t
Primitive descriptor query specification.
Definition: mkldnn_types.h:757
A descriptor of a Batch Normalization operation.
Definition: mkldnn_types.h:578
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:1309
mkldnn_lrn_desc_t data
Definition: mkldnn.hpp:1336
Definition: mkldnn.hpp:550
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, double alpha, double beta)
Initializes a eltwise_desc for forward propagation using prop_kind (possible values are mkldnn_forwar...
mkldnn_status_t MKLDNN_API mkldnn_primitive_desc_create(mkldnn_primitive_desc_t *primitive_desc, const_mkldnn_op_desc_t op_desc, mkldnn_engine_t engine, const_mkldnn_primitive_desc_t hint_forward_primitive_desc)
Creates a primitive_desc using op_desc, engine, and optionally a hint primitive descriptor from forwa...
5D weights tensor in the blocked version of goihw format with output channels data laid out in memory...
Definition: mkldnn_types.h:206
unsigned flags
Definition: mkldnn_types.h:605
Definition: mkldnn.hpp:203
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:961
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:1955
desc(prop_kind aprop_kind, const memory::desc &src_desc, T epsilon, unsigned flags)
Definition: mkldnn.hpp:1853
engine get_engine()
Definition: mkldnn.hpp:1402
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 in the format (input channels, output channels).
Definition: mkldnn_types.h:128
memory consumption – extra (scratch) memory, additional to all inputs and outputs memory (bytes) ...
Definition: mkldnn_types.h:767
Definition: mkldnn.hpp:575
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.hpp:1690
A descriptor of a pooling operation.
Definition: mkldnn_types.h:517
bool operator==(const handle &other) const
Definition: mkldnn.hpp:87
Definition: mkldnn.hpp:828
primitive_desc(const memory::primitive_desc &input, memory::dims dims, memory::dims offsets)
Definition: mkldnn.hpp:637
format
Memory format specification. See mkldnn_memory_format_t for a detailed description.
Definition: mkldnn.hpp:333
Definition: mkldnn.hpp:210
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:1178
Definition: mkldnn.hpp:211
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:1505
memory::primitive_desc workspace_primitive_desc() const
Definition: mkldnn.hpp:1478
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:230
desc(prop_kind aprop_kind, const memory::desc &data_desc, int softmax_axis)
Definition: mkldnn.hpp:1816
Definition: mkldnn.hpp:1711
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, double alpha, double beta, double k)
Definition: mkldnn.hpp:1337
source memory primitive desc
Definition: mkldnn_types.h:790
number of inputs expected
Definition: mkldnn_types.h:763
mkldnn_convolution_relu_desc_t data
Definition: mkldnn.hpp:1287
mkldnn_inner_product_desc_t data
Definition: mkldnn.hpp:2351
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, double alpha, double beta)
Initializes a eltwise_desc for backward propagation using alg_kind algorithm memory descriptors diff_...
An unspecified engine.
Definition: mkldnn_types.h:807
Definition: mkldnn.hpp:559
std::string message
Definition: mkldnn.hpp:129
Definition: mkldnn.hpp:557
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.
4D weights tensor in the format (output channels, input channels, height, width) with output channels...
Definition: mkldnn_types.h:161
mkldnn_softmax_desc_t data
Definition: mkldnn.hpp:1815
desc(algorithm alg_kind, const memory::desc &diff_data_desc, const memory::desc &data_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:1755
Average pooling exclude padding.
Definition: mkldnn_types.h:313
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.
Forward data propagation (inference mode).
Definition: mkldnn_types.h:244
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:1044
A class that provides the destructor for an Intel(R) MKL-DNN C handle.
Definition: mkldnn.hpp:40
desc(const memory::desc &diff_src_desc, const memory::desc &weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2275
memory::primitive_desc diff_bias_primitive_desc() const
Definition: mkldnn.hpp:1233
memory::primitive_desc mean_primitive_desc() const
Definition: mkldnn.hpp:2071
desc(prop_kind aprop_kind, const memory::desc &src_desc, const memory::desc &weights_desc, const memory::desc &dst_desc)
Definition: mkldnn.hpp:2175
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:1864
Definition: mkldnn.hpp:194
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:1692
4D weights tensor in the oihw format with both input and output channels data laid out in memory in 1...
Definition: mkldnn_types.h:143
eltwise_backward relu_backward
Definition: mkldnn.hpp:1811
A memory descriptor.
Definition: mkldnn.hpp:377
reorder(const primitive_desc &aprimitive_desc, const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:608
Definition: mkldnn.hpp:226
pooling_backward(const primitive_desc &aprimitive_desc, const primitive::at &diff_dst, const primitive::at &workspace, const memory &diff_src)
Definition: mkldnn.hpp:1678
5D weights tensor in the blocked version of goihw format with both input and output channels data lai...
Definition: mkldnn_types.h:199
bool operator!=(mkldnn_data_type_t a, memory::data_type b)
Definition: mkldnn.hpp:526
void set_data_handle(void *handle) const
Definition: mkldnn.hpp:508
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:305
mkldnn_status_t MKLDNN_API mkldnn_engine_destroy(mkldnn_engine_t engine)
Destroys an engine.
bool operator==(const primitive_desc &other) const
Definition: mkldnn.hpp:433
2D data tensor.
Definition: mkldnn_types.h:112
Definition: mkldnn.hpp:205
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:2097
memory descriptor for memory and view
Definition: mkldnn_types.h:775
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:2231
memory::primitive_desc workspace_primitive_desc() const
Definition: mkldnn.hpp:1566
mkldnn_padding_kind_t
Kinds of padding.
Definition: mkldnn_types.h:228
mkldnn_query_t convert_to_c(query aquery)
Definition: mkldnn.hpp:228
Lazy stream.
Definition: mkldnn_types.h:811
mkldnn_batch_normalization_desc_t data
Definition: mkldnn.hpp:1851
5D weights tensor in the blocked version of goihw format with output channels data laid out in memory...
Definition: mkldnn_types.h:209
memory::primitive_desc bias_primitive_desc() const
Definition: mkldnn.hpp:1017
Definition: mkldnn.hpp:560
desc(const mkldnn_memory_desc_t &adata)
Constructs a memory descriptor from a C API data structure.
Definition: mkldnn.hpp:400
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.
prop_kind
Definition: mkldnn.hpp:556
Definition: mkldnn.hpp:2349
Forward data propagation (training mode).
Definition: mkldnn_types.h:240
memory::primitive_desc src_primitive_desc() const
Definition: mkldnn.hpp:2195
memory::primitive_desc dst_primitive_desc() const
Definition: mkldnn.hpp:1720
handle(T t=0, bool weak=false)
Constructs a C handle wrapper.
Definition: mkldnn.hpp:64
memory::desc desc()
Returns the memory primitive descriptor.
Definition: mkldnn.hpp:421
An opaque structure to describe a primitive.
Definition: mkldnn.hpp:214
A tensor in a generic format described by the stride and blocking values in each dimension.
Definition: mkldnn_types.h:108
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:1941
desc(prop_kind aprop_kind, algorithm aalgorithm, const memory::desc &src_desc, int local_size, double alpha, double beta)
Definition: mkldnn.hpp:1346
bool operator!=(const T other) const
Definition: mkldnn.hpp:69
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:1073
mkldnn_data_type_t
Data type specification.
Definition: mkldnn_types.h:62
Definition: mkldnn.hpp:1070
convolution descriptor
Definition: mkldnn_types.h:776
primitive_desc(const desc &adesc, const engine &aengine, const inner_product_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:2374
error(mkldnn_status_t astatus, std::string amessage, mkldnn_primitive_t aerror_primitive=0)
Constructs an error instance.
Definition: mkldnn.hpp:139
A memory primitive descriptor.
Definition: mkldnn.hpp:404
bool operator!=(const primitive_desc &other) const
Definition: mkldnn.hpp:437
Definition: mkldnn.hpp:225
mkldnn_pooling_desc_t data
Definition: mkldnn.hpp:1618
4D weights tensor in the oihw format with both input and output channels data laid out in memory in 1...
Definition: mkldnn_types.h:176
mkldnn_eltwise_desc_t data
Definition: mkldnn.hpp:1752
Definition: mkldnn.hpp:1814
data_type
Data type specification. See mkldnn_data_type_t for a detailed description.
Definition: mkldnn.hpp:322
pooling_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &workspace)
Definition: mkldnn.hpp:1604
mkldnn_engine_kind_t
Kinds of engines.
Definition: mkldnn_types.h:655
primitive_desc(const memory::primitive_desc &input, const memory::primitive_desc &output)
Definition: mkldnn.hpp:596
lrn_backward(const primitive_desc &aprimitive_desc, const primitive::at &src, const primitive::at &diff_dst, const memory &diff_src)
Definition: mkldnn.hpp:1518
engine get_engine()
Definition: mkldnn.hpp:660
Memory primitive that describes the data.
Definition: mkldnn.hpp:307
primitive_desc(const desc &adesc, const engine &aengine, const convolution_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:1199
Definition: mkldnn.hpp:1430
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:920
primitive_desc(const desc &adesc, const engine &aengine, const convolution_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:1093
Definition: mkldnn.hpp:1849
desc(const memory::desc &src_desc, const memory::desc &diff_weights_desc, const memory::desc &diff_dst_desc)
Definition: mkldnn.hpp:2362
Definition: mkldnn.hpp:221
primitive_desc()
Definition: mkldnn.hpp:408
engine get_engine()
Definition: mkldnn.hpp:1139
batch_normalization_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &dst, const memory &mean, const memory &variance)
Definition: mkldnn.hpp:1981
5D weights tensor in the blocked version of goihw format with both input and output channels data lai...
Definition: mkldnn_types.h:203
memory::primitive_desc weights_primitive_desc() const
Definition: mkldnn.hpp:1115
An unspecified engine.
Definition: mkldnn_types.h:657
Definition: mkldnn.hpp:754
memory(const primitive &aprimitive)
Constructs a memory primitive from a generic primitive.
Definition: mkldnn.hpp:447
Definition: mkldnn.hpp:196
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:1712
5D weights tensor in the blocked version of goihw format with both input and output channels data lai...
Definition: mkldnn_types.h:187
mkldnn_alg_kind_t
Kinds of algorithms.
Definition: mkldnn_types.h:297
inner product descriptor
Definition: mkldnn_types.h:783
weights memory primitive descriptor desc
Definition: mkldnn_types.h:792
output memory primitive desc
Definition: mkldnn_types.h:789
reorder(const primitive::at &input, const memory &output)
Definition: mkldnn.hpp:619
Definition: mkldnn.hpp:1641
memory(const primitive_desc &adesc)
Constructs a memory primitive.
Definition: mkldnn.hpp:451
engine get_engine()
Definition: mkldnn.hpp:1590
Definition: mkldnn.hpp:595
memory::primitive_desc diff_dst_primitive_desc() const
Definition: mkldnn.hpp:1127
mkldnn_status_t MKLDNN_API mkldnn_primitive_destroy(mkldnn_primitive_t primitive)
Deletes a primitive.
Definition: mkldnn.hpp:564
Definition: mkldnn.hpp:212
lrn_forward(const primitive_desc &aprimitive_desc, const primitive::at &src, const memory &workspace, const memory &dst)
Definition: mkldnn.hpp:1405
memory::primitive_desc weights_primitive_desc() const
Definition: mkldnn.hpp:2309
4D weights tensor in the oihw format with both input and output channels data laid out in memory in 8...
Definition: mkldnn_types.h:154
memory::primitive_desc diff_src_primitive_desc() const
Definition: mkldnn.hpp:1466
Forward data propagation (alias for mkldnn_forward_training)
Definition: mkldnn_types.h:248
lrn descriptor
Definition: mkldnn_types.h:781
workspace memory primitive desc
Definition: mkldnn_types.h:796
Definition: mkldnn.hpp:224
Definition: mkldnn.hpp:561
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...
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:2187
primitive_desc(const desc &adesc, const engine &aengine, const inner_product_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:2287
at(const primitive &aprimitive, size_t at=0)
Constructs a wrapper specifying aprimitive output with index at.
Definition: mkldnn.hpp:112
memory::primitive_desc mean_primitive_desc() const
Definition: mkldnn.hpp:1885
Definition: mkldnn_types.h:778
engine get_engine()
Definition: mkldnn.hpp:1795
weights grad.
Definition: mkldnn_types.h:793
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:2336
4D data tensor in the nchw format typically used in Caffe.
Definition: mkldnn_types.h:114
desc(prop_kind aprop_kind, algorithm alg_kind, const memory::desc &src_desc, T alpha=0, T beta=0)
Definition: mkldnn.hpp:1694
primitive kind
Definition: mkldnn_types.h:761
primitive_desc(std::vector< double > scale, std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:778
Definition: mkldnn.hpp:586
memory::primitive_desc bias_primitive_desc() const
Definition: mkldnn.hpp:2219
primitive_desc(const desc &adesc, const engine &aengine, const lrn_forward::primitive_desc &hint_fwd_primitive_desc)
Definition: mkldnn.hpp:1456
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, double epsilon, unsigned flags)
Initializes a batch normalization descriptor bnrm_desc for forward propagation using prop_kind...
4D weights tensor in the oihw format with output channels data laid out in memory in 16-element block...
Definition: mkldnn_types.h:147
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:2435
Definition: mkldnn.hpp:1285
std::vector< const_mkldnn_primitive_desc_t > cpp_to_c(std::vector< memory::primitive_desc > inputs)
Definition: mkldnn.hpp:755
Definition: mkldnn.hpp:571
stream & submit(std::vector< primitive > primitives)
Submits a vector of primitives to a stream for computations.
Definition: mkldnn.hpp:851
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, double *scale, 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...
primitive_desc(const desc &adesc, const engine &aengine)
Definition: mkldnn.hpp:985
Definition: mkldnn.hpp:572
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...