Add ngraph and std namespaces to c++ files (#2549)

* add ngraph and std namespaces to c++ files

* style

src/ngraph/pass/constant_folding.cpp

@@ -89,7 +89,7 @@ shared_ptr<op::Constant> make_constant_pad(shared_ptr<op::Constant> constant,
     return make_shared<op::Constant>(constant->get_element_type(), out_shape, out_vec);
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_pad()
+void pass::ConstantFolding::construct_constant_pad()
 {
     auto is_constant = pattern::has_class<op::Constant>();
     auto constant_label = make_shared<pattern::op::Label>(element::f32, Shape{6}, is_constant);
@@ -142,7 +142,7 @@ void ngraph::pass::ConstantFolding::construct_constant_pad()
     this->add_matcher(pad_matcher);
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_reshape()
+void pass::ConstantFolding::construct_constant_reshape()
 {
     auto constant_label = make_shared<pattern::op::Label>(
         element::f32, Shape{2, 4}, pattern::has_class<op::Constant>());
@@ -207,7 +207,7 @@ shared_ptr<op::Constant> make_constant_broadcast(shared_ptr<op::Constant> consta
     return make_shared<op::Constant>(constant->get_element_type(), out_shape, out_vec);
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_broadcast()
+void pass::ConstantFolding::construct_constant_broadcast()
 {
     auto constant_label =
         make_shared<pattern::op::Label>(element::f32, Shape{2}, pattern::has_class<op::Constant>());
@@ -324,7 +324,7 @@ bool is_supported_binary_op(std::shared_ptr<Node> n)
             std::dynamic_pointer_cast<op::Minimum>(n));
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_binary()
+void pass::ConstantFolding::construct_constant_binary()
 {
     auto a = make_shared<pattern::op::Label>(
         element::f32, Shape{2, 4}, pattern::has_class<op::Constant>());
@@ -418,7 +418,7 @@ shared_ptr<op::Constant> make_constant_unary(shared_ptr<op::Constant> constant,
     return make_shared<op::Constant>(constant->get_element_type(), out_shape, out_vec);
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_unary()
+void pass::ConstantFolding::construct_constant_unary()
 {
     auto constant_label = make_shared<pattern::op::Label>(
         element::f32, Shape{2, 4}, pattern::has_class<op::Constant>());
@@ -493,7 +493,7 @@ shared_ptr<op::Constant> make_constant_dequantize(shared_ptr<op::Constant> const
     return make_shared<op::Constant>(dequant->get_element_type(), out_shape, out_vec);
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_dequantize()
+void pass::ConstantFolding::construct_constant_dequantize()
 {
     auto constant_label =
         make_shared<pattern::op::Label>(element::u8, Shape{2}, pattern::has_class<op::Constant>());
@@ -567,7 +567,7 @@ shared_ptr<op::Constant> make_constant_quantize(shared_ptr<op::Constant> constan
     return make_shared<op::Constant>(quant->get_element_type(), out_shape, out_vec);
 }
 
-void ngraph::pass::ConstantFolding::construct_constant_quantize()
+void pass::ConstantFolding::construct_constant_quantize()
 {
     auto constant_label =
         make_shared<pattern::op::Label>(element::f32, Shape{2}, pattern::has_class<op::Constant>());

src/ngraph/pass/core_fusion.cpp

@@ -69,7 +69,7 @@ void pass::CoreFusion::construct_relu()
 
         auto pattern_map = m.get_pattern_map();
         auto mzero = m.get_pattern_map()[zero];
-        if (!ngraph::is_zero(mzero))
+        if (!is_zero(mzero))
         {
             NGRAPH_DEBUG << "zero constant = " << mzero->get_name() << " not equal to 0\n";
             return false;
@@ -77,7 +77,7 @@ void pass::CoreFusion::construct_relu()
         auto mpattern = m.get_match_root();
 
         auto cg = shared_ptr<Node>(new op::Relu(pattern_map[val]));
-        ngraph::replace_node(m.get_match_root(), cg);
+        replace_node(m.get_match_root(), cg);
         return true;
     };
 
@@ -100,7 +100,7 @@ void pass::CoreFusion::construct_sigmoid()
     auto divide_1_over_exp = std::make_shared<op::Divide>(skip_broadcast, add_exp);
 
     // Define a call back that needs to called once the DFG matches the pattern
-    ngraph::pattern::graph_rewrite_callback callback = [input, constant](pattern::Matcher& m) {
+    pattern::graph_rewrite_callback callback = [input, constant](pattern::Matcher& m) {
         NGRAPH_DEBUG << "In a callback for construct_fprop_sigmoid pattern against "
                      << m.get_match_root()->get_name();
         auto pattern_map = m.get_pattern_map();
@@ -125,12 +125,11 @@ void pass::CoreFusion::construct_sigmoid()
             return false;
         }
         auto sigmoid_node = std::make_shared<op::Sigmoid>(pattern_map[input]);
-        ngraph::replace_node(m.get_match_root(), sigmoid_node);
+        replace_node(m.get_match_root(), sigmoid_node);
         return true;
     };
 
-    auto m = std::make_shared<ngraph::pattern::Matcher>(
-        divide_1_over_exp, callback, "CoreFusion.Sigmoid");
+    auto m = std::make_shared<pattern::Matcher>(divide_1_over_exp, callback, "CoreFusion.Sigmoid");
     this->add_matcher(m);
 }
 
@@ -159,7 +158,7 @@ void pass::CoreFusion::construct_sigmoid_bprop()
     auto negative_2 = std::make_shared<op::Negative>(multiply_2);
 
     // Define a call back that needs to called once the DFG matches the pattern
-    ngraph::pattern::graph_rewrite_callback callback = [input, delta](pattern::Matcher& m) {
+    pattern::graph_rewrite_callback callback = [input, delta](pattern::Matcher& m) {
         NGRAPH_DEBUG << "In a callback for construct_bprop_sigmoid pattern against "
                      << m.get_match_root()->get_name();
         auto pattern_map = m.get_pattern_map();
@@ -178,12 +177,11 @@ void pass::CoreFusion::construct_sigmoid_bprop()
         }
         auto dsigmoid =
             std::make_shared<op::SigmoidBackprop>(pattern_map[input], pattern_map[delta]);
-        ngraph::replace_node(m.get_match_root(), dsigmoid);
+        replace_node(m.get_match_root(), dsigmoid);
         return true;
     };
 
-    auto m =
-        std::make_shared<ngraph::pattern::Matcher>(negative_2, callback, "CoreFusion.SigmoidBprop");
+    auto m = std::make_shared<pattern::Matcher>(negative_2, callback, "CoreFusion.SigmoidBprop");
     this->add_matcher(m);
 }
 
@@ -212,7 +210,7 @@ void pass::CoreFusion::construct_folded_batch_norm()
     auto shape_r = Shape{1, 2, 2, 2};
     auto bn = std::make_shared<op::BatchNormInference>(eps, gamma, beta, pconv, mean, var);
 
-    ngraph::pattern::graph_rewrite_callback callback = [input, filters, mean, var, gamma, beta](
+    pattern::graph_rewrite_callback callback = [input, filters, mean, var, gamma, beta](
         pattern::Matcher& m) {
         NGRAPH_DEBUG << "In callback for folded batch norm against node = "
                      << m.get_match_root()->get_name();
@@ -258,13 +256,13 @@ void pass::CoreFusion::construct_folded_batch_norm()
                                                       m_conv->get_data_dilation_strides());
         auto conv_bias =
             conv + std::make_shared<op::Broadcast>(new_biases, conv->get_shape(), AxisSet{0, 2, 3});
-        ngraph::replace_node(m.get_match_root(), conv_bias);
+        replace_node(m.get_match_root(), conv_bias);
 
         return true;
 
     };
 
-    auto m = std::make_shared<ngraph::pattern::Matcher>(bn, callback, "CoreFusion.FoldedBatchNorm");
+    auto m = std::make_shared<pattern::Matcher>(bn, callback, "CoreFusion.FoldedBatchNorm");
     this->add_matcher(m);
 }
 
@@ -293,7 +291,7 @@ void pass::CoreFusion::construct_conv_affine_folding()
     auto multiply = std::make_shared<op::Multiply>(conv_label, A_label);
     auto add = std::make_shared<op::Add>(multiply, B_label);
 
-    ngraph::pattern::graph_rewrite_callback callback =
+    pattern::graph_rewrite_callback callback =
         [input, filters, conv_label, A_label, B_label](pattern::Matcher& m) {
             NGRAPH_DEBUG << "In callback for conv affine folding against node = "
                          << m.get_match_root()->get_name();
@@ -345,7 +343,7 @@ void pass::CoreFusion::construct_conv_affine_folding()
                 if (bcast->get_argument(0)->get_shape().size() == 2)
                 {
                     Shape bshape{bcast->get_argument(0)->get_shape()[1]};
-                    return static_pointer_cast<ngraph::Node>(std::make_shared<op::Reshape>(
+                    return static_pointer_cast<Node>(std::make_shared<op::Reshape>(
                         bcast->get_argument(0), AxisVector{0, 1}, bshape));
                 }
                 throw ngraph_error("Unexpected shape for bcast input");
@@ -369,14 +367,13 @@ void pass::CoreFusion::construct_conv_affine_folding()
                                                             conv_m->get_padding_above(),
                                                             conv_m->get_data_dilation_strides());
             auto convbias_n = conv_n + B_m;
-            ngraph::replace_node(m.get_match_root(), convbias_n);
+            replace_node(m.get_match_root(), convbias_n);
 
             return true;
 
         };
 
-    auto m =
-        std::make_shared<ngraph::pattern::Matcher>(add, callback, "CoreFusion.ConvAffineFolding");
+    auto m = std::make_shared<pattern::Matcher>(add, callback, "CoreFusion.ConvAffineFolding");
     this->add_matcher(m);
 }
 
@@ -440,7 +437,7 @@ static size_t shape_to_index(Shape shape)
     }
 }
 
-void ngraph::pass::CoreFusion::construct_reshape_broadcast()
+void pass::CoreFusion::construct_reshape_broadcast()
 {
     Shape input_shape{10};
     auto input = make_shared<pattern::op::Label>(element::f32, input_shape);
@@ -473,7 +470,7 @@ void ngraph::pass::CoreFusion::construct_reshape_broadcast()
             if (d != 1 && d != dim)
             {
                 NGRAPH_DEBUG << "Input is reshaped in a way we can't directly broadcast ( shape = "
-                             << ngraph::vector_to_string(reshape1_m->get_shape()) << ")";
+                             << vector_to_string(reshape1_m->get_shape()) << ")";
                 return false;
             }
 
@@ -502,7 +499,7 @@ void ngraph::pass::CoreFusion::construct_reshape_broadcast()
 
         auto new_broadcast =
             make_shared<op::Broadcast>(input_m, broadcast_m->get_shape(), new_axes);
-        ngraph::replace_node(m.get_match_root(), new_broadcast);
+        replace_node(m.get_match_root(), new_broadcast);
         return true;
     };
 
@@ -520,7 +517,7 @@ void ngraph::pass::CoreFusion::construct_reshape_broadcast()
 void pass::CoreFusion::construct_optimized_strided_conv()
 {
     Shape win_size_1{1, 1, 1, 1};
-    auto is_bc = ngraph::pattern::has_class<op::Broadcast>();
+    auto is_bc = pattern::has_class<op::Broadcast>();
     auto data_stride3 = std::make_shared<pattern::op::Label>(element::f32, Shape{1, 1, 128, 128});
     auto weights_stride3 = std::make_shared<pattern::op::Label>(element::f32, win_size_1);
 
@@ -689,7 +686,7 @@ void pass::CoreFusion::construct_optimized_strided_conv()
                 new_relu_two_convs, sconv->get_argument(1), stride_1, stride_1);
             NGRAPH_DEBUG << "Replacing " << sconv->get_name() << " with "
                          << sconv_28w1s1->get_name();
-            ngraph::replace_node(sconv, sconv_28w1s1);
+            replace_node(sconv, sconv_28w1s1);
         }
         return true;
     };
@@ -699,7 +696,7 @@ void pass::CoreFusion::construct_optimized_strided_conv()
     this->add_matcher(m);
 }
 
-void ngraph::pass::CoreFusion::construct_reshape_softmax_reshape()
+void pass::CoreFusion::construct_reshape_softmax_reshape()
 {
     Shape input_shape{10, 20};
     AxisVector io{1, 0};
@@ -738,7 +735,7 @@ void ngraph::pass::CoreFusion::construct_reshape_softmax_reshape()
         }
 
         auto new_softmax = make_shared<op::Softmax>(input_m, new_axes);
-        ngraph::replace_node(m.get_match_root(), new_softmax);
+        replace_node(m.get_match_root(), new_softmax);
         return true;
     };
 

src/ngraph/pass/cse.cpp

@@ -59,11 +59,12 @@
 #include "ngraph/op/tanh.hpp"
 #include "ngraph/pattern/matcher.hpp"
 
+using namespace std;
 using namespace ngraph;
 
-#define TI(x) std::type_index(typeid(x))
+#define TI(x) type_index(typeid(x))
 
-static bool cse_constant(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
+static bool cse_constant(shared_ptr<Node> a, shared_ptr<Node> b)
 {
     NGRAPH_DEBUG << "In cse_constant for " << a->get_name() << " and " << b->get_name();
 
@@ -72,44 +73,44 @@ static bool cse_constant(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
         return false;
     }
 
-    auto ca = std::static_pointer_cast<op::Constant>(a);
-    auto cb = std::static_pointer_cast<op::Constant>(b);
+    auto ca = static_pointer_cast<op::Constant>(a);
+    auto cb = static_pointer_cast<op::Constant>(b);
 
     size_t size = shape_size(a->get_shape()) * a->get_element_type().size();
 
     return !memcmp(ca->get_data_ptr(), cb->get_data_ptr(), size);
 }
 
-static bool cse_reshape(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
+static bool cse_reshape(shared_ptr<Node> a, shared_ptr<Node> b)
 {
     NGRAPH_DEBUG << "In cse_reshape for " << a->get_name() << " and " << b->get_name();
 
-    auto reshape_a = std::static_pointer_cast<ngraph::op::Reshape>(a);
-    auto reshape_b = std::static_pointer_cast<ngraph::op::Reshape>(b);
+    auto reshape_a = static_pointer_cast<ngraph::op::Reshape>(a);
+    auto reshape_b = static_pointer_cast<ngraph::op::Reshape>(b);
 
     return (a->get_argument(0) == b->get_argument(0)) &&
            (reshape_a->get_input_order() == reshape_b->get_input_order()) &&
            (reshape_a->get_output_shape() == reshape_b->get_output_shape());
 }
-static bool cse_broadcast(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
+static bool cse_broadcast(shared_ptr<Node> a, shared_ptr<Node> b)
 {
     NGRAPH_DEBUG << "In cse_broadcast for " << a->get_name() << " and " << b->get_name();
 
-    auto broadcast_a = std::static_pointer_cast<ngraph::op::Broadcast>(a);
-    auto broadcast_b = std::static_pointer_cast<ngraph::op::Broadcast>(b);
+    auto broadcast_a = static_pointer_cast<ngraph::op::Broadcast>(a);
+    auto broadcast_b = static_pointer_cast<ngraph::op::Broadcast>(b);
 
     return (a->get_argument(0) == b->get_argument(0)) &&
            (broadcast_a->get_broadcast_axes() == broadcast_b->get_broadcast_axes()) &&
            (broadcast_a->get_broadcast_shape() == broadcast_b->get_broadcast_shape());
 }
-static bool cse_unarywise(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
+static bool cse_unarywise(shared_ptr<Node> a, shared_ptr<Node> b)
 {
     NGRAPH_DEBUG << "In cse_unarywise for " << a->get_name() << " and " << b->get_name();
 
     return a->get_argument(0) == b->get_argument(0);
 }
 
-static bool cse_binarywise(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
+static bool cse_binarywise(shared_ptr<Node> a, shared_ptr<Node> b)
 {
     NGRAPH_DEBUG << "In cse_binary for " << a->get_name() << " and " << b->get_name();
 
@@ -117,23 +118,21 @@ static bool cse_binarywise(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
            (a->get_argument(1) == b->get_argument(0) && a->get_argument(0) == b->get_argument(1));
 }
 
-static bool cse_reduction(std::shared_ptr<Node> a, std::shared_ptr<Node> b)
+static bool cse_reduction(shared_ptr<Node> a, shared_ptr<Node> b)
 {
     NGRAPH_DEBUG << "In cse_reduction for " << a->get_name() << " and " << b->get_name();
 
-    auto ar_a = std::static_pointer_cast<op::util::ArithmeticReduction>(a);
-    auto ar_b = std::static_pointer_cast<op::util::ArithmeticReduction>(b);
+    auto ar_a = static_pointer_cast<op::util::ArithmeticReduction>(a);
+    auto ar_b = static_pointer_cast<op::util::ArithmeticReduction>(b);
 
     return ar_a->get_argument(0) == ar_b->get_argument(0) &&
            ar_a->get_reduction_axes() == ar_b->get_reduction_axes();
 }
 
-static std::unordered_map<std::type_index,
-                          std::function<bool(std::shared_ptr<Node>, std::shared_ptr<Node>)>>
+static unordered_map<type_index, function<bool(shared_ptr<Node>, shared_ptr<Node>)>>
     initialize_ops_to_cse_handlers()
 {
-    return std::unordered_map<std::type_index,
-                              std::function<bool(std::shared_ptr<Node>, std::shared_ptr<Node>)>>(
+    return unordered_map<type_index, function<bool(shared_ptr<Node>, shared_ptr<Node>)>>(
         {{TI(op::Abs), cse_unarywise},
          {TI(op::Acos), cse_unarywise},
          {TI(op::Asin), cse_unarywise},
@@ -168,23 +167,21 @@ static std::unordered_map<std::type_index,
          {TI(op::Broadcast), cse_broadcast}});
 }
 
-static std::unordered_map<std::type_index,
-                          std::function<bool(std::shared_ptr<Node>, std::shared_ptr<Node>)>>
+static unordered_map<type_index, function<bool(shared_ptr<Node>, shared_ptr<Node>)>>
     ops_to_cse_handlers = initialize_ops_to_cse_handlers();
 
 class NodeKey
 {
 public:
-    NodeKey(std::shared_ptr<Node> n,
-            std::unordered_map<std::type_index,
-                               std::function<bool(std::shared_ptr<Node>, std::shared_ptr<Node>)>>&
+    NodeKey(shared_ptr<Node> n,
+            unordered_map<type_index, function<bool(shared_ptr<Node>, shared_ptr<Node>)>>&
                 backend_handlers)
         : m_node(n)
         , m_backend_handlers(backend_handlers)
     {
     }
 
-    std::shared_ptr<Node> get_node() const { return m_node; }
+    shared_ptr<Node> get_node() const { return m_node; }
     bool operator==(const NodeKey& other) const
     {
         Node& p_this = *m_node.get();
@@ -215,9 +212,8 @@ public:
     }
 
 private:
-    std::shared_ptr<Node> m_node;
-    std::unordered_map<std::type_index,
-                       std::function<bool(std::shared_ptr<Node>, std::shared_ptr<Node>)>>&
+    shared_ptr<Node> m_node;
+    unordered_map<type_index, function<bool(shared_ptr<Node>, shared_ptr<Node>)>>&
         m_backend_handlers;
 };
 
@@ -226,15 +222,15 @@ namespace std
     template <>
     struct hash<NodeKey>
     {
-        std::size_t operator()(const NodeKey& k) const
+        size_t operator()(const NodeKey& k) const
         {
             Node& p_this = *k.get_node().get();
             auto ti = TI(p_this);
 
-            std::hash<std::type_index> type_hash_compute{};
+            hash<type_index> type_hash_compute{};
             auto type_hash = type_hash_compute(ti);
 
-            std::vector<size_t> arg_ids;
+            vector<size_t> arg_ids;
 
             arg_ids.push_back(type_hash);
 
@@ -244,7 +240,7 @@ namespace std
             // specify how to compute hash for each op?
             if (p_this.is_commutative())
             {
-                std::sort(begin(cargs), end(cargs));
+                sort(begin(cargs), end(cargs));
             }
 
             for (auto arg : cargs)
@@ -258,11 +254,10 @@ namespace std
     };
 }
 
-bool ngraph::pass::CommonSubexpressionElimination::run_on_function(
-    std::shared_ptr<ngraph::Function> f)
+bool ngraph::pass::CommonSubexpressionElimination::run_on_function(shared_ptr<ngraph::Function> f)
 {
     bool replaced = false;
-    std::unordered_map<NodeKey, std::shared_ptr<Node>> expressions{};
+    unordered_map<NodeKey, shared_ptr<Node>> expressions{};
 
     for (auto n : f->get_ordered_ops())
     {
@@ -279,7 +274,7 @@ bool ngraph::pass::CommonSubexpressionElimination::run_on_function(
         }
         else
         {
-            expressions.insert(std::make_pair(n_key, n));
+            expressions.insert(make_pair(n_key, n));
         }
     }
 

src/ngraph/pass/graph_rewrite.cpp

@@ -24,6 +24,9 @@
 #include "ngraph/log.hpp"
 #include "ngraph/pattern/matcher.hpp"
 
+using namespace std;
+using namespace ngraph;
+
 // GraphRewrite algorithm:
 // GraphRewrite processes an input graph in an topological order(i.e. args before users)
 // Given the following graph:          Abs2
@@ -56,16 +59,16 @@
 // c) there's no linear order of fusions which will give
 //    the correct final fusion. i.e. the same fusion needs to occur before and after some other fusion
 
-bool ngraph::pass::GraphRewrite::run_on_function(std::shared_ptr<ngraph::Function> f)
+bool pass::GraphRewrite::run_on_function(shared_ptr<Function> f)
 {
     bool rewritten = false;
     const size_t NUM_TRIES = 10;
     size_t tries = NUM_TRIES;
-    std::vector<std::shared_ptr<pattern::Matcher>> original_matchers{m_matchers};
+    vector<shared_ptr<pattern::Matcher>> original_matchers{m_matchers};
     do
     {
         rewritten = false;
-        std::vector<std::shared_ptr<pattern::Matcher>> matchers{m_matchers};
+        vector<shared_ptr<pattern::Matcher>> matchers{m_matchers};
         m_matchers.clear();
         for (auto node : f->get_ordered_ops())
         {
@@ -92,31 +95,31 @@ bool ngraph::pass::GraphRewrite::run_on_function(std::shared_ptr<ngraph::Functio
     return (NUM_TRIES - tries) > 1; //this means a graph was transformed
 }
 
-static const std::vector<std::regex> initialize_fusion_regexes()
+static const vector<regex> initialize_fusion_regexes()
 {
-    const char* cnsf = std::getenv("NGRAPH_DISABLED_FUSIONS");
-    std::vector<std::regex> regexes;
+    const char* cnsf = getenv("NGRAPH_DISABLED_FUSIONS");
+    vector<regex> regexes;
     if (cnsf)
     {
-        const std::string nsf = cnsf;
-        const auto sregexes = ngraph::split(nsf, ';');
+        const string nsf = cnsf;
+        const auto sregexes = split(nsf, ';');
 
-        std::transform(sregexes.begin(),
-                       sregexes.end(),
-                       std::back_inserter(regexes),
-                       [](const std::string& c) -> std::regex { return std::regex(c); });
+        transform(sregexes.begin(),
+                  sregexes.end(),
+                  back_inserter(regexes),
+                  [](const string& c) -> regex { return regex(c); });
     }
     return regexes;
 }
 
-bool ngraph::pass::GraphRewrite::is_enabled(std::shared_ptr<pattern::Matcher> m)
+bool pass::GraphRewrite::is_enabled(shared_ptr<pattern::Matcher> m)
 {
     //note, regexes are static to avoid re-initialization
     static const auto regexes = initialize_fusion_regexes();
 
     for (const auto& regex : regexes)
     {
-        if (std::regex_match(m->get_name(), regex))
+        if (regex_match(m->get_name(), regex))
         {
             NGRAPH_DEBUG << "Disabling matcher " << m->get_name();
             return false;
@@ -126,7 +129,7 @@ bool ngraph::pass::GraphRewrite::is_enabled(std::shared_ptr<pattern::Matcher> m)
     return true;
 }
 
-void ngraph::pass::GraphRewrite::add_matcher(std::shared_ptr<pattern::Matcher> m)
+void pass::GraphRewrite::add_matcher(shared_ptr<pattern::Matcher> m)
 {
     if (is_enabled(m))
     {
@@ -134,7 +137,7 @@ void ngraph::pass::GraphRewrite::add_matcher(std::shared_ptr<pattern::Matcher> m
     }
 }
 
-bool ngraph::pass::RecurrentGraphRewrite::run_on_function(std::shared_ptr<ngraph::Function> f)
+bool pass::RecurrentGraphRewrite::run_on_function(shared_ptr<Function> f)
 {
     bool changed = false;
     size_t i = 0;

src/ngraph/pass/like_replacement.cpp

@@ -30,27 +30,28 @@
 #include "ngraph/op/sum.hpp"
 #include "ngraph/util.hpp"
 
-#define TI(x) std::type_index(typeid(x))
+using namespace std;
+using namespace ngraph;
 
-#define HANDLER_DECL(x) static bool x(const std::shared_ptr<ngraph::Node>& node)
+#define TI(x) type_index(typeid(x))
+
+#define HANDLER_DECL(x) static bool x(const shared_ptr<Node>& node)
 
 HANDLER_DECL(replace_broadcast_like)
 {
     // Replace a broadcast like with the broadcast to eliminate the pseudo-dependency on the "like" argument
-    auto broadcast_like = std::static_pointer_cast<ngraph::op::BroadcastLike>(node);
-    ngraph::replace_node(
-        node,
-        std::make_shared<ngraph::op::Broadcast>(broadcast_like->get_argument(0),
-                                                broadcast_like->get_broadcast_shape(),
-                                                broadcast_like->get_broadcast_axes()));
+    auto broadcast_like = static_pointer_cast<op::BroadcastLike>(node);
+    replace_node(node,
+                 make_shared<op::Broadcast>(broadcast_like->get_argument(0),
+                                            broadcast_like->get_broadcast_shape(),
+                                            broadcast_like->get_broadcast_axes()));
     return true;
 }
 
-static const std::unordered_map<std::type_index,
-                                std::function<bool(const std::shared_ptr<ngraph::Node>&)>>
-    dispatcher{{TI(ngraph::op::BroadcastLike), &replace_broadcast_like}};
+static const unordered_map<type_index, function<bool(const shared_ptr<Node>&)>> dispatcher{
+    {TI(op::BroadcastLike), &replace_broadcast_like}};
 
-bool ngraph::pass::LikeReplacement::run_on_function(std::shared_ptr<ngraph::Function> function)
+bool pass::LikeReplacement::run_on_function(shared_ptr<Function> function)
 {
     bool clobbered = false;
 
@@ -66,10 +67,10 @@ bool ngraph::pass::LikeReplacement::run_on_function(std::shared_ptr<ngraph::Func
 
         // Here we're checking on a common base class of a family of template classes,
         // which is more than type info can handle.
-        auto sclb = std::dynamic_pointer_cast<ngraph::op::ScalarConstantLikeBase>(n);
+        auto sclb = dynamic_pointer_cast<op::ScalarConstantLikeBase>(n);
         if (sclb != nullptr)
         {
-            ngraph::replace_node(sclb, sclb->as_constant());
+            replace_node(sclb, sclb->as_constant());
             clobbered = true;
         }
     }

src/ngraph/pass/liveness.cpp

@@ -33,7 +33,7 @@
 using namespace std;
 using namespace ngraph;
 
-bool pass::Liveness::run_on_function(shared_ptr<ngraph::Function> function)
+bool pass::Liveness::run_on_function(shared_ptr<Function> function)
 {
     list<shared_ptr<Node>> ops = function->get_ordered_ops();
 

src/ngraph/pass/manager.cpp

@@ -35,7 +35,7 @@
 using namespace std;
 using namespace ngraph;
 
-ngraph::pass::Manager::Manager()
+pass::Manager::Manager()
 {
     static const auto nevt = std::getenv("NGRAPH_ENABLE_VISUALIZE_TRACING");
     if (nevt)
@@ -49,15 +49,15 @@ ngraph::pass::Manager::Manager()
     }
 }
 
-ngraph::pass::Manager::~Manager()
+pass::Manager::~Manager()
 {
 }
 
-void ngraph::pass::Manager::initialize_default_passes()
+void pass::Manager::initialize_default_passes()
 {
 }
 
-void ngraph::pass::Manager::run_passes(shared_ptr<Function> func, bool transitive)
+void pass::Manager::run_passes(shared_ptr<Function> func, bool transitive)
 {
     bool profile_enabled = getenv("NGRAPH_PROFILE_PASS_ENABLE") != nullptr;
 
@@ -167,7 +167,7 @@ void ngraph::pass::Manager::run_passes(shared_ptr<Function> func, bool transitiv
     }
 }
 
-ngraph::pass::ManagerState& ngraph::pass::Manager::get_state()
+pass::ManagerState& pass::Manager::get_state()
 {
     return m_state;
 }

src/ngraph/pass/manager_state.cpp

@@ -25,7 +25,7 @@
 using namespace std;
 using namespace ngraph;
 
-const vector<shared_ptr<Function>>& ngraph::pass::ManagerState::get_functions()
+const vector<shared_ptr<Function>>& pass::ManagerState::get_functions()
 {
     return m_function_list;
 }

src/ngraph/pass/memory_layout.cpp

@@ -40,7 +40,7 @@ pass::MemoryLayout::MemoryLayout(size_t alignment, bool disable_memory_sharing)
     }
 }
 
-bool pass::MemoryLayout::run_on_function(shared_ptr<ngraph::Function> function)
+bool pass::MemoryLayout::run_on_function(shared_ptr<Function> function)
 {
     MemoryManager mm(m_alignment, m_disable_memory_sharing);
     for (shared_ptr<Node> node : function->get_ordered_ops())

src/ngraph/pass/memory_visualize.cpp

@@ -34,7 +34,7 @@ pass::MemoryVisualize::MemoryVisualize(const string& filename)
 {
 }
 
-bool pass::MemoryVisualize::run_on_module(vector<shared_ptr<ngraph::Function>>& functions)
+bool pass::MemoryVisualize::run_on_module(vector<shared_ptr<Function>>& functions)
 {
     ofstream file(m_filename);
     {

src/ngraph/pass/nop_elimination.cpp

@@ -30,94 +30,93 @@
 #include "ngraph/util.hpp"
 #include "nop_elimination.hpp"
 
-#define TI(x) std::type_index(typeid(x))
+using namespace std;
+using namespace ngraph;
 
-#define HANDLER_DECL(x) static bool x(const std::shared_ptr<ngraph::Node>& node)
+#define TI(x) std::type_index(typeid(x))
 
-HANDLER_DECL(eliminate_pad)
+static bool eliminate_pad(const std::shared_ptr<Node>& node)
 {
-    auto pad = std::static_pointer_cast<ngraph::op::Pad>(node);
+    auto pad = std::static_pointer_cast<op::Pad>(node);
     if (pad->get_input_shape(0) == pad->get_output_shape(0))
     {
-        ngraph::replace_node(node, node->get_argument(0));
+        replace_node(node, node->get_argument(0));
         return true;
     }
     return false;
 }
 
-HANDLER_DECL(eliminate_sum)
+static bool eliminate_sum(const std::shared_ptr<Node>& node)
 {
-    auto sum = std::static_pointer_cast<ngraph::op::Sum>(node);
+    auto sum = std::static_pointer_cast<op::Sum>(node);
     if (sum->get_reduction_axes().empty())
     {
-        ngraph::replace_node(node, node->get_argument(0));
+        replace_node(node, node->get_argument(0));
         return true;
     }
     return false;
 }
 
-HANDLER_DECL(eliminate_convert)
+static bool eliminate_convert(const std::shared_ptr<Node>& node)
 {
-    auto convert = std::static_pointer_cast<ngraph::op::Convert>(node);
+    auto convert = std::static_pointer_cast<op::Convert>(node);
     if (convert->get_convert_element_type() == convert->get_argument(0)->get_element_type())
     {
-        ngraph::replace_node(node, node->get_argument(0));
+        replace_node(node, node->get_argument(0));
         return true;
     }
     return false;
 }
 
-HANDLER_DECL(eliminate_slice)
+static bool eliminate_slice(const std::shared_ptr<Node>& node)
 {
-    auto slice = std::static_pointer_cast<ngraph::op::Slice>(node);
+    auto slice = std::static_pointer_cast<op::Slice>(node);
     if (slice->get_input_shape(0) == slice->get_output_shape(0))
     {
-        ngraph::replace_node(node, node->get_argument(0));
+        replace_node(node, node->get_argument(0));
         return true;
     }
     return false;
 }
 
-HANDLER_DECL(replace_broadcast_like)
+static bool replace_broadcast_like(const std::shared_ptr<Node>& node)
 {
     // Replace a broadcast like with the broadcast to eliminate the pseudo-dependency on the "like" argument
-    auto broadcast_like = std::static_pointer_cast<ngraph::op::BroadcastLike>(node);
-    ngraph::replace_node(
-        node,
-        std::make_shared<ngraph::op::Broadcast>(broadcast_like->get_argument(0),
-                                                broadcast_like->get_broadcast_shape(),
-                                                broadcast_like->get_broadcast_axes()));
+    auto broadcast_like = std::static_pointer_cast<op::BroadcastLike>(node);
+    replace_node(node,
+                 std::make_shared<op::Broadcast>(broadcast_like->get_argument(0),
+                                                 broadcast_like->get_broadcast_shape(),
+                                                 broadcast_like->get_broadcast_axes()));
     return true;
 }
 
-HANDLER_DECL(eliminate_broadcast)
+static bool eliminate_broadcast(const std::shared_ptr<Node>& node)
 {
-    auto broadcast = std::static_pointer_cast<ngraph::op::Broadcast>(node);
+    auto broadcast = std::static_pointer_cast<op::Broadcast>(node);
     if (broadcast->get_input_shape(0) == broadcast->get_output_shape(0))
     {
-        ngraph::replace_node(node, node->get_argument(0));
+        replace_node(node, node->get_argument(0));
         return true;
     }
     return false;
 }
 
-HANDLER_DECL(eliminate_stop_gradient)
+static bool eliminate_stop_gradient(const std::shared_ptr<Node>& node)
 {
-    ngraph::replace_node(node, node->get_argument(0));
+    replace_node(node, node->get_argument(0));
     return true;
 }
 
-static const std::unordered_map<std::type_index,
-                                std::function<bool(const std::shared_ptr<ngraph::Node>&)>>
-    dispatcher{{TI(ngraph::op::Pad), &eliminate_pad},
-               {TI(ngraph::op::Sum), &eliminate_sum},
-               {TI(ngraph::op::Convert), &eliminate_convert},
-               {TI(ngraph::op::Slice), &eliminate_slice},
-               {TI(ngraph::op::StopGradient), &eliminate_stop_gradient},
-               {TI(ngraph::op::BroadcastLike), &replace_broadcast_like},
-               {TI(ngraph::op::Broadcast), &eliminate_broadcast}};
-
-bool ngraph::pass::NopElimination::run_on_function(std::shared_ptr<ngraph::Function> function)
+static const std::unordered_map<std::type_index, std::function<bool(const std::shared_ptr<Node>&)>>
+    dispatcher{{TI(op::Pad), &eliminate_pad},
+               {TI(op::Sum), &eliminate_sum},
+               {TI(op::Convert), &eliminate_convert},
+               {TI(op::Slice), &eliminate_slice},
+               {TI(op::StopGradient), &eliminate_stop_gradient},
+               {TI(op::BroadcastLike), &replace_broadcast_like},
+               {TI(op::Broadcast), &eliminate_broadcast}};
+
+bool pass::NopElimination::run_on_function(std::shared_ptr<Function> function)
 {
     bool clobbered = false;
 
@@ -133,10 +132,10 @@ bool ngraph::pass::NopElimination::run_on_function(std::shared_ptr<ngraph::Funct
 
         // Here we're checking on a common base class of a family of template classes,
         // which is more than type info can handle.
-        auto sclb = std::dynamic_pointer_cast<ngraph::op::ScalarConstantLikeBase>(n);
+        auto sclb = std::dynamic_pointer_cast<op::ScalarConstantLikeBase>(n);
         if (sclb != nullptr)
         {
-            ngraph::replace_node(sclb, sclb->as_constant());
+            replace_node(sclb, sclb->as_constant());
             clobbered = true;
         }
     }

src/ngraph/pass/pass.cpp

@@ -17,12 +17,15 @@
 #include "ngraph/pass/pass.hpp"
 #include "ngraph/pass/manager.hpp"
 
-ngraph::pass::ManagerState& ngraph::pass::PassBase::get_state()
+using namespace std;
+using namespace ngraph;
+
+pass::ManagerState& pass::PassBase::get_state()
 {
     return *m_state;
 }
 
-void ngraph::pass::PassBase::set_state(ManagerState& state)
+void pass::PassBase::set_state(ManagerState& state)
 {
     m_state = &state;
 }

src/ngraph/pass/pass_config.cpp

@@ -19,10 +19,11 @@
 #include "ngraph/log.hpp"
 #include "ngraph/util.hpp"
 
+using namespace std;
 using namespace ngraph;
 
 // TODO: Add file-based configuration support
-ngraph::pass::PassConfig::PassConfig(ngraph::pass::CompilationMode mode)
+pass::PassConfig::PassConfig(pass::CompilationMode mode)
     : m_compilation_mode(mode)
 {
     /**
@@ -32,15 +33,15 @@ ngraph::pass::PassConfig::PassConfig(ngraph::pass::CompilationMode mode)
     * E.g., NGRAPH_PASS_ENABLES="CoreFusion:0;LikeReplacement:1;CPUCollapseDims" would
     *       set disables on CoreFusion and enables on LikeReplacement and CPUCollapseDims
     **/
-    const char* env_str = std::getenv("NGRAPH_PASS_ENABLES");
+    const char* env_str = getenv("NGRAPH_PASS_ENABLES");
     if (env_str)
     {
-        std::stringstream ss;
+        stringstream ss;
         ss << env_str;
         while (ss.good())
         {
-            std::string substr;
-            std::getline(ss, substr, ';');
+            string substr;
+            getline(ss, substr, ';');
             auto split_str = split(substr, ':', false);
             switch (split_str.size())
             {
@@ -58,15 +59,15 @@ ngraph::pass::PassConfig::PassConfig(ngraph::pass::CompilationMode mode)
     * would set false on "OptimizeForMemory", true on "MemoryAssignment::ReuseMemory" and true on
     * "UseDefaultLayouts"
     **/
-    env_str = std::getenv("NGRAPH_PASS_ATTRIBUTES");
+    env_str = getenv("NGRAPH_PASS_ATTRIBUTES");
     if (env_str)
     {
-        std::stringstream ss;
+        stringstream ss;
         ss << env_str;
         while (ss.good())
         {
-            std::string substr;
-            std::getline(ss, substr, ';');
+            string substr;
+            getline(ss, substr, ';');
             auto split_str = split(substr, '=', false);
             switch (split_str.size())
             {
@@ -80,12 +81,12 @@ ngraph::pass::PassConfig::PassConfig(ngraph::pass::CompilationMode mode)
     }
 }
 
-void ngraph::pass::PassConfig::set_pass_enable(std::string name, bool enable)
+void pass::PassConfig::set_pass_enable(string name, bool enable)
 {
     m_pass_enables[name] = enable;
 }
 
-bool ngraph::pass::PassConfig::get_pass_enable(std::string name)
+bool pass::PassConfig::get_pass_enable(string name)
 {
     if (m_pass_enables.find(name) == m_pass_enables.end())
     {
@@ -94,12 +95,12 @@ bool ngraph::pass::PassConfig::get_pass_enable(std::string name)
     return m_pass_enables[name];
 }
 
-void ngraph::pass::PassConfig::set_pass_attribute(std::string name, bool enable)
+void pass::PassConfig::set_pass_attribute(string name, bool enable)
 {
     m_pass_attributes[name] = enable;
 }
 
-bool ngraph::pass::PassConfig::get_pass_attribute(std::string name)
+bool pass::PassConfig::get_pass_attribute(string name)
 {
     if (m_pass_attributes.find(name) == m_pass_attributes.end())
     {

src/ngraph/pass/prefix_reshape_elimination.cpp

@@ -24,14 +24,17 @@
 #include "ngraph/pattern/op/any_of.hpp"
 #include "ngraph/pattern/op/label.hpp"
 
-ngraph::pass::PrefixReshapeElimination::PrefixReshapeElimination()
+using namespace std;
+using namespace ngraph;
+
+pass::PrefixReshapeElimination::PrefixReshapeElimination()
 {
-    auto src_op = std::make_shared<pattern::op::Label>(
-        element::i8, Shape{}, [](std::shared_ptr<Node>) { return true; });
-    auto reshape_op = std::make_shared<pattern::op::Any>(
+    auto src_op = make_shared<pattern::op::Label>(
+        element::i8, Shape{}, [](shared_ptr<Node>) { return true; });
+    auto reshape_op = make_shared<pattern::op::Any>(
         element::i8,
         Shape{},
-        [](std::shared_ptr<Node> node) {
+        [](shared_ptr<Node> node) {
             op::Reshape* reshape = dynamic_cast<op::Reshape*>(node.get());
             if (!reshape)
             {
@@ -46,14 +49,14 @@ ngraph::pass::PrefixReshapeElimination::PrefixReshapeElimination()
 
             // Make sure that logical dimension sizes match.
             const Shape& src_shape = reshape->get_input_shape(0);
-            for (std::size_t idx = 0; idx < reshape->get_output_shape().size(); ++idx)
+            for (size_t idx = 0; idx < reshape->get_output_shape().size(); ++idx)
             {
-                std::size_t src_size = 1;
+                size_t src_size = 1;
                 if (idx < src_shape.size())
                 {
                     src_size = src_shape.at(src_shape.size() - 1 - idx);
                 }
-                std::size_t dest_size =
+                size_t dest_size =
                     reshape->get_output_shape().at(reshape->get_output_shape().size() - 1 - idx);
                 if (dest_size != src_size)
                 {
@@ -64,10 +67,10 @@ ngraph::pass::PrefixReshapeElimination::PrefixReshapeElimination()
             return true;
         },
         NodeVector{src_op});
-    auto target_op = std::make_shared<pattern::op::AnyOf>(
+    auto target_op = make_shared<pattern::op::AnyOf>(
         element::i8,
         Shape{},
-        [](std::shared_ptr<Node> node) {
+        [](shared_ptr<Node> node) {
             return pattern::has_class<op::Reshape>()(node) ||
                    pattern::has_class<op::util::UnaryElementwiseArithmetic>()(node) ||
                    pattern::has_class<op::util::BinaryElementwiseArithmetic>()(node);
@@ -78,5 +81,5 @@ ngraph::pass::PrefixReshapeElimination::PrefixReshapeElimination()
         replace_node(m.get_matched_nodes().at(1), m.get_matched_nodes().at(2));
         return true;
     };
-    add_matcher(std::make_shared<pattern::Matcher>(target_op, callback));
+    add_matcher(make_shared<pattern::Matcher>(target_op, callback));
 }

src/ngraph/pass/propagate_cacheability.cpp

@@ -22,15 +22,16 @@
 #include "ngraph/op/util/op_annotations.hpp"
 #include "ngraph/runtime/cpu/cpu_op_annotations.hpp"
 
+using namespace std;
 using namespace ngraph;
 
-bool ngraph::pass::PropagateCacheability::run_on_function(std::shared_ptr<Function> function)
+bool pass::PropagateCacheability::run_on_function(shared_ptr<Function> function)
 {
     for (auto& node : function->get_ordered_ops())
     {
         if (node->is_op())
         {
-            auto op = std::static_pointer_cast<op::Op>(node);
+            auto op = static_pointer_cast<op::Op>(node);
             NGRAPH_DEBUG << "propagate cacheability: node is " << node->get_name();
             auto op_annotations = op->get_op_annotations();
             if (!op_annotations)
@@ -41,7 +42,7 @@ bool ngraph::pass::PropagateCacheability::run_on_function(std::shared_ptr<Functi
             }
             if (node->is_parameter())
             {
-                auto parameter = std::static_pointer_cast<op::Parameter>(node);
+                auto parameter = static_pointer_cast<op::Parameter>(node);
                 op_annotations->set_cacheable(parameter->get_cacheable());
                 NGRAPH_DEBUG << "propagate cacheability: cacheability is "
                              << parameter->get_cacheable();
@@ -54,7 +55,7 @@ bool ngraph::pass::PropagateCacheability::run_on_function(std::shared_ptr<Functi
                     NGRAPH_DEBUG << "propagate cacheability: arg is " << arg->get_name();
                     if (arg->is_op())
                     {
-                        auto arg_op = std::static_pointer_cast<op::Op>(arg);
+                        auto arg_op = static_pointer_cast<op::Op>(arg);
                         auto arg_op_annotations = arg_op->get_op_annotations();
                         NGRAPH_ASSERT(arg_op_annotations);
                         if (!arg_op_annotations->is_cacheable())

src/ngraph/pass/reshape_elimination.cpp

@@ -33,17 +33,19 @@
 #include "ngraph/pattern/op/skip.hpp"
 #include "ngraph/util.hpp"
 
-extern template ngraph::AxisVector
-    ngraph::apply_permutation<ngraph::AxisVector>(ngraph::AxisVector input,
-                                                  ngraph::AxisVector order);
+using namespace std;
+using namespace ngraph;
 
-void ngraph::pass::ReshapeElimination::construct_identity_reshape_pattern()
+extern template AxisVector ngraph::apply_permutation<AxisVector>(AxisVector input,
+                                                                 AxisVector order);
+
+void pass::ReshapeElimination::construct_identity_reshape_pattern()
 {
     Shape shape_op{3};
     Shape shape_r1{1, 3};
 
-    auto op = std::make_shared<pattern::op::Label>(element::f32, shape_op);
-    auto reshape1 = std::make_shared<op::Reshape>(op, AxisVector{0}, shape_r1);
+    auto op = make_shared<pattern::op::Label>(element::f32, shape_op);
+    auto reshape1 = make_shared<op::Reshape>(op, AxisVector{0}, shape_r1);
 
     auto callback = [op](pattern::Matcher& m) {
         NGRAPH_DEBUG << "In callback for construct_identity_reshape_pattern against node = "
@@ -51,7 +53,7 @@ void ngraph::pass::ReshapeElimination::construct_identity_reshape_pattern()
         auto pattern_map = m.get_pattern_map();
         auto gop = pattern_map[op];
 
-        auto r1 = std::dynamic_pointer_cast<op::Reshape>(m.get_match_root());
+        auto r1 = dynamic_pointer_cast<op::Reshape>(m.get_match_root());
 
         if (r1->get_shape() != gop->get_shape())
         {
@@ -59,7 +61,7 @@ void ngraph::pass::ReshapeElimination::construct_identity_reshape_pattern()
             return false;
         }
 
-        auto do_r1 = ngraph::get_default_order(r1->get_shape());
+        auto do_r1 = get_default_order(r1->get_shape());
 
         if (do_r1 != r1->get_input_order())
         {
@@ -67,22 +69,22 @@ void ngraph::pass::ReshapeElimination::construct_identity_reshape_pattern()
             return false;
         }
 
-        ngraph::replace_node(m.get_match_root(), gop);
+        replace_node(m.get_match_root(), gop);
         return true;
     };
 
-    auto m = std::make_shared<ngraph::pattern::Matcher>(reshape1, callback);
+    auto m = make_shared<pattern::Matcher>(reshape1, callback);
     this->add_matcher(m);
 }
 
-void ngraph::pass::ReshapeElimination::construct_reshapex2_pattern()
+void pass::ReshapeElimination::construct_reshapex2_pattern()
 {
     Shape shape_op{3};
     Shape shape_r1{1, 3};
 
-    auto op = std::make_shared<pattern::op::Label>(element::f32, shape_op);
-    auto reshape1 = std::make_shared<op::Reshape>(op, AxisVector{0}, shape_r1);
-    auto reshape2 = std::make_shared<op::Reshape>(reshape1, AxisVector{0, 1}, shape_op);
+    auto op = make_shared<pattern::op::Label>(element::f32, shape_op);
+    auto reshape1 = make_shared<op::Reshape>(op, AxisVector{0}, shape_r1);
+    auto reshape2 = make_shared<op::Reshape>(reshape1, AxisVector{0, 1}, shape_op);
 
     auto callback = [op](pattern::Matcher& m) {
         NGRAPH_DEBUG << "In callback for construct_reshapex2_pattern against node = "
@@ -101,11 +103,11 @@ void ngraph::pass::ReshapeElimination::construct_reshapex2_pattern()
             return false;
         }
 
-        auto r2 = std::dynamic_pointer_cast<op::Reshape>(m.get_match_root());
-        auto r1 = std::dynamic_pointer_cast<op::Reshape>(r2->get_argument(0));
+        auto r2 = dynamic_pointer_cast<op::Reshape>(m.get_match_root());
+        auto r1 = dynamic_pointer_cast<op::Reshape>(r2->get_argument(0));
 
-        auto do_r2 = ngraph::get_default_order(r1->get_shape());
-        auto do_r1 = ngraph::get_default_order(gop->get_shape());
+        auto do_r2 = get_default_order(r1->get_shape());
+        auto do_r1 = get_default_order(gop->get_shape());
 
         NGRAPH_DEBUG << "r1's i/o = " << vector_to_string(r1->get_input_order())
                      << "do_r1 = " << vector_to_string(do_r1);
@@ -115,40 +117,40 @@ void ngraph::pass::ReshapeElimination::construct_reshapex2_pattern()
         if (r1->get_input_order() == do_r1 && r2->get_input_order() == do_r2)
         {
             NGRAPH_DEBUG << "Two reshapes were removed!";
-            ngraph::replace_node(m.get_match_root(), gop);
+            replace_node(m.get_match_root(), gop);
             return true;
         }
 
-        auto perm1 = ngraph::apply_permutation(do_r1, r1->get_input_order());
-        auto perm2 = ngraph::apply_permutation(perm1, r2->get_input_order());
+        auto perm1 = apply_permutation(do_r1, r1->get_input_order());
+        auto perm2 = apply_permutation(perm1, r2->get_input_order());
         if (perm2 == do_r1)
         {
             NGRAPH_DEBUG << "Two transposes were removed!";
-            ngraph::replace_node(m.get_match_root(), gop);
+            replace_node(m.get_match_root(), gop);
             return true;
         }
 
         return false;
     };
-    auto m = std::make_shared<ngraph::pattern::Matcher>(reshape2, callback);
+    auto m = make_shared<pattern::Matcher>(reshape2, callback);
     this->add_matcher(m);
 }
 
-void ngraph::pass::ReshapeElimination::construct_dot_transpose_pattern()
+void pass::ReshapeElimination::construct_dot_transpose_pattern()
 {
     // dot(A,B).T = dot (B.T, A.T)
-    auto dot_pred = [](std::shared_ptr<Node> n) {
-        return static_cast<bool>(std::dynamic_pointer_cast<op::Dot>(n));
+    auto dot_pred = [](shared_ptr<Node> n) {
+        return static_cast<bool>(dynamic_pointer_cast<op::Dot>(n));
     };
 
-    auto pdot = std::make_shared<pattern::op::Label>(element::f32, Shape{2, 1}, dot_pred);
-    auto preshape = std::make_shared<op::Reshape>(pdot, AxisVector{1, 0}, Shape{1, 2});
+    auto pdot = make_shared<pattern::op::Label>(element::f32, Shape{2, 1}, dot_pred);
+    auto preshape = make_shared<op::Reshape>(pdot, AxisVector{1, 0}, Shape{1, 2});
 
-    ngraph::pattern::graph_rewrite_callback callback = [](pattern::Matcher& m) {
+    pattern::graph_rewrite_callback callback = [](pattern::Matcher& m) {
         NGRAPH_DEBUG << "In callback for construct_dot_transpose_pattern against node = "
                      << m.get_match_root()->get_name();
 
-        auto mtranspose = std::static_pointer_cast<op::Reshape>(m.get_match_root());
+        auto mtranspose = static_pointer_cast<op::Reshape>(m.get_match_root());
         // this also checks the rank
         if (mtranspose->get_input_order() != AxisVector{1, 0})
         {
@@ -171,7 +173,7 @@ void ngraph::pass::ReshapeElimination::construct_dot_transpose_pattern()
             return false;
         }
         auto reshape0_shape = Shape{arg0->get_shape().at(1), arg0->get_shape().at(0)};
-        auto reshape0 = std::make_shared<op::Reshape>(arg0, AxisVector{1, 0}, reshape0_shape);
+        auto reshape0 = make_shared<op::Reshape>(arg0, AxisVector{1, 0}, reshape0_shape);
 
         auto arg1 = mdot->get_argument(1);
         if (arg1->get_shape().size() != 2)
@@ -180,13 +182,13 @@ void ngraph::pass::ReshapeElimination::construct_dot_transpose_pattern()
             return false;
         }
         auto reshape1_shape = Shape{arg1->get_shape().at(1), arg1->get_shape().at(0)};
-        auto reshape1 = std::make_shared<op::Reshape>(arg1, AxisVector{1, 0}, reshape1_shape);
+        auto reshape1 = make_shared<op::Reshape>(arg1, AxisVector{1, 0}, reshape1_shape);
 
-        auto tdot = std::shared_ptr<Node>(new op::Dot(reshape1, reshape0));
-        ngraph::replace_node(m.get_match_root(), tdot);
+        auto tdot = shared_ptr<Node>(new op::Dot(reshape1, reshape0));
+        replace_node(m.get_match_root(), tdot);
         return true;
     };
 
-    auto m = std::make_shared<ngraph::pattern::Matcher>(preshape, callback);
+    auto m = make_shared<pattern::Matcher>(preshape, callback);
     this->add_matcher(m);
 }

src/ngraph/pass/visualize_tree.cpp

@@ -27,9 +27,9 @@
 using namespace ngraph;
 using namespace std;
 
-#define TI(x) std::type_index(typeid(x))
+#define TI(x) type_index(typeid(x))
 
-bool pass::VisualizeTree::run_on_module(vector<shared_ptr<ngraph::Function>>& functions)
+bool pass::VisualizeTree::run_on_module(vector<shared_ptr<Function>>& functions)
 {
     for (shared_ptr<Function> f : functions)
     {
@@ -42,10 +42,10 @@ bool pass::VisualizeTree::run_on_module(vector<shared_ptr<ngraph::Function>>& fu
                 m_ss << add_attributes(node);
                 m_ss << "    " << arg->get_name() << " -> " << node->get_name();
 
-                if (std::getenv("NGRAPH_VISUALIZE_EDGE_LABELS") != nullptr)
+                if (getenv("NGRAPH_VISUALIZE_EDGE_LABELS") != nullptr)
                 {
                     size_t output = 0;
-                    if (auto goe = std::dynamic_pointer_cast<op::GetOutputElement>(node))
+                    if (auto goe = dynamic_pointer_cast<op::GetOutputElement>(node))
                     {
                         output = goe->get_n();
                     }
@@ -71,7 +71,7 @@ pass::VisualizeTree::VisualizeTree(const string& file_name, node_modifiers_t nm)
 {
 }
 
-std::string pass::VisualizeTree::add_attributes(shared_ptr<Node> node)
+string pass::VisualizeTree::add_attributes(shared_ptr<Node> node)
 {
     string rc;
     if (m_nodes_with_attributes.find(node) == m_nodes_with_attributes.end())
@@ -82,7 +82,7 @@ std::string pass::VisualizeTree::add_attributes(shared_ptr<Node> node)
     return rc;
 }
 
-std::string pass::VisualizeTree::get_attributes(shared_ptr<Node> node)
+string pass::VisualizeTree::get_attributes(shared_ptr<Node> node)
 {
     vector<string> attributes;
     if (node->is_parameter() || node->is_output())
@@ -110,22 +110,22 @@ std::string pass::VisualizeTree::get_attributes(shared_ptr<Node> node)
         stringstream label;
         label << "label=\"" << node->get_friendly_name();
 
-        static const char* nvtos = std::getenv("NGRAPH_VISUALIZE_TREE_OUTPUT_SHAPES");
+        static const char* nvtos = getenv("NGRAPH_VISUALIZE_TREE_OUTPUT_SHAPES");
         if (nvtos != nullptr)
         {
             // The shapes of the Outputs of a multi-output op
             // will be printed for its corresponding `GetOutputElement`s
-            label << " " << (node->get_outputs().size() != 1 ? std::string("[skipped]")
+            label << " " << (node->get_outputs().size() != 1 ? string("[skipped]")
                                                              : vector_to_string(node->get_shape()));
         }
 
-        static const char* nvtot = std::getenv("NGRAPH_VISUALIZE_TREE_OUTPUT_TYPES");
+        static const char* nvtot = getenv("NGRAPH_VISUALIZE_TREE_OUTPUT_TYPES");
         if (nvtot != nullptr)
         {
             // The types of the Outputs of a multi-output op
             // will be printed for its corresponding `GetOutputElement`s
             label << " "
-                  << ((node->get_outputs().size() != 1) ? std::string("[skipped]")
+                  << ((node->get_outputs().size() != 1) ? string("[skipped]")
                                                         : node->get_element_type().c_type_string());
         }
 
@@ -150,9 +150,9 @@ std::string pass::VisualizeTree::get_attributes(shared_ptr<Node> node)
     return ss.str();
 }
 
-std::string pass::VisualizeTree::get_file_ext()
+string pass::VisualizeTree::get_file_ext()
 {
-    const char* format = std::getenv("NGRAPH_VISUALIZE_TREE_OUTPUT_FORMAT");
+    const char* format = getenv("NGRAPH_VISUALIZE_TREE_OUTPUT_FORMAT");
     if (!format)
     {
         format = "png";
@@ -163,7 +163,7 @@ std::string pass::VisualizeTree::get_file_ext()
         format += 1;
     }
 
-    return std::string(format);
+    return string(format);
 }
 
 void pass::VisualizeTree::render() const

src/ngraph/pass/zero_dim_tensor_elimination.cpp

@@ -30,9 +30,10 @@
 #include "ngraph/op/sum.hpp"
 #include "zero_dim_tensor_elimination.hpp"
 
+using namespace std;
 using namespace ngraph;
 
-static bool has_zero_dim(std::shared_ptr<Node> node)
+static bool has_zero_dim(shared_ptr<Node> node)
 {
     if (node->get_output_size() != 1)
     {
@@ -40,12 +41,12 @@ static bool has_zero_dim(std::shared_ptr<Node> node)
     }
 
     const auto& shape = node->get_shape();
-    return std::find(shape.begin(), shape.end(), 0) != shape.end();
+    return find(shape.begin(), shape.end(), 0) != shape.end();
 }
 
-static bool verify_no_internal_zero_length_ops(std::shared_ptr<ngraph::Function> f)
+static bool verify_no_internal_zero_length_ops(shared_ptr<Function> f)
 {
-    std::set<std::shared_ptr<Node>> zero_length_nodes;
+    set<shared_ptr<Node>> zero_length_nodes;
     for (auto n : f->get_ordered_ops())
     {
         if (n->is_output() || n->is_parameter() || n->get_outputs().size() > 1)
@@ -76,10 +77,10 @@ static bool verify_no_internal_zero_length_ops(std::shared_ptr<ngraph::Function>
     return zero_length_nodes.size() > 0;
 }
 
-bool ngraph::pass::ZeroDimTensorElimination::run_on_function(std::shared_ptr<ngraph::Function> f)
+bool pass::ZeroDimTensorElimination::run_on_function(shared_ptr<Function> f)
 {
     bool replaced = false;
-    auto cvals = std::vector<std::string>(0);
+    auto cvals = vector<string>(0);
     // we need to go over all nodes since we could have sum or any other 0-length-tensor-to scalar op
     // as an internal node (i.e. a node that isn't an argument to `op::Result`)
     for (auto n : f->get_ordered_ops())
@@ -98,8 +99,7 @@ bool ngraph::pass::ZeroDimTensorElimination::run_on_function(std::shared_ptr<ngr
         {
             // we don't have to create constants every time but this is the easiest
             // and it's CSE's job to eliminate the same ones
-            auto constant =
-                std::make_shared<op::Constant>(n->get_element_type(), n->get_shape(), cvals);
+            auto constant = make_shared<op::Constant>(n->get_element_type(), n->get_shape(), cvals);
             replace_node(n, constant);
             NGRAPH_DEBUG << " Replacing " << n->get_name() << " with " << constant->get_name();
             replaced = true;
@@ -111,7 +111,7 @@ bool ngraph::pass::ZeroDimTensorElimination::run_on_function(std::shared_ptr<ngr
             continue;
         }
 
-        if (auto concat = std::dynamic_pointer_cast<op::Concat>(n))
+        if (auto concat = dynamic_pointer_cast<op::Concat>(n))
         {
             NodeVector non_zero_dim_args;
             for (auto arg : concat->get_arguments())
@@ -127,7 +127,7 @@ bool ngraph::pass::ZeroDimTensorElimination::run_on_function(std::shared_ptr<ngr
                 auto new_concat = concat->copy_with_new_args(non_zero_dim_args);
                 NGRAPH_DEBUG << " Replacing " << n->get_name() << " with "
                              << new_concat->get_name();
-                ngraph::replace_node(concat, new_concat);
+                replace_node(concat, new_concat);
                 continue;
             }
         }