Publishing R4 (#41)

* Publishing R4

63 files changed, 693 insertions, 648 deletions

diff --git a/inference-engine/thirdparty/clDNN/src/include/activation_grad_inst.h b/inference-engine/thirdparty/clDNN/src/include/activation_grad_inst.h
index 0ecbda439..35bc30ada 100644
--- a/inference-engine/thirdparty/clDNN/src/include/activation_grad_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/activation_grad_inst.h
@@ -30,9 +30,9 @@ struct typed_program_node<activation_grad> : public typed_program_node_base<acti
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) input_arg() const { return get_dependency(1); }
-    decltype(auto) slope_input() const { return get_dependency(2); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& input_arg() const { return get_dependency(1); }
+    program_node& slope_input() const { return get_dependency(2); }
 
     bool is_parameterized() const { return !typed_desc()->additional_params_input.empty(); }
 };
@@ -50,7 +50,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, activation_grad_node const& node);
 
-    decltype(auto) slope_memory() const { return dep_memory(2); }
+    memory_impl& slope_memory() const { return dep_memory(2); }
 
     bool is_parameterized() const { return !argument.additional_params_input.empty(); }
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/activation_inst.h b/inference-engine/thirdparty/clDNN/src/include/activation_inst.h
index 762158367..80a56475c 100644
--- a/inference-engine/thirdparty/clDNN/src/include/activation_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/activation_inst.h
@@ -30,8 +30,8 @@ struct typed_program_node<activation> : public typed_program_node_base<activatio
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) slope_input() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& slope_input() const { return get_dependency(1); }
 
     bool is_parameterized() const { return !typed_desc()->additional_params_input.empty(); }
 };
@@ -49,7 +49,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, activation_node const& node);
 
-    decltype(auto) slope_memory() const { return dep_memory(1); }
+    memory_impl& slope_memory() const { return dep_memory(1); }
 
     bool is_parameterized() const { return !argument.additional_params_input.empty(); }
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/apply_adam_inst.h b/inference-engine/thirdparty/clDNN/src/include/apply_adam_inst.h
index 7e4bb3b4e..f9c735815 100644
--- a/inference-engine/thirdparty/clDNN/src/include/apply_adam_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/apply_adam_inst.h
@@ -30,11 +30,14 @@ struct typed_program_node<apply_adam> : public typed_program_node_base<apply_ada
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) m() const { return get_dependency(1); }
-    decltype(auto) v() const { return get_dependency(2); }
-    decltype(auto) beta1_power() const { return get_dependency(3); }
-    decltype(auto) beta2_power() const { return get_dependency(4); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& m() const { return get_dependency(1); }
+    program_node& v() const { return get_dependency(2); }
+    program_node& beta1_power() const { return get_dependency(3); }
+    program_node& beta2_power() const { return get_dependency(4); }
+    program_node& additional_dep() const { return get_dependency(5); }
+
+    bool has_additional_dep() const { return get_dependencies().size() > 5; }
 };
 
 using apply_adam_node = typed_program_node<apply_adam>;
@@ -51,10 +54,13 @@ public:
 public:
     typed_primitive_inst(network_impl& network, apply_adam_node const& node);
 
-    decltype(auto) m_memory() const { return dep_memory(1); }
-    decltype(auto) v_memory() const { return dep_memory(2); }
-    decltype(auto) beta1_power_memory() const { return dep_memory(3); }
-    decltype(auto) beta2_power_memory() const { return dep_memory(4); }
+    memory_impl& m_memory() const { return dep_memory(1); }
+    memory_impl& v_memory() const { return dep_memory(2); }
+    memory_impl& beta1_power_memory() const { return dep_memory(3); }
+    memory_impl& beta2_power_memory() const { return dep_memory(4); }
+    memory_impl& additional_dep() const { return dep_memory(5); }
+
+    bool has_additional_dep() const { return _deps.size() > 5; }
 };
 
 using apply_adam_inst = typed_primitive_inst<apply_adam>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/arg_max_min_inst.h b/inference-engine/thirdparty/clDNN/src/include/arg_max_min_inst.h
index eed5b066d..744bad8e1 100644
--- a/inference-engine/thirdparty/clDNN/src/include/arg_max_min_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/arg_max_min_inst.h
@@ -34,7 +34,7 @@ namespace cldnn
 			: parent(prim, prog)
 		{
 		}
-		decltype(auto) input() const { return get_dependency(0); }
+        program_node& input() const { return get_dependency(0); }
 	};
 
 	using arg_max_min_node = typed_program_node<arg_max_min>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/average_unpooling_inst.h b/inference-engine/thirdparty/clDNN/src/include/average_unpooling_inst.h
index 90721606b..173d43d0e 100644
--- a/inference-engine/thirdparty/clDNN/src/include/average_unpooling_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/average_unpooling_inst.h
@@ -29,7 +29,7 @@ namespace cldnn
 
     public:
         using parent::parent;
-        decltype(auto) input() const { return get_dependency(0); }
+        program_node& input() const { return get_dependency(0); }
     };
 
     using average_unpooling_node = typed_program_node<average_unpooling>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/batch_norm_grad_inst.h b/inference-engine/thirdparty/clDNN/src/include/batch_norm_grad_inst.h
index 5238a4814..66d839999 100644
--- a/inference-engine/thirdparty/clDNN/src/include/batch_norm_grad_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/batch_norm_grad_inst.h
@@ -29,8 +29,8 @@ namespace cldnn
 
     public:
         using parent::parent;
-        decltype(auto) input() const { return get_dependency(0); }
-        decltype(auto) inv_variance() const { return get_dependency(2); }
+        program_node& input() const { return get_dependency(0); }
+        program_node& inv_variance() const { return get_dependency(2); }
     };
 
     using batch_norm_grad_node = typed_program_node<batch_norm_grad>;
@@ -43,7 +43,7 @@ namespace cldnn
     public:
         typed_primitive_inst(network_impl& network, batch_norm_grad_node const& desc);
 
-        decltype(auto) inv_variance_memory() const { return dep_memory(2); }
+        memory_impl& inv_variance_memory() const { return dep_memory(2); }
 
         static layout calc_output_layout(batch_norm_grad_node const& node);
         static std::string to_string(batch_norm_grad_node const& node);
diff --git a/inference-engine/thirdparty/clDNN/src/include/batch_norm_inst.h b/inference-engine/thirdparty/clDNN/src/include/batch_norm_inst.h
index 1973b739d..956952777 100644
--- a/inference-engine/thirdparty/clDNN/src/include/batch_norm_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/batch_norm_inst.h
@@ -30,10 +30,10 @@ struct typed_program_node<batch_norm> : public typed_program_node_base<batch_nor
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) mean() const { return get_dependency(1); }
-    decltype(auto) variance() const { return get_dependency(2); }
-    decltype(auto) inv_variance() const { return get_dependency(1); };
+    program_node& input() const { return get_dependency(0); }
+    program_node& mean() const { return get_dependency(1); }
+    program_node& variance() const { return get_dependency(2); }
+    program_node& inv_variance() const { return get_dependency(1); };
     bool variance_term() const { return !get_primitive()->variance.empty(); }
     bool use_global_stats() const { return !get_primitive()->mean.empty() && !get_primitive()->variance.empty(); };
     bool forwad_pass() const { return !get_primitive()->inv_variance.empty(); };
@@ -54,9 +54,9 @@ public:
 public:
     typed_primitive_inst(network_impl& network, batch_norm_node const& node);
 
-    decltype(auto) mean_memory() const { return dep_memory(1); }
-    decltype(auto) variance_memory() const { return dep_memory(2); }
-    decltype(auto) inv_variance_memory() const { return dep_memory(1); };
+    memory_impl& mean_memory() const { return dep_memory(1); }
+    memory_impl& variance_memory() const { return dep_memory(2); }
+    memory_impl& inv_variance_memory() const { return dep_memory(1); };
     bool use_global_stats() const { return !argument.mean.empty() && !argument.variance.empty(); };
     bool forwad_pass() const { return !argument.inv_variance.empty(); };
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/border_inst.h b/inference-engine/thirdparty/clDNN/src/include/border_inst.h
new file mode 100644
index 000000000..ff3b28b2a
--- /dev/null
+++ b/inference-engine/thirdparty/clDNN/src/include/border_inst.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <api/CPP/border.hpp>
+
+#include "primitive_inst.h"
+
+
+namespace cldnn
+{
+template <>
+struct typed_program_node<border> : typed_program_node_base<border>
+{
+private:
+    using parent = typed_program_node_base<border>;
+
+
+public:
+    using parent::parent;
+
+    program_node& input() const { return get_dependency(0); }
+};
+
+using border_node = typed_program_node<border>;
+
+
+template <>
+class typed_primitive_inst<border> : public typed_primitive_inst_base<border>
+{
+    using parent = typed_primitive_inst_base<border>;
+
+public:
+    static layout calc_output_layout(border_node const& node);
+    static std::string to_string(border_node const& node);
+    typed_primitive_inst(network_impl& network, border_node const& node);
+};
+
+using border_inst = typed_primitive_inst<border>;
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/broadcast_inst.h b/inference-engine/thirdparty/clDNN/src/include/broadcast_inst.h
new file mode 100644
index 000000000..f10b562c5
--- /dev/null
+++ b/inference-engine/thirdparty/clDNN/src/include/broadcast_inst.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <api/CPP/broadcast.hpp>
+
+#include "primitive_inst.h"
+
+
+namespace cldnn
+{
+template <>
+struct typed_program_node<broadcast> : typed_program_node_base<broadcast>
+{
+private:
+    using parent = typed_program_node_base<broadcast>;
+
+
+public:
+    using parent::parent;
+
+    program_node& input() const { return get_dependency(0); }
+};
+
+using broadcast_node = typed_program_node<broadcast>;
+
+
+template <>
+class typed_primitive_inst<broadcast> : public typed_primitive_inst_base<broadcast>
+{
+    using parent = typed_primitive_inst_base<broadcast>;
+
+public:
+    static layout calc_output_layout(broadcast_node const& node);
+    static std::string to_string(broadcast_node const& node);
+    typed_primitive_inst(network_impl& network, broadcast_node const& node);
+};
+
+using broadcast_inst = typed_primitive_inst<broadcast>;
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/concatenation_inst.h b/inference-engine/thirdparty/clDNN/src/include/concatenation_inst.h
index 76f335125..2ef3b1bb9 100644
--- a/inference-engine/thirdparty/clDNN/src/include/concatenation_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/concatenation_inst.h
@@ -30,9 +30,9 @@ struct typed_program_node<concatenation> : public typed_program_node_base<concat
 public:
     using parent::parent;
 
-    decltype(auto) input(size_t idx = 0) const { return get_dependency(idx); }
+    program_node& input(size_t idx = 0) const { return get_dependency(idx); }
 
-    auto inputs_count() const { return desc->input.size(); }
+    size_t inputs_count() const { return desc->input.size(); }
 };
 
 using concatenation_node = typed_program_node<concatenation>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/constants_propagator.h b/inference-engine/thirdparty/clDNN/src/include/constants_propagator.h
index 1886fcd81..7b402f37a 100644
--- a/inference-engine/thirdparty/clDNN/src/include/constants_propagator.h
+++ b/inference-engine/thirdparty/clDNN/src/include/constants_propagator.h
@@ -41,6 +41,8 @@ private:
 
     void handle_constant(program_node& node);
     void add_constant(program_node& node);
+    void add_deps_to_tpl(const std::vector<program_node*>& node);
+    bool is_already_in_tpl(const primitive_id& id);
 };
 
 }
diff --git a/inference-engine/thirdparty/clDNN/src/include/convolution_grad_weights_inst.h b/inference-engine/thirdparty/clDNN/src/include/convolution_grad_weights_inst.h
index 32d37a860..ed32f0c8e 100644
--- a/inference-engine/thirdparty/clDNN/src/include/convolution_grad_weights_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/convolution_grad_weights_inst.h
@@ -42,9 +42,9 @@ public:
     void set_depthwise_sep_opt(bool node_depthwise_sep_opt) { depthwise_sep_opt = node_depthwise_sep_opt; }
     bool get_depthwise_sep_opt() const { return depthwise_sep_opt; }
 
-    decltype(auto) input(size_t idx = 0) const { return get_dependency(idx); }
+    program_node& input(size_t idx = 0) const { return get_dependency(idx); }
 
-    decltype(auto) weights(size_t idx = 0) const
+    program_node& weights(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= get_split())
             throw std::range_error("weights offset too big");
@@ -52,7 +52,7 @@ public:
         return get_dependency(2 + idx);
     }
 
-    decltype(auto) bias(size_t idx = 0) const
+    program_node& bias(size_t idx = 0) const
     { 
         if (static_cast<int32_t>(idx) >= get_split())
             throw std::range_error("bias offset too big");
@@ -60,14 +60,14 @@ public:
         return get_dependency(2 + this->get_split() + idx);
     }
 
-    decltype(auto) prev_weights_grad(size_t idx = 0) const
+    program_node& prev_weights_grad(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= get_split())
             throw std::range_error("prev weights grad offset too big");
         return get_dependency(2 + (bias_term() ? 2 : 1) * get_split() + idx);
     }
 
-    decltype(auto) prev_bias_grad(size_t idx = 0) const
+    program_node& prev_bias_grad(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= get_split())
             throw std::range_error("prev bias grad offset too big");
@@ -109,7 +109,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, convolution_grad_weights_node const& node);
 
