onnx 1.17.0__cp310-cp310-win32.whl → 1.19.0__cp310-cp310-win32.whl

onnx/common/ir.h

@@ -9,16 +9,13 @@
 
 #pragma once
 
-#include <stdint.h>
-
 #include <algorithm>
-#include <atomic>
+#include <array>
 #include <cstdint>
 #include <functional>
 #include <iostream>
 #include <limits>
 #include <memory>
-#include <set>
 #include <sstream>
 #include <string>
 #include <unordered_set>
@@ -65,11 +62,11 @@ struct Value;
 
 class ResourceGuard final {
   std::function<void()> destructor_;
-  bool released_;
+  bool released_{false};
 
  public:
   ONNX_DISALLOW_COPY_AND_ASSIGN(ResourceGuard);
-  explicit ResourceGuard(std::function<void()> destructor) : destructor_(std::move(destructor)), released_(false) {}
+  explicit ResourceGuard(std::function<void()> destructor) : destructor_(std::move(destructor)) {}
   ResourceGuard(ResourceGuard&& other) = default;
   ResourceGuard& operator=(ResourceGuard&& other) = default;
 
@@ -85,8 +82,8 @@ class ResourceGuard final {
 
 struct Dimension final {
   Dimension() : is_unknown(true), is_int(false), dim(-1) {}
-  Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {} // NOLINT
-  Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {} // NOLINT
+  explicit Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {}
+  explicit Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {}
 
   bool is_unknown;
   bool is_int;
@@ -112,8 +109,9 @@ enum class AttributeKind : uint8_t {
 };
 
 static inline const char* toString(AttributeKind kind) {
+  // NOLINTNEXTLINE(modernize-avoid-c-arrays)
   static constexpr const char* names[] = {"f", "fs", "i", "is", "s", "ss", "t", "ts", "g", "gs", "tp", "tps"};
-  ONNX_ASSERT(size_t(kind) < sizeof(names) / sizeof(const char*));
+  ONNX_ASSERT(size_t(kind) < sizeof(names) / sizeof(const char*))
   return names[int(kind)];
 }
 
@@ -130,14 +128,14 @@ template <typename T, AttributeKind Kind>
 struct ScalarAttributeValue final : public AttributeValue {
   using ConstructorType = const T&;
   using ValueType = T;
-  ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(value_) {}
+  ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(std::move(value_)) {}
   ValueType& value() {
     return value_;
   }
-  virtual Ptr clone() const override {
-    return Ptr(new ScalarAttributeValue(name, value_));
+  Ptr clone() const override {
+    return std::make_unique<ScalarAttributeValue>(name, value_);
   }
-  virtual AttributeKind kind() const override {
+  AttributeKind kind() const override {
     return Kind;
   }
 
@@ -149,16 +147,15 @@ template <typename T, AttributeKind Kind>
 struct VectorAttributeValue final : public AttributeValue {
   using ConstructorType = const std::vector<T>&&;
   using ValueType = std::vector<T>;
-  VectorAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(std::move(value_)) {}
+  VectorAttributeValue(Symbol name, ValueType value_) : AttributeValue(name), value_(std::move(value_)) {}
   ValueType& value() {
     return value_;
   }
-  virtual AttributeKind kind() const override {
+  AttributeKind kind() const override {
     return Kind;
   }
-  virtual std::unique_ptr<AttributeValue> clone() const override {
-    auto copy = value_;
-    return Ptr(new VectorAttributeValue(name, std::move(copy)));
+  std::unique_ptr<AttributeValue> clone() const override {
+    return std::make_unique<VectorAttributeValue>(name, ValueType(value_));
   }
 
  private:
@@ -184,7 +181,9 @@ using TypeProtosAttr = VectorAttributeValue<TypeProto, AttributeKind::tps>;
 // we return Derived* pointers because Nodes are normally held as pointers.
 template <typename Derived>
 struct Attributes {
-  Attributes() {}
+  // NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility)
+  Attributes() = default;
+
   void copyAttributes(const Attributes& rhs) {
     values_.clear();
     values_.reserve(rhs.values_.size());
@@ -243,7 +242,7 @@ struct Attributes {
   template <typename T>
   Derived* set(Symbol name, typename T::ConstructorType v) {
     auto it = find(name, false);
-    auto nv = AVPtr(new T(name, std::forward<typename T::ConstructorType>(v)));
+    auto nv = std::make_unique<T>(name, std::forward<typename T::ConstructorType>(v));
     if (it == values_.end()) {
       values_.push_back(std::move(nv));
     } else {
@@ -265,7 +264,7 @@ struct Attributes {
   using iterator = std::vector<AVPtr>::iterator;
   iterator find(Symbol name, bool required) {
     auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; });
-    ONNX_ASSERT(!required || it != values_.end());
+    ONNX_ASSERT(!required || it != values_.end())
     return it;
   }
   using const_iterator = std::vector<AVPtr>::const_iterator;
@@ -277,7 +276,7 @@ struct Attributes {
         __FILE__,
         __LINE__,
         __func__,
-        name.toString());
+        name.toString())
     return it;
   }
 };
@@ -317,10 +316,10 @@ struct Value final {
   size_t unique_ = 0; // unique id
   size_t stage_ = 0; // 0-forward, 1-backward, 2-double-backward,...
   use_list uses_in_current_graph_;
-  bool has_unique_name_;
+  bool has_unique_name_{false};
   std::string unique_name_;
-  int32_t elem_type_;
-  bool has_sizes_;
+  int32_t elem_type_{ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED};
+  bool has_sizes_{false};
   std::vector<Dimension> sizes_;
 
  public:
@@ -378,7 +377,7 @@ struct Value final {
   Graph* owningGraph();
   const Graph* owningGraph() const;
   // TODO: make this more const correct
-  const use_list uses() const;
+  use_list uses() const;
 
   // Replaces all uses of this node with 'newValue'.
   //
@@ -391,7 +390,7 @@ struct Value final {
   //          %5 = h(%6, %6)
   void replaceAllUsesWith(Value* newValue);
 
-  Value* copyMetadata(Value* from) {
+  Value* copyMetadata(const Value* from) {
     setElemType(from->elemType());
     setSizes(from->sizes());
     if (from->has_unique_name()) {
@@ -419,7 +418,7 @@ struct Node : public Attributes<Node> {
   // using an array to allow the same iterator class for forward and reverse node lists
   // This list represents a topological sort
 
-  Node* next_in_graph[2] = {nullptr, nullptr};
+  std::array<Node*, 2> next_in_graph{nullptr, nullptr};
   Node*& next() {
     return next_in_graph[kNextDirection];
   }
@@ -438,13 +437,13 @@ struct Node : public Attributes<Node> {
   std::vector<Value*> outputs_;
   Graph* graph_;
   size_t stage_;
-  bool has_name_;
+  bool has_name_{false};
   std::string name_;
-  bool has_domain_;
+  bool has_domain_{false};
   std::string domain_;
-  bool has_doc_string_;
+  bool has_doc_string_{false};
   std::string doc_string_;
-  bool has_overload_;
+  bool has_overload_{false};
   std::string overload_;
 
  protected:
@@ -543,7 +542,7 @@ struct Node : public Attributes<Node> {
     return false;
   }
   void replaceAllUsesWith(Node* n) {
-    ONNX_ASSERT(outputs().size() == n->outputs().size());
+    ONNX_ASSERT(outputs().size() == n->outputs().size())
     size_t nOutputs = outputs().size();
     for (size_t i = 0; i < nOutputs; i++) {
       outputs()[i]->replaceAllUsesWith(n->outputs()[i]);
@@ -552,19 +551,19 @@ struct Node : public Attributes<Node> {
   // lots of things like chunk have a single input or single output, so we have a
   // helper to make accessing it easier
   Value* input() {
-    ONNX_ASSERT(inputs_.size() == 1);
+    ONNX_ASSERT(inputs_.size() == 1)
     return inputs_.at(0);
   }
   Value* output() {
-    ONNX_ASSERT(outputs_.size() == 1);
+    ONNX_ASSERT(outputs_.size() == 1)
     return outputs_.at(0);
   }
   const Value* input() const {
-    ONNX_ASSERT(inputs_.size() == 1);
+    ONNX_ASSERT(inputs_.size() == 1)
     return inputs_.at(0);
   }
   Value* output() const {
-    ONNX_ASSERT(outputs_.size() == 1);
+    ONNX_ASSERT(outputs_.size() == 1)
     return outputs_.at(0);
   }
   // Access a particular input.  This is a checked index.
@@ -596,7 +595,7 @@ struct Node : public Attributes<Node> {
   // Execute: %3.addInput(%4)
   // Result:  %3 = f(%1, %2, %4)
   Value* addInput(Value* node) {
-    ONNX_ASSERT(graph_ == node->owningGraph());
+    ONNX_ASSERT(graph_ == node->owningGraph())
     node->uses_in_current_graph_.emplace_back(this, inputs_.size());
     inputs_.push_back(node);
     return node;
@@ -609,7 +608,7 @@ struct Node : public Attributes<Node> {
   // Execute: %3.replaceInput(1, %4)
   // Result:  %3 = f(%1, %4)
   Value* replaceInput(size_t i, Value* newValue) {
-    ONNX_ASSERT(newValue->owningGraph() == graph_);
+    ONNX_ASSERT(newValue->owningGraph() == graph_)
     Value* old = dropInput(i);
     inputs_[i] = newValue;
     newValue->uses_in_current_graph_.emplace_back(this, i);
@@ -623,8 +622,8 @@ struct Node : public Attributes<Node> {
   // Execute: %3.replaceInputWith(%1, %4)
   // Result:  %3 = f(%4, %2, %4)
   void replaceInputWith(Value* from, Value* to) {
-    ONNX_ASSERT(from->owningGraph() == graph_);
-    ONNX_ASSERT(to->owningGraph() == graph_);
+    ONNX_ASSERT(from->owningGraph() == graph_)
+    ONNX_ASSERT(to->owningGraph() == graph_)
     size_t i = 0;
     for (auto input : inputs()) {
       if (input == from)
@@ -651,7 +650,7 @@ struct Node : public Attributes<Node> {
   //          %5 = h(%1)
   //          %4 = g(%3)
   Node* insertBefore(Node* n) {
-    ONNX_ASSERT(n->inGraphList());
+    ONNX_ASSERT(n->inGraphList())
     insertAfter(n->prev());
     return this;
   }
@@ -667,7 +666,7 @@ struct Node : public Attributes<Node> {
   //          %4 = g(%3)
   //          %5 = h(%1)
   Node* insertAfter(Node* n) {
-    ONNX_ASSERT(!inGraphList() && n->inGraphList());
+    ONNX_ASSERT(!inGraphList() && n->inGraphList())
     Node* next = n->next();
     n->next() = this;
     this->prev() = n;
@@ -732,7 +731,7 @@ struct Node : public Attributes<Node> {
   }
 
   // Check whether this node is before node n in the graph.
-  bool isBefore(Node* n);
+  bool isBefore(const Node* n);
 
   // iterators of the node list starting at this node
   // useful for resuming a search starting at this node
@@ -765,7 +764,7 @@ struct Node : public Attributes<Node> {
   }
   template <typename T>
   T* expect() {
-    ONNX_ASSERTM(T::Kind == kind(), "expected a %s but found a %s", T::Kind.toString(), kind().toString());
+    ONNX_ASSERTM(T::Kind == kind(), "expected a %s but found a %s", T::Kind.toString(), kind().toString())
     return static_cast<T*>(this);
   }
 
@@ -778,7 +777,7 @@ struct Node : public Attributes<Node> {
     // O(N) on the use list, but unless we get nodes with +100 uses
     // vector traversal still is probably faster than linked list
     auto use_it = std::find(input_uses.begin(), input_uses.end(), Use(this, i));
-    ONNX_ASSERT(use_it != input_uses.end());
+    ONNX_ASSERT(use_it != input_uses.end())
     return use_it;
   }
 
@@ -786,7 +785,7 @@ struct Node : public Attributes<Node> {
   // is only used internally to Node before setting it to a new value
   // or erasing the entry from the list.
   Value* dropInput(size_t i) {
-    ONNX_ASSERT(i < inputs_.size());
+    ONNX_ASSERT(i < inputs_.size())
     auto input_node = inputs_[i];
     auto use_it = findUseForInput(i);
     input_node->uses_in_current_graph_.erase(use_it);
@@ -795,11 +794,11 @@ struct Node : public Attributes<Node> {
   }
 
   bool inGraphList() const {
-    ONNX_ASSERT(next() != nullptr || prev() == nullptr);
+    ONNX_ASSERT(next() != nullptr || prev() == nullptr)
     return next() != nullptr;
   }
   void removeFromList() {
-    ONNX_ASSERT(inGraphList());
+    ONNX_ASSERT(inGraphList())
     Node* next = this->next();
     Node* prev = this->prev();
     prev->next() = next;
@@ -842,7 +841,7 @@ class OpSetID final {
   // Default Domain Constructor
   explicit OpSetID(const int64_t version) : domain_(""), version_(version) {}
 
-  explicit OpSetID(const std::string& domain, int64_t version) : domain_(domain), version_(version) {}
+  explicit OpSetID(std::string domain, int64_t version) : domain_(std::move(domain)), version_(version) {}
 
   // target must be in the form "<domain>&<version>"
   std::string toString() const {
@@ -852,12 +851,12 @@ class OpSetID final {
   // target must be in the form "<domain>&<version>"
   static OpSetID fromString(const std::string& target) {
     ONNX_TRY {
-      std::string new_domain = target.substr(0, target.find("$"));
-      int new_version = ONNX_NAMESPACE::stoi(target.substr(target.find("$") + 1, target.length()).c_str());
+      std::string new_domain = target.substr(0, target.find('$'));
+      int new_version = ONNX_NAMESPACE::stoi(target.substr(target.find('$') + 1, target.length()));
       return OpSetID(new_domain, new_version);
     }
     ONNX_CATCH(const std::runtime_error& e) {
-      ONNX_HANDLE_EXCEPTION([&]() { ONNX_ASSERTM(false, "Error in fromString: %s", e.what()); });
+      ONNX_HANDLE_EXCEPTION([&]() { ONNX_ASSERTM(false, "Error in fromString: %s", e.what()) });
     }
 
     // The control will never reach here.
@@ -898,9 +897,9 @@ struct Graph final {
 
   std::unordered_set<const Node*> all_nodes;
   std::unordered_set<const Value*> all_values;
-  size_t next_unique_;
+  size_t next_unique_{0};
 
-  size_t new_node_stage_;
+  size_t new_node_stage_{0};
 
   // holds outputs in a way that can be reflected
   // as a Use object
@@ -914,9 +913,9 @@ struct Graph final {
   std::vector<Tensor> initializers_;
   std::vector<std::string> initializer_names_;
 
-  bool has_name_;
+  bool has_name_{false};
   std::string name_;
-  bool has_doc_string_;
+  bool has_doc_string_{false};
   std::string doc_string_;
 
   std::vector<OpSetID> opset_versions_;
@@ -954,14 +953,7 @@ struct Graph final {
   }
 
  public:
-  Graph()
-      : next_unique_(0),
-        new_node_stage_(0),
-        output_(initOutput(create(kReturn, 0))),
-        input_(create(kParam, 0)),
-        initializer_node_(create(kParam, 0)),
-        has_name_(false),
-        has_doc_string_(false) {}
+  Graph() : output_(initOutput(create(kReturn, 0))), input_(create(kParam, 0)), initializer_node_(create(kParam, 0)) {}
 
   bool has_doc_string() const {
     return has_doc_string_;
@@ -1139,13 +1131,13 @@ struct Graph final {
   }
 
   Node* appendNode(Node* n) {
-    ONNX_ASSERT(n->graph_ == this && !n->inGraphList());
+    ONNX_ASSERT(n->graph_ == this && !n->inGraphList())
     n->insertBefore(output_);
     return n;
   }
 
   Node* prependNode(Node* n) {
-    ONNX_ASSERT(n->graph_ == this && !n->inGraphList());
+    ONNX_ASSERT(n->graph_ == this && !n->inGraphList())
     n->insertAfter(output_);
     return n;
   }
@@ -1229,7 +1221,7 @@ struct Graph final {
   }
 
   void forEachNode(const std::function<void(Node*)>& fn) {
-    forSelfAndEachSubGraph([fn](Graph* graph) {
+    forSelfAndEachSubGraph([&fn](Graph* graph) {
       for (Node* node : graph->nodes()) {
         fn(node);
       }
@@ -1252,26 +1244,20 @@ struct Graph final {
 
   void freeNode(Node* n) {
     auto it = all_nodes.find(n);
-    ONNX_ASSERT(it != all_nodes.end());
+    ONNX_ASSERT(it != all_nodes.end())
     delete *it;
     all_nodes.erase(it);
   }
   void freeValue(Value* v) {
     auto it = all_values.find(v);
-    ONNX_ASSERT(it != all_values.end());
+    ONNX_ASSERT(it != all_values.end())
     delete *it;
     all_values.erase(it);
   }
 };
 
 inline Value::Value(Node* node_, size_t offset_)
-    : node_(node_),
-      offset_(offset_),
-      unique_(node_->graph_->getNextUnique()),
-      stage_(node_->graph_->new_node_stage_),
-      has_unique_name_(false),
-      elem_type_(ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED),
-      has_sizes_(false) {
+    : node_(node_), offset_(offset_), unique_(node_->graph_->getNextUnique()), stage_(node_->graph_->new_node_stage_) {
   node_->graph_->all_values.emplace(this);
 }
 
@@ -1319,7 +1305,7 @@ inline Value* Value::setUniqueName(const std::string& name, bool update_related_
 
 inline void Value::replaceAllUsesWith(Value* newValue) {
   auto* graph = owningGraph();
-  ONNX_ASSERT(graph == newValue->owningGraph());
+  ONNX_ASSERT(graph == newValue->owningGraph())
   // propagate sizes and elem type
   if (this->has_sizes()) {
     newValue->setSizes(this->sizes());
@@ -1356,20 +1342,13 @@ inline void Value::replaceAllUsesWith(Value* newValue) {
   assert(this->uses().empty());
 }
 
-inline Node::Node(Graph* graph_, NodeKind kind_)
-    : kind_(kind_),
-      graph_(graph_),
-      stage_(graph_->new_node_stage_),
-      has_name_(false),
-      has_domain_(false),
-      has_doc_string_(false),
-      has_overload_(false) {
+inline Node::Node(Graph* graph_, NodeKind kind_) : kind_(kind_), graph_(graph_), stage_(graph_->new_node_stage_) {
   graph_->all_nodes.emplace(this);
 }
 
 inline void Node::eraseOutput(size_t i) {
-  ONNX_ASSERT(i < outputs_.size());
-  ONNX_ASSERT(outputs_[i]->uses().empty());
+  ONNX_ASSERT(i < outputs_.size())
+  ONNX_ASSERT(outputs_[i]->uses().empty())
   Value* n = outputs_[i];
   outputs_.erase(outputs_.begin() + i);
   owningGraph()->freeValue(n);
@@ -1378,7 +1357,7 @@ inline void Node::eraseOutput(size_t i) {
   }
 }
 
-inline bool Node::isBefore(Node* n) {
+inline bool Node::isBefore(const Node* n) {
   if (n == nullptr || this == n) {
     // Bail out early.
     return false;
@@ -1391,7 +1370,7 @@ inline bool Node::isBefore(Node* n) {
   if (n->kind() == kParam) {
     return false;
   }
-  ONNX_ASSERT(n->inGraphList());
+  ONNX_ASSERT(n->inGraphList())
   for (Node* p = next(); p != *graph_->end(); p = p->next()) {
     if (p == n) {
       return true;
@@ -1401,7 +1380,7 @@ inline bool Node::isBefore(Node* n) {
 }
 
 inline void Node::destroy() {
-  ONNX_ASSERT(inGraphList());
+  ONNX_ASSERT(inGraphList())
   while (!outputs().empty())
     eraseOutput(outputs().size() - 1);
   removeAllInputs();
@@ -1428,7 +1407,7 @@ inline const_graph_node_list_iterator Node::reverseIterator() const {
 // nodes in subgraph are also included.
 // This method is usually used to check whether it is
 // safe to delete a Value.
-inline const use_list Value::uses() const {
+inline use_list Value::uses() const {
   use_list all_uses = uses_in_current_graph_;
   owningGraph()->forEachNode([this, &all_uses](const Node* node) {
     if (node->owningGraph() == this->owningGraph()) {