Initialize CPU transformer the same way for static and non-static linking (#3516)

* Initialize CPU transformer the same way for static and non-static linking.

* Initialize earlier

src/ngraph/runtime/cpu/builder/add.cpp

@@ -78,11 +78,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Add);
-
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_add_cpp() {}
-#endif
+            void register_builders_add_cpp() { REGISTER_OP_BUILDER(Add); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/allreduce.cpp

@@ -67,11 +67,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(AllReduce);
-
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_allreduce_cpp() {}
-#endif
+            void register_builders_allreduce_cpp() { REGISTER_OP_BUILDER(AllReduce); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/argmax.cpp

@@ -209,11 +209,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(ArgMax);
-
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_argmax_cpp() {}
-#endif
+            void register_builders_argmax_cpp() { REGISTER_OP_BUILDER(ArgMax); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/argmin.cpp

@@ -209,10 +209,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(ArgMin);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_argmin_cpp() {}
-#endif
+            void register_builders_argmin_cpp() { REGISTER_OP_BUILDER(ArgMin); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/avg_pool.cpp

@@ -195,12 +195,12 @@ namespace ngraph
                     functors.emplace_back(functor);
                 }
             }
-            REGISTER_OP_BUILDER(AvgPool);
-            REGISTER_OP_BUILDER(AvgPoolBackprop);
 
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_avg_pool_cpp() {}
-#endif
+            void register_builders_avg_pool_cpp()
+            {
+                REGISTER_OP_BUILDER(AvgPool);
+                REGISTER_OP_BUILDER(AvgPoolBackprop);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/batch_norm.cpp

@@ -511,15 +511,14 @@ namespace ngraph
                     external_function, node, args, out, true, false);
             }
 
-            REGISTER_OP_BUILDER(BatchNormTraining);
-            REGISTER_OP_BUILDER(BatchNormInference);
-            REGISTER_OP_BUILDER(BatchNormTrainingRelu);
-            REGISTER_OP_BUILDER(BatchNormInferenceRelu);
-            REGISTER_OP_BUILDER(BatchNormTrainingBackprop);
-
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_batch_norm_cpp() {}
-#endif
+            void register_builders_batch_norm_cpp()
+            {
+                REGISTER_OP_BUILDER(BatchNormTraining);
+                REGISTER_OP_BUILDER(BatchNormInference);
+                REGISTER_OP_BUILDER(BatchNormTrainingRelu);
+                REGISTER_OP_BUILDER(BatchNormInferenceRelu);
+                REGISTER_OP_BUILDER(BatchNormTrainingBackprop);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/bounded_relu.cpp

@@ -87,10 +87,8 @@ namespace ngraph
                     functors.emplace_back(functor);
                 }
             }
-            REGISTER_OP_BUILDER(BoundedRelu);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_bounded_relu_cpp() {}
-#endif
+
+            void register_builders_bounded_relu_cpp() { REGISTER_OP_BUILDER(BoundedRelu); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/broadcast.cpp

@@ -186,7 +186,6 @@ namespace ngraph
                 }
                 return functor;
             }
-            REGISTER_CF_BUILDER(Broadcast);
 
             template <>
             void Builder::BUILDER_DECL(ngraph::op::Broadcast)
@@ -231,10 +230,11 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Broadcast);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_broadcast_cpp() {}
-#endif
+            void register_builders_broadcast_cpp()
+            {
+                REGISTER_CF_BUILDER(Broadcast);
+                REGISTER_OP_BUILDER(Broadcast);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/broadcast_distributed.cpp

@@ -43,10 +43,11 @@ namespace ngraph
                 };
                 functors.emplace_back(functor);
             }
-            REGISTER_OP_BUILDER(BroadcastDistributed);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_broadcast_distributed_cpp() {}
-#endif
+
+            void register_builders_broadcast_distributed_cpp()
+            {
+                REGISTER_OP_BUILDER(BroadcastDistributed);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/concat.cpp

@@ -171,10 +171,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Concat);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_concat_cpp() {}
-#endif
+            void register_builders_concat_cpp() { REGISTER_OP_BUILDER(Concat); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/convert.cpp

@@ -114,10 +114,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Convert);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_convert_cpp() {}
-#endif
+            void register_builders_convert_cpp() { REGISTER_OP_BUILDER(Convert); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/convert_layout.cpp

@@ -103,10 +103,8 @@ namespace ngraph
                     };
                 functors.emplace_back(functor);
             }