-    decltype(auto) weights_memory(size_t index) const
+    memory_impl& weights_memory(size_t index) const
     {
         if (static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("weights offset too big");
@@ -117,7 +117,7 @@ public:
         return dep_memory(2 + index);
     }
 
-    decltype(auto) bias_memory(size_t index) const
+    memory_impl& bias_memory(size_t index) const
     {
         if (argument.bias.size() == 0 && static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("no bias data");
@@ -128,7 +128,7 @@ public:
         return dep_memory(2 + node.get_split() + index);
     }
 
-    decltype(auto) prev_weights_grad(size_t index) const
+    memory_impl& prev_weights_grad(size_t index) const
     {
         if(argument.prev_weights_grad.size() == 0 && static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("no prev weights grad data");
@@ -139,7 +139,7 @@ public:
         return dep_memory(2 + (bias_term() ? 2 : 1) * node.get_split() + index);
     }
 
-    decltype(auto) prev_bias_grad(size_t index) const
+    memory_impl& prev_bias_grad(size_t index) const
     {
         if (argument.prev_bias_grad.size() == 0 && static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("no prev bias grad data");
diff --git a/inference-engine/thirdparty/clDNN/src/include/convolution_inst.h b/inference-engine/thirdparty/clDNN/src/include/convolution_inst.h
index c4a175b1e..b47e09fab 100644
--- a/inference-engine/thirdparty/clDNN/src/include/convolution_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/convolution_inst.h
@@ -49,9 +49,9 @@ public:
     void set_transposed(bool node_transposed) { transposed = node_transposed; }
     bool get_transposed() const { return transposed; }
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 
-    decltype(auto) weights(size_t idx = 0) const
+    program_node& weights(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= this->get_split())
             throw std::range_error("weights offset too big");
@@ -59,7 +59,7 @@ public:
         return get_dependency(1 + idx);
     }
 
-    decltype(auto) bias(size_t idx = 0) const
+    program_node& bias(size_t idx = 0) const
     { 
         if (static_cast<int32_t>(idx) >= this->get_split())
             throw std::range_error("bias offset too big");
@@ -67,7 +67,7 @@ public:
         return get_dependency(1 + this->get_split() + idx);
     }
 
-    decltype(auto) weights_quantization_factors(size_t idx = 0) const
+    program_node& weights_quantization_factors(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= this->get_split())
             throw std::range_error("quantization factor offset too big");
@@ -75,7 +75,7 @@ public:
         return get_dependency(1 + 2*this->get_split() + idx);
     }
 
-    decltype(auto) output_calibration_factors(size_t idx = 0) const
+    program_node& output_calibration_factors(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= this->get_split())
             throw std::range_error("calibration factor offset too big");
@@ -123,7 +123,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, convolution_node const& node);
 
-    decltype(auto)weights_memory(size_t index) const
+    memory_impl& weights_memory(size_t index) const
     {
         if (static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("weights offset too big");
@@ -131,7 +131,7 @@ public:
         return dep_memory(1 + index);
     }
 
-    decltype(auto) bias_memory(size_t index) const
+    memory_impl& bias_memory(size_t index) const
     { 
         if (static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("bias offset too big");
@@ -139,7 +139,7 @@ public:
         return dep_memory(1 + node.get_split() + index);
     }
 
-    decltype(auto) weights_quantization_factors_memory(size_t index) const
+    memory_impl& weights_quantization_factors_memory(size_t index) const
     {
         if (static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("quantization factors offset too big");
@@ -147,7 +147,7 @@ public:
         return dep_memory(1 + 2*node.get_split() + index);
     }
 
-    decltype(auto) output_calibration_factors_memory(size_t index) const
+    memory_impl& output_calibration_factors_memory(size_t index) const
     {
         if (static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("quantization factors offset too big");
diff --git a/inference-engine/thirdparty/clDNN/src/include/crop_inst.h b/inference-engine/thirdparty/clDNN/src/include/crop_inst.h
index ee3519bd0..ef4260f9c 100644
--- a/inference-engine/thirdparty/clDNN/src/include/crop_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/crop_inst.h
@@ -30,7 +30,7 @@ class typed_program_node<crop> : public typed_program_node_base<crop>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 };
 
 using crop_node = typed_program_node<crop>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/custom_gpu_primitive_inst.h b/inference-engine/thirdparty/clDNN/src/include/custom_gpu_primitive_inst.h
index 8af329d26..377be1d10 100644
--- a/inference-engine/thirdparty/clDNN/src/include/custom_gpu_primitive_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/custom_gpu_primitive_inst.h
@@ -29,7 +29,7 @@ struct typed_program_node<custom_gpu_primitive> : public typed_program_node_base
 public:
     using parent::parent;
 
-    decltype(auto) input(size_t idx = 0) const { return get_dependency(idx); }
+    program_node& input(size_t idx = 0) const { return get_dependency(idx); }
 };
 
 using custom_gpu_primitive_node = typed_program_node<custom_gpu_primitive>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/deconvolution_inst.h b/inference-engine/thirdparty/clDNN/src/include/deconvolution_inst.h
index 446715954..a2e1516f2 100644
--- a/inference-engine/thirdparty/clDNN/src/include/deconvolution_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/deconvolution_inst.h
@@ -42,9 +42,9 @@ public:
     void set_depthwise_sep_opt(bool node_depthwise_sep_opt) { depthwise_sep_opt = node_depthwise_sep_opt; }
     bool get_depthwise_sep_opt() const { return depthwise_sep_opt; }
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 
-    decltype(auto) weights(size_t idx = 0) const
+    program_node& weights(size_t idx = 0) const
     {
         if (static_cast<int32_t>(idx) >= get_split())
             throw std::range_error("weights offset too big");
@@ -52,7 +52,7 @@ public:
         return get_dependency(1 + idx);
     }
 
-    decltype(auto) bias(size_t idx = 0) const
+    program_node& bias(size_t idx = 0) const
     { 
         if (static_cast<int32_t>(idx) >= get_split())
             throw std::range_error("bias offset too big");
@@ -68,6 +68,23 @@ public:
             return false;
     }
 
+    program_node& fused_sum(size_t idx = 0) const
+    {
+        if (static_cast<int32_t>(idx) > 0)
+            throw std::range_error("Only one input for fused sum is supported");
+
+        int d_idx = 1 + this->get_split() + idx;
+        d_idx += bias_term() ? this->get_split() : 0;
+        return get_dependency(d_idx);
+    }
+
+    bool has_fused_sum() const
+    {
+        int d_idx = 1 + this->get_split();
+        d_idx += bias_term() ? this->get_split() : 0;
+        return static_cast<int>(dependencies.size()) == (d_idx + 1);
+    }
+
 private:
     int32_t split;
     bool depthwise_sep_opt;
@@ -87,7 +104,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, deconvolution_node const& node);
 
-    decltype(auto) weights_memory(size_t index) const
+    memory_impl& weights_memory(size_t index) const
     {
         if (static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("weights offset too big");
@@ -95,7 +112,7 @@ public:
         return dep_memory(1 + index);
     }
 
-    decltype(auto) bias_memory(size_t index) const
+    memory_impl& bias_memory(size_t index) const
     {
         if (argument.bias.size() == 0 && static_cast<int32_t>(index) >= node.get_split())
             throw std::range_error("no bias data");
diff --git a/inference-engine/thirdparty/clDNN/src/include/detection_output_inst.h b/inference-engine/thirdparty/clDNN/src/include/detection_output_inst.h
index 2a4bc4dc8..f918b6d47 100644
--- a/inference-engine/thirdparty/clDNN/src/include/detection_output_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/detection_output_inst.h
@@ -34,9 +34,9 @@ class typed_program_node<detection_output> : public typed_program_node_base<dete
 public:
     using parent::parent;
 
-    decltype(auto) location() const { return get_dependency(0); }
-    decltype(auto) confidence() const { return get_dependency(1); }
-    decltype(auto) prior_box() const { return get_dependency(2); }
+    program_node& location() const { return get_dependency(0); }
+    program_node& confidence() const { return get_dependency(1); }
+    program_node& prior_box() const { return get_dependency(2); }
 };
 
 using detection_output_node = typed_program_node<detection_output>;
@@ -53,11 +53,11 @@ public:
 public:
     typed_primitive_inst(network_impl& network, detection_output_node const& node);
 
-    decltype(auto) location_memory() const { return dep_memory(0); }
-    decltype(auto) confidence_memory() const { return dep_memory(1); }
-    decltype(auto) prior_box_memory() const { return dep_memory(2); }
+    memory_impl& location_memory() const { return dep_memory(0); }
+    memory_impl& confidence_memory() const { return dep_memory(1); }
+    memory_impl& prior_box_memory() const { return dep_memory(2); }
 };
 
 using detection_output_inst = typed_primitive_inst<detection_output>;
 
-}
\ No newline at end of file
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/eltwise_inst.h b/inference-engine/thirdparty/clDNN/src/include/eltwise_inst.h
index 2e95d0369..f6d8f6115 100644
--- a/inference-engine/thirdparty/clDNN/src/include/eltwise_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/eltwise_inst.h
@@ -37,9 +37,9 @@ public:
     }
 
 
-    decltype(auto) input(size_t idx = 0) const { return get_dependency(idx); }
+    program_node& input(size_t idx = 0) const { return get_dependency(idx); }
     size_t inputs_count() const { return get_dependencies().size() - (output_cf ? 1 : 0); }
-    decltype(auto) output_calibration_factors() const { return get_dependency(inputs_count()); }
+    program_node& output_calibration_factors() const { return get_dependency(inputs_count()); }
     bool output_calibration_term() const { return !get_primitive()->output_calibration_factors.empty(); }
     float get_output_qf() const { return output_qf; }
 
@@ -62,7 +62,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, eltwise_node const& node);
 
-    decltype(auto) output_calibration_factors_memory() const { return dep_memory(node.inputs_count()); } // because last place should be reserved for calibration factors
+    memory_impl& output_calibration_factors_memory() const { return dep_memory(node.inputs_count()); } // because last place should be reserved for calibration factors
     bool output_calibration_factors_term() const { return node.output_calibration_term(); }
 };
 
diff --git a/inference-engine/thirdparty/clDNN/src/include/embed_inst.h b/inference-engine/thirdparty/clDNN/src/include/embed_inst.h
index 7f5a09bc5..045522624 100644
--- a/inference-engine/thirdparty/clDNN/src/include/embed_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/embed_inst.h
@@ -29,9 +29,9 @@ namespace cldnn
 	public:
 		using parent::parent;
 
-		decltype(auto) input() const { return get_dependency(0); }
-		decltype(auto) weights() const { return get_dependency(1); }
-		decltype(auto) bias() const { return get_dependency(2); }
+		program_node& input() const { return get_dependency(0); }
+		program_node& weights() const { return get_dependency(1); }
+		program_node& bias() const { return get_dependency(2); }
 		bool bias_term() const { return !get_primitive()->bias.empty(); }
 	};
 
@@ -48,11 +48,11 @@ namespace cldnn
 
 	public:
 		typed_primitive_inst(network_impl& network, embed_node const& node);
-		decltype(auto) weights_memory() const { return dep_memory(1); }
-		decltype(auto) bias_memory() const { return dep_memory(2); }
+		memory_impl& weights_memory() const { return dep_memory(1); }
+		memory_impl& bias_memory() const { return dep_memory(2); }
 		bool bias_term() const { return !argument.bias.empty(); }
 	};
 
 	using embed_inst = typed_primitive_inst<embed>;
 
-}
\ No newline at end of file
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/error_handler.h b/inference-engine/thirdparty/clDNN/src/include/error_handler.h
index 38808113a..36f6bd733 100644
--- a/inference-engine/thirdparty/clDNN/src/include/error_handler.h
+++ b/inference-engine/thirdparty/clDNN/src/include/error_handler.h
@@ -16,32 +16,23 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
-#include <iostream>
 #include <sstream>
 #include <vector>
 #include <array>
 #include <algorithm>
 #include <type_traits>
 #include "api/CPP/layout.hpp"
