De-Eigenize remaining unops

src/ngraph/runtime/kernel/asin.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void asin(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::asin(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/atan.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void atan(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::atan(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/ceiling.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void ceiling(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::ceil(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/cos.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void cos(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::cos(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/cosh.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void cosh(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::cosh(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/exp.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void exp(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::exp(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/floor.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void floor(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::floor(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/log.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void log(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::log(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/negate.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void negate(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = -arg[i];
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/sign.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void sign(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = (arg[i] < 0 ? -1 : (arg[i] > 0 ? 1 : 0));
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/sin.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void sin(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::sin(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/sinh.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void sinh(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::sinh(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/sqrt.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void sqrt(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::sqrt(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/tan.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void tan(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::tan(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/kernel/tanh.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// 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
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <cmath>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace kernel
+        {
+            template <typename T>
+            void tanh(T* arg, T* out, size_t count)
+            {
+                for (size_t i = 0; i < count; i++)
+                {
+                    out[i] = std::tanh(arg[i]);
+                }
+            }
+        }
+    }
+}

src/ngraph/runtime/ngvm/external_function.cpp

@@ -73,30 +73,30 @@
 #include "ngraph/runtime/ngvm/eigen/abs.hpp"
 #include "ngraph/runtime/ngvm/instruction/acos.hpp"
 #include "ngraph/runtime/ngvm/instruction/add.hpp"
-#include "ngraph/runtime/ngvm/eigen/asin.hpp"
-#include "ngraph/runtime/ngvm/eigen/atan.hpp"
+#include "ngraph/runtime/ngvm/instruction/asin.hpp"
+#include "ngraph/runtime/ngvm/instruction/atan.hpp"
 #include "ngraph/runtime/ngvm/eigen/broadcast_scalar.hpp"
 #include "ngraph/runtime/ngvm/eigen/broadcast_vector_colwise.hpp"
 #include "ngraph/runtime/ngvm/eigen/broadcast_vector_rowwise.hpp"
 #include "ngraph/runtime/ngvm/eigen/call.hpp"
-#include "ngraph/runtime/ngvm/eigen/ceiling.hpp"
+#include "ngraph/runtime/ngvm/instruction/ceiling.hpp"
 #include "ngraph/runtime/ngvm/eigen/concat_matrix.hpp"
 #include "ngraph/runtime/ngvm/eigen/concat_vector.hpp"
 #include "ngraph/runtime/ngvm/eigen/constant.hpp"
 #include "ngraph/runtime/ngvm/eigen/convert.hpp"
 #include "ngraph/runtime/ngvm/eigen/copy.hpp"
-#include "ngraph/runtime/ngvm/eigen/cos.hpp"
-#include "ngraph/runtime/ngvm/eigen/cosh.hpp"
+#include "ngraph/runtime/ngvm/instruction/cos.hpp"
+#include "ngraph/runtime/ngvm/instruction/cosh.hpp"
 #include "ngraph/runtime/ngvm/eigen/divide.hpp"
 #include "ngraph/runtime/ngvm/eigen/dot.hpp"
 #include "ngraph/runtime/ngvm/eigen/equal.hpp"
-#include "ngraph/runtime/ngvm/eigen/exp.hpp"
-#include "ngraph/runtime/ngvm/eigen/floor.hpp"
+#include "ngraph/runtime/ngvm/instruction/exp.hpp"
+#include "ngraph/runtime/ngvm/instruction/floor.hpp"
 #include "ngraph/runtime/ngvm/eigen/greater_eq.hpp"
 #include "ngraph/runtime/ngvm/eigen/greater_than.hpp"
 #include "ngraph/runtime/ngvm/eigen/less_eq.hpp"
 #include "ngraph/runtime/ngvm/eigen/less_than.hpp"
-#include "ngraph/runtime/ngvm/eigen/log.hpp"
+#include "ngraph/runtime/ngvm/instruction/log.hpp"
 #include "ngraph/runtime/ngvm/eigen/matrix_mult.hpp"
 #include "ngraph/runtime/ngvm/eigen/matrix_slice.hpp"
 #include "ngraph/runtime/ngvm/eigen/matrix_transpose.hpp"
@@ -104,7 +104,7 @@
 #include "ngraph/runtime/ngvm/eigen/maximum.hpp"
 #include "ngraph/runtime/ngvm/eigen/minimum.hpp"
 #include "ngraph/runtime/ngvm/eigen/multiply.hpp"
-#include "ngraph/runtime/ngvm/eigen/negate.hpp"
+#include "ngraph/runtime/ngvm/instruction/negate.hpp"
 #include "ngraph/runtime/ngvm/eigen/not.hpp"
 #include "ngraph/runtime/ngvm/eigen/not_equal.hpp"
 #include "ngraph/runtime/ngvm/eigen/power.hpp"
@@ -116,16 +116,16 @@
 #include "ngraph/runtime/ngvm/eigen/return.hpp"
 #include "ngraph/runtime/ngvm/eigen/scalar_tensor_product.hpp"
 #include "ngraph/runtime/ngvm/eigen/select.hpp"
-#include "ngraph/runtime/ngvm/eigen/sign.hpp"
-#include "ngraph/runtime/ngvm/eigen/sin.hpp"
-#include "ngraph/runtime/ngvm/eigen/sinh.hpp"
-#include "ngraph/runtime/ngvm/eigen/sqrt.hpp"
+#include "ngraph/runtime/ngvm/instruction/sign.hpp"
+#include "ngraph/runtime/ngvm/instruction/sin.hpp"
+#include "ngraph/runtime/ngvm/instruction/sinh.hpp"
+#include "ngraph/runtime/ngvm/instruction/sqrt.hpp"
 #include "ngraph/runtime/ngvm/eigen/subtract.hpp"
 #include "ngraph/runtime/ngvm/eigen/sum_matrix_columns.hpp"
 #include "ngraph/runtime/ngvm/eigen/sum_matrix_rows.hpp"
 #include "ngraph/runtime/ngvm/eigen/sum_to_scalar.hpp"
-#include "ngraph/runtime/ngvm/eigen/tan.hpp"
-#include "ngraph/runtime/ngvm/eigen/tanh.hpp"
+#include "ngraph/runtime/ngvm/instruction/tan.hpp"
+#include "ngraph/runtime/ngvm/instruction/tanh.hpp"
 #include "ngraph/runtime/ngvm/eigen/vector_slice.hpp"
 #include "ngraph/runtime/ngvm/external_function.hpp"
 #include "ngraph/runtime/utils.hpp"
@@ -389,21 +389,21 @@ ExternalFunction::OpMap& ExternalFunction::get_op_map()
     if (!initialized)
     {
         REGISTER_NUMERIC_UNOP(op::Acos, instruction::AcosInstruction);
-        REGISTER_NUMERIC_UNOP(op::Asin, eigen::AsinInstruction);
-        REGISTER_NUMERIC_UNOP(op::Atan, eigen::AtanInstruction);
-        REGISTER_NUMERIC_UNOP(op::Ceiling, eigen::CeilingInstruction);
-        REGISTER_NUMERIC_UNOP(op::Cos, eigen::CosInstruction);
-        REGISTER_NUMERIC_UNOP(op::Cosh, eigen::CoshInstruction);
-        REGISTER_NUMERIC_UNOP(op::Exp, eigen::ExpInstruction);
-        REGISTER_NUMERIC_UNOP(op::Floor, eigen::FloorInstruction);
-        REGISTER_NUMERIC_UNOP(op::Log, eigen::LogInstruction);
-        REGISTER_NUMERIC_UNOP(op::Negative, eigen::NegateInstruction);
-        REGISTER_NUMERIC_UNOP(op::Sign, eigen::SignInstruction);
-        REGISTER_NUMERIC_UNOP(op::Sin, eigen::SinInstruction);
-        REGISTER_NUMERIC_UNOP(op::Sinh, eigen::SinhInstruction);
-        REGISTER_NUMERIC_UNOP(op::Sqrt, eigen::SqrtInstruction);
-        REGISTER_NUMERIC_UNOP(op::Tan, eigen::TanInstruction);
-        REGISTER_NUMERIC_UNOP(op::Tanh, eigen::TanhInstruction);
+        REGISTER_NUMERIC_UNOP(op::Asin, instruction::AsinInstruction);
+        REGISTER_NUMERIC_UNOP(op::Atan, instruction::AtanInstruction);
+        REGISTER_NUMERIC_UNOP(op::Ceiling, instruction::CeilingInstruction);
+        REGISTER_NUMERIC_UNOP(op::Cos, instruction::CosInstruction);
+        REGISTER_NUMERIC_UNOP(op::Cosh, instruction::CoshInstruction);
+        REGISTER_NUMERIC_UNOP(op::Exp, instruction::ExpInstruction);
+        REGISTER_NUMERIC_UNOP(op::Floor, instruction::FloorInstruction);
+        REGISTER_NUMERIC_UNOP(op::Log, instruction::LogInstruction);
+        REGISTER_NUMERIC_UNOP(op::Negative, instruction::NegateInstruction);
+        REGISTER_NUMERIC_UNOP(op::Sign, instruction::SignInstruction);
+        REGISTER_NUMERIC_UNOP(op::Sin, instruction::SinInstruction);
+        REGISTER_NUMERIC_UNOP(op::Sinh, instruction::SinhInstruction);
+        REGISTER_NUMERIC_UNOP(op::Sqrt, instruction::SqrtInstruction);
+        REGISTER_NUMERIC_UNOP(op::Tan, instruction::TanInstruction);
+        REGISTER_NUMERIC_UNOP(op::Tanh, instruction::TanhInstruction);
 
         REGISTER_SIGNED_NUMERIC_UNOP(op::Abs, eigen::AbsInstruction);
 

src/ngraph/runtime/ngvm/eigen/asin.hpp → src/ngraph/runtime/ngvm/instruction/asin.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/asin.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class AsinInstruction : public Instruction
                 {
                 public:
-                    AsinInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    AsinInstruction(const TensorViewInfo& arg,
+                                   const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).asin();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::asin<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/atan.hpp → src/ngraph/runtime/ngvm/instruction/atan.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/atan.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class AtanInstruction : public Instruction
                 {
                 public:
-                    AtanInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    AtanInstruction(const TensorViewInfo& arg,
+                                   const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).atan();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::atan<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/ceiling.hpp → src/ngraph/runtime/ngvm/instruction/ceiling.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/ceiling.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class CeilingInstruction : public Instruction
                 {
                 public:
-                    CeilingInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    CeilingInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).ceil();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::ceiling<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/cos.hpp → src/ngraph/runtime/ngvm/instruction/cos.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/cos.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class CosInstruction : public Instruction
                 {
                 public:
-                    CosInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    CosInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).cos();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::cos<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/cosh.hpp → src/ngraph/runtime/ngvm/instruction/cosh.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/cosh.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class CoshInstruction : public Instruction
                 {
                 public:
-                    CoshInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    CoshInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).cosh();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::cosh<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/exp.hpp → src/ngraph/runtime/ngvm/instruction/exp.hpp

@@ -14,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/exp.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -25,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class ExpInstruction : public Instruction
                 {
                 public:
-                    ExpInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    ExpInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -39,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).exp();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::exp<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/floor.hpp → src/ngraph/runtime/ngvm/instruction/floor.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/floor.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class FloorInstruction : public Instruction
                 {
                 public:
-                    FloorInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    FloorInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).floor();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::floor<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/log.hpp → src/ngraph/runtime/ngvm/instruction/log.hpp

@@ -14,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/log.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -25,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class LogInstruction : public Instruction
                 {
                 public:
-                    LogInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    LogInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -39,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            Eigen::log(EigenArray1d<ET, fmt::V>(call_frame, m_arg));
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::log<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/negate.hpp → src/ngraph/runtime/ngvm/instruction/negate.hpp

@@ -14,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/negate.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -25,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class NegateInstruction : public Instruction
                 {
                 public:
-                    NegateInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    NegateInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -39,7 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET>(call_frame, m_out) = -EigenArray1d<ET>(call_frame, m_arg);
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::negate<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/sign.hpp → src/ngraph/runtime/ngvm/instruction/sign.hpp

@@ -14,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/sign.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -25,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class SignInstruction : public Instruction
                 {
                 public:
-                    SignInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    SignInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -39,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).sign();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::sign<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/sin.hpp → src/ngraph/runtime/ngvm/instruction/sin.hpp

@@ -14,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/sin.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -25,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class SinInstruction : public Instruction
                 {
                 public:
-                    SinInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    SinInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -39,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).sin();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::sin<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/sinh.hpp → src/ngraph/runtime/ngvm/instruction/sinh.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/sinh.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class SinhInstruction : public Instruction
                 {
                 public:
-                    SinhInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    SinhInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).sinh();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::sinh<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/sqrt.hpp → src/ngraph/runtime/ngvm/instruction/sqrt.hpp

@@ -14,11 +14,11 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/sqrt.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
-#include "ngraph/runtime/tensor_view_info.hpp"
 
 namespace ngraph
 {
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class SqrtInstruction : public Instruction
                 {
                 public:
-                    SqrtInstruction(const TensorViewInfo& arg, const TensorViewInfo& out)
+                    SqrtInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET>(call_frame, m_out) =
-                            Eigen::sqrt(EigenArray1d<ET>(call_frame, m_arg));
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::sqrt<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/tan.hpp → src/ngraph/runtime/ngvm/instruction/tan.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/tan.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class TanInstruction : public Instruction
                 {
                 public:
-                    TanInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    TanInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).tan();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::tan<typename ET::type>(arg, out, count);
                     }
 
                 protected:

src/ngraph/runtime/ngvm/eigen/tanh.hpp → src/ngraph/runtime/ngvm/instruction/tanh.hpp

-
 // ----------------------------------------------------------------------------
 // Copyright 2017 Nervana Systems Inc.
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +14,9 @@
 
 #pragma once
 
+#include "ngraph/runtime/kernel/tanh.hpp"
 #include "ngraph/runtime/ngvm/call_frame.hpp"
-#include "ngraph/runtime/ngvm/eigen/utils.hpp"
+#include "ngraph/runtime/ngvm/utils.hpp"
 #include "ngraph/runtime/ngvm/instruction.hpp"
 #include "ngraph/runtime/tensor_view.hpp"
 
@@ -26,13 +26,14 @@ namespace ngraph
     {
         namespace ngvm
         {
-            namespace eigen
+            namespace instruction
             {
                 template <typename ET>
                 class TanhInstruction : public Instruction
                 {
                 public:
-                    TanhInstruction(TensorViewInfo arg, TensorViewInfo out)
+                    TanhInstruction(const TensorViewInfo& arg,
+                                       const TensorViewInfo& out)
                         : m_arg(arg)
                         , m_out(out)
                     {
@@ -40,8 +41,12 @@ namespace ngraph
 
                     virtual void execute(CallFrame& call_frame) const override
                     {
-                        EigenArray1d<ET, fmt::V>(call_frame, m_out) =
-                            EigenArray1d<ET, fmt::V>(call_frame, m_arg).tanh();
+                        typename ET::type* arg = get_tensor_data_ptr<ET>(call_frame, m_arg);
+                        typename ET::type* out = get_tensor_data_ptr<ET>(call_frame, m_out);
+
+                        size_t count = get_tensor_element_count(call_frame, m_arg);
+
+                        kernel::tanh<typename ET::type>(arg, out, count);
                     }
 
                 protected: