Optimize various IdString methods to avoid allocating storage for NEW_IDs

Author: rocallahan

kernel/rtlil.h

@@ -270,6 +270,26 @@ struct RTLIL::IdString
 		*out += std::to_string(-index_);
 	}
 
+	inline bool lt_by_name(const IdString &rhs) const {
+		std::string lhs_str;
+		std::string rhs_str;
+		const char* lhs_cstr;
+		const char* rhs_cstr;
+		if (index_ >= 0)
+			lhs_cstr = global_id_storage_.at(index_);
+		else {
+			append_to(&lhs_str);
+			lhs_cstr = lhs_str.c_str();
+		}
+		if (rhs.index_ >= 0)
+			rhs_cstr = global_id_storage_.at(rhs.index_);
+		else {
+			rhs.append_to(&rhs_str);
+			rhs_cstr = rhs_str.c_str();
+		}
+		return strcmp(lhs_cstr, rhs_cstr) < 0;
+	}
+
 	inline bool operator<(const IdString &rhs) const {
 		return index_ < rhs.index_;
 	}
@@ -288,14 +308,20 @@ struct RTLIL::IdString
 	bool operator!=(const char *rhs) const { return strcmp(c_str(), rhs) != 0; }
 
 	char operator[](size_t i) const {
-					const char *p = c_str();
+		if (index_ >= 0) {
+			const char *p = global_id_storage_.at(index_);
 #ifndef NDEBUG
-		for (; i != 0; i--, p++)
-			log_assert(*p != 0);
-		return *p;
+			for (; i != 0; i--, p++)
+				log_assert(*p != 0);
+			return *p;
 #else
-		return *(p + i);
+			return *(p + i);
 #endif
+		}
+		const std::string &id_start = *global_negative_id_prefix_storage_.at(index_);
+		if (i < id_start.size())
+			return id_start[i];
+		return std::to_string(-index_)[i - id_start.size()];
 	}
 
 	std::string substr(size_t pos = 0, size_t len = std::string::npos) const {
@@ -310,23 +336,43 @@ struct RTLIL::IdString
 	}
 
 	bool begins_with(const char* prefix) const {
-		size_t len = strlen(prefix);
-		if (size() < len) return false;
-		return compare(0, len, prefix) == 0;
+		size_t prefix_len = strlen(prefix);
+		if (index_ >= 0) {
+			const char *id = global_id_storage_.at(index_);
+			if (strlen(id) < prefix_len)
+				return false;
+			return strncmp(id, prefix, prefix_len) == 0;
+		}
+
+		const std::string &id_start = *global_negative_id_prefix_storage_.at(index_);
+		if (prefix_len <= id_start.size())
+			return strncmp(id_start.c_str(), prefix, prefix_len) == 0;
+		if (strncmp(id_start.c_str(), prefix, id_start.size()) != 0)
+			return false;
+
+		prefix += id_start.size();
+		prefix_len -= id_start.size();
+		std::string v = std::to_string(-index_);
+		if (v.size() < prefix_len)
+			return false;
+		return strncmp(v.c_str(), prefix, prefix_len) == 0;
 	}
 
 	bool ends_with(const char* suffix) const {
 		size_t len = strlen(suffix);
-		if (size() < len) return false;
-		return compare(size()-len, len, suffix) == 0;
+		size_t id_len = size();
+		if (id_len < len) return false;
+		return compare(id_len, len, suffix) == 0;
 	}
 
 	bool contains(const char* str) const {
 		return strstr(c_str(), str);
 	}
 
 	size_t size() const {
-		return strlen(c_str());
+		if (index_ >= 0)
+			return strlen(global_id_storage_.at(index_));
+		return global_negative_id_prefix_storage_.at(index_)->size() + std::to_string(-index_).size();
 	}
 
 	bool empty() const {
@@ -624,7 +670,7 @@ namespace RTLIL {
 
 	struct sort_by_id_str {
 		bool operator()(const RTLIL::IdString &a, const RTLIL::IdString &b) const {
-			return strcmp(a.c_str(), b.c_str()) < 0;
+			return a.lt_by_name(b);
 		}
 	};
 

passes/opt/opt_clean.cc

@@ -283,7 +283,7 @@ bool compare_signals(RTLIL::SigBit &s1, RTLIL::SigBit &s2, SigPool &regs, SigPoo
 	if (attrs1 != attrs2)
 		return attrs2 > attrs1;
 
-	return strcmp(w2->name.c_str(), w1->name.c_str()) < 0;
+	return w2->name.lt_by_name(w1->name);
 }
 
 bool check_public_name(RTLIL::IdString id)

tests/unit/kernel/rtlilTest.cc

@@ -373,6 +373,16 @@ namespace RTLIL {
 		EXPECT_EQ(id, id2);
 	}
 
+	TEST_F(KernelRtlilTest, NewIdBeginsWith) {
+		IdString id = NEW_ID;
+		EXPECT_TRUE(id.begins_with("$auto"));
+		EXPECT_FALSE(id.begins_with("xyz"));
+		EXPECT_TRUE(id.begins_with("$auto$"));
+		EXPECT_FALSE(id.begins_with("abcdefghijklmn"));
+		EXPECT_TRUE(id.begins_with("$auto$rtlilTest"));
+		EXPECT_FALSE(id.begins_with("$auto$rtlilX"));
+	}
+
 	class WireRtlVsHdlIndexConversionTest :
 		public KernelRtlilTest,
 		public testing::WithParamInterface<std::tuple<bool, int, int>>