-#include "api/CPP/lrn.hpp"
 
 namespace cldnn
 {
-namespace err_details
-{
-    void cldnn_print_error_message(std::string file, int line, std::string instance_id, std::stringstream &msg, std::string add_msg = "");
-}
 
-template <class T1, class T2>
-std::ostream& operator <<(std::ostream& left, std::pair<T1, T2> const& right)
+namespace err_details
 {
-    left << "{ " << right.first << ", " << right.second << " }";
-    return left;
+    void cldnn_print_error_message(const std::string& file, int line, const std::string& instance_id, std::stringstream &msg, const std::string& add_msg = "");
 }
 
-
 template<typename N1, typename N2>
-inline void error_on_not_equal(std::string file, int line, std::string instance_id, std::string number_id, N1 number, std::string compare_to_id, N2 number_to_compare_to, std::string additional_message = "")
+inline void error_on_not_equal(const std::string& file, int line, const std::string& instance_id, const std::string& number_id, N1 number, const std::string& compare_to_id, N2 number_to_compare_to, const std::string& additional_message = "")
 {
     std::stringstream error_msg;
     {
@@ -55,7 +46,7 @@ inline void error_on_not_equal(std::string file, int line, std::string instance_
 #define CLDNN_ERROR_NOT_EQUAL(instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg) error_on_not_equal(__FILE__, __LINE__, instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg)
 
 template<typename N1, typename N2>
-inline void error_on_greater_than(std::string file, int line, std::string instance_id, std::string number_id, N1 number, std::string compare_to_id, N2 number_to_compare_to, std::string additional_message = "")
+inline void error_on_greater_than(const std::string& file, int line, const std::string& instance_id, const std::string& number_id, N1 number, const std::string& compare_to_id, N2 number_to_compare_to, const std::string& additional_message = "")
 {
     std::stringstream error_msg;
     if (number > static_cast<decltype(number)>(number_to_compare_to))
@@ -67,7 +58,7 @@ inline void error_on_greater_than(std::string file, int line, std::string instan
 #define CLDNN_ERROR_GREATER_THAN(instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg) error_on_greater_than(__FILE__, __LINE__, instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg)
 
 template<typename N1, typename N2>
-inline void error_on_less_than(std::string file, int line, std::string instance_id, std::string number_id, N1 number, std::string compare_to_id, N2 number_to_compare_to, std::string additional_message = "")
+inline void error_on_less_than(const std::string& file, int line, const std::string& instance_id, const std::string& number_id, N1 number, const std::string& compare_to_id, N2 number_to_compare_to, const std::string& additional_message = "")
 {
     std::stringstream error_msg;
     if (number < static_cast<decltype(number)>(number_to_compare_to))
@@ -79,7 +70,7 @@ inline void error_on_less_than(std::string file, int line, std::string instance_
 #define CLDNN_ERROR_LESS_THAN(instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg) error_on_less_than(__FILE__, __LINE__, instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg)
 
 template<typename N1, typename N2>
-inline void error_on_less_or_equal_than(std::string file, int line, std::string instance_id, std::string number_id, N1 number, std::string compare_to_id, N2 number_to_compare_to, std::string additional_message = "")
+inline void error_on_less_or_equal_than(const std::string& file, int line, const std::string& instance_id, const std::string& number_id, N1 number, const std::string& compare_to_id, N2 number_to_compare_to, const std::string& additional_message = "")
 {
     std::stringstream error_msg;
     if (number <= static_cast<decltype(number)>(number_to_compare_to))
@@ -91,7 +82,7 @@ inline void error_on_less_or_equal_than(std::string file, int line, std::string
 #define CLDNN_ERROR_LESS_OR_EQUAL_THAN(instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg) error_on_less_or_equal_than(__FILE__, __LINE__, instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg)
 
 template<typename N1, typename N2>
-inline void error_on_greater_or_equal_than(std::string file, int line, std::string instance_id, std::string number_id, N1 number, std::string compare_to_id, N2 number_to_compare_to, std::string additional_message = "")
+inline void error_on_greater_or_equal_than(const std::string& file, int line, const std::string& instance_id, const std::string& number_id, N1 number, const std::string& compare_to_id, N2 number_to_compare_to, const std::string& additional_message = "")
 {
     std::stringstream error_msg;
     if (number >= static_cast<decltype(number)>(number_to_compare_to))
@@ -103,7 +94,7 @@ inline void error_on_greater_or_equal_than(std::string file, int line, std::stri
 #define CLDNN_ERROR_GREATER_OR_EQUAL_THAN(instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg) error_on_greater_or_equal_than(__FILE__, __LINE__, instance_id, number_id, number, compare_to_id, number_to_compare_to, add_msg)
 
 template<typename ptr>
-inline void error_on_nullptr(std::string file, int line, std::string instance_id, std::string condition_id, ptr condition, std::string additional_message = "")
+inline void error_on_nullptr(const std::string& file, int line, const std::string& instance_id, const std::string& condition_id, ptr condition, const std::string& additional_message = "")
 {
     std::stringstream error_msg;
     if (condition == nullptr)
@@ -114,8 +105,8 @@ inline void error_on_nullptr(std::string file, int line, std::string instance_id
 }
 #define CLDNN_ERROR_NULLPTR(instance_id, condition_id, condition, add_msg) error_on_nullptr(__FILE__, __LINE__, instance_id, condition_id, condition, add_msg)
 
-template<typename M, typename... Ms>
-inline void error_on_not_proper_enum_values(std::string file, int line, std::string instance_id, std::string mode_id, M mode, std::string modes_id, Ms... modes_to_compare_to)
+template<typename M = format, typename... Ms>
+inline void error_on_not_proper_enum_values(const std::string& file, int line, const std::string& instance_id, const std::string& mode_id, M mode, const std::string& modes_id, Ms... modes_to_compare_to)
 {
     std::stringstream error_msg;
     auto enum_value_string = [](const M& mode)->std::string {
@@ -123,10 +114,6 @@ inline void error_on_not_proper_enum_values(std::string file, int line, std::str
         {
             return format::traits(mode).order;
         }
-        else if (std::is_same<M, cldnn_lrn_norm_region>::value)
-        {
-            return mode == 0 ? "cldnn_lrn_norm_region_across_channel" : "cldnn_lrn_norm_region_within_channel";
-        }
         return "error during error parsing";
     };
     const std::array<const M, sizeof...(Ms)> modes{ std::forward<Ms>(modes_to_compare_to)... };
@@ -142,27 +129,30 @@ inline void error_on_not_proper_enum_values(std::string file, int line, std::str
     }
 }
 #define CLDNN_ERROR_NOT_PROPER_FORMAT(instance_id, format_id, formatt, formats_ids, ...) error_on_not_proper_enum_values(__FILE__, __LINE__, instance_id, format_id, formatt, formats_ids, __VA_ARGS__)
-#define CLDNN_ERROR_NOT_PROPER_LRN_NORM_REGION(instance_id, lrn_norm_region_id, lrn_norm_region, lrn_norm_region_ids, ...) error_on_not_proper_enum_values(__FILE__, __LINE__, instance_id, lrn_norm_region_id, lrn_norm_region, lrn_norm_region_ids, __VA_ARGS__)
 
-void error_message(std::string file, int line, std::string instance_id, std::string message);
+void error_message(const std::string& file, int line, const std::string& instance_id, const std::string& message);
 #define CLDNN_ERROR_MESSAGE(instance_id, message) error_message(__FILE__, __LINE__, instance_id, message)
 
-void error_on_not_supported_fp16(std::string file, int line, std::string instance_id, uint8_t supp_fp16, bool fp16_used);
+void error_on_not_supported_fp16(const std::string& file, int line, const std::string& instance_id, uint8_t supp_fp16, bool fp16_used);
 #define CLDNN_ERROR_NOT_SUPPORTED_FP16(instance_id, gpu_supp_fp16, fp16_used) error_on_not_supported_fp16(__FILE__, __LINE__, instance_id, gpu_supp_fp16, fp16_used)
 
-void error_on_mismatch_layout(std::string file, int line, std::string instance_id, std::string layout_1_id, layout layout_1, std::string layout_2_id, layout layout_2, std::string additional_message = "");
+void error_on_mismatch_layout(const std::string& file, int line, const std::string& instance_id, const std::string& layout_1_id, const layout& layout_1, const std::string& layout_2_id, const layout& layout_2, const std::string& additional_message = "");
 #define CLDNN_ERROR_LAYOUT_MISMATCH(instance_id, layout_1_id, layout_1, layout_2_id, layout_2, add_msg) error_on_mismatch_layout(__FILE__, __LINE__, instance_id, layout_1_id, layout_1, layout_2_id, layout_2, add_msg)
 
-void error_on_bool(std::string file, int line, std::string instance_id, std::string condition_id, bool condition, std::string additional_message = "");
+void error_on_bool(const std::string& file, int line, const std::string& instance_id, const std::string& condition_id, bool condition, const std::string& additional_message = "");
 #define CLDNN_ERROR_BOOL(instance_id, condition_id, condition, add_msg) error_on_bool(__FILE__, __LINE__, instance_id, condition_id, condition, add_msg)
 
-void error_on_mismatching_data_types(std::string file, int line, std::string instance_id, std::string data_format_1_id, data_types data_format_1, std::string data_format_2_id, data_types data_format_2, std::string additional_message = "");
+void error_on_mismatching_data_types(const std::string& file, int line, const std::string& instance_id, const std::string& data_format_1_id, data_types data_format_1, const std::string& data_format_2_id, data_types data_format_2, const std::string& additional_message = "");
 #define CLDNN_ERROR_DATA_TYPES_MISMATCH(instance_id, data_format_1_id, data_format_1, data_format_2_id, data_format_2, add_msg) error_on_mismatching_data_types(__FILE__, __LINE__, instance_id, data_format_1_id, data_format_1, data_format_2_id, data_format_2, add_msg)
 
-void error_on_tensor_dims_less_than_other_tensor_dims(std::string file, int line, std::string instance_id, std::string tensor_id, tensor tens, std::string tensor_to_compare_to_id, tensor tens_to_compre, std::string additional_message = "");
+void error_on_tensor_dims_less_than_other_tensor_dims(const std::string& file, int line, const std::string& instance_id, const std::string& tensor_id, const tensor& tens, const std::string& tensor_to_compare_to_id, const tensor& tens_to_compre, const std::string& additional_message = "");
 #define CLDNN_ERROR_TENSOR_SIZES_LESS_THAN(instance_id, tensor_id, tensor_1, compare_to_id, tensor_to_compare_to, ...) error_on_tensor_dims_less_than_other_tensor_dims(__FILE__, __LINE__, instance_id, tensor_id, tensor_1, compare_to_id, tensor_to_compare_to, __VA_ARGS__)
 
-void error_on_tensor_dims_greater_than_other_tensor_dims(std::string file, int line, std::string instance_id, std::string tensor_id, tensor tens, std::string tensor_to_compare_to, tensor tens_to_compre, std::string additional_message = "");
+void error_on_tensor_dims_greater_than_other_tensor_dims(const std::string& file, int line, const std::string& instance_id, const std::string& tensor_id, const tensor& tens, const std::string& tensor_to_compare_to_id, const tensor& tens_to_compre, const std::string& additional_message = "");
 #define CLDNN_ERROR_TENSOR_SIZES_GREATER_THAN(instance_id, tensor_id, tensor_1, compare_to_id, tensor_to_compare_to, ...) error_on_tensor_dims_greater_than_other_tensor_dims(__FILE__, __LINE__, instance_id, tensor_id, tensor_1, compare_to_id, tensor_to_compare_to, __VA_ARGS__)
 
+void error_on_tensor_dims_not_dividable_by_other_tensor_dims(const std::string& file, int line, const std::string& instance_id, const std::string& tensor_id, const tensor& tens, const std::string& tensor_to_compare_to_id, const tensor& tens_to_compre, const std::string& additional_message = "");
+#define CLDNN_ERROR_TENSOR_SIZES_NOT_DIVIDABLE(instance_id, tensor_id, tensor_1, compare_to_id, tensor_to_compare_to, ...) error_on_tensor_dims_not_dividable_by_other_tensor_dims(__FILE__, __LINE__, instance_id, tensor_id, tensor_1, compare_to_id, tensor_to_compare_to, __VA_ARGS__)
+
+
 }
diff --git a/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_input_inst.h b/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_input_inst.h
index 60a429043..4813516bf 100644
--- a/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_input_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_input_inst.h
@@ -29,8 +29,8 @@ struct typed_program_node<fully_connected_grad_input> : public typed_program_nod
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) weights() const { return get_dependency(2); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& weights() const { return get_dependency(2); }
 
 };
 
@@ -48,7 +48,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, fully_connected_grad_input_node const& node);
 
-    decltype(auto) weights_memory() const { return dep_memory(2); }
+    memory_impl& weights_memory() const { return dep_memory(2); }
     bool bias_term() const { return false; }
 
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_weights_inst.h b/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_weights_inst.h
index 1ca26bc68..6217b9a99 100644
--- a/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_weights_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/fully_connected_grad_weights_inst.h
@@ -29,11 +29,11 @@ struct typed_program_node<fully_connected_grad_weights> : public typed_program_n
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) weights() const { return get_dependency(2); }
-    decltype(auto) bias() const { return get_dependency(3); }
-    decltype(auto) prev_weights_grad() const { return bias_term() ? get_dependency(4) : get_dependency(3); }
-    decltype(auto) prev_bias_grad() const { return get_dependency(5); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& weights() const { return get_dependency(2); }
+    program_node& bias() const { return get_dependency(3); }
+    program_node& prev_weights_grad() const { return bias_term() ? get_dependency(4) : get_dependency(3); }
+    program_node& prev_bias_grad() const { return get_dependency(5); }
     bool use_momentum() const { return !get_primitive()->prev_weights_grad.empty(); }
     bool bias_term() const { return !get_primitive()->bias.empty(); }
 };
@@ -52,10 +52,10 @@ public:
 public:
     typed_primitive_inst(network_impl& network, fully_connected_grad_weights_node const& node);
 
-    decltype(auto) weights_memory() const { return dep_memory(2); }
-    decltype(auto) bias_memory() const { return dep_memory(3); }
-    decltype(auto) prev_weights_grad() const { return bias_term() ? dep_memory(4) : dep_memory(3); }
-    decltype(auto) prev_bias_grad() const { return dep_memory(5); }
+    memory_impl& weights_memory() const { return dep_memory(2); }
+    memory_impl& bias_memory() const { return dep_memory(3); }
+    memory_impl& prev_weights_grad() const { return bias_term() ? dep_memory(4) : dep_memory(3); }
+    memory_impl& prev_bias_grad() const { return dep_memory(5); }
     bool use_momentum() const { return !argument.prev_weights_grad.empty(); }
     bool bias_term() const { return !argument.bias.empty(); }
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/fully_connected_inst.h b/inference-engine/thirdparty/clDNN/src/include/fully_connected_inst.h
index ad068fc00..395fc61f1 100644
--- a/inference-engine/thirdparty/clDNN/src/include/fully_connected_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/fully_connected_inst.h
@@ -34,11 +34,11 @@ public:
     {
     }
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) weights() const { return get_dependency(1); }
-    decltype(auto) bias() const { return get_dependency(2); }
-    decltype(auto) weights_quantization_factors() const { return get_dependency(3); }
-    decltype(auto) output_calibration_factors() const { return get_dependency(4); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& weights() const { return get_dependency(1); }
+    program_node& bias() const { return get_dependency(2); }
+    program_node& weights_quantization_factors() const { return get_dependency(3); }
+    program_node& output_calibration_factors() const { return get_dependency(4); }
     bool bias_term() const { return !get_primitive()->bias.empty(); }
     bool weights_quantization_term() const { return !get_primitive()->weights_quantization_factors.empty(); }
     bool output_calibration_term() const { return !get_primitive()->output_calibration_factors.empty(); }
@@ -64,10 +64,10 @@ public:
 public:
     typed_primitive_inst(network_impl& network, fully_connected_node const& node);
 
-    decltype(auto) weights_memory() const { return dep_memory(1); }
-    decltype(auto) bias_memory() const { return dep_memory(2); }
-    decltype(auto) weights_quantization_factors_memory() const { return dep_memory(3); }
-    decltype(auto) output_calibration_factors_memory() const { return dep_memory(4); }
+    memory_impl& weights_memory() const { return dep_memory(1); }
+    memory_impl& bias_memory() const { return dep_memory(2); }
+    memory_impl& weights_quantization_factors_memory() const { return dep_memory(3); }
+    memory_impl& output_calibration_factors_memory() const { return dep_memory(4); }
 
     bool bias_term() const { return !argument.bias.empty(); }
     bool weights_quantization_factors_term() const { return node.weights_quantization_term(); }
diff --git a/inference-engine/thirdparty/clDNN/src/include/gemm_inst.h b/inference-engine/thirdparty/clDNN/src/include/gemm_inst.h
new file mode 100644
index 000000000..05ba722c6
--- /dev/null
+++ b/inference-engine/thirdparty/clDNN/src/include/gemm_inst.h
@@ -0,0 +1,53 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+#include "api/CPP/gemm.hpp"
+#include "primitive_inst.h"
+
+namespace cldnn
+{
+template <>
+struct typed_program_node<gemm> : public typed_program_node_base<gemm>
+{
+    using parent = typed_program_node_base<gemm>;
+
+public:
+    using parent::parent;
+
+    program_node& input(size_t idx = 0) const { return get_dependency(idx); }
+    size_t inputs_count() const { return get_dependencies().size(); }
+};
+
+using gemm_node = typed_program_node<gemm>;
+
+template <>
+class typed_primitive_inst<gemm> : public typed_primitive_inst_base<gemm>
+{
+    using parent = typed_primitive_inst_base<gemm>;
+
+public:
+    static layout calc_output_layout(gemm_node const& node);
+    static std::string to_string(gemm_node const& node);
+
+public:
+    typed_primitive_inst(network_impl& network, gemm_node const& node);
+};
+
+using gemm_inst = typed_primitive_inst<gemm>;
+
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/generic_layer_inst.h b/inference-engine/thirdparty/clDNN/src/include/generic_layer_inst.h
index 9bae70bd8..468591b3e 100644
--- a/inference-engine/thirdparty/clDNN/src/include/generic_layer_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/generic_layer_inst.h
@@ -29,7 +29,7 @@ struct typed_program_node<generic_layer> : public typed_program_node_base<generi
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 };
 
 using generic_layer_node = typed_program_node<generic_layer>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/index_select_inst.h b/inference-engine/thirdparty/clDNN/src/include/index_select_inst.h
new file mode 100644
index 000000000..0d775f65b
--- /dev/null
+++ b/inference-engine/thirdparty/clDNN/src/include/index_select_inst.h
@@ -0,0 +1,61 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+#include "api/CPP/index_select.hpp"
+#include "primitive_inst.h"
+
+#include <memory>
+
+namespace cldnn
+{
+
+	template <>
+	struct typed_program_node<index_select> : public typed_program_node_base<index_select>
+	{
+		using parent = typed_program_node_base<index_select>;
+
+	public:
+		typed_program_node(std::shared_ptr<primitive> prim, program_impl& prog)
+			: parent(prim, prog)
+		{
+		}
+		program_node& input() const { return get_dependency(0); }
+        program_node& indices() const { return get_dependency(1); }
+        index_select_axis_name get_axis() const { return get_primitive()->axis; }
+	};
+
+	using index_select_node = typed_program_node<index_select>;
+
+	template <>
+	class typed_primitive_inst<index_select> : public typed_primitive_inst_base<index_select>
+	{
+		using parent = typed_primitive_inst_base<index_select>;
+
+	public:
+		static layout calc_output_layout(index_select_node const& node);
+		static std::string to_string(index_select_node const& node);
+		typed_primitive_inst(network_impl& network, index_select_node const& node);
+
+        memory_impl& input() const { return dep_memory(0); }
+        memory_impl& indices() const { return dep_memory(1); }
+        index_select_axis_name get_axis() const { return node.get_axis(); }
+	};
+
+	using index_select_inst = typed_primitive_inst<index_select>;
+
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/internal_primitive_type_base.h b/inference-engine/thirdparty/clDNN/src/include/internal_primitive_type_base.h
index d4e55dcf0..1f1467781 100644
--- a/inference-engine/thirdparty/clDNN/src/include/internal_primitive_type_base.h
+++ b/inference-engine/thirdparty/clDNN/src/include/internal_primitive_type_base.h
@@ -27,7 +27,7 @@ namespace cldnn
 template <class PType>
 struct internal_primitive_type_base : public ::cldnn_primitive_type
 {
-    static_assert(meta::is_internal_primitive_v<PType>, "Primitive type passed to internal_primitive_type_base should derive from internal_primitive");
+    static_assert(meta::is_internal_primitive<PType>::value, "Primitive type passed to internal_primitive_type_base should derive from internal_primitive");
 
     [[noreturn]]
     std::shared_ptr<primitive> from_dto(const CLDNN_PRIMITIVE_DESC(primitive)*) const override
diff --git a/inference-engine/thirdparty/clDNN/src/include/json_object.h b/inference-engine/thirdparty/clDNN/src/include/json_object.h
index d6549655c..8807f8a0f 100644
--- a/inference-engine/thirdparty/clDNN/src/include/json_object.h
+++ b/inference-engine/thirdparty/clDNN/src/include/json_object.h
@@ -17,9 +17,7 @@
 #include <string>
 #include <type_traits>
 #include <unordered_map>
-#include <map>
-#include <algorithm>
-#include <iostream>
+#include <ostream>
 #include <memory>
 
 namespace cldnn
@@ -33,6 +31,7 @@ namespace cldnn
     {
     public:
         virtual void dump(std::ostream& out, int offset) = 0;
+        virtual ~json_base() = default;
     };
 
     template<class Type>
diff --git a/inference-engine/thirdparty/clDNN/src/include/kernel_selector_helper.h b/inference-engine/thirdparty/clDNN/src/include/kernel_selector_helper.h
index ac4837dd9..6030ccd25 100644
--- a/inference-engine/thirdparty/clDNN/src/include/kernel_selector_helper.h
+++ b/inference-engine/thirdparty/clDNN/src/include/kernel_selector_helper.h
@@ -1,5 +1,4 @@
-/*
-// Copyright (c) 2016 Intel Corporation
+// Copyright (c) 2016-2018 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,17 +11,20 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-*/
 
 #pragma once
+
 #include "api/C/cldnn.h"
 #include "api/CPP/program.hpp"
-#include "program_impl.h"
+
 #include "gpu/ocl_toolkit.h"
-#include "tensor_type.h"
+#include "program_impl.h"
+
 #include "kernel_selector_params.h"
 #include "kernel_selector_common.h"
-#include "jitter.h"
+#include "tensor_type.h"
+
+#include <cstdint>
 
 using namespace cldnn;
 
@@ -37,7 +39,6 @@ namespace kernel_selector
     using kernel_argument_types             = kernel_selector::ArgumentDescriptor::Types;
     using kernel_scalar_arguments           = kernel_selector::Scalars;
     using kernel_scalar_argument_types      = kernel_selector::ScalarDescriptor::Types;
-    using jit_constants                     = kernel_selector::JitConstants;
 
     using data_type                         = kernel_selector::Datatype;
     using kernel_type                       = kernel_selector::KernelType;
@@ -45,8 +46,8 @@ namespace kernel_selector
     using activation_function               = kernel_selector::ActivationFunction;
     using pool_type                         = kernel_selector::PoolType;
     using pool_remainder                    = kernel_selector::PoolRemainder;
-	using argm_axis							= kernel_selector::ArgMaxMinAxis;
-	using argm_output						= kernel_selector::ArgMaxMinOut;
+	using argm_axis                         = kernel_selector::ArgMaxMinAxis;
+	using argm_output                       = kernel_selector::ArgMaxMinOut;
     using lookt_axis                        = kernel_selector::LookUpTableAxis;
     using lrn_mode                          = kernel_selector::LRNMode;
     using normalize_mode                    = kernel_selector::NormalizeMode;
@@ -58,11 +59,14 @@ namespace kernel_selector
     using mean_subtruct_mode                = kernel_selector::MeanSubtractMode;
     using mean_op                           = kernel_selector::MeanOp;
     using concat_axis                       = kernel_selector::ConcatAxis;
+    using tile_axis                         = kernel_selector::TileAxis;
     using tuning_mode                       = kernel_selector::TuningMode;
     using sample_type                       = kernel_selector::SampleType;
+    using border_type                       = kernel_selector::BorderType;
 
     using data_tensor                       = kernel_selector::DataTensor;
     using weights_tensor                    = kernel_selector::WeightsTensor;
+    template <typename T> using dim_tensor  = kernel_selector::DimTensor<T>;
     using data_layout                       = kernel_selector::DataLayout;
     using weights_layout                    = kernel_selector::WeightsLayout;
     using multi_data_tensor                 = kernel_selector::MultiDataTensor;
@@ -72,249 +76,38 @@ namespace kernel_selector
     using generic_kernel_params             = kernel_selector::GenericKernelParams;
 }
 
-inline kernel_selector::data_type to_data_type(data_types dt)
-{
-    switch (dt)
-    {
-    case cldnn::data_types::i8:     return kernel_selector::data_type::INT8;
-    case cldnn::data_types::u8:     return kernel_selector::data_type::UINT8;
-    case cldnn::data_types::f16:    return kernel_selector::data_type::F16;
-    case cldnn::data_types::f32:    return kernel_selector::data_type::F32;
-    default:
-        assert(0);
-        return kernel_selector::data_type::F16;
-    }
-}
-
-inline data_types from_data_type(kernel_selector::data_type dt)
-{
-    switch (dt)
-    {
-    case kernel_selector::data_type::INT8:   return cldnn::data_types::i8;
-    case kernel_selector::data_type::UINT8:   return cldnn::data_types::u8;
-    case kernel_selector::data_type::F16:    return cldnn::data_types::f16;
-    case kernel_selector::data_type::F32:    return cldnn::data_types::f32;
-    default:
-        assert(0);
-        return cldnn::data_types::f16;
-    }
-}
-
-inline kernel_selector::weights_type to_weights_type(data_types dt)
-{
-    switch (dt)
-    {
-    case cldnn::data_types::i8:     return kernel_selector::weights_type::INT8;
-    case cldnn::data_types::f16:    return kernel_selector::weights_type::F16;
-    case cldnn::data_types::f32:    return kernel_selector::weights_type::F32;
-    default:
-        assert(0);
-        return kernel_selector::weights_type::F16;
-    }
-}
-
-inline data_types from_weights_type(kernel_selector::weights_type dt)
-{
-    switch (dt)
-    {
-    case kernel_selector::weights_type::INT8:   return data_types::i8;
-    case kernel_selector::weights_type::F16:    return data_types::f16;
-    case kernel_selector::weights_type::F32:    return data_types::f32;
-    default:
-        assert(0);
-        return data_types::f16;;
-    }
-}
-
-inline kernel_selector::data_layout to_data_layout(format f)
-{
-    switch (f)
-    {
-    case format::bfyx:              return kernel_selector::data_layout::bfyx;
-    case format::yxfb:              return kernel_selector::data_layout::yxfb;
-    case format::byxf:              return kernel_selector::data_layout::byxf;
-    case format::fyxb:              return kernel_selector::data_layout::fyxb;
-    case format::bs_x_bsv16:        return kernel_selector::data_layout::bs_f_bsv16__af8;
-    case format::bs_xs_xsv8_bsv8:   return kernel_selector::data_layout::bs_f_bsv8__af8;
-    case format::bs_xs_xsv8_bsv16:  return kernel_selector::data_layout::bs_f_bsv16__af8;
-    case format::bf8_xy16:          return kernel_selector::data_layout::bf8_xy16;
-    case format::winograd_2x3_s1_data:  return kernel_selector::data_layout::winograd_2x3_s1_data;
-    case format::byxf_af32: return kernel_selector::data_layout::byxf_af32;
-//     case format::brfyx:          return kernel_selector::data_layout::brfyx;
-    default:
-        return kernel_selector::data_layout::bfyx;
-    }
-}
-
-static inline cldnn::format from_data_layout(kernel_selector::data_layout l)
-{
-    switch (l)
-    {
-    case kernel_selector::data_layout::bf:                return cldnn::format::bfyx;
-    case kernel_selector::data_layout::fb:                return cldnn::format::fyxb;
-    case kernel_selector::data_layout::bfyx:              return cldnn::format::bfyx;
-    case kernel_selector::data_layout::yxfb:              return cldnn::format::yxfb;
-    case kernel_selector::data_layout::byxf:              return cldnn::format::byxf;
-    case kernel_selector::data_layout::fyxb:              return cldnn::format::fyxb;
-    case kernel_selector::data_layout::bs_f_bsv8__af8:    return cldnn::format::bs_xs_xsv8_bsv8;
-    case kernel_selector::data_layout::bs_f_bsv16__af8:   return cldnn::format::bs_x_bsv16;
-    case kernel_selector::data_layout::bf8_xy16:          return cldnn::format::bf8_xy16;
-    case kernel_selector::data_layout::brfyx:             return cldnn::format::bfyx;
-    case kernel_selector::data_layout::winograd_2x3_s1_data:   return cldnn::format::winograd_2x3_s1_data;
-    case kernel_selector::data_layout::byxf_af32: return cldnn::format::byxf_af32;
-    default:
-        return cldnn::format::bfyx;
-        break;
-    }
-}
-
-inline kernel_selector::weights_layout to_weights_layout(format f)
-{
-    switch (f)
-    {
-    case format::bfyx:              return kernel_selector::weights_layout::oiyx;
-    case format::fyxb:              return kernel_selector::weights_layout::iyxo;
-    case format::byxf:              return kernel_selector::weights_layout::oyxi;
-    case format::yxfb:              return kernel_selector::weights_layout::yxio;
-    case format::os_iyx_osv16:      return kernel_selector::weights_layout::os_iyx_osv16;
-    case format::bs_xs_xsv8_bsv8:   return kernel_selector::weights_layout::os_i_osv8__ai8;
-    case format::bs_xs_xsv8_bsv16:  return kernel_selector::weights_layout::os_i_osv16__ai8;
-    case format::bs_x_bsv16:        return kernel_selector::weights_layout::os_i_osv16;
-    case format::image_2d_weights_c4_fyx_b:     return kernel_selector::weights_layout::image_2d_weights_c4_fyx_b;
-    case format::image_2d_weights_c1_b_fyx:     return kernel_selector::weights_layout::image_2d_weights_c1_b_fyx;
-    case format::winograd_2x3_s1_weights:       return kernel_selector::weights_layout::winograd_2x3_s1_weights;
-    case format::winograd_2x3_s1_fused_weights: return kernel_selector::weights_layout::winograd_2x3_s1_fused_weights;
-    case format::winograd_6x3_s1_fused_weights: return kernel_selector::weights_layout::winograd_6x3_s1_fused_weights;
-    case format::image_2d_weights_winograd_6x3_s1_fbxyb:     return kernel_selector::weights_layout::image_2d_weights_winograd_6x3_s1_fbxyb;
-    case format::image_2d_weights_winograd_6x3_s1_xfbyb:     return kernel_selector::weights_layout::image_2d_weights_winograd_6x3_s1_xfbyb;
-    case format::os_is_yx_isa8_osv8_isv4: return kernel_selector::weights_layout::os_is_yx_isa8_osv8_isv4;
-    default:
-        return kernel_selector::weights_layout::oi;
-    }
-}
-
-static inline cldnn::format::type from_weights_layout(kernel_selector::weights_layout l)
-{
-    switch (l)
-    {
-    case kernel_selector::weights_layout::oi:
-    case kernel_selector::weights_layout::oiyx:               return cldnn::format::bfyx;
-    case kernel_selector::weights_layout::oyxi:               return cldnn::format::byxf;
-    case kernel_selector::weights_layout::io:
-    case kernel_selector::weights_layout::iyxo:               return cldnn::format::fyxb;
-    case kernel_selector::weights_layout::yxio:               return cldnn::format::yxfb;
-    case kernel_selector::weights_layout::os_iyx_osv16:       return cldnn::format::os_iyx_osv16;
-    case kernel_selector::weights_layout::os_i_osv16:         return cldnn::format::bs_x_bsv16;
-    case kernel_selector::weights_layout::os_i_osv8__ai8:     return cldnn::format::bs_xs_xsv8_bsv8;
-    case kernel_selector::weights_layout::os_i_osv16__ai8:    return cldnn::format::bs_xs_xsv8_bsv16;
-    case kernel_selector::weights_layout::image_2d_weights_c4_fyx_b:        return cldnn::format::image_2d_weights_c4_fyx_b;
-    case kernel_selector::weights_layout::image_2d_weights_c1_b_fyx:        return cldnn::format::image_2d_weights_c1_b_fyx;
-    case kernel_selector::weights_layout::winograd_2x3_s1_weights:          return cldnn::format::winograd_2x3_s1_weights;
-    case kernel_selector::weights_layout::winograd_2x3_s1_fused_weights:    return cldnn::format::winograd_2x3_s1_fused_weights;
-    case kernel_selector::weights_layout::winograd_6x3_s1_fused_weights:    return cldnn::format::winograd_6x3_s1_fused_weights;
-    case kernel_selector::weights_layout::image_2d_weights_winograd_6x3_s1_fbxyb:        return cldnn::format::image_2d_weights_winograd_6x3_s1_fbxyb;
-    case kernel_selector::weights_layout::image_2d_weights_winograd_6x3_s1_xfbyb:        return cldnn::format::image_2d_weights_winograd_6x3_s1_xfbyb;
-    case kernel_selector::weights_layout::os_is_yx_isa8_osv8_isv4: return cldnn::format::os_is_yx_isa8_osv8_isv4;
-    default:
-        return cldnn::format::bfyx;
-    }
-}
-
-inline kernel_selector::tuning_mode to_tuning_mode(cldnn::tuning_mode mode)
-{
-    switch (mode)
-    {
-    case cldnn::tuning_mode::tuning_disabled:         return kernel_selector::tuning_mode::TUNING_DISABLED;
-    case cldnn::tuning_mode::tuning_use_cache:        return kernel_selector::tuning_mode::TUNING_USE_CACHE;
-    case cldnn::tuning_mode::tuning_tune_and_cache:   return kernel_selector::tuning_mode::TUNING_TUNE_AND_CACHE;
-    default:
-        return kernel_selector::tuning_mode::TUNING_DISABLED;
-    }
-}
-
-inline std::string to_host_version(const cldnn::version_t& version)
-{
-    std::stringstream ss;
-    ss << version.major << "." << version.minor << "." << version.build << "." << version.revision;
-    return ss.str();
-}
-
-inline kernel_selector::data_tensor convert_data_tensor(const layout& l, uint32_t split = 1, const tensor view_offset = {})
-{
-    const auto& pad = l.data_padding;
-    const auto& vals = l.size.sizes(l.format);
-    const auto& add_offsets = view_offset.sizes(l.format);
-    const auto& lower_pad = pad.lower_size().sizes(l.format);
-    const auto& upper_pad = pad.upper_size().sizes(l.format);
-    const auto ks_layout = to_data_layout(l.format);
-    kernel_selector::n_dims vec(kernel_selector::DataTensor::ChannelsCount(ks_layout));
-
-    size_t pitch = 1;
-    size_t offset = 0;
-
-    auto new_vals = vals;
-
-    if (ks_layout == kernel_selector::Tensor::byxf_af32)
-    {
-        new_vals[3] = align_to(vals[3], 32);
-    }
-
-    for (size_t i = 0; i < vec.size(); i++)
-    {
-        const size_t tensor_index = vec.size() - 1 - i;
-        const auto d = vals[tensor_index];
-        const auto lp = lower_pad[tensor_index];
-        const auto up = upper_pad[tensor_index];
-        // tells us how many elements are reserved in memory for this tensor index
-        const auto reserved_in_mem_count = new_vals[tensor_index];
-
-        auto& elm = vec[i];
-        elm.v = static_cast<size_t>(d - add_offsets[tensor_index]);
-        elm.pitch = pitch;
-        elm.pad.before = lp;
-        elm.pad.after = up;
-
-        offset += pitch*(add_offsets[tensor_index]);
-        pitch *= (reserved_in_mem_count + lp + up);
-    }
-
-    const int feature_index = kernel_selector::DataTensor::Channelndex(ks_layout, kernel_selector::Tensor::DataChannelName::FEATURE);
-    vec[feature_index].v /= split;
-
-    return kernel_selector::data_tensor(
-        vec,
-        to_data_type(l.data_type),
-        ks_layout,
-        offset);
-}
-
-inline kernel_selector::weights_tensor convert_weights_tensor(const layout& l)
-{
-    assert(l.format.dimension() == 4);
-    const auto& t = l.size.sizes(format::bfyx);
-    const auto base_layout = kernel_selector::weights_layout::oiyx;
-    const auto ks_type = to_weights_type(l.data_type);
-    const auto ks_layout = to_weights_layout(l.format);
-    std::vector<size_t> vec(kernel_selector::WeightsTensor::ChannelsCount(base_layout));
-
-    for (size_t i = 0; i < vec.size(); i++)
-    {
-        const size_t tensor_index = t.size() - 1 - i;
-        const auto d = t[tensor_index];
-        vec[i] = static_cast<size_t>(d);
-    }
-
-    return kernel_selector::weights_tensor(
-        vec,
-        ks_type,
-        base_layout).TransformIgnorePadding(ks_layout);
+kernel_selector::data_type to_data_type(data_types dt);
+data_types from_data_type(kernel_selector::data_type dt);
+kernel_selector::weights_type to_weights_type(data_types dt);
+data_types from_weights_type(kernel_selector::weights_type dt);
+kernel_selector::data_layout to_data_layout(format f);
+cldnn::format from_data_layout(kernel_selector::data_layout l);
+kernel_selector::weights_layout to_weights_layout(format f);
+cldnn::format::type from_weights_layout(kernel_selector::weights_layout l);
+kernel_selector::tuning_mode to_tuning_mode(cldnn::tuning_mode mode);
+std::string to_host_version(const cldnn::version_t& version);
+kernel_selector::data_tensor convert_data_tensor(const layout& l, uint32_t split = 1, const tensor view_offset = {});
+kernel_selector::weights_tensor convert_weights_tensor(const layout& l);
+kernel_selector::activation_function get_kernel_selector_activation_param(cldnn_activation_func activation_func);
+kernel_selector::activation_function get_kernel_selector_activation_grad_param(cldnn_activation_grad_func activation_grad_func);
+
+template <typename T = std::uint32_t>
+kernel_selector::dim_tensor<T> convert_dim_vector(const tensor& t)
+{
+    const auto& sizes = t.sizes(format::bfyx);
+    return {
+        static_cast<T>(sizes[0]),
+        static_cast<T>(sizes[1]),
+        static_cast<T>(sizes[2]),
+        static_cast<T>(sizes[3]),
+    };
 }
 
 template <typename p_type>
 inline void convert_activation_func_params(const p_type primitive, kernel_selector::base_params& params)
 {
     const float negative_slope = primitive->activation_negative_slope;
-    if (negative_slope)
+    if (negative_slope != 0.0f)
     {
         params.activationParams.m = negative_slope;
         params.activationFunc = kernel_selector::activation_function::RELU_NEGATIVE_SLOPE;
@@ -325,56 +118,6 @@ inline void convert_activation_func_params(const p_type primitive, kernel_select
     }
 }
 
-inline kernel_selector::activation_function get_kernel_selector_activation_param(cldnn_activation_func activation_func)
-{
-    switch (activation_func)
-    {
-    case activation_none:
-        return kernel_selector::activation_function::NONE;
-    case activation_logistic:
-        return kernel_selector::activation_function::LOGISTIC;
-    case activation_hyperbolic_tan:
-        return kernel_selector::activation_function::HYPERBOLIC_TAN;
-    case activation_relu:
-        return kernel_selector::activation_function::RELU;
-    case activation_relu_negative_slope:
-        return kernel_selector::activation_function::RELU_NEGATIVE_SLOPE;
-    case activation_clamp:
-        return kernel_selector::activation_function::CLAMP;
-    case activation_softrelu:
-        return kernel_selector::activation_function::SOFTRELU;
-    case activation_abs:
-        return kernel_selector::activation_function::ABS;
-    case activation_linear:
-        return kernel_selector::activation_function::LINEAR;
-    case activation_square:
-        return kernel_selector::activation_function::SQUARE;
-    case activation_sqrt:
-        return kernel_selector::activation_function::SQRT;
-    case activation_elu:
-        return kernel_selector::activation_function::ELU;
-    default:
-        throw std::runtime_error("Unknown activation function");
-        break;
-    }
-}
-
-inline kernel_selector::activation_function get_kernel_selector_activation_grad_param(cldnn_activation_grad_func activation_grad_func)
-{
-    switch (activation_grad_func)
-    {
-    case activation_grad_none:
-        return kernel_selector::activation_function::NONE_GRAD;
-    case activation_grad_relu:
-        return kernel_selector::activation_function::RELU_GRAD;
-    case activation_grad_relu_negative_slope:
-        return kernel_selector::activation_function::RELU_NEGATIVE_SLOPE_GRAD;
-    default:
-        throw std::runtime_error("Unknown activation_grad function");
-        break;
-    }
-}
-
 template <typename arg_t>
 inline void convert_fused_activation_func_params(const arg_t& arg, kernel_selector::base_params& params)
 {
@@ -403,6 +146,8 @@ inline params_t get_default_params(const arg_t& arg, uint32_t split = 1)
     params.engineInfo.bSubGroupShortSupport = context->extension_supported("cl_intel_subgroups_short");
     params.engineInfo.bFP16Support          = context->extension_supported("cl_khr_fp16");
     params.engineInfo.bFP64Support          = context->extension_supported("cl_khr_fp64");
+    params.engineInfo.bIMADSupport          = engine_info.supports_imad != 0;
+    params.engineInfo.bIMMADSupport         = engine_info.supports_immad != 0;
     params.engineInfo.bImageSupport         = engine_info.supports_image != 0;
     params.engineInfo.maxWorkGroupSize      = engine_info.max_work_group_size;
     params.engineInfo.maxLocalMemSize       = engine_info.max_local_mem_size;
diff --git a/inference-engine/thirdparty/clDNN/src/include/layout_optimizer.h b/inference-engine/thirdparty/clDNN/src/include/layout_optimizer.h
index 39593728b..a503c338b 100644
--- a/inference-engine/thirdparty/clDNN/src/include/layout_optimizer.h
+++ b/inference-engine/thirdparty/clDNN/src/include/layout_optimizer.h
@@ -32,7 +32,6 @@
 
 #include "kernel_selector_common.h"
 #include "kernel_selector_helper.h"
-#include <boost/optional.hpp>
 
 #include <vector>
 
@@ -145,10 +144,10 @@ public:
                      data_type type,
                      T& node,
                      layout const& user_layout)
-        -> std::enable_if_t<
-            meta::is_any_of_v<T, convolution_node, fully_connected_node, deconvolution_node, detection_output_node, embed_node, lstm_gemm_node>,
+        -> typename std::enable_if<
+            meta::is_any_of<T, convolution_node, fully_connected_node, deconvolution_node, detection_output_node, embed_node, lstm_gemm_node>::value,
             meta::deduce_ret_type_t<decltype(&layout_optimizer::create_reorder_if_needed)>
-        >
+        >::type
     {
         auto expected_layout = get_expected_layout(data_layout, type, node, user_layout);
         return create_reorder_if_needed(data_layout, id, expected_layout);
@@ -161,12 +160,12 @@ public:
                      data_type type,
                      T& node,
                      layout const& user_layout)
-        -> std::enable_if_t<
-            !meta::is_any_of_v<T, convolution_node, fully_connected_node, deconvolution_node, detection_output_node, embed_node, lstm_gemm_node>,
+        -> typename std::enable_if<
+            !meta::is_any_of<T, convolution_node, fully_connected_node, deconvolution_node, detection_output_node, embed_node, lstm_gemm_node>::value,
             meta::deduce_ret_type_t<decltype(&layout_optimizer::create_reorder_if_needed)>
-        >
+        >::type
     {
-        static_assert(meta::always_false_v<T>, "Layout optimization for given primitive type is currently unsupported!");
+        static_assert(meta::always_false<T>::value, "Layout optimization for given primitive type is currently unsupported!");
         return meta::deduce_ret_type_t<decltype(&layout_optimizer::create_reorder_if_needed)>();
     }
 
diff --git a/inference-engine/thirdparty/clDNN/src/include/lookup_table_inst.h b/inference-engine/thirdparty/clDNN/src/include/lookup_table_inst.h
index 639f0c442..34138b8ae 100644
--- a/inference-engine/thirdparty/clDNN/src/include/lookup_table_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/lookup_table_inst.h
@@ -34,8 +34,8 @@ namespace cldnn
             : parent(prim, prog)
         {
         }
-        decltype(auto) input() const { return get_dependency(0); }
-        decltype(auto) indices() const { return get_dependency(1); }
+        program_node& input() const { return get_dependency(0); }
+        program_node& indices() const { return get_dependency(1); }
     };
 
     using lookup_table_node = typed_program_node<lookup_table>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/lstm_elt_inst.h b/inference-engine/thirdparty/clDNN/src/include/lstm_elt_inst.h
index c6e171510..9530b783e 100644
--- a/inference-engine/thirdparty/clDNN/src/include/lstm_elt_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/lstm_elt_inst.h
@@ -29,8 +29,8 @@ struct typed_program_node<lstm_elt> : public typed_program_node_base<lstm_elt>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) cell() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& cell() const { return get_dependency(1); }
     bool cell_term() const { return !get_primitive()->cell.empty(); }
     int32_t offset_order() const { return get_primitive()->offset_order; }
     float clip() const {
@@ -56,7 +56,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, lstm_elt_node const& node);
 
-    decltype(auto) cell_memory() const { return dep_memory(1); }
+    memory_impl& cell_memory() const { return dep_memory(1); }
     bool cell_term() const { return !argument.cell.empty(); }
     int32_t offset_order() const { return argument.offset_order; }
     float clip() const {
diff --git a/inference-engine/thirdparty/clDNN/src/include/lstm_gemm_inst.h b/inference-engine/thirdparty/clDNN/src/include/lstm_gemm_inst.h
index 63e210d78..b4967d4fc 100644
--- a/inference-engine/thirdparty/clDNN/src/include/lstm_gemm_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/lstm_gemm_inst.h
@@ -29,15 +29,16 @@ struct typed_program_node<lstm_gemm> : public typed_program_node_base<lstm_gemm>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) weights() const { return get_dependency(1); }
-    decltype(auto) recurrent() const { return get_dependency(2); }
-    decltype(auto) bias() const { return get_dependency(3); }
-    decltype(auto) hidden() const {
+    program_node& input() const { return get_dependency(0); }
+    program_node& weights() const { return get_dependency(1); }
+    program_node& recurrent() const { return get_dependency(2); }
+    program_node& bias() const { return get_dependency(3); }
+    program_node& hidden() const {
         return bias_term() ? get_dependency(4) : get_dependency(3);
     }
     bool bias_term() const { return !get_primitive()->bias.empty(); }
     bool hidden_term() const { return !get_primitive()->hidden.empty(); }
+    uint32_t direction() const { return get_primitive()->direction; }
 };
 
 using lstm_gemm_node = typed_program_node<lstm_gemm>;
@@ -54,14 +55,15 @@ public:
 public:
     typed_primitive_inst(network_impl& network, lstm_gemm_node const& node);
 
-    decltype(auto) weights_memory() const { return dep_memory(1); }
-    decltype(auto) recurrent_memory() const { return dep_memory(2); }
-    decltype(auto) bias_memory() const { return dep_memory(3); }
-    decltype(auto) hidden_memory() const {
+    memory_impl& weights_memory() const { return dep_memory(1); }
+    memory_impl& recurrent_memory() const { return dep_memory(2); }
+    memory_impl& bias_memory() const { return dep_memory(3); }
+    memory_impl& hidden_memory() const {
         return bias_term() ? dep_memory(4) : dep_memory(3);
     }
     bool bias_term() const { return !argument.bias.empty(); }
     bool hidden_term() const { return !argument.hidden.empty(); }
+    uint32_t direction() const { return argument.direction; }
 };
 
 using lstm_gemm_inst = typed_primitive_inst<lstm_gemm>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/lstm_inst.h b/inference-engine/thirdparty/clDNN/src/include/lstm_inst.h
index 1c9a9f038..86122d89e 100644
--- a/inference-engine/thirdparty/clDNN/src/include/lstm_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/lstm_inst.h
@@ -29,24 +29,25 @@ struct typed_program_node<lstm> : public typed_program_node_base<lstm>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) weights() const { return get_dependency(1); }
-    decltype(auto) recurrent() const { return get_dependency(2); }
-    decltype(auto) bias() const { return get_dependency(3); }
-    decltype(auto) inital_hidden() const {
+    program_node& input() const { return get_dependency(0); }
+    program_node& weights() const { return get_dependency(1); }
+    program_node& recurrent() const { return get_dependency(2); }
+    program_node& bias() const { return get_dependency(3); }
+    program_node& inital_hidden() const {
         return get_dependency(bias_term() ? 4 : 3);
     }
-    decltype(auto) inital_cell() const {
+    program_node& inital_cell() const {
         // This doesn't scale. We should use a map to get the dependencies index at primitive level
         return get_dependency(bias_term() ? (initial_hidden_term() ? 5 : 4) : (initial_hidden_term() ? 4 : 2));
     }
-    decltype(auto) peepholes() const { return get_dependency(6); }
+    program_node& peepholes() const { return get_dependency(6); }
     bool bias_term() const { return !get_primitive()->bias.empty(); }
     bool peepholes_term() const { return !get_primitive()->peepholes.empty(); }
     bool initial_hidden_term() const { return !get_primitive()->initial_hidden.empty(); }
     bool initial_cell_term() const { return !get_primitive()->initial_cell.empty(); }
-    auto activations() const { return get_primitive()->activations; }
-    auto activation_params() const { return get_primitive()->activation_params; }
+    std::vector<cldnn_activation_func> activations() const { return get_primitive()->activations; }
+    std::vector<cldnn_activation_additional_params> activation_params() const { return get_primitive()->activation_params; }
+    size_t sequence_len() const { return get_primitive()->input.size(); }
 };
 
 using lstm_node = typed_program_node<lstm>;
@@ -63,23 +64,23 @@ public:
 public:
     typed_primitive_inst(network_impl& network, lstm_node const& node);
 
-    decltype(auto) weights_memory() const { return dep_memory(1); }
-    decltype(auto) recurrent_memory() const { return dep_memory(2); }
-    decltype(auto) bias_memory() const { return dep_memory(3); }
-    decltype(auto) initial_hidden_memory() const
+    memory_impl& weights_memory() const { return dep_memory(1); }
+    memory_impl& recurrent_memory() const { return dep_memory(2); }
+    memory_impl& bias_memory() const { return dep_memory(3); }
+    memory_impl& initial_hidden_memory() const
     {
         return dep_memory(bias_term() ? 4 : 3);
     }
-    decltype(auto) initial_cell_memory() const {
+    memory_impl& initial_cell_memory() const {
         return dep_memory(bias_term() ? (initial_hidden_term() ? 5 : 4) : (initial_hidden_term() ? 4 : 2));
     }
-    decltype(auto) peepholes_memory() const { return dep_memory(6); }
+    memory_impl& peepholes_memory() const { return dep_memory(6); }
     bool bias_term() const { return !argument.bias.empty(); }
     bool peepholes_term() const { return !argument.peepholes.empty(); }
     bool initial_hidden_term() const { return !argument.initial_hidden.empty(); }
     bool initial_cell_term() const { return !argument.initial_cell.empty(); }
-    auto activations() const { return argument.activations; }
-    auto activation_params() const { return argument.activation_params; }
+    std::vector<cldnn_activation_func> activations() const { return argument.activations; }
+    std::vector<cldnn_activation_additional_params> activation_params() const { return argument.activation_params; }
 };
 
 using lstm_inst = typed_primitive_inst<lstm>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/max_unpooling_inst.h b/inference-engine/thirdparty/clDNN/src/include/max_unpooling_inst.h
index 97496f329..14c449b2f 100644
--- a/inference-engine/thirdparty/clDNN/src/include/max_unpooling_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/max_unpooling_inst.h
@@ -29,8 +29,8 @@ struct typed_program_node<max_unpooling> : public typed_program_node_base<max_un
 
 public:
     using parent::parent;
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) argmax() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& argmax() const { return get_dependency(1); }
 };
 
 using max_unpooling_node = typed_program_node<max_unpooling>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/meta_utils.h b/inference-engine/thirdparty/clDNN/src/include/meta_utils.h
index 4fd15de88..ad18786e8 100644
--- a/inference-engine/thirdparty/clDNN/src/include/meta_utils.h
+++ b/inference-engine/thirdparty/clDNN/src/include/meta_utils.h
@@ -30,9 +30,6 @@ namespace meta
 template <class... T>
 struct pack {};
 
-template <class T, class... U>
-constexpr bool is_any_of_v = is_any_of<T, U...>::value;
-
 //helper type for deducing return type from member function pointer
 //doesn't require passing arguments like std::result_of
 template <class T>
@@ -48,33 +45,21 @@ template <class T>
 using deduce_ret_type_t = typename deduce_ret_type<T>::type;
 
 template <class T>
-constexpr bool always_false_v = always_false<T>::value;
-
-template <class T>
 struct is_primitive : public std::integral_constant<bool,
                                                     std::is_base_of<primitive, T>::value &&
-                                                    !std::is_same<primitive, std::remove_cv_t<T>>::value &&
-                                                    std::is_same<T, std::remove_cv_t<T>>::value> {};
-
-template <class T>
-constexpr bool is_primitive_v = is_primitive<T>::value;
+                                                    !std::is_same<primitive, typename std::remove_cv<T>::type>::value &&
+                                                    std::is_same<T, typename std::remove_cv<T>::type>::value> {};
 
 template <class T>
 struct is_api_primitive : public std::integral_constant<bool,
-                                                    is_primitive_v<T> &&
+                                                    is_primitive<T>::value &&
                                                     !std::is_base_of<internal_primitive, T>::value> {};
 
 template <class T>
-constexpr bool is_api_primitive_v = is_api_primitive<T>::value;
-
-template <class T>
 struct is_internal_primitive : public std::integral_constant<bool,
                                                     std::is_base_of<internal_primitive, T>::value &&
-                                                    !std::is_same<internal_primitive, std::remove_cv_t<T>>::value &&
-                                                    std::is_same<T, std::remove_cv_t<T>>::value> {};
-
-template <class T>
-constexpr bool is_internal_primitive_v = is_internal_primitive<T>::value;
+                                                    !std::is_same<internal_primitive, typename std::remove_cv<T>::type>::value &&
+                                                    std::is_same<T, typename std::remove_cv<T>::type>::value> {};
 
 }
-}
\ No newline at end of file
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/mutable_data_inst.h b/inference-engine/thirdparty/clDNN/src/include/mutable_data_inst.h
index abb73b4fa..0d06f6095 100644
--- a/inference-engine/thirdparty/clDNN/src/include/mutable_data_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/mutable_data_inst.h
@@ -30,10 +30,10 @@ struct typed_program_node<mutable_data> : public typed_program_node_base<mutable
     typed_program_node(const std::shared_ptr<mutable_data> prim, program_impl& prog);
 
     memory_impl& get_attached_memory() const { return *mem; }
-    auto get_attached_memory_ptr() const { return mem; }
+    memory_impl::ptr get_attached_memory_ptr() const { return mem; }
     void attach_memory(memory_impl& new_mem, bool invalidate_users_if_changed = true);
 
-    decltype(auto) input(size_t idx = 0) const { return get_dependency(idx); }
+    program_node& input(size_t idx = 0) const { return get_dependency(idx); }
 
 private:
     memory_impl::ptr mem;
diff --git a/inference-engine/thirdparty/clDNN/src/include/mvn_inst.h b/inference-engine/thirdparty/clDNN/src/include/mvn_inst.h
index 335aa81dd..d1922e1fb 100644
--- a/inference-engine/thirdparty/clDNN/src/include/mvn_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/mvn_inst.h
@@ -30,7 +30,7 @@ struct typed_program_node<mvn> : public typed_program_node_base<mvn>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 };
 
 using mvn_node = typed_program_node<mvn>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/network_impl.h b/inference-engine/thirdparty/clDNN/src/include/network_impl.h
index 25241f5e6..4874d37a5 100644
--- a/inference-engine/thirdparty/clDNN/src/include/network_impl.h
+++ b/inference-engine/thirdparty/clDNN/src/include/network_impl.h
@@ -49,7 +49,7 @@ public:
     void set_learning_rate(const float lr);
     float get_learning_rate();
 
-    auto const& get_outputs() { return _outputs; }
+    std::vector<std::shared_ptr<primitive_inst>> const& get_outputs() { return _outputs; }
 
     const std::vector<std::shared_ptr<const primitive_inst>>& get_outputs() const
     {
@@ -70,10 +70,8 @@ public:
     std::vector<std::shared_ptr<primitive_inst>> get_primitives(const std::vector<program_node*>& nodes);
     event_impl::ptr execute_primitive(const std::shared_ptr<primitive_inst>& primitive, const std::vector<event_impl::ptr>& events);
     void allocate_primitives();
-    void build_exec_order_vist(program_node*);
-    void build_exec_order();
     void build_insts_deps();
-    auto get_id() const { return net_id; }
+    uint32_t get_id() const { return net_id; }
     bool is_internal() const { return _internal; }
 
 private:
diff --git a/inference-engine/thirdparty/clDNN/src/include/normalize_inst.h b/inference-engine/thirdparty/clDNN/src/include/normalize_inst.h
index 11f6da905..650069490 100644
--- a/inference-engine/thirdparty/clDNN/src/include/normalize_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/normalize_inst.h
@@ -30,8 +30,8 @@ struct typed_program_node<normalize> : public typed_program_node_base<normalize>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) scale() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& scale() const { return get_dependency(1); }
 };
 
 using normalize_node = typed_program_node<normalize>;
@@ -47,7 +47,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, normalize_node const& node);
 
-    decltype(auto) scale_memory() const { return dep_memory(1); }
+    memory_impl& scale_memory() const { return dep_memory(1); }
 };
 
 using normalize_inst = typed_primitive_inst<normalize>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/permute_inst.h b/inference-engine/thirdparty/clDNN/src/include/permute_inst.h
index 5ff3696da..bb76c9a16 100644
--- a/inference-engine/thirdparty/clDNN/src/include/permute_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/permute_inst.h
@@ -30,7 +30,7 @@ struct typed_program_node<permute> : public typed_program_node_base<permute>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 };
 
 using permute_node = typed_program_node<permute>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/pooling_inst.h b/inference-engine/thirdparty/clDNN/src/include/pooling_inst.h
index 9b2e42915..2956667b9 100644
--- a/inference-engine/thirdparty/clDNN/src/include/pooling_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/pooling_inst.h
@@ -29,8 +29,8 @@ struct typed_program_node<pooling> : public typed_program_node_base<pooling>
 
 public:
     using parent::parent;
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) argmax() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& argmax() const { return get_dependency(1); }
 };
 
 using pooling_node = typed_program_node<pooling>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/primitive_inst.h b/inference-engine/thirdparty/clDNN/src/include/primitive_inst.h
