Optimize IdString operations to avoid calling c_str()

Author: rocallahan

kernel/rtlil.h

@@ -273,6 +273,85 @@ struct RTLIL::IdString
 		*out += std::to_string(-index_);
 	}
 
+	class const_iterator {
+	private:
+		const std::string *prefix;
+		std::string suffix;
+		const char *c_str;
+		int c_str_len;
+		// When this is INT_MAX it's the generic "end" value.
+		int index;
+
+	public:
+		using iterator_category = std::forward_iterator_tag;
+		using value_type = char;
+		using difference_type = std::ptrdiff_t;
+		using pointer = const char*;
+		using reference = const char&;
+
+		const_iterator(const char *c_str) : prefix(nullptr), c_str(c_str), c_str_len(strlen(c_str)), index(0) {}
+		const_iterator(const std::string *prefix, int number) :
+				prefix(prefix), suffix(std::to_string(number)), c_str(nullptr), c_str_len(0), index(0) {}
+		// Construct end-marker
+		const_iterator() : prefix(nullptr), c_str(nullptr), c_str_len(0), index(INT_MAX) {}
+
+		int size() const {
+			if (c_str != nullptr)
+				return c_str_len;
+			return GetSize(*prefix) + GetSize(suffix);
+		}
+
+		char operator*() const {
+			if (c_str != nullptr)
+				return c_str[index];
+			int prefix_size = GetSize(*prefix);
+			if (index < prefix_size)
+				return prefix->at(index);
+			return suffix[index - prefix_size];
+		}
+
+		const_iterator& operator++() { ++index; return *this; }
+		const_iterator operator++(int) { const_iterator result(*this); ++index; return result; }
+		const_iterator& operator+=(int i) { index += i; return *this; }
+
+		const_iterator operator+(int add) {
+			const_iterator result = *this;
+			result += add;
+			return result;
+		}
+
+		bool operator==(const const_iterator& other) const {
+			return index == other.index || (other.index == INT_MAX && index == size())
+				|| (index == INT_MAX && other.index == other.size());
+		}
+		bool operator!=(const const_iterator& other) const {
+			return !(*this == other);
+		}
+	};
+	const_iterator begin() const {
+		if (index_ >= 0) {
+			return const_iterator(global_id_storage_.at(index_));
+		}
+		return const_iterator(global_negative_id_prefix_storage_.at(index_), -index_);
+	}
+	const_iterator end() const {
+		return const_iterator();
+	}
+
+	inline bool lt_by_name(const IdString &rhs) const {
+		const_iterator rhs_it = rhs.begin();
+		for (char ch : *this) {
+			if (rhs_it == rhs.end())
+				return false;
+			if (ch < *rhs_it)
+				return true;
+			if (ch > *rhs_it)
+				return false;
+			++rhs_it;
+		}
+		return rhs_it != rhs.end();
+	}
+
 	inline bool operator<(const IdString &rhs) const {
 		return index_ < rhs.index_;
 	}
@@ -291,45 +370,81 @@ 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_).c_str()[i - id_start.size()];
 	}
 
 	std::string substr(size_t pos = 0, size_t len = std::string::npos) const {
-		if (len == std::string::npos || len >= strlen(c_str() + pos))
-			return std::string(c_str() + pos);
-		else
-			return std::string(c_str() + pos, len);
+		std::string result;
+		const_iterator it = begin() + pos;
+		const_iterator end_it = end();
+		if (len != std::string::npos && len < it.size() - pos) {
+			end_it = it + len;
+		}
+		std::copy(it, end_it, std::back_inserter(result));
+		return result;
 	}
 
 	int compare(size_t pos, size_t len, const char* s) const {
-		return strncmp(c_str()+pos, s, len);
+		const_iterator it = begin() + pos;
+		const_iterator end_it = end();
+		while (len > 0 && *s != 0 && it != end_it) {
+			int diff = *it - *s;
+			if (diff != 0)
+				return diff;
+			++it;
+			++s;
+			--len;
+		}
+		return 0;
 	}
 
 	bool begins_with(const char* prefix) const {
-		size_t len = strlen(prefix);
-		if (size() < len) return false;
-		return compare(0, len, prefix) == 0;
+		const_iterator it = begin();
+		const_iterator end_it = end();
+		while (*prefix != 0) {
+			if (it == end_it || *prefix != *it)
+				return false;
+			++prefix;
+			++it;
+		}
+		return true;
 	}
 
 	bool ends_with(const char* suffix) const {
-		size_t len = strlen(suffix);
-		if (size() < len) return false;
-		return compare(size()-len, len, suffix) == 0;
+		int suffix_len = strlen(suffix);
+		const_iterator it = begin();
+		int sz = it.size();
+		if (suffix_len > sz)
+			return false;
+		it += sz - suffix_len;
+		while (*suffix != 0) {
+			if (*it != *suffix)
+				return false;
+			++suffix;
+			++it;
+		}
+		return true;
 	}
 
 	bool contains(const char* str) const {
 		return strstr(c_str(), str);
 	}
 
 	size_t size() const {
-		return strlen(c_str());
+		return begin().size();
 	}
 
 	bool empty() const {
@@ -627,7 +742,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);
 		}
 	};
 

tests/unit/kernel/rtlilTest.cc

@@ -373,6 +373,24 @@ 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"));
+	}
+
+	TEST_F(KernelRtlilTest, NewIdIndexing) {
+		IdString id = NEW_ID;
+		std::string str = id.str();
+		for (int i = 0; i < GetSize(str) + 1; ++i) {
+			EXPECT_EQ(id[i], str.c_str()[i]);
+		}
+	}
+
 	class WireRtlVsHdlIndexConversionTest :
 		public KernelRtlilTest,
 		public testing::WithParamInterface<std::tuple<bool, int, int>>