Replace all queues with MPSCQueue where possible

src/check_decl.cpp

@@ -1010,7 +1010,7 @@ gb_internal void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) {
 
 	if (ac.deferred_procedure.entity != nullptr) {
 		e->Procedure.deferred_procedure = ac.deferred_procedure;
-		mpmc_enqueue(&ctx->checker->procs_with_deferred_to_check, e);
+		mpsc_enqueue(&ctx->checker->procs_with_deferred_to_check, e);
 	}
 
 	if (is_foreign) {

src/checker.cpp

@@ -1254,12 +1254,12 @@ gb_internal void init_checker(Checker *c) {
 	c->info.checker = c;
 
 	TIME_SECTION("init proc queues");
-	mpmc_init(&c->procs_with_deferred_to_check, a, 1<<10);
+	mpsc_init(&c->procs_with_deferred_to_check, a); //, 1<<10);
 
 	// NOTE(bill): 1 Mi elements should be enough on average
 	array_init(&c->procs_to_check, heap_allocator(), 0, 1<<20);
 
-	mpmc_init(&c->global_untyped_queue, a, 1<<20);
+	mpsc_init(&c->global_untyped_queue, a); // , 1<<20);
 
 	c->builtin_ctx = make_checker_context(c);
 }
@@ -1270,7 +1270,7 @@ gb_internal void destroy_checker(Checker *c) {
 	destroy_checker_context(&c->builtin_ctx);
 
 	array_free(&c->procs_to_check);
-	mpmc_destroy(&c->global_untyped_queue);
+	mpsc_destroy(&c->global_untyped_queue);
 }
 
 
@@ -4647,10 +4647,10 @@ gb_internal GB_COMPARE_PROC(sort_file_by_name) {
 gb_internal void check_create_file_scopes(Checker *c) {
 	for_array(i, c->parser->packages) {
 		AstPackage *pkg = c->parser->packages[i];
-		isize total_pkg_decl_count = 0;
 
 		gb_sort_array(pkg->files.data, pkg->files.count, sort_file_by_name);
 
+		isize total_pkg_decl_count = 0;
 		for_array(j, pkg->files) {
 			AstFile *f = pkg->files[j];
 			string_map_set(&c->info.files, f->fullpath, f);
@@ -5382,14 +5382,14 @@ gb_internal void add_untyped_expressions(CheckerInfo *cinfo, UntypedExprInfoMap
 		Ast *expr = entry.key;
 		ExprInfo *info = entry.value;
 		if (expr != nullptr && info != nullptr) {
-			mpmc_enqueue(&cinfo->checker->global_untyped_queue, UntypedExprInfo{expr, info});
+			mpsc_enqueue(&cinfo->checker->global_untyped_queue, UntypedExprInfo{expr, info});
 		}
 	}
 	map_clear(untyped);
 }
 
 gb_internal void check_deferred_procedures(Checker *c) {
-	for (Entity *src = nullptr; mpmc_dequeue(&c->procs_with_deferred_to_check, &src); /**/) {
+	for (Entity *src = nullptr; mpsc_dequeue(&c->procs_with_deferred_to_check, &src); /**/) {
 		GB_ASSERT(src->kind == Entity_Procedure);
 
 		DeferredProcedureKind dst_kind = src->Procedure.deferred_procedure.kind;
@@ -5831,7 +5831,7 @@ gb_internal void check_parsed_files(Checker *c) {
 
 	TIME_SECTION("add untyped expression values");
 	// Add untyped expression values
-	for (UntypedExprInfo u = {}; mpmc_dequeue(&c->global_untyped_queue, &u); /**/) {
+	for (UntypedExprInfo u = {}; mpsc_dequeue(&c->global_untyped_queue, &u); /**/) {
 		GB_ASSERT(u.expr != nullptr && u.info != nullptr);
 		if (is_type_typed(u.info->type)) {
 			compiler_error("%s (type %s) is typed!", expr_to_string(u.expr), type_to_string(u.info->type));

src/checker.hpp

@@ -446,11 +446,10 @@ struct Checker {
 
 	CheckerContext builtin_ctx;
 
-	MPMCQueue<Entity *> procs_with_deferred_to_check;
+	MPSCQueue<Entity *> procs_with_deferred_to_check;
 	Array<ProcInfo *> procs_to_check;
 
-	// TODO(bill): Technically MPSC queue
-	MPMCQueue<UntypedExprInfo> global_untyped_queue;
+	MPSCQueue<UntypedExprInfo> global_untyped_queue;
 };
 
 

src/parser.hpp

@@ -176,6 +176,7 @@ struct AstPackage {
 	BlockingMutex         foreign_files_mutex;
 	BlockingMutex         type_and_value_mutex;
 
+	// NOTE(bill): This must be a MPMCQueue
 	MPMCQueue<AstPackageExportedEntity> exported_entity_queue;
 
 	// NOTE(bill): Created/set in checker

src/queue.cpp

@@ -10,11 +10,12 @@ struct MPSCNode {
 //
 template <typename T>
 struct MPSCQueue {
+	gbAllocator allocator;
+	std::atomic<isize> count;
+
 	std::atomic<MPSCNode<T> *> head;
 	std::atomic<MPSCNode<T> *> tail;
-	std::atomic<isize> count;
 	MPSCNode<T> sentinel;
-	gbAllocator allocator;
 };
 
 template <typename T> gb_internal void         mpsc_init   (MPSCQueue<T> *q, gbAllocator const &allocator);
@@ -29,6 +30,7 @@ gb_internal void mpsc_init(MPSCQueue<T> *q, gbAllocator const &allocator) {
 	q->count.store(0, std::memory_order_relaxed);
 	q->head.store(&q->sentinel, std::memory_order_relaxed);
 	q->tail.store(&q->sentinel, std::memory_order_relaxed);
+
 	q->sentinel.next.store(nullptr, std::memory_order_relaxed);
 }
 
@@ -36,14 +38,20 @@ template <typename T>
 gb_internal void mpsc_destroy(MPSCQueue<T> *q) {
 	while (mpsc_dequeue(q, (T *)nullptr)) {}
 	// DO NOTHING for the time being
+	// free the nodes later
 }
 
 
 template <typename T>
 gb_internal MPSCNode<T> *mpsc_alloc_node(MPSCQueue<T> *q, T const &value) {
-	auto node = gb_alloc_item(q->allocator, MPSCNode<T>);
-	node->value = value;
-	return node;
+	auto new_node = gb_alloc_item(q->allocator, MPSCNode<T>);
+	new_node->value = value;
+	return new_node;
+}
+
+template <typename T>
+gb_internal void mpsc_free_node(MPSCQueue<T> *q, MPSCNode<T> *node) {
+	// TODO(bill): reuse the free nodes
 }
 
 template <typename T>
@@ -68,10 +76,8 @@ gb_internal bool mpsc_dequeue(MPSCQueue<T> *q, T *value_) {
 	auto next = tail->next.load(std::memory_order_relaxed);
 	if (next) {
 		q->tail.store(next, std::memory_order_relaxed);
-		// `tail` is now "dead" and needs to be "freed"
-		tail->value = next->value;
-		T value = tail->value;
-		if (value_) *value_ = value;
+		if (value_) *value_ = next->value;
+		mpsc_free_node(q, tail);
 		q->count.fetch_sub(1, std::memory_order_acq_rel);
 		return true;
 	}