-            REGISTER_CPU_OP_BUILDER(ConvertLayout);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_convert_layout_cpp() {}
-#endif
+
+            void register_builders_convert_layout_cpp() { REGISTER_CPU_OP_BUILDER(ConvertLayout); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/convolution.cpp

@@ -821,21 +821,20 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Convolution);
-            REGISTER_OP_BUILDER(ConvolutionRelu);
-            REGISTER_OP_BUILDER(ConvolutionBias);
-            REGISTER_OP_BUILDER(ConvolutionBiasAdd);
-            REGISTER_OP_BUILDER(ConvolutionBackpropData);
-            REGISTER_OP_BUILDER(ConvolutionBackpropFilters);
-            REGISTER_OP_BUILDER(ConvolutionBiasBackpropFiltersBias);
-            REGISTER_OP_BUILDER(GroupConvolution);
-            REGISTER_OP_BUILDER(ConvolutionAdd);
-            REGISTER_OP_BUILDER(GroupConvolutionBias);
-            REGISTER_OP_BUILDER(DeconvolutionBias)
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_convolution_cpp() {}
-#endif
-
+            void register_builders_convolution_cpp()
+            {
+                REGISTER_OP_BUILDER(Convolution);
+                REGISTER_OP_BUILDER(ConvolutionRelu);
+                REGISTER_OP_BUILDER(ConvolutionBias);
+                REGISTER_OP_BUILDER(ConvolutionBiasAdd);
+                REGISTER_OP_BUILDER(ConvolutionBackpropData);
+                REGISTER_OP_BUILDER(ConvolutionBackpropFilters);
+                REGISTER_OP_BUILDER(ConvolutionBiasBackpropFiltersBias);
+                REGISTER_OP_BUILDER(GroupConvolution);
+                REGISTER_OP_BUILDER(ConvolutionAdd);
+                REGISTER_OP_BUILDER(GroupConvolutionBias);
+                REGISTER_OP_BUILDER(DeconvolutionBias);
+            }
         } // namespace cpu
     }     // namespace runtime
 } // namespace ngraph

src/ngraph/runtime/cpu/builder/dot.cpp

@@ -262,10 +262,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Dot);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_dot_cpp() {}
-#endif
+            void register_builders_dot_cpp() { REGISTER_OP_BUILDER(Dot); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/dropout.cpp

@@ -126,10 +126,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Dropout);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_dropout_cpp() {}
-#endif
+            void register_builders_dropout_cpp() { REGISTER_OP_BUILDER(Dropout); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/embedding_lookup.cpp

@@ -244,10 +244,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(EmbeddingLookup);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_embedding_lookup_cpp() {}
-#endif
+            void register_builders_embedding_lookup_cpp() { REGISTER_OP_BUILDER(EmbeddingLookup); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/erf.cpp

@@ -71,10 +71,8 @@ namespace ngraph
                     functors.emplace_back(functor);
                 }
             }
-            REGISTER_OP_BUILDER(Erf);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_erf_cpp() {}
-#endif
+
+            void register_builders_erf_cpp() { REGISTER_OP_BUILDER(Erf); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/gather.cpp

@@ -236,10 +236,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Gather);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_gather_cpp() {}
-#endif
+            void register_builders_gather_cpp() { REGISTER_OP_BUILDER(Gather); }
         } // namespace cpu
     }     // namespace runtime
 } // namespace ngraph

src/ngraph/runtime/cpu/builder/gather_nd.cpp

@@ -138,10 +138,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(GatherND);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_gather_nd_cpp() {}
-#endif
+            void register_builders_gather_nd_cpp() { REGISTER_OP_BUILDER(GatherND); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/get_output_element.cpp

@@ -47,10 +47,10 @@ namespace ngraph
                 return;
             }
 
-            REGISTER_OP_BUILDER(GetOutputElement);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_get_output_element_cpp() {}
-#endif
+            void register_builders_get_output_element_cpp()
+            {
+                REGISTER_OP_BUILDER(GetOutputElement);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/leaky_relu.cpp

@@ -85,10 +85,8 @@ namespace ngraph
                     functors.emplace_back(functor);
                 }
             }
-            REGISTER_OP_BUILDER(CPULeakyRelu);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_leaky_relu_cpp() {}
-#endif
+
+            void register_builders_leaky_relu_cpp() { REGISTER_OP_BUILDER(CPULeakyRelu); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/lrn.cpp

@@ -122,10 +122,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(LRN);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_lrn_cpp() {}
-#endif
+            void register_builders_lrn_cpp() { REGISTER_OP_BUILDER(LRN); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/lstm.cpp

@@ -107,10 +107,8 @@ namespace ngraph
                 };
                 functors.emplace_back(functor);
             }
-            REGISTER_OP_BUILDER(Lstm);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_lstm_cpp() {}
-#endif
+
+            void register_builders_lstm_cpp() { REGISTER_OP_BUILDER(Lstm); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/matmul_bias.cpp

@@ -393,12 +393,12 @@ namespace ngraph
                             cg->get_transpose_arg1());
             }
 
-            REGISTER_OP_BUILDER(MatmulBias);
-            REGISTER_OP_BUILDER(BatchMatMul);
-            REGISTER_OP_BUILDER(BatchMatMulTranspose);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_matmul_bias_cpp() {}
-#endif
+            void register_builders_matmul_bias_cpp()
+            {
+                REGISTER_OP_BUILDER(MatmulBias);
+                REGISTER_OP_BUILDER(BatchMatMul);
+                REGISTER_OP_BUILDER(BatchMatMulTranspose);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/max.cpp

@@ -37,10 +37,7 @@ namespace ngraph
                 BUILD_REDUCTION_FUNCTOR(Max, max);
             }
 
