Kanvi/remove additional attr check

ngraph_bridge/CMakeLists.txt

@@ -35,7 +35,6 @@ set(SRC
    ngraph_assign_clusters.cc
    ngraph_builder.cc
    ngraph_backend_manager.cc
-   ngraph_backend_config.cc
    ngraph_capture_variables.cc
    ngraph_cluster_manager.cc
    ngraph_deassign_clusters.cc

ngraph_bridge/enable_variable_ops/ops/ngraph_ops.cc

@@ -81,6 +81,7 @@ REGISTER_OP("NGraphEncapsulate")
     .Attr("ngraph_cluster: int")
     .Attr("ngraph_graph_id: int")
     .Attr("ngraph_backend: string")
+    .Attr("ngraph_device_id: string")
     .SetIsStateful()
     .Doc("nGraph Encapsulation Op. For use by the nGraph JIT only.");
 

ngraph_bridge/grappler/ngraph_optimizer.cc

@@ -43,22 +43,22 @@ namespace ngraph_bridge {
 Status NgraphOptimizer::Init(
     const tensorflow::RewriterConfig_CustomGraphOptimizer* config) {
   const auto params = config->parameter_map();
-  if (params.count("ngraph_backend")) {
-    config_backend_name = params.at("ngraph_backend").s();
-    NGRAPH_VLOG(3) << config_backend_name;
-    std::vector<std::string> additional_attributes =
-        BackendManager::GetBackendAdditionalAttributes(config_backend_name);
-    for (size_t i = 0; i < additional_attributes.size(); i++) {
-      if (params.count(additional_attributes[i])) {
-        config_map["_ngraph_" + additional_attributes[i]] =
-            params.at(additional_attributes[i]).s();
-        NGRAPH_VLOG(3) << additional_attributes[i] << " "
-                       << config_map["_ngraph_" + additional_attributes[i]];
-      }
+  for (size_t i = 0; i < compulsory_attrs.size(); i++) {
+    if (params.count(compulsory_attrs[i]) == 0) {
+      NGRAPH_VLOG(0) << "NGTF_OPTIMIZER: Compulsory attribute "
+                     << compulsory_attrs[i] << " not found.";
+      return errors::Internal("NGTF_OPTIMIZER: Missing compulsory attributes.");
+    }
+  }
+  config_backend_name = params.at("ngraph_backend").s();
+  NGRAPH_VLOG(3) << "Backend name from config: " << config_backend_name;
+  for (auto i : params) {
+    if (i.first != "ngraph_backend") {
+      config_map[(i.first == "device_id" ? "" : "_") + std::string("ngraph_") +
+                 i.first] = i.second.s();
+      NGRAPH_VLOG(3) << "Attribute: " << i.first
+                     << " Value: " << config_map["_ngraph_" + i.first];
     }
-  } else {
-    NGRAPH_VLOG(5)
-        << "NGTF_OPTIMIZER: parameter_map does not have ngraph_backend";
   }
   return Status::OK();
 }
@@ -194,7 +194,7 @@ Status NgraphOptimizer::Optimize(tensorflow::grappler::Cluster* cluster,
   }
 
   // Get backend + its configurations, to be attached to the nodes
-  // Precedence Order: RewriteConfig > Env Variable > BackendManager
+  // using RewriteConfig
   string backend_name;
   if (!config_backend_name.empty()) {
     if (!BackendManager::IsSupportedBackend(config_backend_name)) {
@@ -203,16 +203,6 @@ Status NgraphOptimizer::Optimize(tensorflow::grappler::Cluster* cluster,
     }
     backend_name = config_backend_name;
     NGRAPH_VLOG(1) << "Setting backend from the RewriteConfig " << backend_name;
-  } else {
-    TF_RETURN_IF_ERROR(
-        BackendManager::GetCurrentlySetBackendName(&backend_name));
-    // splits into {"ngraph_backend", "_ngraph_device_config"}
-    config_map = BackendManager::GetBackendAttributeValues(
-        backend_name);  // SplitBackendConfig
-    backend_name = config_map.at("ngraph_backend");
-    // config_map in EncapsulateClusters is not expected to contain
-    // ngraph_backend
-    config_map.erase("ngraph_backend");
   }
   NGRAPH_VLOG(0) << "NGraph using backend: " << backend_name;
 

ngraph_bridge/grappler/ngraph_optimizer.h

@@ -74,6 +74,7 @@ class NgraphOptimizer : public tensorflow::grappler::CustomGraphOptimizer {
  private:
   std::string config_backend_name;
   std::unordered_map<std::string, std::string> config_map;
+  std::vector<string> compulsory_attrs = {"ngraph_backend", "device_id"};
 
   void DumpGraphs(Graph&, int, std::string, std::string);
 

ngraph_bridge/ngraph_backend_manager.cc

@@ -34,9 +34,6 @@ map<string, Backend*> BackendManager::ng_backend_map_;
 mutex BackendManager::ng_backend_map_mutex_;
 map<std::string, int> BackendManager::ref_count_each_backend_;
 
-unordered_map<string, std::unique_ptr<BackendConfig>>
-    BackendManager::ng_backendconfig_map_;
-
 Status BackendManager::SetBackendName(const string& backend_name) {
   std::lock_guard<std::mutex> lock(BackendManager::ng_backend_name_mutex_);
   if (backend_name.empty() || !IsSupportedBackend(backend_name)) {
@@ -171,53 +168,37 @@ Status BackendManager::GetCurrentlySetBackendName(string* backend_name) {
   return Status::OK();
 };
 
-// Backend Config functions
-// BackendConfig is expected to be a readonly class
-// hence only locked at creation and not during later access
-std::unique_ptr<BackendConfig>& BackendManager::GetBackendConfig(
-    const string& backend_name) {
-  std::lock_guard<std::mutex> lock(BackendManager::ng_backend_map_mutex_);
-  auto itr = BackendManager::ng_backendconfig_map_.find(backend_name);
-  if (itr == BackendManager::ng_backendconfig_map_.end()) {
-    if (backend_name == "NNPI") {
-      BackendManager::ng_backendconfig_map_.insert(std::make_pair(
-          backend_name,
-          std::unique_ptr<BackendNNPIConfig>(new BackendNNPIConfig())));
-    }
-    if (backend_name == "INTERPRETER") {
-      BackendManager::ng_backendconfig_map_.insert(std::make_pair(
-          backend_name, std::unique_ptr<BackendInterpreterConfig>(
-                            new BackendInterpreterConfig())));
-    } else {
-      BackendManager::ng_backendconfig_map_.insert(std::make_pair(
-          backend_name,
-          std::unique_ptr<BackendConfig>(new BackendConfig(backend_name))));
-    }
-  }
-  return BackendManager::ng_backendconfig_map_.at(backend_name);
-}
-
-vector<string> BackendManager::GetBackendAdditionalAttributes(
-    const string& backend_name) {
-  return BackendManager::GetBackendConfig(backend_name)
-      ->GetAdditionalAttributes();
-}
-
+// Split
 unordered_map<string, string> BackendManager::GetBackendAttributeValues(
     const string& backend_config) {
   unordered_map<string, string> backend_parameters;
 
-  string backend_name = backend_config.substr(0, backend_config.find(':'));
-  NGRAPH_VLOG(3) << "Got Backend Name " << backend_name;
+  int delimiter_index = backend_config.find(':');
+  if (delimiter_index < 0) {
+    // ":" not found
+    backend_parameters["ngraph_backend"] = backend_config;
+    backend_parameters["ngraph_device_id"] = "";
+  } else {
+    backend_parameters["ngraph_backend"] =
+        backend_config.substr(0, delimiter_index);
+    backend_parameters["ngraph_device_id"] =
+        backend_config.substr(delimiter_index + 1);
+  }
+
+  NGRAPH_VLOG(3) << "Got Backend Name " << backend_parameters["ngraph_backend"];
+  NGRAPH_VLOG(3) << "Got Device Id  " << backend_parameters["ngraph_device_id"];
 
-  return BackendManager::GetBackendConfig(backend_name)->Split(backend_config);
+  return backend_parameters;
 }
 
-string BackendManager::GetBackendCreationString(
-    const string& backend_name,
-    const unordered_map<string, string>& additional_attribute_map) {
-  return BackendManager::GetBackendConfig(backend_name)
-      ->Join(additional_attribute_map);
+// Join
+string BackendManager::GetBackendCreationString(const string& backend_name,
+                                                const string& device_id) {
+  if (device_id != "") {
+    return backend_name + ":" + device_id;
+  } else {
+    return backend_name;
+  }
 }
 
 }  // namespace ngraph_bridge