Removed global factory for nodes (#3701)

ngraph/core/include/ngraph/factory.hpp

@@ -91,9 +91,6 @@ namespace ngraph
             return create(DERIVED_TYPE::type_info);
         }
 
-        /// \brief Get the factory for BASE_TYPE
-        static FactoryRegistry<BASE_TYPE>& get();
-
     protected:
         FactoryMap m_factory_map;
     };

ngraph/core/include/ngraph/factory_adapter.hpp

@@ -49,11 +49,6 @@ namespace ngraph
                 }
                 visitor.on_attribute("name", type_info_name);
                 visitor.on_attribute("version", type_info_version);
-                if (!type_info_name.empty() && !m_ref)
-                {
-                    m_ref = std::shared_ptr<BASE_TYPE>(FactoryRegistry<BASE_TYPE>::get().create(
-                        DiscreteTypeInfo{type_info_name.c_str(), type_info_version}));
-                }
                 if (m_ref)
                 {
                     visitor.start_structure("value");

ngraph/core/src/factory.cpp

@@ -29,25 +29,4 @@ namespace ngraph
         static mutex registry_mutex;
         return registry_mutex;
     }
-
-    template class NGRAPH_API FactoryRegistry<Node>;
-
-    template <>
-    FactoryRegistry<Node>& FactoryRegistry<Node>::get()
-    {
-        static FactoryRegistry<Node> registry;
-        static mutex init_guard;
-        // TODO: Add a lock
-        if (registry.m_factory_map.size() == 0)
-        {
-            lock_guard<mutex> guard(init_guard);
-            if (registry.m_factory_map.size() == 0)
-            {
-#define NGRAPH_OP(NAME, NAMESPACE, VERSION) registry.register_factory<NAMESPACE::NAME>();
-#include "ngraph/op/op_version_tbl.hpp"
-#undef NGRAPH_OP
-            }
-        }
-        return registry;
-    }
 }

ngraph/test/attributes.cpp