-            REGISTER_OP_BUILDER(Max);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_max_cpp() {}
-#endif
+            void register_builders_max_cpp() { REGISTER_OP_BUILDER(Max); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/max_pool.cpp

@@ -333,13 +333,13 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(MaxPool);
-            REGISTER_OP_BUILDER(MaxPoolBackprop);
-            REGISTER_OP_BUILDER(MaxPoolWithIndices);
-            REGISTER_OP_BUILDER(MaxPoolWithIndicesBackprop);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_max_pool_cpp() {}
-#endif
+            void register_builders_max_pool_cpp()
+            {
+                REGISTER_OP_BUILDER(MaxPool);
+                REGISTER_OP_BUILDER(MaxPoolBackprop);
+                REGISTER_OP_BUILDER(MaxPoolWithIndices);
+                REGISTER_OP_BUILDER(MaxPoolWithIndicesBackprop);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/min.cpp

@@ -37,10 +37,7 @@ namespace ngraph
                 BUILD_REDUCTION_FUNCTOR(Min, min);
             }
 
-            REGISTER_OP_BUILDER(Min);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_min_cpp() {}
-#endif
+            void register_builders_min_cpp() { REGISTER_OP_BUILDER(Min); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/one_hot.cpp

@@ -108,10 +108,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(OneHot);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_one_hot_cpp() {}
-#endif
+            void register_builders_one_hot_cpp() { REGISTER_OP_BUILDER(OneHot); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/pad.cpp

@@ -112,8 +112,6 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Pad);
-
             template <>
             NodeExecutorTy Builder::BUILDER_CF_DECL(ngraph::op::Pad)
             {
@@ -170,10 +168,12 @@ namespace ngraph
                     return functor;
                 }
             }
-            REGISTER_CF_BUILDER(Pad);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_pad_cpp() {}
-#endif
+
+            void register_builders_pad_cpp()
+            {
+                REGISTER_OP_BUILDER(Pad);
+                REGISTER_CF_BUILDER(Pad);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/product.cpp

@@ -37,10 +37,7 @@ namespace ngraph
                 BUILD_REDUCTION_FUNCTOR(Product, product);
             }
 
-            REGISTER_OP_BUILDER(Product);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_product_cpp() {}
-#endif
+            void register_builders_product_cpp() { REGISTER_OP_BUILDER(Product); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/quantization.cpp

@@ -583,11 +583,11 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Dequantize);
-            REGISTER_OP_BUILDER(Quantize);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_quantization_cpp() {}
-#endif
+            void register_builders_quantization_cpp()
+            {
+                REGISTER_OP_BUILDER(Dequantize);
+                REGISTER_OP_BUILDER(Quantize);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/quantized_conv.cpp

@@ -703,14 +703,14 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(QuantizedConvolution);
-            REGISTER_OP_BUILDER(QuantizedConvolutionRelu);
-            REGISTER_OP_BUILDER(QuantizedConvolutionBias);
-            REGISTER_OP_BUILDER(QuantizedConvolutionBiasAdd);
-            REGISTER_OP_BUILDER(QuantizedConvolutionBiasSignedAdd);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_quantized_conv_cpp() {}
-#endif
+            void register_builders_quantized_conv_cpp()
+            {
+                REGISTER_OP_BUILDER(QuantizedConvolution);
+                REGISTER_OP_BUILDER(QuantizedConvolutionRelu);
+                REGISTER_OP_BUILDER(QuantizedConvolutionBias);
+                REGISTER_OP_BUILDER(QuantizedConvolutionBiasAdd);
+                REGISTER_OP_BUILDER(QuantizedConvolutionBiasSignedAdd);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/quantized_dot.cpp

@@ -258,11 +258,12 @@ namespace ngraph
                     functors.emplace_back(functor);
                 }
             }
-            REGISTER_OP_BUILDER(QuantizedDotBias);
-            REGISTER_OP_BUILDER(QuantizedDot);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_quantized_dot_cpp() {}
-#endif
+
+            void register_builders_quantized_dot_cpp()
+            {
+                REGISTER_OP_BUILDER(QuantizedDotBias);
+                REGISTER_OP_BUILDER(QuantizedDot);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/quantized_matmul.cpp

@@ -101,10 +101,8 @@ namespace ngraph
                     throw ngraph_error("Unsupported QuantizedMatmul");
                 }
             }
-            REGISTER_OP_BUILDER(QuantizedMatmul);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_quantized_matmul_cpp() {}
-#endif
+
+            void register_builders_quantized_matmul_cpp() { REGISTER_OP_BUILDER(QuantizedMatmul); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/reduce_function.cpp

@@ -82,11 +82,11 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Any);
-            REGISTER_OP_BUILDER(All);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_reduce_function_cpp() {}
-#endif
+            void register_builders_reduce_function_cpp()
+            {
+                REGISTER_OP_BUILDER(Any);
+                REGISTER_OP_BUILDER(All);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/relu.cpp

@@ -132,11 +132,11 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Relu);
-            REGISTER_OP_BUILDER(ReluBackprop);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_relu_cpp() {}
-#endif
+            void register_builders_relu_cpp()
+            {
+                REGISTER_OP_BUILDER(Relu);
+                REGISTER_OP_BUILDER(ReluBackprop);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/replace_slice.cpp

@@ -134,10 +134,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(ReplaceSlice);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_replace_slice_cpp() {}
-#endif
+            void register_builders_replace_slice_cpp() { REGISTER_OP_BUILDER(ReplaceSlice); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/reshape.cpp

@@ -160,7 +160,6 @@ namespace ngraph
                 }
                 return functor;
             }
-            REGISTER_CF_BUILDER(Reshape);
 
             template <>
             void Builder::BUILDER_DECL(ngraph::op::Reshape)
@@ -247,10 +246,11 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Reshape);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_reshape_cpp() {}
-#endif
+            void register_builders_reshape_cpp()
+            {
+                REGISTER_CF_BUILDER(Reshape);
+                REGISTER_OP_BUILDER(Reshape);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/reverse.cpp

@@ -62,10 +62,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Reverse);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_reverse_cpp() {}
-#endif
+            void register_builders_reverse_cpp() { REGISTER_OP_BUILDER(Reverse); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/reverse_sequence.cpp

@@ -79,10 +79,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(ReverseSequence);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_reverse_sequence_cpp() {}
-#endif
+            void register_builders_reverse_sequence_cpp() { REGISTER_OP_BUILDER(ReverseSequence); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/rnn.cpp

@@ -102,10 +102,8 @@ namespace ngraph
                 };
                 functors.emplace_back(functor);
             }
-            REGISTER_OP_BUILDER(Rnn);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_rnn_cpp() {}
-#endif
+
+            void register_builders_rnn_cpp() { REGISTER_OP_BUILDER(Rnn); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/scatter_add.cpp

@@ -139,10 +139,8 @@ namespace ngraph
                     }
                 }
             }
-            REGISTER_OP_BUILDER(ScatterAdd);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_scatter_add_cpp() {}
-#endif
+
+            void register_builders_scatter_add_cpp() { REGISTER_OP_BUILDER(ScatterAdd); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/scatter_nd_add.cpp

@@ -156,10 +156,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(ScatterNDAdd);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_scatter_nd_add_cpp() {}
-#endif
+            void register_builders_scatter_nd_add_cpp() { REGISTER_OP_BUILDER(ScatterNDAdd); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/select.cpp

@@ -62,10 +62,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Select);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_select_cpp() {}
-#endif
+            void register_builders_select_cpp() { REGISTER_OP_BUILDER(Select); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/sigmoid.cpp

@@ -185,13 +185,13 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(Sigmoid);
-            REGISTER_OP_BUILDER(SigmoidBackprop);
-            REGISTER_OP_BUILDER(SigmoidMultiply);
-            REGISTER_OP_BUILDER(SigmoidMultiplyBackprop);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_sigmoid_cpp() {}
-#endif
+            void register_builders_sigmoid_cpp()
+            {
+                REGISTER_OP_BUILDER(Sigmoid);
+                REGISTER_OP_BUILDER(SigmoidBackprop);
+                REGISTER_OP_BUILDER(SigmoidMultiply);
+                REGISTER_OP_BUILDER(SigmoidMultiplyBackprop);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/builder/slice.cpp

@@ -187,10 +187,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Slice);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_slice_cpp() {}
-#endif
+            void register_builders_slice_cpp() { REGISTER_OP_BUILDER(Slice); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/softmax.cpp

@@ -195,10 +195,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Softmax);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_softmax_cpp() {}
-#endif
+            void register_builders_softmax_cpp() { REGISTER_OP_BUILDER(Softmax); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/state.cpp

@@ -139,10 +139,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(GenerateMask);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_state_cpp() {}
-#endif
+            void register_builders_state_cpp() { REGISTER_OP_BUILDER(GenerateMask); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/sum.cpp

@@ -37,10 +37,7 @@ namespace ngraph
                 BUILD_REDUCTION_FUNCTOR(Sum, sum);
             }
 
-            REGISTER_OP_BUILDER(Sum);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_sum_cpp() {}
-#endif
+            void register_builders_sum_cpp() { REGISTER_OP_BUILDER(Sum); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/tile.cpp

@@ -75,10 +75,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(Tile);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_tile_cpp() {}
-#endif
+            void register_builders_tile_cpp() { REGISTER_OP_BUILDER(Tile); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/topk.cpp

@@ -210,10 +210,7 @@ namespace ngraph
                 functors.emplace_back(functor);
             }
 
-            REGISTER_OP_BUILDER(TopK);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_topk_cpp() {}
-#endif
+            void register_builders_topk_cpp() { REGISTER_OP_BUILDER(TopK); }
         }
     }
 }

src/ngraph/runtime/cpu/builder/update_slice.cpp

@@ -124,10 +124,7 @@ namespace ngraph
                 }
             }
 
-            REGISTER_OP_BUILDER(UpdateSlice);
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-            void register_builders_update_slice_cpp() {}
-#endif
+            void register_builders_update_slice_cpp() { REGISTER_OP_BUILDER(UpdateSlice); }
         }
     }
 }

src/ngraph/runtime/cpu/cpu_backend.cpp

@@ -17,9 +17,11 @@
 #include <tbb/tbb_stddef.h>
 
 #include "cpu_backend_visibility.h"
+
 #include "ngraph/graph_util.hpp"
 #include "ngraph/runtime/backend_manager.hpp"
 #include "ngraph/runtime/cpu/cpu_backend.hpp"
+#include "ngraph/runtime/cpu/cpu_builder_registry.hpp"
 #include "ngraph/runtime/cpu/cpu_call_frame.hpp"
 #include "ngraph/runtime/cpu/cpu_external_function.hpp"
 #include "ngraph/runtime/cpu/cpu_tensor_view.hpp"
@@ -40,8 +42,13 @@ runtime::BackendConstructor* runtime::cpu::get_backend_constructor_pointer()
     public:
         std::shared_ptr<runtime::Backend> create(const std::string& config) override
         {
-            // Force TBB to link to the backend
-            tbb::TBB_runtime_interface_version();
+            static bool s_is_initialized = false;
+            if (!s_is_initialized)
+            {
+                s_is_initialized = true;
+                tbb::TBB_runtime_interface_version();
+                ngraph::runtime::cpu::register_builders();
+            }
             return make_shared<runtime::cpu::CPU_Backend>();
         }
     };
@@ -86,7 +93,6 @@ runtime::cpu::CPU_Backend::~CPU_Backend()
 {
     m_exec_map.clear();
 }
-
 shared_ptr<runtime::cpu::CPU_CallFrame> runtime::cpu::CPU_Backend::make_call_frame(
     const shared_ptr<runtime::cpu::CPU_ExternalFunction>& external_function,
     ngraph::pass::PassConfig& pass_config,
@@ -239,7 +245,6 @@ bool runtime::cpu::CPU_Backend::is_supported(const Node& op) const
 {
     return true;
 }
-
 bool runtime::cpu::CPU_Backend::is_supported_property(const Property prop) const
 {
     if (prop == Property::memory_attach)

src/ngraph/runtime/cpu/cpu_builder.cpp

@@ -614,66 +614,69 @@ namespace ngraph
                 return build_cf_dispatcher_cpu;
             }
 
-            REGISTER_OP_BUILDER(Constant);
-            REGISTER_OP_BUILDER(Result);
-            REGISTER_OP_BUILDER(Subtract);
-            REGISTER_OP_BUILDER(Multiply);
-            REGISTER_OP_BUILDER(Divide);
-            REGISTER_OP_BUILDER(Power);
-            REGISTER_OP_BUILDER(Abs);
-            REGISTER_OP_BUILDER(Acos);
-            REGISTER_OP_BUILDER(Asin);
-            REGISTER_OP_BUILDER(Atan);
-            REGISTER_OP_BUILDER(Ceiling);
-            REGISTER_OP_BUILDER(Cos);
-            REGISTER_OP_BUILDER(Cosh)
-            REGISTER_OP_BUILDER(Floor);
-            REGISTER_OP_BUILDER(Negative);
-            REGISTER_OP_BUILDER(Exp);
-            REGISTER_OP_BUILDER(Log);
-            REGISTER_OP_BUILDER(Sqrt);
-            REGISTER_OP_BUILDER(Sign);
-            REGISTER_OP_BUILDER(Sin);
-            REGISTER_OP_BUILDER(Sinh);
-            REGISTER_OP_BUILDER(Tan);
-            REGISTER_OP_BUILDER(Tanh);
-
-            REGISTER_OP_BUILDER(Not);
-            REGISTER_OP_BUILDER(Equal);
-            REGISTER_OP_BUILDER(NotEqual);
-            REGISTER_OP_BUILDER(Greater);
-            REGISTER_OP_BUILDER(GreaterEq);
-            REGISTER_OP_BUILDER(Less);
-            REGISTER_OP_BUILDER(LessEq);
-            REGISTER_OP_BUILDER(Maximum);
-            REGISTER_OP_BUILDER(Minimum);
-            REGISTER_OP_BUILDER(And);
-            REGISTER_OP_BUILDER(Or);
-            REGISTER_OP_BUILDER(Xor);
-
-            REGISTER_CF_BUILDER(Add);
-            REGISTER_CF_BUILDER(Subtract);
-            REGISTER_CF_BUILDER(Multiply);
-            REGISTER_CF_BUILDER(Divide);
-            REGISTER_CF_BUILDER(Minimum);
-            REGISTER_CF_BUILDER(Maximum);
-            REGISTER_CF_BUILDER(Abs);
-            REGISTER_CF_BUILDER(Negative);
-            REGISTER_CF_BUILDER(Relu);
-            REGISTER_CF_BUILDER(Sqrt);
-            REGISTER_CF_BUILDER(Floor);
-            REGISTER_CF_BUILDER(Ceiling);
-            REGISTER_CF_BUILDER(Equal);
-            REGISTER_CF_BUILDER(NotEqual);
-            REGISTER_CF_BUILDER(Greater);
-            REGISTER_CF_BUILDER(GreaterEq);
-            REGISTER_CF_BUILDER(Less);
-            REGISTER_CF_BUILDER(LessEq);
-            REGISTER_CF_BUILDER(And);
-            REGISTER_CF_BUILDER(Or);
-            REGISTER_CF_BUILDER(Xor);
-            REGISTER_CF_BUILDER(Sign);
-            REGISTER_CF_BUILDER(Not);
+            void register_cpu_builders()
+            {
+                REGISTER_OP_BUILDER(Constant);
+                REGISTER_OP_BUILDER(Result);
+                REGISTER_OP_BUILDER(Subtract);
+                REGISTER_OP_BUILDER(Multiply);
+                REGISTER_OP_BUILDER(Divide);
+                REGISTER_OP_BUILDER(Power);
+                REGISTER_OP_BUILDER(Abs);
+                REGISTER_OP_BUILDER(Acos);
+                REGISTER_OP_BUILDER(Asin);
+                REGISTER_OP_BUILDER(Atan);
+                REGISTER_OP_BUILDER(Ceiling);
+                REGISTER_OP_BUILDER(Cos);
+                REGISTER_OP_BUILDER(Cosh);
+                REGISTER_OP_BUILDER(Floor);
+                REGISTER_OP_BUILDER(Negative);
+                REGISTER_OP_BUILDER(Exp);
+                REGISTER_OP_BUILDER(Log);
+                REGISTER_OP_BUILDER(Sqrt);
+                REGISTER_OP_BUILDER(Sign);
+                REGISTER_OP_BUILDER(Sin);
+                REGISTER_OP_BUILDER(Sinh);
+                REGISTER_OP_BUILDER(Tan);
+                REGISTER_OP_BUILDER(Tanh);
+
+                REGISTER_OP_BUILDER(Not);
+                REGISTER_OP_BUILDER(Equal);
+                REGISTER_OP_BUILDER(NotEqual);
+                REGISTER_OP_BUILDER(Greater);
+                REGISTER_OP_BUILDER(GreaterEq);
+                REGISTER_OP_BUILDER(Less);
+                REGISTER_OP_BUILDER(LessEq);
+                REGISTER_OP_BUILDER(Maximum);
+                REGISTER_OP_BUILDER(Minimum);
+                REGISTER_OP_BUILDER(And);
+                REGISTER_OP_BUILDER(Or);
+                REGISTER_OP_BUILDER(Xor);
+
+                REGISTER_CF_BUILDER(Add);
+                REGISTER_CF_BUILDER(Subtract);
+                REGISTER_CF_BUILDER(Multiply);
+                REGISTER_CF_BUILDER(Divide);
+                REGISTER_CF_BUILDER(Minimum);
+                REGISTER_CF_BUILDER(Maximum);
+                REGISTER_CF_BUILDER(Abs);
+                REGISTER_CF_BUILDER(Negative);
+                REGISTER_CF_BUILDER(Relu);
+                REGISTER_CF_BUILDER(Sqrt);
+                REGISTER_CF_BUILDER(Floor);
+                REGISTER_CF_BUILDER(Ceiling);
+                REGISTER_CF_BUILDER(Equal);
+                REGISTER_CF_BUILDER(NotEqual);
+                REGISTER_CF_BUILDER(Greater);
+                REGISTER_CF_BUILDER(GreaterEq);
+                REGISTER_CF_BUILDER(Less);
+                REGISTER_CF_BUILDER(LessEq);
+                REGISTER_CF_BUILDER(And);
+                REGISTER_CF_BUILDER(Or);
+                REGISTER_CF_BUILDER(Xor);
+                REGISTER_CF_BUILDER(Sign);
+                REGISTER_CF_BUILDER(Not);
+            }
         }
     }
 }

src/ngraph/runtime/cpu/cpu_builder.hpp

@@ -374,48 +374,24 @@
     return functor;
 
 #define REGISTER_OP_BUILDER(OP)                                                                    \
-    static struct __register_##OP##_builder                                                        \
-    {                                                                                              \
-        __register_##OP##_builder()                                                                \
-        {                                                                                          \
-            GetGlobalBuildDispatcher().insert({type_index(typeid(ngraph::op::OP)),                 \
-                                               &runtime::cpu::Builder::build<ngraph::op::OP>});    \
-        }                                                                                          \
-    } __register_##OP##_builder_instance;
+    GetGlobalBuildDispatcher().insert(                                                             \
+        {type_index(typeid(ngraph::op::OP)), &runtime::cpu::Builder::build<ngraph::op::OP>})
 
 #define REGISTER_CPU_OP_BUILDER(OP)                                                                \