index 074e8c9be..563e6d163 100644
--- a/inference-engine/thirdparty/clDNN/src/include/primitive_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/primitive_inst.h
@@ -25,12 +25,10 @@
 #include "memory_impl.h"
 #include "meta_utils.h"
 #include "kernel_selector_helper.h"
-#include "network_impl.h"
 #include "program_node.h"
 
 #include <memory>
 #include <vector>
-#include <boost/optional.hpp>
 
 namespace cldnn
 {
@@ -94,12 +92,12 @@ public:
     primitive_id id() const { return _node.id(); }
     primitive_id org_id() const { return _node.get_org_primitive_id(); }
     bool can_be_optimized() const { return _node.can_be_optimized(); }
-    const auto desc() const { return _node.get_primitive(); }
+    const std::shared_ptr<const primitive> desc() const { return _node.get_primitive(); }
     network_impl& get_network() const { return _network; }
-    uint32_t get_network_id() const { return _network.get_id(); }
+    uint32_t get_network_id() const;
 
     //return pointer to const to prevent arbitrary 'execute' call -> use primitive_inst.execute() instead
-    const auto get_impl() const { return _impl.get(); }
+    const primitive_impl* get_impl() const { return _impl.get(); }
 
     memory_impl& input_memory(size_t index = 0)  const 
     { 
@@ -110,17 +108,10 @@ public:
 
     event_impl::ptr execute(const std::vector<event_impl::ptr>& events);
 
-    auto output_changed() const { return _output_changed; }
+    bool output_changed() const { return _output_changed; }
     void reset_output_change() { _output_changed = false; }
 
-    void build_deps()
-    {
-        if (_deps.empty() && !_node.get_dependencies().empty())
-        {
-             _deps = _network.get_primitives(_node.get_dependencies());
-             _exec_deps = build_exec_deps(_deps);
-        }
-    }
+    void build_deps();
 
 protected:
     primitive_inst(network_impl& network, program_node const& node, bool allocate_memory);
@@ -164,7 +155,7 @@ For example, all convolution implementations should derive from typed_primitive_
 template <class PType>
 struct typed_primitive_impl : public primitive_impl
 {
-    static_assert(meta::is_primitive_v<PType>, "PType should be a non-const, non-volatile class derived from primitive");
+    static_assert(meta::is_primitive<PType>::value, "PType should be a non-const, non-volatile class derived from primitive");
 
     using primitive_impl::primitive_impl;
 
@@ -187,7 +178,7 @@ namespace details
     template<class PType>
     class api_typed_primitive_inst_base : public primitive_inst
     {
-        static_assert(meta::is_api_primitive_v<PType>, "PType should name a non-const, non-volatile type derived from cldnn::primitive but not from cldnn::internal_primitive");
+        static_assert(meta::is_api_primitive<PType>::value, "PType should name a non-const, non-volatile type derived from cldnn::primitive but not from cldnn::internal_primitive");
 
     public:
         using typed_node = typed_program_node<PType>;
@@ -229,7 +220,7 @@ namespace details
     template<class PType>
     class internal_typed_primitive_inst_base : public primitive_inst
     {
-        static_assert(meta::is_internal_primitive_v<PType>, "PType should name a non-const, non-volatile type derived from cldnn::internal_primitive");
+        static_assert(meta::is_internal_primitive<PType>::value, "PType should name a non-const, non-volatile type derived from cldnn::internal_primitive");
 
     public:
         using typed_node = typed_program_node<PType>;
@@ -245,7 +236,7 @@ namespace details
         [[noreturn]]
         void desc(Guard&&...) const
         {
-            static_assert(meta::always_false_v<meta::pack<Guard...>>, "Trying to get primitive from internal node");
+            static_assert(meta::always_false<meta::pack<Guard...>>::value, "Trying to get primitive from internal node");
         }
 
     protected:
@@ -266,7 +257,7 @@ namespace details
     Base class for all concrete primitive instances.
 */
 template <class PType>
-using typed_primitive_inst_base = std::conditional_t<meta::is_api_primitive_v<PType>, details::api_typed_primitive_inst_base<PType>, details::internal_typed_primitive_inst_base<PType>>;
+using typed_primitive_inst_base = typename std::conditional<meta::is_api_primitive<PType>::value, details::api_typed_primitive_inst_base<PType>, details::internal_typed_primitive_inst_base<PType>>::type;
 
 /*
     Template class which represents instance of primitive 'PType'.
@@ -285,7 +276,7 @@ using typed_primitive_inst_base = std::conditional_t<meta::is_api_primitive_v<PT
 template <class PType>
 class typed_primitive_inst : public typed_primitive_inst_base<PType>
 { 
-    static_assert(meta::always_false_v<PType>, "Missing typed_primitive_inst specialization");
+    static_assert(meta::always_false<PType>::value, "Missing typed_primitive_inst specialization");
 };
 
 #define CLDNN_DEFINE_SIMPLE_PRIM_INST(PType) \
diff --git a/inference-engine/thirdparty/clDNN/src/include/primitive_type.h b/inference-engine/thirdparty/clDNN/src/include/primitive_type.h
index 9e476adca..2b19e4ac6 100644
--- a/inference-engine/thirdparty/clDNN/src/include/primitive_type.h
+++ b/inference-engine/thirdparty/clDNN/src/include/primitive_type.h
@@ -23,7 +23,7 @@
 #include "topology_impl.h"
 
 #include <memory>
-#include <sstream>
+
 namespace cldnn {
     struct network_impl;
     struct engine_impl;
diff --git a/inference-engine/thirdparty/clDNN/src/include/primitive_type_base.h b/inference-engine/thirdparty/clDNN/src/include/primitive_type_base.h
index 0785c0759..2f4f74542 100644
--- a/inference-engine/thirdparty/clDNN/src/include/primitive_type_base.h
+++ b/inference-engine/thirdparty/clDNN/src/include/primitive_type_base.h
@@ -29,7 +29,7 @@ namespace cldnn
 template<class PType>
 struct primitive_type_base : ::cldnn_primitive_type
 {
-    static_assert(meta::is_api_primitive_v<PType>, "Primitive type passed to primitive_type_base should derive from cldnn::primitive");
+    static_assert(meta::is_api_primitive<PType>::value, "Primitive type passed to primitive_type_base should derive from cldnn::primitive");
 
     std::shared_ptr<primitive> from_dto(const CLDNN_PRIMITIVE_DESC(primitive)* dto) const override
     {
diff --git a/inference-engine/thirdparty/clDNN/src/include/prior_box_inst.h b/inference-engine/thirdparty/clDNN/src/include/prior_box_inst.h
index b91bd1198..6e0a9ad2c 100644
--- a/inference-engine/thirdparty/clDNN/src/include/prior_box_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/prior_box_inst.h
@@ -19,8 +19,6 @@
 #include "api/CPP/prior_box.hpp"
 #include "primitive_inst.h"
 
-#include <boost/optional.hpp>
-
 namespace cldnn
 {
 
@@ -31,7 +29,7 @@ struct typed_program_node<prior_box> : typed_program_node_base<prior_box>
 
     typed_program_node(std::shared_ptr<prior_box> prim, program_impl& prog);
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 
     void calc_result();
     memory_impl& get_result_buffer() const { return *result; }
@@ -53,7 +51,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, prior_box_node const& node);
 
-    decltype(auto) input_memory() const { return dep_memory(0); }
+    memory_impl& input_memory() const { return dep_memory(0); }
 };
 
 using prior_box_inst = typed_primitive_inst<prior_box>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/program_impl.h b/inference-engine/thirdparty/clDNN/src/include/program_impl.h
index a2e8f4bef..c3cb67329 100644
--- a/inference-engine/thirdparty/clDNN/src/include/program_impl.h
+++ b/inference-engine/thirdparty/clDNN/src/include/program_impl.h
@@ -46,14 +46,14 @@ public:
 
     void dump_memory_pool() const;
 
-    auto& get_engine() const { return *engine; }
-    auto get_options() const { return options; }
+    engine_impl& get_engine() const { return *engine; }
+    build_options get_options() const { return options; }
     bool is_debug_build() const { return options.get<build_option_type::debug>()->enabled(); }
 
     std::list<std::shared_ptr<program_node>> get_nodes() const;
-    auto get_processing_order() const { return processing_order; }
-    auto get_optimized_out() const { return optimized_out; }
-    auto& get_node(primitive_id const& id) 
+    std::list<program_node*> get_processing_order() const { return processing_order; }
+    std::list<primitive_id> get_optimized_out() const { return optimized_out; }
+    program_node& get_node(primitive_id const& id)
     {
         try 
         {
@@ -70,7 +70,7 @@ public:
         return nodes_map.count(prim) > 0;
     }
 
-    auto const& get_node(primitive_id const& id) const
+    program_node const& get_node(primitive_id const& id) const
     {
         try
         {
@@ -120,7 +120,6 @@ private:
     */
     void mark_constants();
     void mark_data_flow();
-    void calc_dominators();
     // TODO: Remove once we will get full support for input/output padding in all primitive implementations.
     void analyze_output_size_handling_need();
     void replace_nodes_pre();
@@ -133,7 +132,7 @@ private:
     */
     void trim_to_outputs();
     void remove_redundant_reorders();
-    void reorder_nodes_for_parallel_execution();
+    void calculate_BFS_processing_order();
     void reorder_inputs(layout_optimizer& lo);
     void pre_optimize_bias(layout_optimizer& lo);
     void post_optimize_weights(layout_optimizer& lo);
@@ -141,10 +140,11 @@ private:
     void prepare_padding();
     void propagate_constants();
     void prepare_buffer_fusing();
+    void fuse_skip_layers(program_node* node);
     void prepare_primitive_fusing();
     void prepare_depthwise_sep_opt();
     void prep_opt_depthwise_sep_post();
-    void update_processing_order();
+    void update_processing_numbers();
 
     /*
     ** Memory pool functions
@@ -227,11 +227,7 @@ private:
     //prereq: node cannot be marked as output and has to have exactly one dependency
     //returns if 'node' has been extracted and removed successfully
     bool extract_and_remove(program_node& node);
-
     void replace_data_with_optimized(std::map<primitive_id, memory_impl::ptr> const& replace_map);
-    void forward_bfs(std::function<void(program_node&)> const& mark_func = nullptr, std::function<void(program_node&)> const& unmark_func = nullptr) const;
-    void backward_bfs(std::function<void(program_node&)> const& mark_func = nullptr, std::function<void(program_node&)> const& unmark_func = nullptr) const;
-
     void dump_program(const char* stage, bool with_full_info, std::function<bool(program_node const&)> const& filter = nullptr) const;
     //Dumps weights and biasses in serialization process, not working yet, in progress.
     void dump_weights_and_biasses(std::vector<unsigned long long>& offsets, std::vector<std::string>& data_names, std::ofstream& file_stream) const;
@@ -239,6 +235,17 @@ private:
     //Placeholder, not working yet, in progress.
     void serialize(std::string network_name, std::function<bool(program_node const&)> const& filter = nullptr) const;
 
+    template <typename T>
+    void optimize_bias(T& node, layout_optimizer& lo);
+
+    template <typename T>
+    void optimize_weights(T& node, layout_optimizer& lo);
+
+    template <typename T>
+    void optimize_depthwise_sep_pre(T& node);
+
+    template <typename T>
+    void optimize_depthwise_sep_post(T& node);
 };
 }
 
diff --git a/inference-engine/thirdparty/clDNN/src/include/program_node.h b/inference-engine/thirdparty/clDNN/src/include/program_node.h
index b5876651e..e9df77a7d 100644
--- a/inference-engine/thirdparty/clDNN/src/include/program_node.h
+++ b/inference-engine/thirdparty/clDNN/src/include/program_node.h
@@ -20,11 +20,10 @@
 #include "api/CPP/primitive.hpp"
 #include "internal_primitive.h"
 
-#include "to_string_utils.h"
-#include "json_object.h"
-#include "xml_object.h"
 #include "meta_utils.h"
 
+#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
 namespace cldnn
 {
 
@@ -36,6 +35,9 @@ struct typed_program_node;
 template <class PType>
 struct internal_primitive_type_base;
 
+class json_composite;
+class xml_composite;
+
 /*
     Base class for all primitives which wraps API class and extends it to be used
     in graph context.
@@ -59,6 +61,8 @@ struct program_node
 
     program_node(program_node const&) = delete;
 
+    virtual ~program_node() = default;
+
 public:
     virtual const primitive_id& id() const { return desc->id; }
     virtual primitive_type_id type() const { return desc->type; }
@@ -66,17 +70,17 @@ public:
     template <class PType>
     bool is_type() const
     {
-        static_assert(meta::is_primitive_v<PType>, "Type argument for program_node::is_type should be a non-const, non-volatile type derived from primitive");
+        static_assert(meta::is_primitive<PType>::value, "Type argument for program_node::is_type should be a non-const, non-volatile type derived from primitive");
         return type() == PType::type_id();
     }
 
-    auto& get_program() { return myprog; }
-    auto const& get_program() const { return myprog; }
+    program_impl& get_program() { return myprog; }
+    program_impl const& get_program() const { return myprog; }
 
-    auto get_selected_impl() const { return selected_impl; }
+    std::shared_ptr<primitive_impl> get_selected_impl() const { return selected_impl; }
 
-    auto const& get_dependencies() const { return dependencies; }
-    auto& get_dependency(size_t idx) const { return *dependencies.at(idx); }
+    std::vector<program_node*> const& get_dependencies() const { return dependencies; }
+    program_node& get_dependency(size_t idx) const { return *dependencies.at(idx); }
 
     //replaces idx-th dependency of 'this' with 'new_dep', calls program::remove_if_dangling(old_dep, detach_whole_branch)
     void replace_dependency(size_t idx, program_node& new_dep, bool detach_whole_branch = false);
@@ -104,16 +108,12 @@ public:
 
     bool is_detached(bool whole_branch = false);
 
-    auto const& get_users() { return users; }
+    std::list<program_node*> const& get_users() { return users; }
     // for const method, add const to stored successors/predecessors
-    auto const& get_users() const { return reinterpret_cast<const std::list<const program_node*>&>(users); }
-
-    bool has_next() const;
-    program_node* get_next() { auto itr = processing_itr; return (*++itr); }
-    const program_node* get_next() const { auto itr = processing_itr; return (*++itr); }
+    std::list<const program_node*> const& get_users() const { return reinterpret_cast<const std::list<const program_node*>&>(users); }
 
-    json_composite desc_to_json() const;
-	xml_composite desc_to_xml() const;
+    std::unique_ptr<json_composite> desc_to_json() const;
+	std::unique_ptr<xml_composite> desc_to_xml() const;
     //do not modify primitive directly to keep synchronisation wit graph
     std::shared_ptr<const primitive> get_primitive() const { return desc; }
     //primitive modification functions
@@ -153,18 +153,18 @@ public:
     bool has_padded_dependency();
     bool has_padded_dependency() const;
 
-    auto is_input() const { return dependencies.empty(); }
-    auto is_endpoint() const { return users.empty(); }
-    auto set_output(bool out) { output = out; }
-    auto is_output() const { return output; }
+    bool is_input() const { return dependencies.empty(); }
+    bool is_endpoint() const { return users.empty(); }
+    void set_output(bool out) { output = out; }
+    bool is_output() const { return output; }
 
-    auto is_valid_output_layout() const { return valid_output_layout; }
-    auto get_processing_num() const { return processing_num; }
+    bool is_valid_output_layout() const { return valid_output_layout; }
+    uint32_t get_processing_num() const { return processing_num; }
 
     uint8_t mark(uint8_t val = 1) { uint8_t ret = user_mark; user_mark = val; return ret; }
     void unmark() { user_mark = 0; }
-    auto is_marked() const { return user_mark != 0; }
-    auto is_marked(uint8_t val) const { return user_mark == val; }
+    bool is_marked() const { return user_mark != 0; }
+    bool is_marked(uint8_t val) const { return user_mark == val; }
     uint8_t get_user_mark() const { return user_mark; }
 
     void set_fused_activation(cldnn_activation_func activation_func, cldnn_activation_additional_params additional_params)
@@ -183,7 +183,7 @@ public:
         return fused_activation.additional_params;
     }
 
-    auto can_be_optimized() const { return optimized; }
+    bool can_be_optimized() const { return optimized; }
     void can_be_optimized(bool opt) { optimized = opt; }
 
     primitive_id get_org_primitive_id() const { return org_id; }
@@ -192,32 +192,12 @@ public:
         org_id = org_prim_id;
     }
 
-    // returns immidiate dominator of this node if it's not its direct predecessor, otherwise returns nullptr
-    program_node* get_dominator() { return dominator; }
-    const program_node* get_dominator() const { return dominator; }
-
-    //returns joint point associated with this node,
-    //if the node is not a split point (i.e. it has exactly one user) this function returns nullptr,
-    //otherwise returns pointer to a node which immidiately post-dominates this
-    program_node* get_joint() { return joint; }
-    const program_node* get_joint() const { return joint; }
-
-    bool is_joint_point() const { return dominator != nullptr; }
-    bool is_split_point() const { return joint != nullptr; }
-
     bool is_constant() const { return constant; }
     bool has_non_const_user() const { return (!constant || constant_frontier); }
-
-    //returns true if all paths from network's source to sink must come through this node
-    //(i.e. if this is a dominator of all the outputs)
-    //a source, in this context, is defined as an input which lies within a data flow (see is_in_data_flow)
-    bool is_in_main_branch() const { return main_branch; }
-
     //returns true if this node is within main data flow of the network (i.e. it does not describe helper data like convolution's weights etc.)
     bool is_in_data_flow() const { return data_flow; }
-
     //conversion from generic to specific
-    template <class To, class..., class = std::enable_if_t<!std::is_same<To, primitive>::value>>
+    template <class To, class..., class = typename std::enable_if<!std::is_same<To, primitive>::value>::type>
     typed_program_node<To>& as()
     {
         if (type() != To::type_id())
@@ -226,7 +206,7 @@ public:
         return reinterpret_cast<typed_program_node<To>&>(*this);
     }
 
-    template <class To, class..., class = std::enable_if_t<!std::is_same<To, primitive>::value>>
+    template <class To, class..., class = typename std::enable_if<!std::is_same<To, primitive>::value>::type>
     typed_program_node<To> const& as() const
     {
         if (type() != To::type_id())
@@ -268,23 +248,22 @@ protected:
     std::vector<program_node*> dependencies;
     std::list<program_node*> users;
 
+#if defined(__GNUC__) && (GCC_VERSION < 40900)
+    std::list<program_node*>::iterator processing_itr;
+#else
     std::list<program_node*>::const_iterator processing_itr;
+#endif
     uint32_t processing_num = 0;
 
     // list of primitives that can reuse same memory buffers due to execution order conflicts
     std::set<primitive_id> memory_dependencies;  
 
-    program_node* dominator = nullptr;
-    program_node* joint = nullptr;
     bool constant = false;
     bool constant_frontier = false;
-
-    bool main_branch = true;
     bool data_flow = false;
 
     bool output = false;
     uint8_t user_mark = 0;
-
     bool optimized = false;
 
     mutable bool has_reused_memory = false;
@@ -308,7 +287,7 @@ namespace details
     template <class PType>
     struct api_typed_program_node_base : public program_node
     {
-        static_assert(meta::is_api_primitive_v<PType>, "PType should name a non-const, non-volatile type derived from cldnn::primitive but not from cldnn::internal_primitive");
+        static_assert(meta::is_api_primitive<PType>::value, "PType should name a non-const, non-volatile type derived from cldnn::primitive but not from cldnn::internal_primitive");
         friend struct cldnn::program_impl;
 
     public:
@@ -339,7 +318,7 @@ namespace details
     template <class PType>
     struct internal_typed_program_node_base : public internal_program_node_base
     {
-        static_assert(meta::is_internal_primitive_v<PType>, "PType should name a non-const, non-volatile type derived from cldnn::internal_primitive");
+        static_assert(meta::is_internal_primitive<PType>::value, "PType should name a non-const, non-volatile type derived from cldnn::internal_primitive");
 
     public:
         using internal_program_node_base::internal_program_node_base;
@@ -350,7 +329,7 @@ namespace details
         [[noreturn]]
         void get_primitive(Guard&&...)
         {
-            static_assert(meta::always_false_v<meta::pack<Guard...>>, "Trying to get primitive from internal node");
+            static_assert(meta::always_false<meta::pack<Guard...>>::value, "Trying to get primitive from internal node");
         }
 
 
@@ -359,7 +338,7 @@ namespace details
         [[noreturn]]
         void typed_desc(Guard&&...)
         {
-            static_assert(meta::always_false_v<meta::pack<Guard...>>, "Trying to get primitive from internal node");
+            static_assert(meta::always_false<meta::pack<Guard...>>::value, "Trying to get primitive from internal node");
         }
     };
 }
@@ -373,7 +352,7 @@ This class shadows 'get_primitive' method from base class which now returns poin
 type.
 */
 template <class PType>
-using typed_program_node_base = std::conditional_t<meta::is_api_primitive_v<PType>, details::api_typed_program_node_base<PType>, details::internal_typed_program_node_base<PType>>;
+using typed_program_node_base = typename std::conditional<meta::is_api_primitive<PType>::value, details::api_typed_program_node_base<PType>, details::internal_typed_program_node_base<PType>>::type;
 
 /*
     Actual template class used in context which requires 'program_node' to wrap
@@ -387,7 +366,7 @@ struct typed_program_node : public typed_program_node_base<PType>
 {
     using typed_program_node_base<PType>::typed_program_node_base;
 
-    decltype(auto) input() const { return program_node::get_dependency(0); }
+    program_node& input() const { return program_node::get_dependency(0); }
 };
 
-}
\ No newline at end of file
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/proposal_inst.h b/inference-engine/thirdparty/clDNN/src/include/proposal_inst.h
index 270e5cad1..529b524c0 100644
--- a/inference-engine/thirdparty/clDNN/src/include/proposal_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/proposal_inst.h
@@ -28,9 +28,9 @@ struct typed_program_node<proposal> : public typed_program_node_base<proposal>
     using parent = typed_program_node_base<proposal>;
     using parent::parent;
 
-    decltype(auto) cls_score() const { return get_dependency(0); }
-    decltype(auto) bbox_pred() const { return get_dependency(1); }
-    decltype(auto) image_info() const { return get_dependency(2); }
+    program_node& cls_score() const { return get_dependency(0); }
+    program_node& bbox_pred() const { return get_dependency(1); }
+    program_node& image_info() const { return get_dependency(2); }
 };
 
 using proposal_node = typed_program_node<proposal>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/refcounted_obj.h b/inference-engine/thirdparty/clDNN/src/include/refcounted_obj.h
index 05ac4ac0d..8eb4fadbe 100644
--- a/inference-engine/thirdparty/clDNN/src/include/refcounted_obj.h
+++ b/inference-engine/thirdparty/clDNN/src/include/refcounted_obj.h
@@ -33,8 +33,8 @@ template<class T>
 class refcounted_obj
 {
 public:
-    using ptr = refcounted_obj_ptr<std::remove_const_t<T>>;
-    using cptr = refcounted_obj_ptr<std::add_const_t<T>>;
+    using ptr = refcounted_obj_ptr<typename std::remove_const<T>::type>;
+    using cptr = refcounted_obj_ptr<typename std::add_const<T>::type>;
 
     refcounted_obj()
         : _ref_count(1)
@@ -67,15 +67,15 @@ struct refcounted_obj_ptr
     template <class U = T>
     refcounted_obj_ptr(T* ptr, bool add_ref = true) : _ptr(ptr)
     {
-        static_assert(std::is_base_of<refcounted_obj<std::remove_const_t<U>>, U>::value, "Object handled with refcounted_obj_ptr should derive from refcounted_obj");
+        static_assert(std::is_base_of<refcounted_obj<typename std::remove_const<U>::type>, U>::value, "Object handled with refcounted_obj_ptr should derive from refcounted_obj");
         if(add_ref) ptr_add_ref();
     }
 
     //for refcounted_obj_ptr<const T>, allow contruction from T*
-    template <class U = T, class = std::enable_if_t<std::is_const<U>::value>>
-    refcounted_obj_ptr(std::remove_const_t<T>* ptr, bool add_ref = true) : _ptr(ptr)
+    template <class U = T, class = typename std::enable_if<std::is_const<U>::value>::type>
+    refcounted_obj_ptr(typename std::remove_const<T>::type* ptr, bool add_ref = true) : _ptr(ptr)
     {
-        static_assert(std::is_base_of<refcounted_obj<std::remove_const_t<U>>, U>::value, "Object handled with refcounted_obj_ptr should derive from refcounted_obj");
+        static_assert(std::is_base_of<refcounted_obj<typename std::remove_const<U>::type>, U>::value, "Object handled with refcounted_obj_ptr should derive from refcounted_obj");
         if (add_ref) ptr_add_ref();
     }
 
diff --git a/inference-engine/thirdparty/clDNN/src/include/reorder_inst.h b/inference-engine/thirdparty/clDNN/src/include/reorder_inst.h
index e54784410..39b89e52d 100644
--- a/inference-engine/thirdparty/clDNN/src/include/reorder_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/reorder_inst.h
@@ -30,12 +30,12 @@ struct typed_program_node<reorder> : public typed_program_node_base<reorder>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) mean() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& mean() const { return get_dependency(1); }
 
     bool has_mean() const { return !typed_desc()->mean.empty(); }
 
-    auto requires_reinterpret() const { return req_reinterpr; }
+    bool requires_reinterpret() const { return req_reinterpr; }
     void requires_reinterpret(bool val) { req_reinterpr = (optimized && val); }
 
     void set_input_offset(tensor const& io) { input_offset = io; }
@@ -60,7 +60,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, reorder_node const& node);
 
-    decltype(auto) mean_memory() const { return dep_memory(1); }
+    memory_impl& mean_memory() const { return dep_memory(1); }
 
     bool has_mean() const { return !argument.mean.empty(); }
 
diff --git a/inference-engine/thirdparty/clDNN/src/include/reshape_inst.h b/inference-engine/thirdparty/clDNN/src/include/reshape_inst.h
index 901257845..1ac9fdfcb 100644
--- a/inference-engine/thirdparty/clDNN/src/include/reshape_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/reshape_inst.h
@@ -30,10 +30,12 @@ struct typed_program_node<reshape> : public typed_program_node_base<reshape>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 
     bool is_in_place() const
     {
+        if (this->is_output() || this->get_fused_activation_func() != activation_none)
+            return false;
         return (!this->get_output_layout().data_padding && !input().get_output_layout(false).data_padding);
     }
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/roi_pooling_inst.h b/inference-engine/thirdparty/clDNN/src/include/roi_pooling_inst.h
index 54ae09e04..01e804664 100644
--- a/inference-engine/thirdparty/clDNN/src/include/roi_pooling_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/roi_pooling_inst.h
@@ -29,8 +29,8 @@ struct typed_program_node<roi_pooling> : public typed_program_node_base<roi_pool
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) rois() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& rois() const { return get_dependency(1); }
 };
 
 using roi_pooling_node = typed_program_node<roi_pooling>;
@@ -47,7 +47,7 @@ public:
 public:    
     using parent::parent;
 
-    decltype(auto) rois_memory() const { return dep_memory(1); }
+    memory_impl& rois_memory() const { return dep_memory(1); }
 };
 
 using roi_pooling_inst = typed_primitive_inst<roi_pooling>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/scale_grad_input_inst.h b/inference-engine/thirdparty/clDNN/src/include/scale_grad_input_inst.h
index 9b5b0c57f..b39402f01 100644
--- a/inference-engine/thirdparty/clDNN/src/include/scale_grad_input_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/scale_grad_input_inst.h
@@ -30,8 +30,8 @@ struct typed_program_node<scale_grad_input> : public typed_program_node_base<sca
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) scale_in() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& scale_in() const { return get_dependency(1); }
 };
 
 using scale_grad_input_node = typed_program_node<scale_grad_input>;
@@ -48,7 +48,7 @@ public:
 public:
     typed_primitive_inst(network_impl& network, scale_grad_input_node const& desc);
 
-    decltype(auto) scale_input_memory() const { return dep_memory(1); }
+    memory_impl& scale_input_memory() const { return dep_memory(1); }
 };
 
 using scale_grad_input_inst = typed_primitive_inst<scale_grad_input>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/scale_grad_weights_inst.h b/inference-engine/thirdparty/clDNN/src/include/scale_grad_weights_inst.h
index a7183dd83..549691965 100644
--- a/inference-engine/thirdparty/clDNN/src/include/scale_grad_weights_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/scale_grad_weights_inst.h
@@ -30,12 +30,12 @@ struct typed_program_node<scale_grad_weights> : public typed_program_node_base<s
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) input_grad() const { return get_dependency(1); };
-    decltype(auto) weights() const { return get_dependency(2); }
-    decltype(auto) bias() const { return get_dependency(3); }
-    decltype(auto) prev_scale_grad() const { return bias_term() ? get_dependency(4) : get_dependency(3); }
-    decltype(auto) prev_bias_grad() const { return get_dependency(5); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& input_grad() const { return get_dependency(1); };
+    program_node& weights() const { return get_dependency(2); }
+    program_node& bias() const { return get_dependency(3); }
+    program_node& prev_scale_grad() const { return bias_term() ? get_dependency(4) : get_dependency(3); }
+    program_node& prev_bias_grad() const { return get_dependency(5); }
 
     bool use_momentum() const { return !get_primitive()->prev_scale_grad.empty(); }
     bool bias_term() const { return get_dependencies().size() > 3; }
@@ -55,10 +55,10 @@ public:
 public:
     typed_primitive_inst(network_impl& network, scale_grad_weights_node const& desc);
 
-    decltype(auto) weights_memory() const { return dep_memory(2); }
-    decltype(auto) bias_memory() const { return dep_memory(3); }
-    decltype(auto) prev_scale_grad() const { return bias_term() ? dep_memory(4) : dep_memory(3); }
-    decltype(auto) prev_bias_grad() const { return dep_memory(5); }
+    memory_impl& weights_memory() const { return dep_memory(2); }
+    memory_impl& bias_memory() const { return dep_memory(3); }
+    memory_impl& prev_scale_grad() const { return bias_term() ? dep_memory(4) : dep_memory(3); }
+    memory_impl& prev_bias_grad() const { return dep_memory(5); }
 
     bool use_momentum() const { return !argument.prev_scale_grad.empty(); }
     bool bias_term() const { return _deps.size() > 3; }
diff --git a/inference-engine/thirdparty/clDNN/src/include/scale_inst.h b/inference-engine/thirdparty/clDNN/src/include/scale_inst.h
index d35bc9364..405507ace 100644
--- a/inference-engine/thirdparty/clDNN/src/include/scale_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/scale_inst.h
@@ -30,9 +30,9 @@ struct typed_program_node<scale> : public typed_program_node_base<scale>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) scale_in() const { return get_dependency(1); }
-    decltype(auto) bias() const { return get_dependency(2); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& scale_in() const { return get_dependency(1); }
+    program_node& bias() const { return get_dependency(2); }
 
     bool bias_term() const { return get_dependencies().size() > 2; }
 };
@@ -51,8 +51,8 @@ public:
 public:
     typed_primitive_inst(network_impl& network, scale_node const& desc);
 
-    decltype(auto) scale_memory() const { return dep_memory(1); }
-    decltype(auto) bias_memory() const { return dep_memory(2); }
+    memory_impl& scale_memory() const { return dep_memory(1); }
+    memory_impl& bias_memory() const { return dep_memory(2); }
 
     bool bias_term() const { return _deps.size() > 2; }
 };
diff --git a/inference-engine/thirdparty/clDNN/src/include/select_inst.h b/inference-engine/thirdparty/clDNN/src/include/select_inst.h
new file mode 100644
index 000000000..2738c82ca
--- /dev/null
+++ b/inference-engine/thirdparty/clDNN/src/include/select_inst.h
@@ -0,0 +1,52 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+#include <api/CPP/select.hpp>
+
+#include "primitive_inst.h"
+
+namespace cldnn
+{
+	template <>
+	struct typed_program_node<select> : public typed_program_node_base<select>
+	{
+		using parent = typed_program_node_base<select>;
+
+	public:
+		using parent::parent;
+
+        program_node& input(size_t idx = 0) const { return get_dependency(idx); }
+		size_t inputs_count() const { return get_dependencies().size(); }
+	};
+
+	using select_node = typed_program_node<select>;
+
+	template <>
+	class typed_primitive_inst<select> : public typed_primitive_inst_base<select>
+	{
+		using parent = typed_primitive_inst_base<select>;
+
+	public:
+		static layout calc_output_layout(select_node const& node);
+		static std::string to_string(select_node const& node);
+		typed_primitive_inst(network_impl& network, select_node const& node);
+
+	};
+
+	using select_inst = typed_primitive_inst<select>;
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/split_inst.h b/inference-engine/thirdparty/clDNN/src/include/split_inst.h
index 6836edd31..251f4c77a 100644
--- a/inference-engine/thirdparty/clDNN/src/include/split_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/split_inst.h
@@ -30,7 +30,7 @@ class typed_program_node<split> : public typed_program_node_base<split>
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
+    program_node& input() const { return get_dependency(0); }
 };
 
 using split_node = typed_program_node<split>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/tile_inst.h b/inference-engine/thirdparty/clDNN/src/include/tile_inst.h
new file mode 100644
index 000000000..ae3784430
--- /dev/null
+++ b/inference-engine/thirdparty/clDNN/src/include/tile_inst.h
@@ -0,0 +1,53 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+#include "api/CPP/tile.hpp"
+#include "primitive_inst.h"
+
+namespace cldnn
+{
+
+template <>
+struct typed_program_node<tile> : public typed_program_node_base<tile>
+{
+    using parent = typed_program_node_base<tile>;
+
+public:
+    using parent::parent;
+
+    program_node& input() const { return get_dependency(0); }
+};
+
+using tile_node = typed_program_node<tile>;
+
+template <>
+class typed_primitive_inst<tile> : public typed_primitive_inst_base<tile>
+{
+    using parent = typed_primitive_inst_base<tile>;
+
+public:
+    static layout calc_output_layout(tile_node const& node);
+    static std::string to_string(tile_node const& node);
+
+public:
+    typed_primitive_inst(network_impl& network, tile_node const& desc);
+};
+
+using tile_inst = typed_primitive_inst<tile>;
+
+}
diff --git a/inference-engine/thirdparty/clDNN/src/include/to_string_utils.h b/inference-engine/thirdparty/clDNN/src/include/to_string_utils.h
index db5373f03..5d83c5b2f 100644
--- a/inference-engine/thirdparty/clDNN/src/include/to_string_utils.h
+++ b/inference-engine/thirdparty/clDNN/src/include/to_string_utils.h
@@ -15,18 +15,15 @@
 */
 #pragma once
 #include <string>
-#include "program_node.h"
+#include "api/CPP/tensor.hpp"
+#include "api/CPP/layout.hpp"
 
 namespace cldnn
 {
 
-inline std::string bool_to_str(const bool condi)
+inline std::string bool_to_str(bool cond)
 {
-	if (condi)
-	{
-		return "true";
-	}
-	return "false";
+    return cond ? "true" : "false";
 }
 
 inline std::string get_extr_type(const char* str)
@@ -63,10 +60,12 @@ inline std::string dt_to_str(data_types dt)
     switch (dt)
     {
     case data_types::i8: return "i8";
+    case data_types::i32: return "i32";
+    case data_types::i64: return "i64";
     case data_types::f16: return "f16";
     case data_types::f32: return "f32";
     default:
-        return "unknown (" + std::to_string(std::underlying_type_t<data_types>(dt)) + ")";
+        return "unknown (" + std::to_string(typename std::underlying_type<data_types>::type(dt)) + ")";
     }
 }
 
@@ -83,7 +82,9 @@ inline std::string fmt_to_str(format fmt)
     case format::bs_xs_xsv8_bsv16: return "bs_xs_xsv8_bsv16";
     case format::os_iyx_osv16: return "os_iyx_osv16";
     case format::os_is_yx_isa8_osv8_isv4: return "os_is_yx_isa8_osv8_isv4";
+    case format::is_o_yx_isv32: return "is_o_yx_isv32";
     case format::byxf_af32: return "byxf_af32";
+    case format::fs_bs_yx_bsv4_fsv32: return "fs_bs_yx_bsv4_fsv32";
     default:
         return "unknown (" + std::to_string(fmt.value) + ")";
     }
diff --git a/inference-engine/thirdparty/clDNN/src/include/topology_impl.h b/inference-engine/thirdparty/clDNN/src/include/topology_impl.h
index fde0d20c1..161879cdd 100644
--- a/inference-engine/thirdparty/clDNN/src/include/topology_impl.h
+++ b/inference-engine/thirdparty/clDNN/src/include/topology_impl.h
@@ -51,7 +51,7 @@ public:
         _primitives.insert({ id, desc });
     }
 
-    const auto& at(primitive_id id) const 
+    const std::shared_ptr<primitive>& at(primitive_id id) const
     {
         try
         {
diff --git a/inference-engine/thirdparty/clDNN/src/include/upsampling_inst.h b/inference-engine/thirdparty/clDNN/src/include/upsampling_inst.h
index 3a001a9cc..2cf4d47e8 100644
--- a/inference-engine/thirdparty/clDNN/src/include/upsampling_inst.h
+++ b/inference-engine/thirdparty/clDNN/src/include/upsampling_inst.h
@@ -31,8 +31,8 @@ struct typed_program_node<upsampling> : public typed_program_node_base<upsamplin
 public:
     using parent::parent;
 
-    decltype(auto) input() const { return get_dependency(0); }
-    decltype(auto) input2() const { return get_dependency(1); }
+    program_node& input() const { return get_dependency(0); }
+    program_node& input2() const { return get_dependency(1); }
 };
 
 using upsampling_node = typed_program_node<upsampling>;
diff --git a/inference-engine/thirdparty/clDNN/src/include/xml_object.h b/inference-engine/thirdparty/clDNN/src/include/xml_object.h
index 66ae93ebf..c32eddd91 100644
--- a/inference-engine/thirdparty/clDNN/src/include/xml_object.h
+++ b/inference-engine/thirdparty/clDNN/src/include/xml_object.h
@@ -17,9 +17,7 @@
 #include <string>
 #include <type_traits>
 #include <unordered_map>
-#include <map>
-#include <algorithm>
-#include <iostream>
+#include <ostream>
 #include <memory>
 
 namespace cldnn