Convert `missing_procedures_to_check` to a queue

src/llvm_backend.cpp

@@ -2477,15 +2477,9 @@ gb_internal void lb_generate_procedures(lbGenerator *gen, bool do_threading) {
 
 gb_internal WORKER_TASK_PROC(lb_generate_missing_procedures_to_check_worker_proc) {
 	lbModule *m = cast(lbModule *)data;
-	for (isize i = 0; i < m->missing_procedures_to_check.count; i++) {
-		lbProcedure *p = m->missing_procedures_to_check[i];
+	for (lbProcedure *p = nullptr; mpsc_dequeue(&m->missing_procedures_to_check, &p); /**/) {
 		debugf("Generate missing procedure: %.*s module %p\n", LIT(p->name), m);
-		isize count = m->procedures_to_generate.count;
 		lb_generate_procedure(m, p);
-		isize new_count = m->procedures_to_generate.count;
-		if (count != new_count) {
-			gb_printf_err("NEW STUFF!\n");
-		}
 	}
 	return 0;
 }
@@ -2505,6 +2499,12 @@ gb_internal void lb_generate_missing_procedures(lbGenerator *gen, bool do_thread
 			lb_generate_missing_procedures_to_check_worker_proc(m);
 		}
 	}
+
+	for (auto const &entry : gen->modules) {
+		lbModule *m = entry.value;
+		GB_ASSERT(m->missing_procedures_to_check.count == 0);
+		GB_ASSERT(m->procedures_to_generate.count == 0);
+	}
 }
 
 gb_internal void lb_debug_info_complete_types_and_finalize(lbGenerator *gen) {

src/llvm_backend.hpp

@@ -176,8 +176,7 @@ struct lbModule {
 	StringMap<lbProcedure *> procedures;
 	PtrMap<LLVMValueRef, Entity *> procedure_values;
 
-	BlockingMutex missing_procedures_to_check_mutex;
-	Array<lbProcedure *> missing_procedures_to_check;
+	MPSCQueue<lbProcedure *> missing_procedures_to_check;
 
 	StringMap<LLVMValueRef>   const_strings;
 	String16Map<LLVMValueRef> const_string16s;

src/llvm_backend_general.cpp

@@ -109,7 +109,7 @@ gb_internal WORKER_TASK_PROC(lb_init_module_worker_proc) {
 
 	array_init(&m->global_procedures_to_create, a, 0, 1024);
 	array_init(&m->global_types_to_create, a, 0, 1024);
-	array_init(&m->missing_procedures_to_check, a, 0, 16);
+	mpsc_init(&m->missing_procedures_to_check, a);
 	map_init(&m->debug_values);
 
 	string_map_init(&m->objc_classes);
@@ -3079,18 +3079,16 @@ gb_internal lbValue lb_find_procedure_value_from_entity(lbModule *m, Entity *e)
 		// defer (mutex_unlock(&gen->anonymous_proc_lits_mutex));
 
 		GB_ASSERT(other_module != nullptr);
-		mutex_lock(&other_module->missing_procedures_to_check_mutex);
 		rw_mutex_shared_lock(&other_module->values_mutex);
 		auto *found = map_get(&other_module->values, e);
 		rw_mutex_shared_unlock(&other_module->values_mutex);
 		if (found == nullptr) {
 			// THIS IS THE RACE CONDITION
 			lbProcedure *missing_proc_in_other_module = lb_create_procedure(other_module, e, false);
-			array_add(&other_module->missing_procedures_to_check, missing_proc_in_other_module);
+			mpsc_enqueue(&other_module->missing_procedures_to_check, missing_proc_in_other_module);
 		}
-		mutex_unlock(&other_module->missing_procedures_to_check_mutex);
 	} else {
-		array_add(&m->missing_procedures_to_check, missing_proc);
+		mpsc_enqueue(&m->missing_procedures_to_check, missing_proc);
 	}
 
 	rw_mutex_shared_lock(&m->values_mutex);
@@ -3157,16 +3155,14 @@ gb_internal lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &pr
 
 
 	if (target_module != m) {
-		mutex_lock(&target_module->missing_procedures_to_check_mutex);
 		rw_mutex_shared_lock(&target_module->values_mutex);
 		lbValue *found = map_get(&target_module->values, e);
 		rw_mutex_shared_unlock(&target_module->values_mutex);
 		if (found == nullptr) {
 			lbProcedure *missing_proc_in_target_module = lb_create_procedure(target_module, e, false);
-			array_add(&target_module->missing_procedures_to_check, missing_proc_in_target_module);
+			mpsc_enqueue(&target_module->missing_procedures_to_check, missing_proc_in_target_module);
 		}
 
-		mutex_unlock(&target_module->missing_procedures_to_check_mutex);
 
 		lbProcedure *p = lb_create_procedure(m, e, true);