-    static struct __register_##OP##_builder                                                        \
-    {                                                                                              \
-        __register_##OP##_builder()                                                                \
-        {                                                                                          \
-            GetGlobalBuildDispatcher().insert(                                                     \
-                {type_index(typeid(ngraph::runtime::cpu::op::OP)),                                 \
-                 &runtime::cpu::Builder::build<ngraph::runtime::cpu::op::OP>});                    \
-        }                                                                                          \
-    } __register_##OP##_builder_instance;
+    GetGlobalBuildDispatcher().insert(                                                             \
+        {type_index(typeid(ngraph::runtime::cpu::op::OP)),                                         \
+         &runtime::cpu::Builder::build<ngraph::runtime::cpu::op::OP>})
 
 #define BUILDER_CF_DECL(op_name) CFbuild<op_name>(const ngraph::Node* node)
 
 #define REGISTER_CF_BUILDER(OP)                                                                    \
-    static struct __register_##OP##_cf_builder                                                     \
-    {                                                                                              \
-        __register_##OP##_cf_builder()                                                             \
-        {                                                                                          \
-            GetGlobalCFDispatcherCPU().insert({type_index(typeid(ngraph::op::OP)),                 \
-                                               &runtime::cpu::Builder::CFbuild<ngraph::op::OP>});  \
-        }                                                                                          \
-    } __register_##OP##_cf_builder_instance;
+    GetGlobalCFDispatcherCPU().insert(                                                             \
+        {type_index(typeid(ngraph::op::OP)), &runtime::cpu::Builder::CFbuild<ngraph::op::OP>})
 
 #define REGISTER_CPU_CF_BUILDER(OP)                                                                \
-    static struct __register_##OP##_cf_builder                                                     \
-    {                                                                                              \
-        __register_##OP##_cf_builder()                                                             \
-        {                                                                                          \
-            GetGlobalCFDispatcherCPU().insert(                                                     \
-                {type_index(typeid(ngraph::runtime::cpu::op::OP)),                                 \
-                 &runtime::cpu::Builder::CFbuild<ngraph::runtime::cpu::op::OP>});                  \
-        }                                                                                          \
-    } __register_##OP##_cf_builder_instance;
+    GetGlobalCFDispatcherCPU().insert(                                                             \
+        {type_index(typeid(ngraph::runtime::cpu::op::OP)),                                         \
+         &runtime::cpu::Builder::CFbuild<ngraph::runtime::cpu::op::OP>})
 
 namespace ngraph
 {

src/ngraph/runtime/cpu/cpu_builder_registry.cpp

@@ -15,7 +15,6 @@
 //*****************************************************************************
 #include "ngraph/runtime/cpu/cpu_builder_registry.hpp"
 
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
 namespace ngraph
 {
     namespace runtime
@@ -76,8 +75,8 @@ namespace ngraph
                 register_builders_tile_cpp();
                 register_builders_topk_cpp();
                 register_builders_update_slice_cpp();
+                register_cpu_builders();
             }
         }
     }
 }
-#endif

src/ngraph/runtime/cpu/cpu_builder_registry.hpp

@@ -15,7 +15,6 @@
 //*****************************************************************************
 #pragma once
 
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
 namespace ngraph
 {
     namespace runtime
@@ -75,7 +74,7 @@ namespace ngraph
             void register_builders_tile_cpp();
             void register_builders_topk_cpp();
             void register_builders_update_slice_cpp();
+            void register_cpu_builders();
         }
     }
 }
-#endif

src/ngraph/runtime/cpu/cpu_emitter.hpp

