diff --git a/et_feeder/et_feeder_node.cpp b/et_feeder/et_feeder_node.cpp
index fa5bb3d..fc71a00 100644
--- a/et_feeder/et_feeder_node.cpp
+++ b/et_feeder/et_feeder_node.cpp
@@ -1,5 +1,7 @@
 #include "et_feeder/et_feeder_node.h"
 
+#include <exception>
+
 using namespace std;
 using namespace Chakra;
 
@@ -7,31 +9,43 @@ ETFeederNode::ETFeederNode(std::shared_ptr<ChakraProtoMsg::Node> node) {
   this->node_ = node;
   this->id_ = node->id();
   this->name_ = node->name();
-  this->runtime_ = node->duration_micros();
-  this->is_cpu_op_ = true;
+  this->runtime_.emplace(node->duration_micros());
+
   for (int i = 0; i < node->attr_size(); i++) {
     string attr_name = node->attr(i).name();
-    if (attr_name == "is_cpu_op") {
-      assign_attr_val(node, i, (void*)(&is_cpu_op_));
-    } else if (attr_name == "num_ops") {
-      assign_attr_val(node, i, (void*)(&num_ops_));
-    } else if (attr_name == "tensor_size") {
-      assign_attr_val(node, i, (void*)(&tensor_size_));
-    } else if (attr_name == "comm_type") {
-      assign_attr_val(node, i, (void*)(&comm_type_));
-    } else if (attr_name == "involved_dim") {
-      assign_attr_val(node, i, (void*)(&involved_dim_));
-      involved_dim_size_ = node->attr(i).bool_list().values_size();
-    } else if (attr_name == "comm_priority") {
-      assign_attr_val(node, i, (void*)(&comm_priority_));
-    } else if (attr_name == "comm_size") {
-      assign_attr_val(node, i, (void*)(&comm_size_));
-    } else if (attr_name == "comm_src") {
-      assign_attr_val(node, i, (void*)(&comm_src_));
-    } else if (attr_name == "comm_dst") {
-      assign_attr_val(node, i, (void*)(&comm_dst_));
-    } else if (attr_name == "comm_tag") {
-      assign_attr_val(node, i, (void*)(&comm_tag_));
+    try {
+      if (attr_name == "is_cpu_op") {
+        assign_attr_val(node->attr(i), static_cast<any>(&is_cpu_op_));
+      } else if (attr_name == "num_ops") {
+        assign_attr_val(node->attr(i), static_cast<any>(&num_ops_));
+      } else if (attr_name == "tensor_size") {
+        assign_attr_val(node->attr(i), static_cast<any>(&tensor_size_));
+      } else if (attr_name == "comm_type") {
+        // TODO: no type of attr fields for comm_type, and it is stored in
+        // int64_val()
+        comm_type_.emplace(static_cast<ChakraProtoMsg::CollectiveCommType>(
+            node->attr(i).int64_val()));
+      } else if (attr_name == "involved_dim") {
+        assign_attr_val(node->attr(i), static_cast<any>(&involved_dim_));
+        this->involved_dim_size_.emplace(
+            node->attr(i).bool_list().values_size());
+      } else if (attr_name == "comm_priority") {
+        assign_attr_val(node->attr(i), static_cast<any>(&comm_priority_));
+      } else if (attr_name == "comm_size") {
+        assign_attr_val(node->attr(i), static_cast<any>(&comm_size_));
+      } else if (attr_name == "comm_src") {
+        assign_attr_val(node->attr(i), static_cast<any>(&comm_src_));
+      } else if (attr_name == "comm_dst") {
+        assign_attr_val(node->attr(i), static_cast<any>(&comm_dst_));
+      } else if (attr_name == "comm_tag") {
+        assign_attr_val(node->attr(i), static_cast<any>(&comm_tag_));
+      } else {
+        throw runtime_error("unsupported attr");
+      }
+    } catch (const bad_any_cast& e) {
+      std::cerr << "Unmatch attr field type of: node=" << this->id_
+                << ", attr_name=" << attr_name << std::endl;
+      throw(e);
     }
   }
 }
@@ -68,136 +82,146 @@ void ETFeederNode::setDepUnresolvedParentIDs(
 }
 
 void ETFeederNode::assign_attr_val(
-    shared_ptr<ChakraProtoMsg::Node> node,
-    int i,
-    void* member) {
-  auto attr = node->attr(i);
-  switch (attr.value_case()) {
-    case ChakraProtoMsg::AttributeProto::kDoubleVal:
-      *((double*)member) = attr.double_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kDoubleList:
-      for (const auto& val : attr.double_list().values()) {
-        (*((std::vector<double>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kFloatVal:
-      *((float*)member) = attr.float_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kFloatList:
-      for (const auto& val : attr.float_list().values()) {
-        (*((std::vector<float>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kInt32Val:
-      *((int32_t*)member) = attr.int32_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kInt32List:
-      for (const auto& val : attr.int32_list().values()) {
-        (*((std::vector<int32_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kInt64Val:
-      *((int64_t*)member) = attr.int64_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kInt64List:
-      for (const auto& val : attr.int64_list().values()) {
-        (*((std::vector<int64_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kUint32Val:
-      *((uint32_t*)member) = attr.uint32_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kUint32List:
-      for (const auto& val : attr.uint32_list().values()) {
-        (*((std::vector<uint32_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kUint64Val:
-      *((uint64_t*)member) = attr.uint64_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kUint64List:
-      for (const auto& val : attr.uint64_list().values()) {
-        (*((std::vector<uint64_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kSint32Val:
-      *((int32_t*)member) = attr.sint32_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kSint32List:
-      for (const auto& val : attr.sint32_list().values()) {
-        (*((std::vector<int32_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kSint64Val:
-      *((int64_t*)member) = attr.sint64_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kSint64List:
-      for (const auto& val : attr.sint64_list().values()) {
-        (*((std::vector<int64_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kFixed32Val:
-      *((uint32_t*)member) = attr.fixed32_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kFixed32List:
-      for (const auto& val : attr.fixed32_list().values()) {
-        (*((std::vector<uint32_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kFixed64Val:
-      *((uint64_t*)member) = attr.fixed64_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kFixed64List:
-      for (const auto& val : attr.fixed64_list().values()) {
-        (*((std::vector<uint64_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kSfixed32Val:
-      *((int32_t*)member) = attr.sfixed32_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kSfixed32List:
-      for (const auto& val : attr.sfixed32_list().values()) {
-        (*((std::vector<int32_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kSfixed64Val:
-      *((int64_t*)member) = attr.sfixed64_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kSfixed64List:
-      for (const auto& val : attr.sfixed64_list().values()) {
-        (*((std::vector<int64_t>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kBoolVal:
-      *((bool*)member) = attr.bool_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kBoolList:
-      for (const auto& val : attr.bool_list().values()) {
-        (*((std::vector<bool>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kStringVal:
-      *((std::string*)member) = attr.string_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kStringList:
-      for (const auto& val : attr.string_list().values()) {
-        (*((std::vector<std::string>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::kBytesVal:
-      *((std::string*)member) = attr.bytes_val();
-      break;
-    case ChakraProtoMsg::AttributeProto::kBytesList:
-      for (const auto& val : attr.bytes_list().values()) {
-        (*((std::vector<std::string>*)member)).push_back(val);
-      }
-      break;
-    case ChakraProtoMsg::AttributeProto::VALUE_NOT_SET:
-    default:
-      std::cerr << "undefined attr type in chakra node" << std::endl;
-      exit(EXIT_FAILURE);
-      break;
+    const ChakraProtoMsg::AttributeProto& attr,
+    std::any member) {
+  const auto& value_type = attr.value_case();
+  if (value_type == ChakraProtoMsg::AttributeProto::kDoubleVal) {
+    auto typed_member = any_cast<optional<double>*>(member);
+    typed_member->emplace(attr.double_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kDoubleList) {
+    auto typed_member = any_cast<optional<vector<double>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.double_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kFloatVal) {
+    auto typed_member = any_cast<optional<float>*>(member);
+    typed_member->emplace(attr.float_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kFloatList) {
+    auto typed_member = any_cast<optional<vector<float>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.float_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kInt32Val) {
+    auto typed_member = any_cast<optional<int32_t>*>(member);
+    typed_member->emplace(attr.int32_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kInt32List) {
+    auto typed_member = any_cast<optional<vector<int32_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.int32_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kInt64Val) {
+    auto typed_member = any_cast<optional<int64_t>*>(member);
+    typed_member->emplace(attr.int64_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kInt64List) {
+    auto typed_member = any_cast<optional<vector<int64_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.int64_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kUint32Val) {
+    auto typed_member = any_cast<optional<uint32_t>*>(member);
+    typed_member->emplace(attr.uint32_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kUint32List) {
+    auto typed_member = any_cast<optional<vector<uint32_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.uint32_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kUint64Val) {
+    auto typed_member = any_cast<optional<uint64_t>*>(member);
+    typed_member->emplace(attr.uint64_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kUint64List) {
+    auto typed_member = any_cast<optional<vector<uint64_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.uint64_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSint32Val) {
+    auto typed_member = any_cast<optional<int32_t>*>(member);
+    typed_member->emplace(attr.sint32_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSint32List) {
+    auto typed_member = any_cast<optional<vector<int32_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.sint32_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSint64Val) {
+    auto typed_member = any_cast<optional<int64_t>*>(member);
+    typed_member->emplace(attr.sint64_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSint64List) {
+    auto typed_member = any_cast<optional<vector<int64_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.sint64_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kFixed32Val) {
+    auto typed_member = any_cast<optional<uint32_t>*>(member);
+    typed_member->emplace(attr.fixed32_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kFixed32List) {
+    auto typed_member = any_cast<optional<vector<uint32_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.fixed32_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kFixed64Val) {
+    auto typed_member = any_cast<optional<uint64_t>*>(member);
+    typed_member->emplace(attr.fixed64_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kFixed64List) {
+    auto typed_member = any_cast<optional<vector<uint64_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.fixed64_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSfixed32Val) {
+    auto typed_member = any_cast<optional<int32_t>*>(member);
+    typed_member->emplace(attr.sfixed32_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSfixed32List) {
+    auto typed_member = any_cast<optional<vector<int32_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.sfixed32_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSfixed64Val) {
+    auto typed_member = any_cast<optional<int64_t>*>(member);
+    typed_member->emplace(attr.sfixed64_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kSfixed64List) {
+    auto typed_member = any_cast<optional<vector<int64_t>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.sfixed64_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kBoolVal) {
+    auto typed_member = any_cast<optional<bool>*>(member);
+    typed_member->emplace(attr.bool_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kBoolList) {
+    auto typed_member = any_cast<optional<vector<bool>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.bool_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kStringVal) {
+    auto typed_member = any_cast<optional<string>*>(member);
+    typed_member->emplace(attr.string_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kStringList) {
+    auto typed_member = any_cast<optional<vector<string>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.string_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kBytesVal) {
+    auto typed_member = any_cast<optional<string>*>(member);
+    typed_member->emplace(attr.bytes_val());
+  } else if (value_type == ChakraProtoMsg::AttributeProto::kBytesList) {
+    auto typed_member = any_cast<optional<vector<string>>*>(member);
+    typed_member->emplace();
+    for (const auto& item : attr.bytes_list().values()) {
+      typed_member->value().push_back(item);
+    }
+  } else {
+    throw runtime_error("undefined attr type in chakra node ");
   }
 }
 
@@ -209,58 +233,257 @@ string ETFeederNode::name() {
   return name_;
 }
 
-bool ETFeederNode::is_cpu_op() {
-  return is_cpu_op_;
-}
-
 ChakraProtoMsg::NodeType ETFeederNode::type() {
   return node_->type();
 }
 
+bool ETFeederNode::is_cpu_op() {
+  if (this->is_cpu_op_.has_value())
+    return is_cpu_op_.value();
+  throw std::runtime_error(
+      "Asked for attr \"is_cpu_op\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
+}
+
 uint64_t ETFeederNode::runtime() {
-  return runtime_;
+  if (this->runtime_.has_value())
+    return this->runtime_.value();
+  throw std::runtime_error(
+      "Asked for attr \"runtime\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint64_t ETFeederNode::num_ops() {
-  return num_ops_;
+  if (this->num_ops_.has_value())
+    return this->num_ops_.value();
+  throw std::runtime_error(
+      "Asked for attr \"num_ops\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint32_t ETFeederNode::tensor_loc() {
-  return tensor_loc_;
+  if (this->tensor_loc_.has_value())
+    return this->tensor_loc_.value();
+  throw std::runtime_error(
+      "Asked for attr \"tensor_loc\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint64_t ETFeederNode::tensor_size() {
-  return tensor_size_;
+  if (this->tensor_size_.has_value())
+    return this->tensor_size_.value();
+  throw std::runtime_error(
+      "Asked for attr \"tensor_size\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 ChakraProtoMsg::CollectiveCommType ETFeederNode::comm_type() {
-  return comm_type_;
+  if (this->comm_type_.has_value())
+    return this->comm_type_.value();
+  throw std::runtime_error(
+      "Asked for attr \"comm_type\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint32_t ETFeederNode::involved_dim_size() {
-  return involved_dim_size_;
+  if (this->involved_dim_size_.has_value())
+    return this->involved_dim_size_.value();
+  throw std::runtime_error(
+      "Asked for attr \"involved_dim_size\" from node " +
+      std::to_string(this->id_) + ", which do not exists");
 }
 
 bool ETFeederNode::involved_dim(int i) {
-  return involved_dim_[i];
+  if (this->involved_dim_.has_value())
+    if (static_cast<size_t>(i) < this->involved_dim_.value().size())
+      return this->involved_dim_.value()[i];
+  throw std::runtime_error(
+      "Asked for attr \"involved_dim\"[" + std::to_string(i) + "] from node " +
+      std::to_string(this->id_) + ", which do not exists");
 }
 
 uint32_t ETFeederNode::comm_priority() {
-  return comm_priority_;
+  if (this->comm_priority_.has_value())
+    return this->comm_priority_.value();
+  throw std::runtime_error(
+      "Asked for attr \"comm_priority\" from node " +
+      std::to_string(this->id_) + ", which do not exists");
 }
 
 uint64_t ETFeederNode::comm_size() {
-  return comm_size_;
+  if (this->comm_size_.has_value())
+    return this->comm_size_.value();
+  throw std::runtime_error(
+      "Asked for attr \"comm_size\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint32_t ETFeederNode::comm_src() {
-  return comm_src_;
+  if (this->comm_src_.has_value())
+    return this->comm_src_.value();
+  throw std::runtime_error(
+      "Asked for attr \"comm_src\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint32_t ETFeederNode::comm_dst() {
-  return comm_dst_;
+  if (this->comm_dst_.has_value())
+    return this->comm_dst_.value();
+  throw std::runtime_error(
+      "Asked for attr \"comm_dst\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
 }
 
 uint32_t ETFeederNode::comm_tag() {
-  return comm_tag_;
+  if (this->comm_tag_.has_value())
+    return this->comm_tag_.value();
+  throw std::runtime_error(
+      "Asked for attr \"comm_tag\" from node " + std::to_string(this->id_) +
+      ", which do not exists");
+}
+
+bool ETFeederNode::has_is_cpu_op() {
+  return this->is_cpu_op_.has_value();
+}
+
+bool ETFeederNode::has_runtime() {
+  return this->runtime_.has_value();
+}
+
+bool ETFeederNode::has_num_ops() {
+  return this->num_ops_.has_value();
+}
+
+bool ETFeederNode::has_tensor_loc() {
+  return this->tensor_loc_.has_value();
+}
+
+bool ETFeederNode::has_tensor_size() {
+  return this->tensor_size_.has_value();
+}
+
+bool ETFeederNode::has_comm_type() {
+  return this->comm_type_.has_value();
+}
+
+bool ETFeederNode::has_involved_dim_size() {
+  return this->involved_dim_size_.has_value();
+}
+
+bool ETFeederNode::has_involved_dim(int i) {
+  if (!this->has_involved_dim_size())
+    return false;
+  return static_cast<size_t>(i) < this->involved_dim_.value().size();
+}
+
+bool ETFeederNode::has_comm_priority() {
+  return this->comm_priority_.has_value();
+}
+
+bool ETFeederNode::has_comm_size() {
+  return this->comm_size_.has_value();
+}
+
+bool ETFeederNode::has_comm_src() {
+  return this->comm_src_.has_value();
+}
+
+bool ETFeederNode::has_comm_dst() {
+  return this->comm_dst_.has_value();
+}
+
+bool ETFeederNode::has_comm_tag() {
+  return this->comm_tag_.has_value();
+}
+
+bool ETFeederNode::is_cpu_op(const bool& default_value) {
+  if (this->has_is_cpu_op()) {
+    return this->is_cpu_op();
+  }
+  return default_value;
+}
+
+uint64_t ETFeederNode::runtime(const uint64_t& default_value) {
+  if (this->has_runtime()) {
+    return this->runtime();
+  }
+  return default_value;
+}
+
+uint64_t ETFeederNode::num_ops(const uint64_t& default_value) {
+  if (this->has_num_ops()) {
+    return this->num_ops();
+  }
+  return default_value;
+}
+
+uint32_t ETFeederNode::tensor_loc(const uint32_t& default_value) {
+  if (this->has_tensor_loc()) {
+    return this->tensor_loc();
+  }
+  return default_value;
+}
+
+uint64_t ETFeederNode::tensor_size(const uint64_t& default_value) {
+  if (this->has_tensor_size()) {
+    return this->tensor_size();
+  }
+  return default_value;
+}
+
+ChakraProtoMsg::CollectiveCommType ETFeederNode::comm_type(
+    const ChakraProtoMsg::CollectiveCommType& default_value) {
+  if (this->has_comm_type()) {
+    return this->comm_type();
+  }
+  return default_value;
+}
+
+uint32_t ETFeederNode::involved_dim_size(const uint32_t& default_value) {
+  if (this->has_involved_dim_size()) {
+    return this->involved_dim_size();
+  }
+  return default_value;
+}
+
+bool ETFeederNode::involved_dim(int i, const bool& default_value) {
+  if (this->has_involved_dim(i)) {
+    return this->involved_dim(i);
+  }
+  return default_value;
+}
+
+uint32_t ETFeederNode::comm_priority(const uint32_t& default_value) {
+  if (this->has_comm_priority()) {
+    return this->comm_priority();
+  }
+  return default_value;
+}
+
+uint64_t ETFeederNode::comm_size(const uint64_t& default_value) {
+  if (this->has_comm_size()) {
+    return this->comm_size();
+  }
+  return default_value;
+}
+
+uint32_t ETFeederNode::comm_src(const uint32_t& default_value) {
+  if (this->has_comm_src()) {
+    return this->comm_src();
+  }
+  return default_value;
+}
+
+uint32_t ETFeederNode::comm_dst(const uint32_t& default_value) {
+  if (this->has_comm_dst()) {
+    return this->comm_dst();
+  }
+  return default_value;
+}
+
+uint32_t ETFeederNode::comm_tag(const uint32_t& default_value) {
+  if (this->has_comm_tag()) {
+    return this->comm_tag();
+  }
+  return default_value;
 }
diff --git a/et_feeder/et_feeder_node.h b/et_feeder/et_feeder_node.h
index 9a59232..f2b4465 100644
--- a/et_feeder/et_feeder_node.h
+++ b/et_feeder/et_feeder_node.h
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <any>
 #include <memory>
+#include <optional>
 #include <unordered_set>
 #include <vector>
 
@@ -21,8 +23,9 @@ class ETFeederNode {
 
   uint64_t id();
   std::string name();
-  bool is_cpu_op();
   ChakraProtoMsg::NodeType type();
+
+  bool is_cpu_op();
   uint64_t runtime();
   uint64_t num_ops();
   uint32_t tensor_loc();
@@ -36,32 +39,63 @@ class ETFeederNode {
   uint32_t comm_dst();
   uint32_t comm_tag();
 
+  bool has_is_cpu_op();
+  bool has_runtime();
+  bool has_num_ops();
+  bool has_tensor_loc();
+  bool has_tensor_size();
+  bool has_comm_type();
+  bool has_involved_dim_size();
+  bool has_involved_dim(int i);
+  bool has_comm_priority();
+  bool has_comm_size();
+  bool has_comm_src();
+  bool has_comm_dst();
+  bool has_comm_tag();
+
+  bool is_cpu_op(const bool& default_value);
+  uint64_t runtime(const uint64_t& default_value);
+  uint64_t num_ops(const uint64_t& default_value);
+  uint32_t tensor_loc(const uint32_t& default_value);
+  uint64_t tensor_size(const uint64_t& default_value);
+  ChakraProtoMsg::CollectiveCommType comm_type(
+      const ChakraProtoMsg::CollectiveCommType& default_value);
+  uint32_t involved_dim_size(const uint32_t& default_value);
+  bool involved_dim(int i, const bool& default_value);
+  uint32_t comm_priority(const uint32_t& default_value);
+  uint64_t comm_size(const uint64_t& default_value);
+  uint32_t comm_src(const uint32_t& default_value);
+  uint32_t comm_dst(const uint32_t& default_value);
+  uint32_t comm_tag(const uint32_t& default_value);
+
  private:
   void assign_attr_val(
-      std::shared_ptr<ChakraProtoMsg::Node> node,
-      int i,
-      void* member);
+      const ChakraProtoMsg::AttributeProto& attr,
+      std::any member);
 
   std::shared_ptr<ChakraProtoMsg::Node> node_{nullptr};
   std::unordered_set<std::shared_ptr<ETFeederNode>> children_set_{};
   std::vector<std::shared_ptr<ETFeederNode>> children_vec_{};
   std::vector<uint64_t> dep_unresolved_parent_ids_{};
 
+  // necessary fields
   uint64_t id_;
   std::string name_;
-  bool is_cpu_op_;
-  uint64_t runtime_;
-  uint64_t num_ops_;
-  uint32_t tensor_loc_;
-  uint64_t tensor_size_;
-  ChakraProtoMsg::CollectiveCommType comm_type_;
-  uint32_t involved_dim_size_;
-  std::vector<bool> involved_dim_;
-  uint32_t comm_priority_;
-  uint64_t comm_size_;
-  uint32_t comm_src_;
-  uint32_t comm_dst_;
-  uint32_t comm_tag_;
+
+  // optional fields
+  std::optional<bool> is_cpu_op_;
+  std::optional<uint64_t> runtime_;
+  std::optional<uint64_t> num_ops_;
+  std::optional<uint32_t> tensor_loc_;
+  std::optional<uint64_t> tensor_size_;
+  std::optional<ChakraProtoMsg::CollectiveCommType> comm_type_;
+  std::optional<uint32_t> involved_dim_size_;
+  std::optional<std::vector<bool>> involved_dim_;
+  std::optional<uint32_t> comm_priority_;
+  std::optional<uint64_t> comm_size_;
+  std::optional<uint32_t> comm_src_;
+  std::optional<uint32_t> comm_dst_;
+  std::optional<uint32_t> comm_tag_;
 };
 
 } // namespace Chakra