Make doc writer use the old "Ordered Insertion" based PtrMap

src/docs_writer.cpp

@@ -26,11 +26,11 @@ struct OdinDocWriter {
 
 	StringMap<OdinDocString> string_cache;
 
-	PtrMap<AstFile *,    OdinDocFileIndex>   file_cache;
+	OrderedInsertPtrMap<AstFile *,    OdinDocFileIndex>   file_cache;
-	PtrMap<AstPackage *, OdinDocPkgIndex>    pkg_cache;
+	OrderedInsertPtrMap<AstPackage *, OdinDocPkgIndex>    pkg_cache;
-	PtrMap<Entity *,     OdinDocEntityIndex> entity_cache;
+	OrderedInsertPtrMap<Entity *,     OdinDocEntityIndex> entity_cache;
-	PtrMap<Type *,       OdinDocTypeIndex>   type_cache;
+	OrderedInsertPtrMap<Type *,       OdinDocTypeIndex>   type_cache;
-	PtrMap<Type *,       Type *>             stable_type_cache;
+	OrderedInsertPtrMap<Type *,       Type *>             stable_type_cache;
 
 	OdinDocWriterItemTracker<OdinDocFile>   files;
 	OdinDocWriterItemTracker<OdinDocPkg>    pkgs;
@@ -57,11 +57,11 @@ gb_internal void odin_doc_writer_prepare(OdinDocWriter *w) {
 
 	string_map_init(&w->string_cache);
 
-	map_init(&w->file_cache);
+	map_init(&w->file_cache,        1<<10);
-	map_init(&w->pkg_cache);
+	map_init(&w->pkg_cache,         1<<10);
-	map_init(&w->entity_cache);
+	map_init(&w->entity_cache,      1<<18);
-	map_init(&w->type_cache);
+	map_init(&w->type_cache,        1<<18);
-	map_init(&w->stable_type_cache);
+	map_init(&w->stable_type_cache, 1<<18);
 
 	odin_doc_writer_item_tracker_init(&w->files,    1);
 	odin_doc_writer_item_tracker_init(&w->pkgs,     1);
@@ -485,6 +485,13 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 		return 0;
 	}
 
+	if (type->kind == Type_Named) {
+		Entity *e = type->Named.type_name;
+		if (e->TypeName.is_type_alias) {
+			type = type->Named.base;
+		}
+	}
+
 	// Type **mapped_type = map_get(&w->stable_type_cache, type); // may map to itself
 	// if (mapped_type && *mapped_type) {
 	// 	type = *mapped_type;
@@ -506,13 +513,6 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) {
 		if (!x | !y) {
 			continue;
 		}
-
-		if (x->kind == Type_Named) {
-			Entity *e = x->Named.type_name;
-			if (e->TypeName.is_type_alias) {
-				x = x->Named.base;
-			}
-		}
 		if (y->kind == Type_Named) {
 			Entity *e = y->Named.type_name;
 			if (e->TypeName.is_type_alias) {

src/ptr_map.cpp

@@ -9,12 +9,6 @@ enum {
 };
 
 
-struct MapFindResult {
-	MapIndex hash_index;
-	MapIndex entry_prev;
-	MapIndex entry_index;
-};
-
 enum : MapIndex { MAP_SENTINEL = ~(MapIndex)0 };
 static void *const MAP_TOMBSTONE = (void *)~(uintptr)0;
 
@@ -433,3 +427,435 @@ gb_internal PtrMapIterator<K, V> const begin(PtrMap<K, V> const &m) noexcept {
 	}
 	return PtrMapIterator<K, V>{&m, index};
 }
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+struct MapFindResult {
+	MapIndex hash_index;
+	MapIndex entry_prev;
+	MapIndex entry_index;
+};
+
+template <typename K, typename V>
+struct OrderedInsertPtrMapEntry {
+	static_assert(sizeof(K) == sizeof(void *), "Key size must be pointer size");
+
+	K        key;
+	V        value;
+	MapIndex next;
+};
+
+template <typename K, typename V>
+struct OrderedInsertPtrMap {
+	MapIndex *hashes;
+	usize     hashes_count;
+	OrderedInsertPtrMapEntry<K, V> *entries;
+	u32       count;
+	u32       entries_capacity;
+};
+
+
+template <typename K, typename V> gb_internal void map_destroy          (OrderedInsertPtrMap<K, V> *h);
+template <typename K, typename V> gb_internal V *  map_get              (OrderedInsertPtrMap<K, V> *h, K key);
+template <typename K, typename V> gb_internal void map_set              (OrderedInsertPtrMap<K, V> *h, K key, V const &value);
+template <typename K, typename V> gb_internal bool map_set_if_not_previously_exists(OrderedInsertPtrMap<K, V> *h, K key, V const &value); // returns true if it previously existed
+template <typename K, typename V> gb_internal void map_remove           (OrderedInsertPtrMap<K, V> *h, K key);
+template <typename K, typename V> gb_internal void map_clear            (OrderedInsertPtrMap<K, V> *h);
+template <typename K, typename V> gb_internal void map_grow             (OrderedInsertPtrMap<K, V> *h);
+template <typename K, typename V> gb_internal void map_rehash           (OrderedInsertPtrMap<K, V> *h, isize new_count);
+template <typename K, typename V> gb_internal void map_reserve          (OrderedInsertPtrMap<K, V> *h, isize cap);
+
+// Mutlivalued map procedure
+template <typename K, typename V> gb_internal OrderedInsertPtrMapEntry<K, V> * multi_map_find_first(OrderedInsertPtrMap<K, V> *h, K key);
+template <typename K, typename V> gb_internal OrderedInsertPtrMapEntry<K, V> * multi_map_find_next (OrderedInsertPtrMap<K, V> *h, OrderedInsertPtrMapEntry<K, V> *e);
+
+template <typename K, typename V> gb_internal isize multi_map_count     (OrderedInsertPtrMap<K, V> *h, K key);
+template <typename K, typename V> gb_internal void  multi_map_get_all   (OrderedInsertPtrMap<K, V> *h, K key, V *items);
+template <typename K, typename V> gb_internal void  multi_map_insert    (OrderedInsertPtrMap<K, V> *h, K key, V const &value);
+template <typename K, typename V> gb_internal void  multi_map_remove    (OrderedInsertPtrMap<K, V> *h, K key, OrderedInsertPtrMapEntry<K, V> *e);
+template <typename K, typename V> gb_internal void  multi_map_remove_all(OrderedInsertPtrMap<K, V> *h, K key);
+
+template <typename K, typename V>
+gb_internal gb_inline void map_init(OrderedInsertPtrMap<K, V> *h, isize capacity) {
+	capacity = next_pow2_isize(capacity);
+	map_reserve(h, capacity);
+}
+
+template <typename K, typename V>
+gb_internal gb_inline void map_destroy(OrderedInsertPtrMap<K, V> *h) {
+	gbAllocator a = map_allocator();
+	gb_free(a, h->hashes);
+	gb_free(a, h->entries);
+}
+
+template <typename K, typename V>
+gb_internal void map__resize_hashes(OrderedInsertPtrMap<K, V> *h, usize count) {
+	h->hashes_count = cast(u32)resize_array_raw(&h->hashes, map_allocator(), h->hashes_count, count, MAP_CACHE_LINE_SIZE);
+}
+
+template <typename K, typename V>
+gb_internal void map__reserve_entries(OrderedInsertPtrMap<K, V> *h, usize capacity) {
+	h->entries_capacity = cast(u32)resize_array_raw(&h->entries, map_allocator(), h->entries_capacity, capacity, MAP_CACHE_LINE_SIZE);
+}
+
+
+template <typename K, typename V>
+gb_internal MapIndex map__add_entry(OrderedInsertPtrMap<K, V> *h, K key) {
+	OrderedInsertPtrMapEntry<K, V> e = {};
+	e.key = key;
+	e.next = MAP_SENTINEL;
+	if (h->count+1 >= h->entries_capacity) {
+		map__reserve_entries(h, gb_max(h->entries_capacity*2, 4));
+	}
+	h->entries[h->count++] = e;
+	return cast(MapIndex)(h->count-1);
+}
+
+template <typename K, typename V>
+gb_internal MapFindResult map__find(OrderedInsertPtrMap<K, V> *h, K key) {
+	MapFindResult fr = {MAP_SENTINEL, MAP_SENTINEL, MAP_SENTINEL};
+	if (h->hashes_count == 0) {
+		return fr;
+	}
+	u32 hash = ptr_map_hash_key(key);
+	fr.hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
+	fr.entry_index = h->hashes[fr.hash_index];
+	while (fr.entry_index != MAP_SENTINEL) {
+		auto *entry = &h->entries[fr.entry_index];
+		if (entry->key == key) {
+			return fr;
+		}
+		fr.entry_prev = fr.entry_index;
+		fr.entry_index = entry->next;
+	}
+	return fr;
+}
+
+template <typename K, typename V>
+gb_internal MapFindResult map__find_from_entry(OrderedInsertPtrMap<K, V> *h, OrderedInsertPtrMapEntry<K, V> *e) {
+	MapFindResult fr = {MAP_SENTINEL, MAP_SENTINEL, MAP_SENTINEL};
+	if (h->hashes_count == 0) {
+		return fr;
+	}
+	u32 hash = ptr_map_hash_key(e->key);
+	fr.hash_index  = cast(MapIndex)(hash & (h->hashes_count-1));
+	fr.entry_index = h->hashes[fr.hash_index];
+	while (fr.entry_index != MAP_SENTINEL) {
+		if (&h->entries[fr.entry_index] == e) {
+			return fr;
+		}
+		fr.entry_prev = fr.entry_index;
+		fr.entry_index = h->entries[fr.entry_index].next;
+	}
+	return fr;
+}
+
+template <typename K, typename V>
+gb_internal b32 map__full(OrderedInsertPtrMap<K, V> *h) {
+	return 0.75f * h->hashes_count <= h->count;
+}
+
+template <typename K, typename V>
+gb_internal gb_inline void map_grow(OrderedInsertPtrMap<K, V> *h) {
+	isize new_count = gb_max(h->hashes_count<<1, 16);
+	map_rehash(h, new_count);
+}
+
+template <typename K, typename V>
+gb_internal void map_reset_entries(OrderedInsertPtrMap<K, V> *h) {
+	for (usize i = 0; i < h->hashes_count; i++) {
+		h->hashes[i] = MAP_SENTINEL;
+	}
+	for (usize i = 0; i < h->count; i++) {
+		MapFindResult fr;
+		OrderedInsertPtrMapEntry<K, V> *e = &h->entries[i];
+		e->next = MAP_SENTINEL;
+		fr = map__find_from_entry(h, e);
+		if (fr.entry_prev == MAP_SENTINEL) {
+			h->hashes[fr.hash_index] = cast(MapIndex)i;
+		} else {
+			h->entries[fr.entry_prev].next = cast(MapIndex)i;
+		}
+	}
+}
+
+template <typename K, typename V>
+gb_internal void map_reserve(OrderedInsertPtrMap<K, V> *h, isize cap) {
+	if (h->count*2 < h->hashes_count) {
+		return;
+	}
+	map__reserve_entries(h, cap);
+	map__resize_hashes(h, cap*2);
+	map_reset_entries(h);
+}
+
+
+template <typename K, typename V>
+gb_internal void map_rehash(OrderedInsertPtrMap<K, V> *h, isize new_count) {
+	map_reserve(h, new_count);
+}
+
+template <typename K, typename V>
+gb_internal V *map_get(OrderedInsertPtrMap<K, V> *h, K key) {
+	MapIndex hash_index  = MAP_SENTINEL;
+	MapIndex entry_prev  = MAP_SENTINEL;
+	MapIndex entry_index = MAP_SENTINEL;
+	if (h->hashes_count != 0) {
+		u32 hash = ptr_map_hash_key(key);
+		hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
+		entry_index = h->hashes[hash_index];
+		while (entry_index != MAP_SENTINEL) {
+			auto *entry = &h->entries[entry_index];
+			if (entry->key == key) {
+				return &entry->value;
+			}
+			entry_prev = entry_index;
+			entry_index = entry->next;
+		}
+	}
+	return nullptr;
+}
+template <typename K, typename V>
+gb_internal V *map_try_get(OrderedInsertPtrMap<K, V> *h, K key, MapFindResult *fr_) {
+	MapFindResult fr = {MAP_SENTINEL, MAP_SENTINEL, MAP_SENTINEL};
+	if (h->hashes_count != 0) {
+		u32 hash = ptr_map_hash_key(key);
+		fr.hash_index = cast(MapIndex)(hash & (h->hashes_count-1));
+		fr.entry_index = h->hashes[fr.hash_index];
+		while (fr.entry_index != MAP_SENTINEL) {
+			auto *entry = &h->entries[fr.entry_index];
+			if (entry->key == key) {
+				return &entry->value;
+			}
+			fr.entry_prev = fr.entry_index;
+			fr.entry_index = entry->next;
+		}
+	}
+	if (h->hashes_count == 0 || map__full(h)) {
+		map_grow(h);
+	}
+	if (fr_) *fr_ = fr;
+	return nullptr;
+}
+
+
+template <typename K, typename V>
+gb_internal void map_set_internal_from_try_get(OrderedInsertPtrMap<K, V> *h, K key, V const &value, MapFindResult const &fr) {
+	MapIndex index = map__add_entry(h, key);
+	if (fr.entry_prev != MAP_SENTINEL) {
+		h->entries[fr.entry_prev].next = index;
+	} else {
+		h->hashes[fr.hash_index] = index;
+	}
+	h->entries[index].value = value;
+}
+
+template <typename K, typename V>
+gb_internal V &map_must_get(OrderedInsertPtrMap<K, V> *h, K key) {
+	V *ptr = map_get(h, key);
+	GB_ASSERT(ptr != nullptr);
+	return *ptr;
+}
+
+template <typename K, typename V>
+gb_internal void map_set(OrderedInsertPtrMap<K, V> *h, K key, V const &value) {
+	MapIndex index;
+	MapFindResult fr;
+	if (h->hashes_count == 0) {
+		map_grow(h);
+	}
+	fr = map__find(h, key);
+	if (fr.entry_index != MAP_SENTINEL) {
+		index = fr.entry_index;
+	} else {
+		index = map__add_entry(h, key);
+		if (fr.entry_prev != MAP_SENTINEL) {
+			h->entries[fr.entry_prev].next = index;
+		} else {
+			h->hashes[fr.hash_index] = index;
+		}
+	}
+	h->entries[index].value = value;
+
+	if (map__full(h)) {
+		map_grow(h);
+	}
+}
+
+// returns true if it previously existed
+template <typename K, typename V>
+gb_internal bool map_set_if_not_previously_exists(OrderedInsertPtrMap<K, V> *h, K key, V const &value) {
+	MapIndex index;
+	MapFindResult fr;
+	if (h->hashes_count == 0) {
+		map_grow(h);
+	}
+	fr = map__find(h, key);
+	if (fr.entry_index != MAP_SENTINEL) {
+		return true;
+	} else {
+		index = map__add_entry(h, key);
+		if (fr.entry_prev != MAP_SENTINEL) {
+			h->entries[fr.entry_prev].next = index;
+		} else {
+			h->hashes[fr.hash_index] = index;
+		}
+	}
+	h->entries[index].value = value;
+
+	if (map__full(h)) {
+		map_grow(h);
+	}
+	return false;
+}
+
+
+template <typename K, typename V>
+gb_internal void map__erase(OrderedInsertPtrMap<K, V> *h, MapFindResult const &fr) {
+	MapFindResult last;
+	if (fr.entry_prev == MAP_SENTINEL) {
+		h->hashes[fr.hash_index] = h->entries[fr.entry_index].next;
+	} else {
+		h->entries[fr.entry_prev].next = h->entries[fr.entry_index].next;
+	}
+	if (fr.entry_index == h->count-1) {
+		h->count--;
+		return;
+	}
+	h->entries[fr.entry_index] = h->entries[h->count-1];
+	h->count--;
+
+	last = map__find(h, h->entries[fr.entry_index].key);
+	if (last.entry_prev != MAP_SENTINEL) {
+		h->entries[last.entry_prev].next = fr.entry_index;
+	} else {
+		h->hashes[last.hash_index] = fr.entry_index;
+	}
+}
+
+template <typename K, typename V>
+gb_internal void map_remove(OrderedInsertPtrMap<K, V> *h, K key) {
+	MapFindResult fr = map__find(h, key);
+	if (fr.entry_index != MAP_SENTINEL) {
+		map__erase(h, fr);
+	}
+}
+
+template <typename K, typename V>
+gb_internal gb_inline void map_clear(OrderedInsertPtrMap<K, V> *h) {
+	h->count = 0;
+	for (usize i = 0; i < h->hashes_count; i++) {
+		h->hashes[i] = MAP_SENTINEL;
+	}
+}
+
+
+template <typename K, typename V>
+gb_internal OrderedInsertPtrMapEntry<K, V> *multi_map_find_first(OrderedInsertPtrMap<K, V> *h, K key) {
+	MapIndex i = map__find(h, key).entry_index;
+	if (i == MAP_SENTINEL) {
+		return nullptr;
+	}
+	return &h->entries[i];
+}
+
+template <typename K, typename V>
+gb_internal OrderedInsertPtrMapEntry<K, V> *multi_map_find_next(OrderedInsertPtrMap<K, V> *h, OrderedInsertPtrMapEntry<K, V> *e) {
+	MapIndex i = e->next;
+	while (i != MAP_SENTINEL) {
+		if (h->entries[i].key == e->key) {
+			return &h->entries[i];
+		}
+		i = h->entries[i].next;
+	}
+	return nullptr;
+}
+
+template <typename K, typename V>
+gb_internal isize multi_map_count(OrderedInsertPtrMap<K, V> *h, K key) {
+	isize count = 0;
+	OrderedInsertPtrMapEntry<K, V> *e = multi_map_find_first(h, key);
+	while (e != nullptr) {
+		count++;
+		e = multi_map_find_next(h, e);
+	}
+	return count;
+}
+
+template <typename K, typename V>
+gb_internal void multi_map_get_all(OrderedInsertPtrMap<K, V> *h, K key, V *items) {
+	usize i = 0;
+	OrderedInsertPtrMapEntry<K, V> *e = multi_map_find_first(h, key);
+	while (e != nullptr) {
+		items[i++] = e->value;
+		e = multi_map_find_next(h, e);
+	}
+}
+
+template <typename K, typename V>
+gb_internal void multi_map_insert(OrderedInsertPtrMap<K, V> *h, K key, V const &value) {
+	MapFindResult fr;
+	MapIndex i;
+	if (h->hashes_count == 0) {
+		map_grow(h);
+	}
+	// Make
+	fr = map__find(h, key);
+	i = map__add_entry(h, key);
+	if (fr.entry_prev == MAP_SENTINEL) {
+		h->hashes[fr.hash_index] = i;
+	} else {
+		h->entries[fr.entry_prev].next = i;
+	}
+	h->entries[i].next = fr.entry_index;
+	h->entries[i].value = value;
+	// Grow if needed
+	if (map__full(h)) {
+		map_grow(h);
+	}
+}
+
+template <typename K, typename V>
+gb_internal void multi_map_remove(OrderedInsertPtrMap<K, V> *h, K key, OrderedInsertPtrMapEntry<K, V> *e) {
+	MapFindResult fr = map__find_from_entry(h, e);
+	if (fr.entry_index != MAP_SENTINEL) {
+		map__erase(h, fr);
+	}
+}
+
+template <typename K, typename V>
+gb_internal void multi_map_remove_all(OrderedInsertPtrMap<K, V> *h, K key) {
+	while (map_get(h, key) != nullptr) {
+		map_remove(h, key);
+	}
+}
+
+
+template <typename K, typename V>
+gb_internal OrderedInsertPtrMapEntry<K, V> *begin(OrderedInsertPtrMap<K, V> &m) {
+	return m.entries;
+}
+template <typename K, typename V>
+gb_internal OrderedInsertPtrMapEntry<K, V> const *begin(OrderedInsertPtrMap<K, V> const &m) {
+	return m.entries;
+}
+
+
+template <typename K, typename V>
+gb_internal OrderedInsertPtrMapEntry<K, V> *end(OrderedInsertPtrMap<K, V> &m) {
+	return m.entries + m.count;
+}
+
+template <typename K, typename V>
+gb_internal OrderedInsertPtrMapEntry<K, V> const *end(OrderedInsertPtrMap<K, V> const &m) {
+	return m.entries + m.count;
+}