@@ -33,10 +33,137 @@
 
 namespace ngraph
 {
+    namespace op
+    {
+        class Add;
+        class AllReduce;
+        class BroadcastDistributed;
+        class MatmulBias;
+        class BatchMatMul;
+        class BatchMatMulTranspose;
+        class Lstm;
+        class Rnn;
+        class BatchNormTraining;
+        class BatchNormInference;
+        class BatchNormTrainingRelu;
+        class BatchNormInferenceRelu;
+        class BatchNormTrainingBackprop;
+        class Dot;
+        class Multiply;
+        class GetOutputElement;
+        class Abs;
+        class Concat;
+        class Divide;
+        class Equal;
+        class Greater;
+        class GreaterEq;
+        class Less;
+        class LessEq;
+        class Any;
+        class All;
+        class LRN;
+        class Log;
+        class Maximum;
+        class Minimum;
+        class Negative;
+        class NotEqual;
+        class Select;
+        class Subtract;
+        class Broadcast;
+        class Convert;
+        class Constant;
+        class Reshape;
+        class Sign;
+        class Slice;
+        class Sum;
+        class Exp;
+        class EmbeddingLookup;
+        class Sin;
+        class Sinh;
+        class Cos;
+        class Cosh;
+        class Tan;
+        class Tanh;
+        class Asin;
+        class Atan;
+        class ArgMin;
+        class ArgMax;
+        class TopK;
+        class Gather;
+        class GatherND;
+        class ScatterAdd;
+        class ScatterNDAdd;
+        class Power;
+        class UpdateSlice;
+        class ReplaceSlice;
+        class OneHot;
+        class Ceiling;
+        class Floor;
+        class Sqrt;
+        class ConvolutionRelu;
+        class QuantizedConvolutionRelu;
+        class QuantizedConvolution;
+        class GroupConvolution;
+        class GroupConvolutionBias;
+        class Convolution;
+        class ConvolutionBackpropFilters;
+        class DeconvolutionBias;
+        class ConvolutionBackpropData;
+        class QuantizedConvolutionBias;
+        class QuantizedConvolutionBiasAdd;
+        class QuantizedConvolutionBiasSignedAdd;
+        class QuantizedDotBias;
+        class QuantizedDot;
+        class QuantizedMatmul;
+        class ConvolutionBias;
+        class ConvolutionBiasAdd;
+        class ConvolutionAdd;
+        class ConvolutionBiasBackpropFiltersBias;
+        class Not;
+        class QuantizedMaxPool;
+        class QuantizedAvgPool;
+        class MaxPoolWithIndices;
+        class Reverse;
+        class ReverseSequence;
+        class AvgPool;
+        class Pad;
+        class AvgPoolBackprop;
+        class MaxPoolBackprop;
+        class MaxPoolWithIndicesBackprop;
+        class Product;
+        class Max;
+        class Erf;
+        class Min;
+        class ReluBackprop;
+        class Relu;
+        class CPULeakyRelu;
+        class BoundedRelu;
+        class Sigmoid;
+        class SigmoidBackprop;
+        class SigmoidMultiply;
+        class SigmoidMultiplyBackprop;
+        class Softmax;
+        class Result;
+        class And;
+        class Or;
+        class Xor;
+        class CompiledKernel;
+        class GenerateMask;
+        class Dropout;
+        class Dequantize;
+        class Quantize;
+        class QuantizedConcat;
+        class Tile;
+    }
     namespace runtime
     {
         namespace cpu
         {
+            namespace op
+            {
+                class ConvertLayout;
+            }
+
             class CPU_Emitter
             {
             public:
@@ -50,7 +177,6 @@ namespace ngraph
                     throw std::runtime_error("Unimplemented op '" + node->description() +
                                              "' in CPU emitter");
                 }
-
                 static void nop(CPU_ExternalFunction* external_function,
                                 CodeWriter& writer,
                                 const ngraph::Node* node,
@@ -79,6 +205,247 @@ namespace ngraph
                 static std::string emit_for_lt(const std::string& prefix, size_t index, size_t to);
                 static std::string emit_indices(const std::vector<std::string> indices);
             };
+
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Add);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::AllReduce);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BroadcastDistributed);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::MatmulBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchMatMul);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchMatMulTranspose);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Lstm);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Rnn);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchNormTraining);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchNormInference);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchNormTrainingRelu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchNormInferenceRelu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BatchNormTrainingBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Dot);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Multiply);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::GetOutputElement);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Abs);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Concat);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Divide);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Equal);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Greater);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::GreaterEq);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Less);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::LessEq);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Any);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::All);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::LRN);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Log);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Maximum);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Minimum);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Negative);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::NotEqual);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Select);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Subtract);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Broadcast);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Convert);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Constant);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Reshape);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Sign);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Slice);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Sum);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Exp);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::EmbeddingLookup);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Sin);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Sinh);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Cos);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Cosh);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Tan);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Tanh);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Asin);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Atan);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ArgMin);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ArgMax);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::TopK);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Gather);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::GatherND);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ScatterAdd);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ScatterNDAdd);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Power);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::UpdateSlice);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ReplaceSlice);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::OneHot);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Ceiling);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Floor);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Sqrt);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionRelu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedConvolutionRelu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedConvolution);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::GroupConvolution);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::GroupConvolutionBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Convolution);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionBackpropFilters);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::DeconvolutionBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionBackpropData);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedConvolutionBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedConvolutionBiasAdd);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedConvolutionBiasSignedAdd);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedDotBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedDot);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedMatmul);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionBiasAdd);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionAdd);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ConvolutionBiasBackpropFiltersBias);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Not);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedMaxPool);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedAvgPool);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::MaxPoolWithIndices);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Reverse);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ReverseSequence);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::AvgPool);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Pad);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::AvgPoolBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::MaxPoolBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::MaxPoolWithIndicesBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Product);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Max);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Erf);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Min);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::runtime::cpu::op::ConvertLayout);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::ReluBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Relu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::CPULeakyRelu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::BoundedRelu);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Sigmoid);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::SigmoidBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::SigmoidMultiply);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::SigmoidMultiplyBackprop);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Softmax);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Result);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::And);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Or);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Xor);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::CompiledKernel);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::GenerateMask);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Dropout);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Dequantize);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Quantize);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::QuantizedConcat);
+            template <>
+            void CPU_Emitter::EMITTER_DECL(ngraph::op::Tile);
         }
     }
 }

src/ngraph/runtime/cpu/cpu_external_function.cpp

@@ -1374,11 +1374,6 @@ void runtime::cpu::CPU_ExternalFunction::build(ngraph::pass::PassConfig& pass_co
             "enabled due to concurrent graph execution");
     }
 
-// reference all the builders for static library
-#ifdef NGRAPH_CPU_STATIC_LIB_ENABLE
-    ngraph::runtime::cpu::register_builders();
-#endif
-
     // stream writer to dump the debug manifest for the DEX
     static const string s_debug_dir = "cpu_codegen";
     static StaticInitializers s_static_initializers(s_debug_dir);