[mlir] remove StringMap to make -view-op-graph attr order deterministic

[erikdesjardins]

Summary

I am planning to change the StringMap hash function in D142862,
which breaks mlir/test/Transforms/print-op-graph.mlir because
it changes the iteration order.

A map isn't necessary in this situation. Switch to SmallVector instead.

[python3kgae]

mlir/lib/Transforms/ViewOpGraph.cpp

62

Will the max size of Attributes change in the future?

[erikdesjardins]

use ArrayRef

mlir/lib/Transforms/ViewOpGraph.cpp

62

Sure, if someone adds another attribute and they want to keep the SmallVector on the stack, this size could change.

This does make me realize that SmallVector is only necessary at one callsite, so we might as well use ArrayRef here instead (done in latest version of patch).

[erikdesjardins]

Obviated by https://reviews.llvm.org/rG618caf6fcce17d6f1ca752604138fb234e781ff3

mlir/lib/Transforms/ViewOpGraph.cpp

 //===- ViewOpGraph.cpp - View/write op graphviz graphs --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/ViewOpGraph.h"
 
 #include "mlir/IR/Block.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/IndentedOstream.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/GraphWriter.h"
-#include <utility>
 #include <optional>
+#include <utility>
 
 namespace mlir {
 #define GEN_PASS_DEF_VIEWOPGRAPH
 #include "mlir/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
static std::string escapeString(std::string str) {
   return strFromOs([&](raw_ostream &os) { os.write_escaped(str); });
 }
 
 /// Put quotation marks around a given string.
 static std::string quoteString(const std::string &str) {
   return "\"" + str + "\"";
 }
 
-using AttributeMap = llvm::StringMap<std::string>;
+using Attributes = ArrayRef<std::pair<StringRef, std::string>>;
 
 namespace {
 
 /// This struct represents a node in the DOT language. Each node has an
 /// identifier and an optional identifier for the cluster (subgraph) that
 /// contains the node.
 /// Note: In the DOT language, edges can be drawn only from nodes to nodes, but
 /// not between clusters. However, edges can be clipped to the boundary of a
private:
   }
 
   /// Generate an attribute statement.
   std::string attrStmt(const Twine &key, const Twine &value) {
     return (key + " = " + value).str();
   }
 
   /// Emit an attribute list.
-  void emitAttrList(raw_ostream &os, const AttributeMap &map) {
+  void emitAttrList(raw_ostream &os, const Attributes &attrs) {
     os << "[";
-    interleaveComma(map, os, [&](const auto &it) {
-      os << this->attrStmt(it.getKey(), it.getValue());
+    interleaveComma(attrs, os, [&](const auto &kv) {
+      const auto &[Key, Value] = kv;
+      os << this->attrStmt(Key, Value);
     });
     os << "]";
   }
 
   // Print an MLIR attribute to `os`. Large attributes are truncated.
   void emitMlirAttr(raw_ostream &os, Attribute attr) {
     // A value used to elide large container attribute.
     int64_t largeAttrLimit = getLargeAttributeSizeLimit();
void emitMlirAttr(raw_ostream &os, Attribute attr) {
     llvm::raw_string_ostream ss(buf);
     attr.print(ss);
     os << truncateString(ss.str());
   }
 
   /// Append an edge to the list of edges.
   /// Note: Edges are written to the output stream via `emitAllEdgeStmts`.
   void emitEdgeStmt(Node n1, Node n2, std::string label, StringRef style) {
-    AttributeMap attrs;
-    attrs["style"] = style.str();
+    SmallVector<std::pair<StringRef, std::string>, 3> attrs;
+    attrs.emplace_back("style", style.str());
     // Do not label edges that start/end at a cluster boundary. Such edges are
     // clipped at the boundary, but labels are not. This can lead to labels
     // floating around without any edge next to them.
     if (!n1.clusterId && !n2.clusterId)
-      attrs["label"] = quoteString(escapeString(std::move(label)));
+      attrs.emplace_back("label", quoteString(escapeString(std::move(label))));
     // Use `ltail` and `lhead` to draw edges between clusters.
     if (n1.clusterId)
-      attrs["ltail"] = "cluster_" + std::to_string(*n1.clusterId);
+      attrs.emplace_back("ltail", "cluster_" + std::to_string(*n1.clusterId));
     if (n2.clusterId)
-      attrs["lhead"] = "cluster_" + std::to_string(*n2.clusterId);
+      attrs.emplace_back("lhead", "cluster_" + std::to_string(*n2.clusterId));
 
     edges.push_back(strFromOs([&](raw_ostream &os) {
       os << llvm::format("v%i -> v%i ", n1.id, n2.id);
       emitAttrList(os, attrs);
     }));
   }
 
   /// Emit a graph. The specified builder generates the body of the graph.
   void emitGraph(function_ref<void()> builder) {
     os << "digraph G {\n";
     os.indent();
     // Edges between clusters are allowed only in compound mode.
     os << attrStmt("compound", "true") << ";\n";
     builder();
     os.unindent();
     os << "}\n";
   }
 
   /// Emit a node statement.
   Node emitNodeStmt(std::string label, StringRef shape = kShapeNode) {
     int nodeId = ++counter;
-    AttributeMap attrs;
-    attrs["label"] = quoteString(escapeString(std::move(label)));
-    attrs["shape"] = shape.str();
+    std::array<std::pair<StringRef, std::string>, 2> attrs = {
+        {{"label", quoteString(escapeString(std::move(label)))},
+         {"shape", shape.str()}}};
     os << llvm::format("v%i ", nodeId);
     emitAttrList(os, attrs);
     os << ";\n";
     return Node(nodeId);
   }
 
   /// Generate a label for an operation.
   std::string getLabel(Operation *op) {