[PlaidML] Specialize within namespaces (for Linux) (#1948)

src/ngraph/runtime/plaidml/plaidml_ops_concat.cpp

@@ -17,87 +17,101 @@
 #include "ngraph/op/concat.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// Concat views a tensor as a new type.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Concat>::operator()()
+namespace ngraph
 {
-    check_outputs(1);
-
-    auto f = start_tile_function();
-    f.add(builder::Output{"O"});
-    std::size_t dim_count = op().get_shape().size();
-    std::ostringstream offset;
-    std::ostringstream oexpr;
-    std::ostringstream concat_dsize;
-    bool saw_non_zero_tensor = false;
-    for (std::size_t iidx = 0; iidx < op().get_inputs().size(); ++iidx)
+    namespace runtime
     {
-        if (!shape_size(op().get_input_shape(iidx)))
-        {
-            continue;
-        }
-        if (saw_non_zero_tensor)
+        namespace plaidml
         {
-            concat_dsize << "+";
-        }
-        saw_non_zero_tensor = true;
-        concat_dsize << "I" << iidx << "_D" << op().get_concatenation_axis();
-    }
+            // Concat views a tensor as a new type.
+            template <>
+            void Impl<op::Concat>::operator()()
+            {
+                check_outputs(1);
 
-    saw_non_zero_tensor = false;
-    for (std::size_t iidx = 0; iidx < op().get_inputs().size(); ++iidx)
-    {
-        if (!shape_size(op().get_input_shape(iidx)))
-        {
-            continue;
-        }
-        std::string sidx{std::to_string(iidx)};
-        f.add(builder::Input{op_input(iidx), "I" + sidx}.add_dims("I" + sidx + "_D", 0, dim_count));
-        f.add(builder::UnaryContraction{"="}
-                  .set(builder::ContractionOutput{"E" + sidx}
-                           .add_dims([&](std::back_insert_iterator<std::list<std::string>> out) {
-                               for (std::size_t idx = 0; idx < dim_count; ++idx)
-                               {
-                                   std::ostringstream s;
-                                   if (idx == op().get_concatenation_axis())
-                                   {
-                                       out = concat_dsize.str();
-                                   }
-                                   else
-                                   {
-                                       s << "I" << iidx << "_D" << idx;
-                                       out = s.str();
-                                   }
-                               }
-                           })
-                           .add_indices([&](std::back_insert_iterator<std::list<std::string>> out) {
-                               for (std::size_t idx = 0; idx < dim_count; ++idx)
-                               {
-                                   std::ostringstream s;
-                                   s << "d" << idx;
-                                   if (saw_non_zero_tensor && idx == op().get_concatenation_axis())
-                                   {
-                                       s << " + " << offset.str();
-                                   }
-                                   out = s.str();
-                               }
-                           }))
-                  .set(builder::ContractionInput{"I" + sidx}.add_indices("d", 0, dim_count)));
-        if (saw_non_zero_tensor)
-        {
-            oexpr << " + ";
-            offset << " + ";
-        }
-        oexpr << "E" << sidx;
-        offset << "I" << iidx << "_D" << op().get_concatenation_axis();
-        saw_non_zero_tensor = true;
-    }
-    f.add(builder::Elementwise{"O", oexpr.str()});
+                auto f = start_tile_function();
+                f.add(builder::Output{"O"});
+                std::size_t dim_count = op().get_shape().size();
+                std::ostringstream offset;
+                std::ostringstream oexpr;
+                std::ostringstream concat_dsize;
+                bool saw_non_zero_tensor = false;
+                for (std::size_t iidx = 0; iidx < op().get_inputs().size(); ++iidx)
+                {
+                    if (!shape_size(op().get_input_shape(iidx)))
+                    {
+                        continue;
+                    }
+                    if (saw_non_zero_tensor)
+                    {
+                        concat_dsize << "+";
+                    }
+                    saw_non_zero_tensor = true;
+                    concat_dsize << "I" << iidx << "_D" << op().get_concatenation_axis();
+                }
 
-    set_output(f.finalize());
-}
+                saw_non_zero_tensor = false;
+                for (std::size_t iidx = 0; iidx < op().get_inputs().size(); ++iidx)
+                {
+                    if (!shape_size(op().get_input_shape(iidx)))
+                    {
+                        continue;
+                    }
+                    std::string sidx{std::to_string(iidx)};
+                    f.add(builder::Input{op_input(iidx), "I" + sidx}.add_dims(
+                        "I" + sidx + "_D", 0, dim_count));
+                    f.add(builder::UnaryContraction{"="}
+                              .set(builder::ContractionOutput{"E" + sidx}
+                                       .add_dims([&](
+                                           std::back_insert_iterator<std::list<std::string>> out) {
+                                           for (std::size_t idx = 0; idx < dim_count; ++idx)
+                                           {
+                                               std::ostringstream s;
+                                               if (idx == op().get_concatenation_axis())
+                                               {
+                                                   out = concat_dsize.str();
+                                               }
+                                               else
+                                               {
+                                                   s << "I" << iidx << "_D" << idx;
+                                                   out = s.str();
+                                               }
+                                           }
+                                       })
+                                       .add_indices([&](
+                                           std::back_insert_iterator<std::list<std::string>> out) {
+                                           for (std::size_t idx = 0; idx < dim_count; ++idx)
+                                           {
+                                               std::ostringstream s;
+                                               s << "d" << idx;
+                                               if (saw_non_zero_tensor &&
+                                                   idx == op().get_concatenation_axis())
+                                               {
+                                                   s << " + " << offset.str();
+                                               }
+                                               out = s.str();
+                                           }
+                                       }))
+                              .set(builder::ContractionInput{"I" + sidx}.add_indices(
+                                  "d", 0, dim_count)));
+                    if (saw_non_zero_tensor)
+                    {
+                        oexpr << " + ";
+                        offset << " + ";
+                    }
+                    oexpr << "E" << sidx;
+                    offset << "I" << iidx << "_D" << op().get_concatenation_axis();
+                    saw_non_zero_tensor = true;
+                }
+                f.add(builder::Elementwise{"O", oexpr.str()});
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::Concat>::Registration register_concat;
+                set_output(f.finalize());
+            }
+
+            namespace
+            {
+                Impl<op::Concat>::Registration register_concat;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_convert.cpp

@@ -18,21 +18,31 @@
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 #include "ngraph/runtime/plaidml/plaidml_translate.hpp"
 
-// Convert views a tensor as a new type.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Convert>::operator()()
+namespace ngraph
 {
-    check_inputs(1);
-    check_outputs(1);
-    set_output(start_tile_function()
-                   .add(builder::Input{op_input(), "I"})
-                   .add(builder::Output{"O"})
-                   .add(builder::Elementwise{
-                       "O", tile_converter("I", to_plaidml(op().get_convert_element_type()))})
-                   .finalize());
-}
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // Convert views a tensor as a new type.
+            template <>
+            void Impl<op::Convert>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
+                set_output(
+                    start_tile_function()
+                        .add(builder::Input{op_input(), "I"})
+                        .add(builder::Output{"O"})
+                        .add(builder::Elementwise{
+                            "O", tile_converter("I", to_plaidml(op().get_convert_element_type()))})
+                        .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::Convert>::Registration register_convert;
+            namespace
+            {
+                Impl<op::Convert>::Registration register_convert;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_dot.cpp

@@ -20,50 +20,60 @@
 #include "ngraph/op/dot.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// Dot is a generalized dot product operation -- scalar-tensor,
-// matrix-vector, and matrix multiplication.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Dot>::operator()()
+namespace ngraph
 {
-    check_inputs(2);
-    check_outputs(1);
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // Dot is a generalized dot product operation -- scalar-tensor,
+            // matrix-vector, and matrix multiplication.
+            template <>
+            void Impl<op::Dot>::operator()()
+            {
+                check_inputs(2);
+                check_outputs(1);
 
-    auto l_dim_limit = op().get_inputs()[0].get_shape().size();
-    auto r_dim_limit = op().get_inputs()[1].get_shape().size();
-    auto reduce_limit = op().get_reduction_axes_count();
-    auto l_dim_mac = l_dim_limit - reduce_limit;
-    auto r_dim_mic = reduce_limit;
+                auto l_dim_limit = op().get_inputs()[0].get_shape().size();
+                auto r_dim_limit = op().get_inputs()[1].get_shape().size();
+                auto reduce_limit = op().get_reduction_axes_count();
+                auto l_dim_mac = l_dim_limit - reduce_limit;
+                auto r_dim_mic = reduce_limit;
 
-    NGRAPH_DEBUG << "l_dim_limit=" << l_dim_limit;
-    NGRAPH_DEBUG << "r_dim_limit=" << r_dim_limit;
-    NGRAPH_DEBUG << "reduce_limit=" << reduce_limit;
-    NGRAPH_DEBUG << "l_dim_mac=" << l_dim_mac;
-    NGRAPH_DEBUG << "r_dim_mic=" << r_dim_mic;
+                NGRAPH_DEBUG << "l_dim_limit=" << l_dim_limit;
+                NGRAPH_DEBUG << "r_dim_limit=" << r_dim_limit;
+                NGRAPH_DEBUG << "reduce_limit=" << reduce_limit;
+                NGRAPH_DEBUG << "l_dim_mac=" << l_dim_mac;
+                NGRAPH_DEBUG << "r_dim_mic=" << r_dim_mic;
 
-    set_output(start_tile_function()
-                   .add(builder::Input{op_input(0), "L"}
-                            .add_dims("DL", 1, l_dim_mac + 1)
-                            .add_dims("DC", 1, reduce_limit + 1))
-                   .add(builder::Input{op_input(1), "R"}
-                            .add_dims("DC", 1, reduce_limit + 1)
-                            .add_dims("DR", r_dim_mic + 1, r_dim_limit + 1))
-                   .add(builder::Output{"O"})
-                   .add(builder::BinaryContraction{"+", "*"}
-                            .set(builder::ContractionOutput{"O"}
-                                     .add_indices("dl", 1, l_dim_mac + 1)
-                                     .add_indices("dr", r_dim_mic + 1, r_dim_limit + 1)
-                                     .add_dims("DL", 1, l_dim_mac + 1)
-                                     .add_dims("DR", r_dim_mic + 1, r_dim_limit + 1))
-                            .set_lhs(builder::ContractionInput{"L"}
-                                         .add_indices("dl", 1, l_dim_mac + 1)
-                                         .add_indices("dc", 1, reduce_limit + 1))
-                            .set_rhs(builder::ContractionInput{"R"}
-                                         .add_indices("dc", 1, reduce_limit + 1)
-                                         .add_indices("dr", r_dim_mic + 1, r_dim_limit + 1)))
-                   .finalize());
-}
+                set_output(
+                    start_tile_function()
+                        .add(builder::Input{op_input(0), "L"}
+                                 .add_dims("DL", 1, l_dim_mac + 1)
+                                 .add_dims("DC", 1, reduce_limit + 1))
+                        .add(builder::Input{op_input(1), "R"}
+                                 .add_dims("DC", 1, reduce_limit + 1)
+                                 .add_dims("DR", r_dim_mic + 1, r_dim_limit + 1))
+                        .add(builder::Output{"O"})
+                        .add(builder::BinaryContraction{"+", "*"}
+                                 .set(builder::ContractionOutput{"O"}
+                                          .add_indices("dl", 1, l_dim_mac + 1)
+                                          .add_indices("dr", r_dim_mic + 1, r_dim_limit + 1)
+                                          .add_dims("DL", 1, l_dim_mac + 1)
+                                          .add_dims("DR", r_dim_mic + 1, r_dim_limit + 1))
+                                 .set_lhs(builder::ContractionInput{"L"}
+                                              .add_indices("dl", 1, l_dim_mac + 1)
+                                              .add_indices("dc", 1, reduce_limit + 1))
+                                 .set_rhs(builder::ContractionInput{"R"}
+                                              .add_indices("dc", 1, reduce_limit + 1)
+                                              .add_indices("dr", r_dim_mic + 1, r_dim_limit + 1)))
+                        .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::Dot>::Registration register_dot;
+            namespace
+            {
+                Impl<op::Dot>::Registration register_dot;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_function.cpp

@@ -19,29 +19,39 @@
 #include "ngraph/runtime/plaidml/plaidml_compiler.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// FunctionCall invokes a sub-function.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::FunctionCall>::operator()()
+namespace ngraph
 {
-    Build b;
-    build()->compiler->build(op().get_functions()[0], &b);
-    vertexai::plaidml::function f{b.composer};
-    vertexai::plaidml::function::parameters_t inputs;
-    for (std::size_t idx = 0; idx < op().get_input_size(); ++idx)
+    namespace runtime
     {
-        auto* oitv = op().get_inputs()[idx].get_output().get_tensor_ptr().get();
-        auto* iitv = b.func->get_parameters()[idx]->get_outputs()[0].get_tensor_ptr().get();
-        inputs.emplace_back(b.input_names.at(iitv), build()->bindings.at(oitv).var);
-    }
-    vertexai::plaidml::application app{f.apply(inputs)};
-    for (std::size_t idx = 0; idx < op().get_output_size(); ++idx)
-    {
-        auto* iotv = b.func->get_results()[idx]->get_output_tensor_ptr().get();
-        set_output(idx, app.get_output(b.output_names[iotv]));
-    }
-}
+        namespace plaidml
+        {
+            // FunctionCall invokes a sub-function.
+            template <>
+            void Impl<op::FunctionCall>::operator()()
+            {
+                Build b;
+                build()->compiler->build(op().get_functions()[0], &b);
+                vertexai::plaidml::function f{b.composer};
+                vertexai::plaidml::function::parameters_t inputs;
+                for (std::size_t idx = 0; idx < op().get_input_size(); ++idx)
+                {
+                    auto* oitv = op().get_inputs()[idx].get_output().get_tensor_ptr().get();
+                    auto* iitv =
+                        b.func->get_parameters()[idx]->get_outputs()[0].get_tensor_ptr().get();
+                    inputs.emplace_back(b.input_names.at(iitv), build()->bindings.at(oitv).var);
+                }
+                vertexai::plaidml::application app{f.apply(inputs)};
+                for (std::size_t idx = 0; idx < op().get_output_size(); ++idx)
+                {
+                    auto* iotv = b.func->get_results()[idx]->get_output_tensor_ptr().get();
+                    set_output(idx, app.get_output(b.output_names[iotv]));
+                }
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::FunctionCall>::Registration register_function_call;
+            namespace
+            {
+                Impl<op::FunctionCall>::Registration register_function_call;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_io.cpp

@@ -20,35 +20,44 @@
 
 namespace vp = vertexai::plaidml;
 
-// Parameter binds a descriptor::Tensor to a PlaidML Placeholder.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Parameter>::operator()()
+namespace ngraph
 {
-    check_inputs(0);
-    check_outputs(1);
-    vp::placeholder ph{build()->io_dim_override ? build()->io_dim_override_count
-                                                : op().get_output_shape(0).size()};
-    std::string name = std::string{"I"} + std::to_string(build()->input_names.size());
-    descriptor::Tensor* tv = op().get_output_tensor_ptr().get();
-    build()->bindings.emplace(tv, TensorInfo{ph, TensorContents::DATA});
-    build()->composer.input(name, ph);
-    build()->input_names.emplace(tv, std::move(name));
-}
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // Parameter binds a descriptor::Tensor to a PlaidML Placeholder.
+            template <>
+            void Impl<op::Parameter>::operator()()
+            {
+                check_inputs(0);
+                check_outputs(1);
+                vp::placeholder ph{build()->io_dim_override ? build()->io_dim_override_count
+                                                            : op().get_output_shape(0).size()};
+                std::string name = std::string{"I"} + std::to_string(build()->input_names.size());
+                descriptor::Tensor* tv = op().get_output_tensor_ptr().get();
+                build()->bindings.emplace(tv, TensorInfo{ph, TensorContents::DATA});
+                build()->composer.input(name, ph);
+                build()->input_names.emplace(tv, std::move(name));
+            }
 
-// Result binds a PlaidML variable to a composed function output.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Result>::operator()()
-{
-    check_inputs(1);
-    check_outputs(1);
-    std::string name = std::string{"O"} + std::to_string(build()->output_names.size());
-    descriptor::Tensor* tv = op().get_output_tensor_ptr().get();
-    build()->composer.output(name, op_input());
-    build()->output_names.emplace(tv, std::move(name));
-}
+            // Result binds a PlaidML variable to a composed function output.
+            template <>
+            void Impl<op::Result>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
+                std::string name = std::string{"O"} + std::to_string(build()->output_names.size());
+                descriptor::Tensor* tv = op().get_output_tensor_ptr().get();
+                build()->composer.output(name, op_input());
+                build()->output_names.emplace(tv, std::move(name));
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::Parameter>::Registration register_parameter;
-    ngraph::runtime::plaidml::Impl<ngraph::op::Result>::Registration register_result;
+            namespace
+            {
+                Impl<op::Parameter>::Registration register_parameter;
+                Impl<op::Result>::Registration register_result;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_local_response_norm.cpp

@@ -17,40 +17,52 @@
 #include "ngraph/op/lrn.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// LRN implements Local Response Normalization
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::LRN>::operator()()
+namespace ngraph
 {
-    check_inputs(1);
-    check_outputs(1);
-    auto dim_limit = op().get_inputs()[0].get_shape().size();
-    auto rank = dim_limit - 2;
-    auto distance = op().get_nsize() / 2;
-    std::ostringstream div_expr;
-    div_expr << "I / pow(" << op().get_bias() << ".0 + ((" << op().get_alpha() << ".0 / "
-             << op().get_nsize() << ".0) * S), " << op().get_beta() << ".0)";
-    set_output(
-        start_tile_function()
-            .add(builder::Input{op_input(), "I"}.add_dims({"N", "C"}).add_dims("D", 0, rank))
-            .add(builder::Output{"O"})
-            .add(builder::Elementwise{"ISQ", "I * I"})
-            .add(builder::UnaryContraction{"+"}
-                     .set(builder::ContractionOutput{"S"}
-                              .add_indices({"n", "c"})
-                              .add_indices("d", 0, rank)
-                              .add_dims({"N", "C"})
-                              .add_dims("D", 0, rank))
-                     .set(builder::ContractionInput{"ISQ"}
-                              .add_indices({"n", "c + z - " + std::to_string(distance)})
-                              .add_indices("d", 0, rank))
-                     .add_constraints([&](std::back_insert_iterator<std::list<std::string>> out) {
-                         out = "z < " + std::to_string(op().get_nsize());
-                     }))
-            .add(builder::Elementwise{"O", div_expr.str()})
-            .finalize());
-}
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // LRN implements Local Response Normalization
+            template <>
+            void Impl<op::LRN>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
+                auto dim_limit = op().get_inputs()[0].get_shape().size();
+                auto rank = dim_limit - 2;
+                auto distance = op().get_nsize() / 2;
+                std::ostringstream div_expr;
+                div_expr << "I / pow(" << op().get_bias() << ".0 + ((" << op().get_alpha()
+                         << ".0 / " << op().get_nsize() << ".0) * S), " << op().get_beta() << ".0)";
+                set_output(
+                    start_tile_function()
+                        .add(builder::Input{op_input(), "I"}
+                                 .add_dims({"N", "C"})
+                                 .add_dims("D", 0, rank))
+                        .add(builder::Output{"O"})
+                        .add(builder::Elementwise{"ISQ", "I * I"})
+                        .add(builder::UnaryContraction{"+"}
+                                 .set(builder::ContractionOutput{"S"}
+                                          .add_indices({"n", "c"})
+                                          .add_indices("d", 0, rank)
+                                          .add_dims({"N", "C"})
+                                          .add_dims("D", 0, rank))
+                                 .set(builder::ContractionInput{"ISQ"}
+                                          .add_indices({"n", "c + z - " + std::to_string(distance)})
+                                          .add_indices("d", 0, rank))
+                                 .add_constraints(
+                                     [&](std::back_insert_iterator<std::list<std::string>> out) {
+                                         out = "z < " + std::to_string(op().get_nsize());
+                                     }))
+                        .add(builder::Elementwise{"O", div_expr.str()})
+                        .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::LRN>::Registration register_local_response_norm;
+            namespace
+            {
+                Impl<op::LRN>::Registration register_local_response_norm;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_logical.cpp

@@ -19,53 +19,62 @@
 #include "ngraph/op/or.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// And performs a simple elementwise logical and.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::And>::operator()()
+namespace ngraph
 {
-    check_inputs(2);
-    check_outputs(1);
-    set_output(start_tile_function()
-                   .add(builder::Input{op_input(0, TensorContents::LOGICAL), "A"})
-                   .add(builder::Input{op_input(1, TensorContents::LOGICAL), "B"})
-                   .add(builder::Output{"C"})
-                   .add(builder::Elementwise{"C", "A ? B : A"})
-                   .finalize(),
-               TensorContents::LOGICAL);
-}
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // And performs a simple elementwise logical and.
+            template <>
+            void Impl<op::And>::operator()()
+            {
+                check_inputs(2);
+                check_outputs(1);
+                set_output(start_tile_function()
+                               .add(builder::Input{op_input(0, TensorContents::LOGICAL), "A"})
+                               .add(builder::Input{op_input(1, TensorContents::LOGICAL), "B"})
+                               .add(builder::Output{"C"})
+                               .add(builder::Elementwise{"C", "A ? B : A"})
+                               .finalize(),
+                           TensorContents::LOGICAL);
+            }
 
-// Not performs a simple elementwise logical not.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Not>::operator()()
-{
-    check_inputs(1);
-    check_outputs(1);
-    set_output(start_tile_function()
-                   .add(builder::Input{op_input(0, TensorContents::LOGICAL), "I"})
-                   .add(builder::Output{"O"})
-                   .add(builder::Elementwise{"O", "cmp_eq(I, 0)"})
-                   .finalize(),
-               TensorContents::LOGICAL);
-}
+            // Not performs a simple elementwise logical not.
+            template <>
+            void Impl<op::Not>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
+                set_output(start_tile_function()
+                               .add(builder::Input{op_input(0, TensorContents::LOGICAL), "I"})
+                               .add(builder::Output{"O"})
+                               .add(builder::Elementwise{"O", "cmp_eq(I, 0)"})
+                               .finalize(),
+                           TensorContents::LOGICAL);
+            }
 
-// Or performs a simple elementwise logical or.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Or>::operator()()
-{
-    check_inputs(2);
-    check_outputs(1);
-    set_output(start_tile_function()
-                   .add(builder::Input{op_input(0, TensorContents::LOGICAL), "A"})
-                   .add(builder::Input{op_input(1, TensorContents::LOGICAL), "B"})
-                   .add(builder::Output{"C"})
-                   .add(builder::Elementwise{"C", "A ? A : B"})
-                   .finalize(),
-               TensorContents::LOGICAL);
-}
+            // Or performs a simple elementwise logical or.
+            template <>
+            void Impl<op::Or>::operator()()
+            {
+                check_inputs(2);
+                check_outputs(1);
+                set_output(start_tile_function()
+                               .add(builder::Input{op_input(0, TensorContents::LOGICAL), "A"})
+                               .add(builder::Input{op_input(1, TensorContents::LOGICAL), "B"})
+                               .add(builder::Output{"C"})
+                               .add(builder::Elementwise{"C", "A ? A : B"})
+                               .finalize(),
+                           TensorContents::LOGICAL);
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::And>::Registration register_and;
-    ngraph::runtime::plaidml::Impl<ngraph::op::Not>::Registration register_not;
-    ngraph::runtime::plaidml::Impl<ngraph::op::Or>::Registration register_or;
+            namespace
+            {
+                Impl<op::And>::Registration register_and;
+                Impl<op::Not>::Registration register_not;
+                Impl<op::Or>::Registration register_or;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_one_hot.cpp

@@ -20,80 +20,93 @@
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 #include "ngraph/runtime/plaidml/plaidml_translate.hpp"
 
-// OneHot performs one-hot encoding along the requested axis.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::OneHot>::operator()()
+namespace ngraph
 {
-    check_inputs(1);
-    check_outputs(1);
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // OneHot performs one-hot encoding along the requested axis.
+            template <>
+            void Impl<op::OneHot>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
 
-    // Here's what's going on to implement OneHot:
-    //
-    // * We reshape the input tensor to add a size=1 dimension where we want the one-hot axis to be,
-    //
-    // * We create an index tensor that's size=1 on every dimension except the one-hot dimension,
-    //
-    // * We perform an elementwise conditional across them to assign the one-hot values.
-    //
-    // The broadcast rules will expand the index tensor on all non-one-hot dimensions to match the
-    // input, and will expand the input tensor on the one-hot dimension to match the index.
-    //
-    // In theory, it'd be pretty easy to implement all this with purely elementwise operations.  The
-    // current definition of index() requires an input tensor of the index() output shape, and it's
-    // a little tricky to fix that, so we generate a zero tensor of the correct shape using a
-    // contraction.  TODO: Optimize out the zero tensor contraction.
+                // Here's what's going on to implement OneHot:
+                //
+                // * We reshape the input tensor to add a size=1 dimension where we want the one-hot axis to be,
+                //
+                // * We create an index tensor that's size=1 on every dimension except the one-hot dimension,
+                //
+                // * We perform an elementwise conditional across them to assign the one-hot values.
+                //
+                // The broadcast rules will expand the index tensor on all non-one-hot dimensions to match the
+                // input, and will expand the input tensor on the one-hot dimension to match the index.
+                //
+                // In theory, it'd be pretty easy to implement all this with purely elementwise operations.  The
+                // current definition of index() requires an input tensor of the index() output shape, and it's
+                // a little tricky to fix that, so we generate a zero tensor of the correct shape using a
+                // contraction.  TODO: Optimize out the zero tensor contraction.
 
-    const auto& in_shape = op().get_inputs()[0].get_shape();
-    const auto& out_shape = op().get_shape();
+                const auto& in_shape = op().get_inputs()[0].get_shape();
+                const auto& out_shape = op().get_shape();
 
-    std::ostringstream in_reshape;
-    for (std::size_t idx = 0; idx < out_shape.size(); ++idx)
-    {
-        if (idx)
-        {
-            in_reshape << ", ";
-        }
-        if (idx == op().get_one_hot_axis())
-        {
-            in_reshape << 1;
-        }
-        else
-        {
-            in_reshape << out_shape[idx];
-        }
-    }
+                std::ostringstream in_reshape;
+                for (std::size_t idx = 0; idx < out_shape.size(); ++idx)
+                {
+                    if (idx)
+                    {
+                        in_reshape << ", ";
+                    }
+                    if (idx == op().get_one_hot_axis())
+                    {
+                        in_reshape << 1;
+                    }
+                    else
+                    {
+                        in_reshape << out_shape[idx];
+                    }
+                }
 
-    set_output(
-        start_tile_function()
-            .add(builder::Input{op_input(), "I"}.add_dims("D", 0, in_shape.size()))
-            .add(builder::Input{static_cast<std::int64_t>(0), "Zero"})
-            .add(builder::Output{"O"})
-            .add(builder::UnaryContraction{"="}
-                     .set(builder::ContractionOutput{"ZS"}
-                              .add_dims([&](std::back_insert_iterator<std::list<std::string>> out) {
-                                  for (std::size_t idx = 0; idx < out_shape.size(); ++idx)
-                                  {
-                                      if (idx == op().get_one_hot_axis())
-                                      {
-                                          out = std::to_string(out_shape[idx]);
-                                      }
-                                      else
-                                      {
-                                          out = "1";
-                                      }
-                                  }
-                              })
-                              .add_indices("d", 0, out_shape.size()))
-                     .set(builder::ContractionInput{"Zero"}))
-            .add(builder::Elementwise{"Idx",
-                                      "index(ZS, " + std::to_string(op().get_one_hot_axis()) + ")"})
-            .add(builder::Elementwise{"IS", "reshape(I, " + in_reshape.str() + ")"})
-            .add(builder::Elementwise{"OV", "IS == Idx ? 1 : 0"})
-            .add(builder::Elementwise{"O", tile_converter("OV", op().get_element_type())})
-            .finalize());
-}
+                set_output(
+                    start_tile_function()
+                        .add(builder::Input{op_input(), "I"}.add_dims("D", 0, in_shape.size()))
+                        .add(builder::Input{static_cast<std::int64_t>(0), "Zero"})
+                        .add(builder::Output{"O"})
+                        .add(
+                            builder::UnaryContraction{"="}
+                                .set(
+                                    builder::ContractionOutput{"ZS"}
+                                        .add_dims([&](
+                                            std::back_insert_iterator<std::list<std::string>> out) {
+                                            for (std::size_t idx = 0; idx < out_shape.size(); ++idx)
+                                            {
+                                                if (idx == op().get_one_hot_axis())
+                                                {
+                                                    out = std::to_string(out_shape[idx]);
+                                                }
+                                                else
+                                                {
+                                                    out = "1";
+                                                }
+                                            }
+                                        })
+                                        .add_indices("d", 0, out_shape.size()))
+                                .set(builder::ContractionInput{"Zero"}))
+                        .add(builder::Elementwise{
+                            "Idx", "index(ZS, " + std::to_string(op().get_one_hot_axis()) + ")"})
+                        .add(builder::Elementwise{"IS", "reshape(I, " + in_reshape.str() + ")"})
+                        .add(builder::Elementwise{"OV", "IS == Idx ? 1 : 0"})
+                        .add(builder::Elementwise{"O",
+                                                  tile_converter("OV", op().get_element_type())})
+                        .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::OneHot>::Registration register_one_hot;
+            namespace
+            {
+                Impl<op::OneHot>::Registration register_one_hot;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_replace_slice.cpp

@@ -19,74 +19,87 @@
 #include "ngraph/op/replace_slice.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// ReplaceSlice replaces part of a tensor with another tensor.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::ReplaceSlice>::operator()()
+namespace ngraph
 {
-    check_inputs(2);
-    check_outputs(1);
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // ReplaceSlice replaces part of a tensor with another tensor.
+            template <>
+            void Impl<op::ReplaceSlice>::operator()()
+            {
+                check_inputs(2);
+                check_outputs(1);
 
-    // For ReplaceSlice:
-    //
-    // * Pad the second tensor to match the first (same-size dimensions and offset according to the
-    // * lower bounds of the replacement, with the desired stridings)
-    //
-    // * Generate a boolean tensor of the same shape as the first, where true == "Do the
-    // * replacement".
-    //
-    // * Use a trinary to do the replacement.
+                // For ReplaceSlice:
+                //
+                // * Pad the second tensor to match the first (same-size dimensions and offset according to the
+                // * lower bounds of the replacement, with the desired stridings)
+                //
+                // * Generate a boolean tensor of the same shape as the first, where true == "Do the
+                // * replacement".
+                //
+                // * Use a trinary to do the replacement.
 
-    const auto& shape = op().get_shape();
+                const auto& shape = op().get_shape();
 
-    set_output(
-        start_tile_function()
-            .add(builder::Input{op_input(0), "L"}.add_dims("D", 0, shape.size()))
-            .add(builder::Input{op_input(1), "S"}.add_dims("SD", 0, shape.size()))
-            .add(builder::Output{"O"})
-            .add(builder::UnaryContraction{"="}
-                     .set(builder::ContractionOutput{"O"}
-                              .add_dims("D", 0, shape.size())
-                              .add_indices(
-                                  [&](std::back_insert_iterator<std::list<std::string>> out) {
-                                      for (std::size_t idx = 0; idx < shape.size(); ++idx)
-                                      {
-                                          auto stride = op().get_strides()[idx];
-                                          auto lower_bound = op().get_lower_bounds()[idx];
-                                          std::ostringstream didx;
-                                          if ((stride != 1) && lower_bound)
-                                          {
-                                              didx << "(";
-                                          }
-                                          didx << "d" << idx;
-                                          if (stride != 1)
-                                          {
-                                              didx << "*" << stride;
-                                          }
-                                          if ((stride != 1) && lower_bound)
-                                          {
-                                              didx << ")";
-                                          }
-                                          if (lower_bound)
-                                          {
-                                              didx << "+" << lower_bound;
-                                          }
-                                          out = didx.str();
-                                      }
-                                  }))
-                     .set(builder::ContractionInput{"S"}.add_indices("d", 0, shape.size()))
-                     .add_constraints([&](std::back_insert_iterator<std::list<std::string>> out) {
-                         for (std::size_t idx = 0; idx < shape.size(); ++idx)
-                         {
-                             out = "d" + std::to_string(idx) + " < " +
-                                   std::to_string(op().get_upper_bounds()[idx] -
-                                                  op().get_lower_bounds()[idx]);
-                         }
-                     })
-                     .set_default("L"))
-            .finalize());
-}
+                set_output(
+                    start_tile_function()
+                        .add(builder::Input{op_input(0), "L"}.add_dims("D", 0, shape.size()))
+                        .add(builder::Input{op_input(1), "S"}.add_dims("SD", 0, shape.size()))
+                        .add(builder::Output{"O"})
+                        .add(
+                            builder::UnaryContraction{"="}
+                                .set(
+                                    builder::ContractionOutput{"O"}
+                                        .add_dims("D", 0, shape.size())
+                                        .add_indices([&](
+                                            std::back_insert_iterator<std::list<std::string>> out) {
+                                            for (std::size_t idx = 0; idx < shape.size(); ++idx)
+                                            {
+                                                auto stride = op().get_strides()[idx];
+                                                auto lower_bound = op().get_lower_bounds()[idx];
+                                                std::ostringstream didx;
+                                                if ((stride != 1) && lower_bound)
+                                                {
+                                                    didx << "(";
+                                                }
+                                                didx << "d" << idx;
+                                                if (stride != 1)
+                                                {
+                                                    didx << "*" << stride;
+                                                }
+                                                if ((stride != 1) && lower_bound)
+                                                {
+                                                    didx << ")";
+                                                }
+                                                if (lower_bound)
+                                                {
+                                                    didx << "+" << lower_bound;
+                                                }
+                                                out = didx.str();
+                                            }
+                                        }))
+                                .set(builder::ContractionInput{"S"}.add_indices(
+                                    "d", 0, shape.size()))
+                                .add_constraints(
+                                    [&](std::back_insert_iterator<std::list<std::string>> out) {
+                                        for (std::size_t idx = 0; idx < shape.size(); ++idx)
+                                        {
+                                            out = "d" + std::to_string(idx) + " < " +
+                                                  std::to_string(op().get_upper_bounds()[idx] -
+                                                                 op().get_lower_bounds()[idx]);
+                                        }
+                                    })
+                                .set_default("L"))
+                        .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::ReplaceSlice>::Registration register_replace_slice;
+            namespace
+            {
+                Impl<op::ReplaceSlice>::Registration register_replace_slice;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_reverse.cpp

@@ -19,41 +19,50 @@
 #include "ngraph/op/reverse.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// Reverse reverses the selected axes within a tensor.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Reverse>::operator()()
+namespace ngraph
 {
-    check_inputs(1);
-    check_outputs(1);
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // Reverse reverses the selected axes within a tensor.
+            template <>
+            void Impl<op::Reverse>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
 
-    const auto& shape = op().get_shape();
+                const auto& shape = op().get_shape();
 
-    set_output(start_tile_function()
-                   .add(builder::Input{op_input(), "I"}.add_dims("D", 0, shape.size()))
-                   .add(builder::Output{"O"})
-                   .add(builder::UnaryContraction{"="}
-                            .set(builder::ContractionOutput{"O"}
-                                     .add_indices("d", 0, shape.size())
-                                     .add_dims("D", 0, shape.size()))
-                            .set(builder::ContractionInput{"I"}.add_indices(
-                                [&](std::back_insert_iterator<std::list<std::string>> out) {
-                                    for (std::size_t idx = 0; idx < shape.size(); ++idx)
-                                    {
-                                        auto sidx = std::to_string(idx);
-                                        if (op().get_reversed_axes().count(idx))
-                                        {
-                                            out = "D" + sidx + "-d" + sidx + "-1";
-                                        }
-                                        else
-                                        {
-                                            out = "d" + sidx;
-                                        }
-                                    }
-                                })))
-                   .finalize());
-}
+                set_output(start_tile_function()
+                               .add(builder::Input{op_input(), "I"}.add_dims("D", 0, shape.size()))
+                               .add(builder::Output{"O"})
+                               .add(builder::UnaryContraction{"="}
+                                        .set(builder::ContractionOutput{"O"}
+                                                 .add_indices("d", 0, shape.size())
+                                                 .add_dims("D", 0, shape.size()))
+                                        .set(builder::ContractionInput{"I"}.add_indices([&](
+                                            std::back_insert_iterator<std::list<std::string>> out) {
+                                            for (std::size_t idx = 0; idx < shape.size(); ++idx)
+                                            {
+                                                auto sidx = std::to_string(idx);
+                                                if (op().get_reversed_axes().count(idx))
+                                                {
+                                                    out = "D" + sidx + "-d" + sidx + "-1";
+                                                }
+                                                else
+                                                {
+                                                    out = "d" + sidx;
+                                                }
+                                            }
+                                        })))
+                               .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::Reverse>::Registration register_reverse;
+            namespace
+            {
+                Impl<op::Reverse>::Registration register_reverse;
+            }
+        }
+    }
 }

src/ngraph/runtime/plaidml/plaidml_ops_slice.cpp

@@ -18,87 +18,100 @@
 #include "ngraph/op/slice.hpp"
 #include "ngraph/runtime/plaidml/plaidml_impl.hpp"
 
-// Slice takes a sub-slice of a tensor.
-template <>
-void ngraph::runtime::plaidml::Impl<ngraph::op::Slice>::operator()()
+namespace ngraph
 {
-    check_inputs(1);
-    check_outputs(1);
-    NGRAPH_DEBUG << "Slice: low: " << op().get_lower_bounds();
-    NGRAPH_DEBUG << "Slice high: " << op().get_upper_bounds();
-    NGRAPH_DEBUG << "Slice stride: " << op().get_strides();
-    const auto& shape = op().get_inputs()[0].get_shape();
-    auto dim_limit = shape.size();
-    set_output(
-        start_tile_function()
-            .add(builder::Input{op_input(), "I"}.add_dims("ID", 0, dim_limit))
-            .add(builder::Output{"O"})
-            .add(builder::UnaryContraction{"="}
-                     .set(builder::ContractionOutput{"O"}
-                              .add_indices("od", 0, dim_limit)
-                              .add_dims([&](std::back_insert_iterator<std::list<std::string>> out) {
-                                  for (std::size_t idx = 0; idx < dim_limit; ++idx)
-                                  {
-                                      std::ostringstream s;
-                                      std::size_t stride = op().get_strides()[idx];
-                                      std::ptrdiff_t trim_count =
-                                          op().get_lower_bounds()[idx] +
-                                          (shape[idx] - op().get_upper_bounds()[idx]) + 1 - stride;
-                                      if ((stride != 1) && trim_count)
-                                      {
-                                          s << "(";
-                                      }
-                                      s << "ID" << idx;
-                                      if (0 < trim_count)
-                                      {
-                                          s << " - " << trim_count;
-                                      }
-                                      if (trim_count < 0)
-                                      {
-                                          s << " + " << -trim_count;
-                                      }
-                                      if ((stride != 1) && trim_count)
-                                      {
-                                          s << ")";
-                                      }
-                                      if (stride != 1)
-                                      {
-                                          s << " / " << stride;
-                                      }
-                                      out = s.str();
-                                  }
-                              }))
-                     .set(builder::ContractionInput{"I"}.add_indices(
-                         [&](std::back_insert_iterator<std::list<std::string>> out) {
-                             for (std::size_t idx = 0; idx < dim_limit; ++idx)
-                             {
-                                 std::ostringstream s;
-                                 std::size_t stride = op().get_strides()[idx];
-                                 std::size_t offset = op().get_lower_bounds()[idx];
-                                 if ((stride != 1) && offset)
-                                 {
-                                     s << "(";
-                                 }
-                                 s << "od" << idx;
-                                 if (stride != 1)
-                                 {
-                                     s << " * " << stride;
-                                 }
-                                 if ((stride != 1) && offset)
-                                 {
-                                     s << ")";
-                                 }
-                                 if (offset)
-                                 {
-                                     s << " + " << offset;
-                                 }
-                                 out = s.str();
-                             }
-                         })))
-            .finalize());
-}
+    namespace runtime
+    {
+        namespace plaidml
+        {
+            // Slice takes a sub-slice of a tensor.
+            template <>
+            void Impl<op::Slice>::operator()()
+            {
+                check_inputs(1);
+                check_outputs(1);
+                NGRAPH_DEBUG << "Slice: low: " << op().get_lower_bounds();
+                NGRAPH_DEBUG << "Slice high: " << op().get_upper_bounds();
+                NGRAPH_DEBUG << "Slice stride: " << op().get_strides();
+                const auto& shape = op().get_inputs()[0].get_shape();
+                auto dim_limit = shape.size();
+                set_output(
+                    start_tile_function()
+                        .add(builder::Input{op_input(), "I"}.add_dims("ID", 0, dim_limit))
+                        .add(builder::Output{"O"})
+                        .add(
+                            builder::UnaryContraction{"="}
+                                .set(
+                                    builder::ContractionOutput{"O"}
+                                        .add_indices("od", 0, dim_limit)
+                                        .add_dims([&](
+                                            std::back_insert_iterator<std::list<std::string>> out) {
+                                            for (std::size_t idx = 0; idx < dim_limit; ++idx)
+                                            {
+                                                std::ostringstream s;
+                                                std::size_t stride = op().get_strides()[idx];
+                                                std::ptrdiff_t trim_count =
+                                                    op().get_lower_bounds()[idx] +
+                                                    (shape[idx] - op().get_upper_bounds()[idx]) +
+                                                    1 - stride;
+                                                if ((stride != 1) && trim_count)
+                                                {
+                                                    s << "(";
+                                                }
+                                                s << "ID" << idx;
+                                                if (0 < trim_count)
+                                                {
+                                                    s << " - " << trim_count;
+                                                }
+                                                if (trim_count < 0)
+                                                {
+                                                    s << " + " << -trim_count;
+                                                }
+                                                if ((stride != 1) && trim_count)
+                                                {
+                                                    s << ")";
+                                                }
+                                                if (stride != 1)
+                                                {
+                                                    s << " / " << stride;
+                                                }
+                                                out = s.str();
+                                            }
+                                        }))
+                                .set(builder::ContractionInput{"I"}.add_indices(
+                                    [&](std::back_insert_iterator<std::list<std::string>> out) {
+                                        for (std::size_t idx = 0; idx < dim_limit; ++idx)
+                                        {
+                                            std::ostringstream s;
+                                            std::size_t stride = op().get_strides()[idx];
+                                            std::size_t offset = op().get_lower_bounds()[idx];
+                                            if ((stride != 1) && offset)
+                                            {
+                                                s << "(";
+                                            }
+                                            s << "od" << idx;
+                                            if (stride != 1)
+                                            {
+                                                s << " * " << stride;
+                                            }
+                                            if ((stride != 1) && offset)
+                                            {
+                                                s << ")";
+                                            }
+                                            if (offset)
+                                            {
+                                                s << " + " << offset;
+                                            }
+                                            out = s.str();
+                                        }
+                                    })))
+                        .finalize());
+            }
 
-namespace
-{
-    ngraph::runtime::plaidml::Impl<ngraph::op::Slice>::Registration register_slice;
+            namespace
+            {
+                Impl<op::Slice>::Registration register_slice;
+            }
+        }
+    }
 }