@@ -347,7 +347,7 @@ constexpr NodeTypeInfo Oracle::type_info;
 
 TEST(attributes, user_op)
 {
-    FactoryRegistry<Node>::get().register_factory<Oracle>();
+    NodeBuilder::get_ops().register_factory<Oracle>();
     auto program = make_shared<op::Parameter>(element::i32, Shape{200});
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto result = make_shared<op::Result>(data);
@@ -437,7 +437,7 @@ TEST(attributes, user_op)
 
 TEST(attributes, matmul_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::MatMul>();
+    NodeBuilder::get_ops().register_factory<opset1::MatMul>();
     auto A = make_shared<op::Parameter>(element::f32, Shape{0, 2});
     auto B = make_shared<op::Parameter>(element::f32, Shape{2, 0});
 
@@ -491,7 +491,7 @@ TEST(attributes, partial_shape)
 
 TEST(attributes, max_pool_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::MaxPool>();
+    NodeBuilder::get_ops().register_factory<opset1::MaxPool>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{64, 3, 5});
 
     auto strides = Strides{2};
@@ -516,7 +516,7 @@ TEST(attributes, max_pool_op)
 
 TEST(attributes, mod_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Mod>();
+    NodeBuilder::get_ops().register_factory<opset1::Mod>();
     auto A = make_shared<op::Parameter>(element::f32, Shape{0, 2});
     auto B = make_shared<op::Parameter>(element::f32, Shape{2, 0});
 
@@ -531,7 +531,7 @@ TEST(attributes, mod_op)
 
 TEST(attributes, non_max_suppression_op_custom_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::NonMaxSuppression>();
+    NodeBuilder::get_ops().register_factory<opset1::NonMaxSuppression>();
     auto boxes = make_shared<op::Parameter>(element::f32, Shape{1, 1, 4});
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
@@ -549,7 +549,7 @@ TEST(attributes, non_max_suppression_op_custom_attributes)
 
 TEST(attributes, non_max_suppression_op_default_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::NonMaxSuppression>();
+    NodeBuilder::get_ops().register_factory<opset1::NonMaxSuppression>();
     auto boxes = make_shared<op::Parameter>(element::f32, Shape{1, 1, 4});
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
@@ -563,7 +563,7 @@ TEST(attributes, non_max_suppression_op_default_attributes)
 
 TEST(attributes, non_max_suppression_v3_op_custom_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::NonMaxSuppression>();
+    NodeBuilder::get_ops().register_factory<opset3::NonMaxSuppression>();
     auto boxes = make_shared<op::Parameter>(element::f32, Shape{1, 1, 4});
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
@@ -583,7 +583,7 @@ TEST(attributes, non_max_suppression_v3_op_custom_attributes)
 
 TEST(attributes, non_max_suppression_v3_op_default_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::NonMaxSuppression>();
+    NodeBuilder::get_ops().register_factory<opset3::NonMaxSuppression>();
     auto boxes = make_shared<op::Parameter>(element::f32, Shape{1, 1, 4});
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
@@ -598,7 +598,7 @@ TEST(attributes, non_max_suppression_v3_op_default_attributes)
 
 TEST(attributes, normalize_l2_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::NormalizeL2>();
+    NodeBuilder::get_ops().register_factory<opset1::NormalizeL2>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{1});
     const auto axes = make_shared<op::Constant>(element::i32, Shape{}, vector<int32_t>{0});
 
@@ -615,7 +615,7 @@ TEST(attributes, normalize_l2_op)
 
 TEST(attributes, one_hot_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::OneHot>();
+    NodeBuilder::get_ops().register_factory<opset1::OneHot>();
     auto indices = make_shared<op::Parameter>(element::i64, Shape{1, 3, 2, 3});
     auto depth = op::Constant::create(element::i64, Shape{}, {4});
     auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
@@ -632,7 +632,7 @@ TEST(attributes, one_hot_op)
 
 TEST(attributes, pad_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Pad>();
+    NodeBuilder::get_ops().register_factory<opset1::Pad>();
     auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
     auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
     auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
@@ -648,7 +648,7 @@ TEST(attributes, pad_op)
 
 TEST(attributes, psroi_pooling_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::PSROIPooling>();
+    NodeBuilder::get_ops().register_factory<opset1::PSROIPooling>();
     auto input = make_shared<op::Parameter>(element::f32, Shape{1, 1024, 63, 38});
     auto coords = make_shared<op::Parameter>(element::f32, Shape{300, 5});
 
@@ -675,7 +675,7 @@ TEST(attributes, psroi_pooling_op)
 TEST(attributes, reduce_logical_and_op)
 {
     // ReduceLogicalAnd derives visit_attributes from op::util::LogicalReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceLogicalAnd>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceLogicalAnd>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -691,7 +691,7 @@ TEST(attributes, reduce_logical_and_op)
 TEST(attributes, reduce_logical_or_op)
 {
     // ReduceLogicalOr derives visit_attributes from op::util::LogicalReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceLogicalOr>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceLogicalOr>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -707,7 +707,7 @@ TEST(attributes, reduce_logical_or_op)
 TEST(attributes, reduce_max_op)
 {
     // ReduceMax derives visit_attributes from op::util::ArithmeticReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceMax>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceMax>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -723,7 +723,7 @@ TEST(attributes, reduce_max_op)
 TEST(attributes, reduce_mean_op)
 {
     // ReduceMean derives visit_attributes from op::util::ArithmeticReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceMean>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceMean>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -739,7 +739,7 @@ TEST(attributes, reduce_mean_op)
 TEST(attributes, reduce_min_op)
 {
     // ReduceMin derives visit_attributes from op::util::ArithmeticReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceMin>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceMin>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -755,7 +755,7 @@ TEST(attributes, reduce_min_op)
 TEST(attributes, reduce_prod_op)
 {
     // ReduceProd derives visit_attributes from op::util::ArithmeticReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceProd>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceProd>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -771,7 +771,7 @@ TEST(attributes, reduce_prod_op)
 TEST(attributes, reduce_sum_op)
 {
     // ReduceSum derives visit_attributes from op::util::ArithmeticReductionKeepDims
-    FactoryRegistry<Node>::get().register_factory<opset1::ReduceSum>();
+    NodeBuilder::get_ops().register_factory<opset1::ReduceSum>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     auto reduction_axes = make_shared<op::Parameter>(element::i64, Shape{2});
 
@@ -786,7 +786,7 @@ TEST(attributes, reduce_sum_op)
 
 TEST(attributes, region_yolo_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::RegionYolo>();
+    NodeBuilder::get_ops().register_factory<opset1::RegionYolo>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{1, 255, 26, 26});
 
     size_t num_coords = 4;
@@ -815,7 +815,7 @@ TEST(attributes, region_yolo_op)
 
 TEST(attributes, reshape_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Reshape>();
+    NodeBuilder::get_ops().register_factory<opset1::Reshape>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4});
     auto pattern = make_shared<op::Parameter>(element::i32, Shape{2});
 
@@ -830,7 +830,7 @@ TEST(attributes, reshape_op)
 
 TEST(attributes, reverse_op_enum_mode)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Reverse>();
+    NodeBuilder::get_ops().register_factory<opset1::Reverse>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto reversed_axes = make_shared<op::Parameter>(element::i32, Shape{200});
 
@@ -843,7 +843,7 @@ TEST(attributes, reverse_op_enum_mode)
 
 TEST(attributes, reverse_op_string_mode)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Reverse>();
+    NodeBuilder::get_ops().register_factory<opset1::Reverse>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto reversed_axes = make_shared<op::Parameter>(element::i32, Shape{200});
 
@@ -858,7 +858,7 @@ TEST(attributes, reverse_op_string_mode)
 
 TEST(attributes, reverse_sequence_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::ReverseSequence>();
+    NodeBuilder::get_ops().register_factory<opset1::ReverseSequence>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4, 2});
     auto seq_indices = make_shared<op::Parameter>(element::i32, Shape{4});
 
@@ -878,7 +878,7 @@ TEST(attributes, reverse_sequence_op)
 
 TEST(attributes, rnn_cell_op_custom_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::RNNCell>();
+    NodeBuilder::get_ops().register_factory<opset1::RNNCell>();
     auto X = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto H = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto W = make_shared<op::Parameter>(element::f32, Shape{3, 3});
@@ -905,7 +905,7 @@ TEST(attributes, rnn_cell_op_custom_attributes)
 
 TEST(attributes, rnn_cell_op_default_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::RNNCell>();
+    NodeBuilder::get_ops().register_factory<opset1::RNNCell>();
     auto X = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto H = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto W = make_shared<op::Parameter>(element::f32, Shape{3, 3});
@@ -927,7 +927,7 @@ TEST(attributes, rnn_cell_op_default_attributes)
 
 TEST(attributes, elu_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Elu>();
+    NodeBuilder::get_ops().register_factory<opset1::Elu>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 4});
 
     double alpha = 0.1;
@@ -941,7 +941,7 @@ TEST(attributes, elu_op)
 
 TEST(attributes, fake_quantize_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::FakeQuantize>();
+    NodeBuilder::get_ops().register_factory<opset1::FakeQuantize>();
     const auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
     const auto input_low = make_shared<op::Parameter>(element::f32, Shape{});
     const auto input_high = make_shared<op::Parameter>(element::f32, Shape{});
@@ -962,7 +962,7 @@ TEST(attributes, fake_quantize_op)
 
 TEST(attributes, broadcast_v3)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::Broadcast>();
+    NodeBuilder::get_ops().register_factory<opset3::Broadcast>();
     const auto arg = make_shared<op::Parameter>(element::i64, Shape{1, 3, 1});
     const auto shape = make_shared<op::Parameter>(element::i64, Shape{3});
     const auto broadcast_spec = op::BroadcastType::BIDIRECTIONAL;
@@ -976,7 +976,7 @@ TEST(attributes, broadcast_v3)
 
 TEST(attributes, grn_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::GRN>();
+    NodeBuilder::get_ops().register_factory<opset1::GRN>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4, 5});
 
     float bias = 1.25f;
@@ -990,7 +990,7 @@ TEST(attributes, grn_op)
 
 TEST(attributes, group_conv_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::GroupConvolution>();
+    NodeBuilder::get_ops().register_factory<opset1::GroupConvolution>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{1, 12, 224, 224});
     auto filters = make_shared<op::Parameter>(element::f32, Shape{4, 1, 3, 5, 5});
     auto strides = Strides{1, 1};
@@ -1010,7 +1010,7 @@ TEST(attributes, group_conv_op)
 
 TEST(attributes, group_conv_backprop_data_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::GroupConvolutionBackpropData>();
+    NodeBuilder::get_ops().register_factory<opset1::GroupConvolutionBackpropData>();
     const auto data = make_shared<op::Parameter>(element::f32, Shape{1, 20, 224, 224});
     const auto filter = make_shared<op::Parameter>(element::f32, Shape{4, 5, 2, 3, 3});
     const auto output_shape = make_shared<op::Parameter>(element::f32, Shape{1, 8, 447, 447});
@@ -1044,7 +1044,7 @@ TEST(attributes, group_conv_backprop_data_op)
 
 TEST(attributes, lrn_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::LRN>();
+    NodeBuilder::get_ops().register_factory<opset1::LRN>();
     const auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
     const auto axes = make_shared<op::Parameter>(element::i32, Shape{2});
 
@@ -1065,7 +1065,7 @@ TEST(attributes, lrn_op)
 
 TEST(attributes, lstm_cell_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset4::LSTMCell>();
+    NodeBuilder::get_ops().register_factory<opset4::LSTMCell>();
     auto X = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto H = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto W = make_shared<op::Parameter>(element::f32, Shape{12, 3});
@@ -1100,7 +1100,7 @@ TEST(attributes, lstm_cell_op)
 
 TEST(attributes, lstm_sequence_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset5::LSTMSequence>();
+    NodeBuilder::get_ops().register_factory<opset5::LSTMSequence>();
 
     const size_t batch_size = 4;
     const size_t num_directions = 2;
@@ -1153,7 +1153,7 @@ TEST(attributes, lstm_sequence_op)
 
 TEST(attributes, shuffle_channels_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::ShuffleChannels>();
+    NodeBuilder::get_ops().register_factory<opset1::ShuffleChannels>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto axis = 0;
     auto groups = 2;
@@ -1167,7 +1167,7 @@ TEST(attributes, shuffle_channels_op)
 
 TEST(attributes, softmax_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Softmax>();
+    NodeBuilder::get_ops().register_factory<opset1::Softmax>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto axis = 0;
     auto softmax = make_shared<opset1::Softmax>(data, axis);
@@ -1179,7 +1179,7 @@ TEST(attributes, softmax_op)
 
 TEST(attributes, space_to_depth_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::SpaceToDepth>();
+    NodeBuilder::get_ops().register_factory<opset1::SpaceToDepth>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 50, 50});
     auto block_size = 2;
     auto mode = opset1::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST;
@@ -1193,7 +1193,7 @@ TEST(attributes, space_to_depth_op)
 
 TEST(attributes, split_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Split>();
+    NodeBuilder::get_ops().register_factory<opset1::Split>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto axis = make_shared<op::Parameter>(element::i32, Shape{});
     auto num_splits = 2;
@@ -1206,7 +1206,7 @@ TEST(attributes, split_op)
 
 TEST(attributes, squared_difference_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::SquaredDifference>();
+    NodeBuilder::get_ops().register_factory<opset1::SquaredDifference>();
     auto x1 = make_shared<op::Parameter>(element::i32, Shape{200});
     auto x2 = make_shared<op::Parameter>(element::i32, Shape{200});
     auto auto_broadcast = op::AutoBroadcastType::NUMPY;
@@ -1219,7 +1219,7 @@ TEST(attributes, squared_difference_op)
 
 TEST(attributes, strided_slice_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::StridedSlice>();
+    NodeBuilder::get_ops().register_factory<opset1::StridedSlice>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4, 5});
     auto begin = make_shared<op::Parameter>(element::i32, Shape{2});
     auto end = make_shared<op::Parameter>(element::i32, Shape{2});
@@ -1252,7 +1252,7 @@ TEST(attributes, strided_slice_op)
 
 TEST(attributes, topk_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::TopK>();
+    NodeBuilder::get_ops().register_factory<opset1::TopK>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4, 5});
     auto k = make_shared<op::Parameter>(element::i32, Shape{});
 
@@ -1271,7 +1271,7 @@ TEST(attributes, topk_op)
 
 TEST(attributes, logical_xor_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::LogicalXor>();
+    NodeBuilder::get_ops().register_factory<opset1::LogicalXor>();
     auto x1 = make_shared<op::Parameter>(element::boolean, Shape{200});
     auto x2 = make_shared<op::Parameter>(element::boolean, Shape{200});
 
@@ -1286,7 +1286,7 @@ TEST(attributes, logical_xor_op)
 
 TEST(attributes, extractimagepatches_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::ExtractImagePatches>();
+    NodeBuilder::get_ops().register_factory<opset3::ExtractImagePatches>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{64, 3, 10, 10});
 
     auto sizes = Shape{3, 3};
@@ -1307,7 +1307,7 @@ TEST(attributes, extractimagepatches_op)
 
 TEST(attributes, mvn_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::MVN>();
+    NodeBuilder::get_ops().register_factory<opset3::MVN>();
     const auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4, 5});
 
     const auto axes = AxisSet{0, 1};
@@ -1325,7 +1325,7 @@ TEST(attributes, mvn_op)
 
 TEST(attributes, reorg_yolo_op_stride)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::ReorgYolo>();
+    NodeBuilder::get_ops().register_factory<opset3::ReorgYolo>();
     const auto data = make_shared<op::Parameter>(element::i32, Shape{1, 64, 26, 26});
 
     const auto op = make_shared<op::v0::ReorgYolo>(data, 2);
@@ -1337,7 +1337,7 @@ TEST(attributes, reorg_yolo_op_stride)
 
 TEST(attributes, reorg_yolo_op_strides)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::ReorgYolo>();
+    NodeBuilder::get_ops().register_factory<opset3::ReorgYolo>();
     const auto data = make_shared<op::Parameter>(element::i32, Shape{1, 64, 26, 26});
 
     const auto op = make_shared<op::v0::ReorgYolo>(data, Strides{2});
@@ -1349,7 +1349,7 @@ TEST(attributes, reorg_yolo_op_strides)
 
 TEST(attributes, roi_pooling_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::ROIPooling>();
+    NodeBuilder::get_ops().register_factory<opset3::ROIPooling>();
     const auto data = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4, 5});
     const auto coords = make_shared<op::Parameter>(element::f32, Shape{2, 5});
 
@@ -1378,7 +1378,7 @@ TEST(attributes, constant_op)
 
 TEST(attributes, bucketize_v3_op_default_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::Bucketize>();
+    NodeBuilder::get_ops().register_factory<opset3::Bucketize>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
     auto buckets = make_shared<op::Parameter>(element::f32, Shape{5});
     auto bucketize = make_shared<opset3::Bucketize>(data, buckets);
@@ -1392,7 +1392,7 @@ TEST(attributes, bucketize_v3_op_default_attributes)
 
 TEST(attributes, bucketize_v3_op_custom_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::Bucketize>();
+    NodeBuilder::get_ops().register_factory<opset3::Bucketize>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
     auto buckets = make_shared<op::Parameter>(element::f32, Shape{5});
     element::Type output_type = element::i32;
@@ -1409,7 +1409,7 @@ TEST(attributes, bucketize_v3_op_custom_attributes)
 
 TEST(attributes, cum_sum_op_default_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::CumSum>();
+    NodeBuilder::get_ops().register_factory<opset3::CumSum>();
 
     Shape shape{1, 4};
     auto A = make_shared<op::Parameter>(element::f32, shape);
@@ -1425,7 +1425,7 @@ TEST(attributes, cum_sum_op_default_attributes)
 
 TEST(attributes, cum_sum_op_custom_attributes)
 {
-    FactoryRegistry<Node>::get().register_factory<opset3::CumSum>();
+    NodeBuilder::get_ops().register_factory<opset3::CumSum>();
 
     Shape shape{1, 4};
     auto A = make_shared<op::Parameter>(element::f32, shape);
@@ -1443,7 +1443,7 @@ TEST(attributes, cum_sum_op_custom_attributes)
 
 TEST(attributes, interpolate_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Interpolate>();
+    NodeBuilder::get_ops().register_factory<opset1::Interpolate>();
     auto img = make_shared<op::Parameter>(element::f32, Shape{1, 3, 32, 32});
     auto out_shape = make_shared<op::Parameter>(element::i32, Shape{2});
 
@@ -1472,7 +1472,7 @@ TEST(attributes, interpolate_op)
 
 TEST(attributes, detection_output_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::DetectionOutput>();
+    NodeBuilder::get_ops().register_factory<opset1::DetectionOutput>();
     const auto box_logits = make_shared<op::Parameter>(element::f32, Shape{1, 2 * 1 * 4});
     const auto class_preds = make_shared<op::Parameter>(element::f32, Shape{1, 2 * 32});
     const auto proposals = make_shared<op::Parameter>(element::f32, Shape{1, 2, 2 * 4});
@@ -1525,7 +1525,7 @@ TEST(attributes, detection_output_op)
 
 TEST(attributes, prior_box_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::PriorBox>();
+    NodeBuilder::get_ops().register_factory<opset1::PriorBox>();
     const auto layer_shape = make_shared<op::Parameter>(element::i64, Shape{128, 128});
     const auto image_shape = make_shared<op::Parameter>(element::i64, Shape{32, 32});
 
@@ -1566,7 +1566,7 @@ TEST(attributes, prior_box_op)
 
 TEST(attributes, prior_box_clustered_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::PriorBoxClustered>();
+    NodeBuilder::get_ops().register_factory<opset1::PriorBoxClustered>();
     const auto layer_shape = make_shared<op::Parameter>(element::i64, Shape{128, 128});
     const auto image_shape = make_shared<op::Parameter>(element::i64, Shape{32, 32});
 
@@ -1597,7 +1597,7 @@ TEST(attributes, prior_box_clustered_op)
 
 TEST(attributes, proposal_op)
 {
-    FactoryRegistry<Node>::get().register_factory<opset1::Proposal>();
+    NodeBuilder::get_ops().register_factory<opset1::Proposal>();
     const auto class_probs = make_shared<op::Parameter>(element::i64, Shape{1024, 3, 128, 128});
     const auto class_logits = make_shared<op::Parameter>(element::i64, Shape{1024, 3, 128, 128});
     const auto image_shape = make_shared<op::Parameter>(element::i64, Shape{4});

ngraph/test/opset1.cpp

@@ -211,7 +211,7 @@ TEST(opset, new_op)
     fred = shared_ptr<Node>(opset1_copy.create_insensitive("FReD"));
     EXPECT_TRUE(fred);
     // Fred should not be in the registry
-    ASSERT_FALSE(FactoryRegistry<Node>::get().has_factory<NewOp>());
+    ASSERT_FALSE(get_opset1().contains_type(NewOp::type_info));
 }
 
 TEST(opset, dump)

ngraph/test/util/visitor.hpp

@@ -16,12 +16,14 @@
 
 #pragma once
 
+#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "ngraph/attribute_visitor.hpp"
 #include "ngraph/factory.hpp"
+#include "ngraph/ops.hpp"
 #include "ngraph/runtime/host_tensor.hpp"
 
 namespace ngraph
@@ -367,12 +369,30 @@ namespace ngraph
             // Does not validate, since inputs aren't set
             std::shared_ptr<Node> create()
             {
-                std::shared_ptr<Node> node(FactoryRegistry<Node>::get().create(m_node_type_info));
+                std::shared_ptr<Node> node(get_ops().create(m_node_type_info));
                 node->visit_attributes(*this);
                 return node;
             }
             AttributeVisitor& get_node_saver() { return m_serializer; }
             AttributeVisitor& get_node_loader() { return *this; }
+            static FactoryRegistry<Node>& get_ops()
+            {
+                static std::shared_ptr<FactoryRegistry<Node>> registry;
+                static std::mutex init_guard;
+                if (!registry)
+                {
+                    std::lock_guard<std::mutex> guard(init_guard);
+                    if (!registry)
+                    {
+                        registry = std::make_shared<FactoryRegistry<Node>>();
+#define NGRAPH_OP(NAME, NAMESPACE, VERSION) registry->register_factory<NAMESPACE::NAME>();
+#include "op_version_tbl.hpp"
+#undef NGRAPH_OP
+                    }
+                }
+                return *registry;
+            }
+
         protected:
             Node::type_info_t m_node_type_info;
             SerializeAttributeVisitor m_serializer;