Remove the synchronization primitive init/destroy calls

src/build_settings.cpp

@@ -1363,7 +1363,6 @@ gb_internal bool init_build_paths(String init_filename) {
 	array_init(&bc->build_paths, permanent_allocator(), BuildPathCOUNT);
 
 	string_set_init(&bc->target_features_set, heap_allocator(), 1024);
-	mutex_init(&bc->target_features_mutex);
 
 	// [BuildPathMainPackage] Turn given init path into a `Path`, which includes normalizing it into a full path.
 	bc->build_paths[BuildPath_Main_Package] = path_from_string(ha, init_filename);

src/checker.cpp

@@ -184,7 +184,6 @@ gb_internal void init_decl_info(DeclInfo *d, Scope *scope, DeclInfo *parent) {
 	ptr_set_init(&d->deps,           heap_allocator());
 	ptr_set_init(&d->type_info_deps, heap_allocator());
 	array_init  (&d->labels,         heap_allocator());
-	mutex_init(&d->proc_checked_mutex);
 }
 
 gb_internal DeclInfo *make_decl_info(Scope *scope, DeclInfo *parent) {
@@ -225,7 +224,6 @@ gb_internal Scope *create_scope(CheckerInfo *info, Scope *parent, isize init_ele
 	s->parent = parent;
 	string_map_init(&s->elements, heap_allocator(), init_elements_capacity);
 	ptr_set_init(&s->imported, heap_allocator(), 0);
-	mutex_init(&s->mutex);
 
 	if (parent != nullptr && parent != builtin_pkg->scope) {
 		Scope *prev_head_child = parent->head_child.exchange(s, std::memory_order_acq_rel);
@@ -306,7 +304,6 @@ gb_internal void destroy_scope(Scope *scope) {
 
 	string_map_destroy(&scope->elements);
 	ptr_set_destroy(&scope->imported);
-	mutex_destroy(&scope->mutex);
 
 	// NOTE(bill): No need to free scope as it "should" be allocated in an arena (except for the global scope)
 }
@@ -1134,24 +1131,9 @@ gb_internal void init_checker_info(CheckerInfo *i) {
 
 	TIME_SECTION("checker info: mutexes");
 
-	mutex_init(&i->gen_procs_mutex);
-	mutex_init(&i->gen_types_mutex);
-	mutex_init(&i->lazy_mutex);
-	mutex_init(&i->builtin_mutex);
-	mutex_init(&i->global_untyped_mutex);
-	mutex_init(&i->type_info_mutex);
-	mutex_init(&i->deps_mutex);
-	mutex_init(&i->type_and_value_mutex);
-	mutex_init(&i->identifier_uses_mutex);
-	mutex_init(&i->foreign_mutex);
-
-	semaphore_init(&i->collect_semaphore);
-
 	mpmc_init(&i->intrinsics_entry_point_usage, a, 1<<10); // just waste some memory here, even if it probably never used
 
-	mutex_init(&i->objc_types_mutex);
 	map_init(&i->objc_msgSend_types, a);
-	mutex_init(&i->load_file_mutex);
 	string_map_init(&i->load_file_cache, a);
 }
 
@@ -1175,20 +1157,7 @@ gb_internal void destroy_checker_info(CheckerInfo *i) {
 	mpmc_destroy(&i->required_global_variable_queue);
 	mpmc_destroy(&i->required_foreign_imports_through_force_queue);
 
-	mutex_destroy(&i->gen_procs_mutex);
-	mutex_destroy(&i->gen_types_mutex);
-	mutex_destroy(&i->lazy_mutex);
-	mutex_destroy(&i->builtin_mutex);
-	mutex_destroy(&i->global_untyped_mutex);
-	mutex_destroy(&i->type_info_mutex);
-	mutex_destroy(&i->deps_mutex);
-	mutex_destroy(&i->type_and_value_mutex);
-	mutex_destroy(&i->identifier_uses_mutex);
-	mutex_destroy(&i->foreign_mutex);
-
-	mutex_destroy(&i->objc_types_mutex);
 	map_destroy(&i->objc_msgSend_types);
-	mutex_init(&i->load_file_mutex);
 	string_map_destroy(&i->load_file_cache);
 }
 
@@ -1201,11 +1170,9 @@ gb_internal CheckerContext make_checker_context(Checker *c) {
 
 	ctx.type_path = new_checker_type_path();
 	ctx.type_level = 0;
-	mutex_init(&ctx.mutex);
 	return ctx;
 }
 gb_internal void destroy_checker_context(CheckerContext *ctx) {
-	mutex_destroy(&ctx->mutex);
 	destroy_checker_type_path(ctx->type_path);
 }
 
@@ -1264,7 +1231,6 @@ gb_internal void init_checker(Checker *c) {
 
 	// NOTE(bill): 1 Mi elements should be enough on average
 	mpmc_init(&c->procs_to_check_queue, heap_allocator(), 1<<20);
-	semaphore_init(&c->procs_to_check_semaphore);
 
 	mpmc_init(&c->global_untyped_queue, a, 1<<20);
 
@@ -1277,8 +1243,6 @@ gb_internal void destroy_checker(Checker *c) {
 	destroy_checker_context(&c->builtin_ctx);
 
 	mpmc_destroy(&c->procs_to_check_queue);
-	semaphore_destroy(&c->procs_to_check_semaphore);
-
 	mpmc_destroy(&c->global_untyped_queue);
 }
 

src/common_memory.cpp

@@ -42,8 +42,6 @@ gb_global BlockingMutex global_memory_allocator_mutex;
 gb_internal void platform_virtual_memory_init(void);
 
 gb_internal void virtual_memory_init(void) {
-	mutex_init(&global_memory_block_mutex);
-	mutex_init(&global_memory_allocator_mutex);
 	platform_virtual_memory_init();
 }
 

src/entity.cpp

@@ -154,7 +154,6 @@ struct TypeNameObjCMetadata {
 gb_internal TypeNameObjCMetadata *create_type_name_obj_c_metadata() {
 	TypeNameObjCMetadata *md = gb_alloc_item(permanent_allocator(), TypeNameObjCMetadata);
 	md->mutex = gb_alloc_item(permanent_allocator(), BlockingMutex);
-	mutex_init(md->mutex);
 	array_init(&md->type_entries,  heap_allocator());
 	array_init(&md->value_entries, heap_allocator());
 	return md;

src/error.cpp

@@ -22,10 +22,6 @@ gb_internal bool any_errors(void) {
 }
 
 gb_internal void init_global_error_collector(void) {
-	mutex_init(&global_error_collector.mutex);
-	mutex_init(&global_error_collector.block_mutex);
-	mutex_init(&global_error_collector.error_out_mutex);
-	mutex_init(&global_error_collector.string_mutex);
 	array_init(&global_error_collector.errors, heap_allocator());
 	array_init(&global_error_collector.error_buffer, heap_allocator());
 	array_init(&global_file_path_strings, heap_allocator(), 1, 4096);

src/llvm_backend_general.cpp

@@ -132,7 +132,6 @@ gb_internal bool lb_init_generator(lbGenerator *gen, Checker *c) {
 	map_init(&gen->anonymous_proc_lits, heap_allocator(), 1024);
 
 
-	mutex_init(&gen->foreign_mutex);
 	array_init(&gen->foreign_libraries,       heap_allocator(), 0, 1024);
 	ptr_set_init(&gen->foreign_libraries_set, heap_allocator(), 1024);
 

src/main.cpp

@@ -2498,15 +2498,10 @@ int main(int arg_count, char const **arg_ptr) {
 	MAIN_TIME_SECTION("initialization");
 
 	virtual_memory_init();
-	mutex_init(&fullpath_mutex);
-	mutex_init(&hash_exact_value_mutex);
-	mutex_init(&global_type_name_objc_metadata_mutex);
 
-	init_string_buffer_memory();
 	init_string_interner();
 	init_global_error_collector();
 	init_keyword_hash_table();
-	init_type_mutex();
 
 	if (!check_env()) {
 		return 1;

src/parser.cpp

@@ -4858,10 +4858,6 @@ gb_internal bool init_parser(Parser *p) {
 	GB_ASSERT(p != nullptr);
 	string_set_init(&p->imported_files, heap_allocator());
 	array_init(&p->packages, heap_allocator());
-	mutex_init(&p->imported_files_mutex);
-	mutex_init(&p->file_decl_mutex);
-	mutex_init(&p->packages_mutex);
-	mutex_init(&p->file_error_mutex);
 	return true;
 }
 
@@ -4878,10 +4874,6 @@ gb_internal void destroy_parser(Parser *p) {
 	}
 	array_free(&p->packages);
 	string_set_destroy(&p->imported_files);
-	mutex_destroy(&p->imported_files_mutex);
-	mutex_destroy(&p->file_decl_mutex);
-	mutex_destroy(&p->packages_mutex);
-	mutex_destroy(&p->file_error_mutex);
 }
 
 
@@ -4978,9 +4970,6 @@ gb_internal AstPackage *try_add_import_path(Parser *p, String const &path, Strin
 	pkg->fullpath = path;
 	array_init(&pkg->files, heap_allocator());
 	pkg->foreign_files.allocator = heap_allocator();
-	mutex_init(&pkg->files_mutex);
-	mutex_init(&pkg->foreign_files_mutex);
-
 
 	// NOTE(bill): Single file initial package
 	if (kind == Package_Init && string_ends_with(path, FILE_EXT)) {

src/queue.cpp

@@ -52,7 +52,6 @@ gb_internal void mpmc_init(MPMCQueue<T> *q, gbAllocator a, isize size_i) {
 	size = next_pow2(size);
 	GB_ASSERT(gb_is_power_of_two(size));
 
-	mutex_init(&q->mutex);
 	q->mask = size-1;
 	q->allocator = a;
 	q->nodes   = gb_alloc_array(a, T, size);
@@ -65,7 +64,6 @@ gb_internal void mpmc_init(MPMCQueue<T> *q, gbAllocator a, isize size_i) {
 
 template <typename T>
 gb_internal void mpmc_destroy(MPMCQueue<T> *q) {
-	mutex_destroy(&q->mutex);
 	gb_free(q->allocator, q->nodes);
 	gb_free(q->allocator, q->indices);
 }

src/string.cpp

@@ -1,10 +1,5 @@
 gb_global BlockingMutex string_buffer_mutex = {};
 
-gb_internal void init_string_buffer_memory(void) {
-	mutex_init(&string_buffer_mutex);
-}
-
-
 // NOTE(bill): Used for UTF-8 strings
 struct String {
 	u8 *  text;

src/thread_pool.cpp

@@ -23,9 +23,6 @@ struct ThreadPool {
 };
 
 gb_internal void thread_pool_init(ThreadPool *pool, gbAllocator const &a, isize thread_count, char const *worker_name) {
-	mutex_init(&pool->task_lock);
-	condition_init(&pool->tasks_available);
-
 	pool->allocator = a;
 	slice_init(&pool->threads, a, thread_count + 1);
 
@@ -54,8 +51,6 @@ gb_internal void thread_pool_destroy(ThreadPool *pool) {
 	}
 
 	gb_free(pool->allocator, pool->threads.data);
-	mutex_destroy(&pool->task_lock);
-	condition_destroy(&pool->tasks_available);
 }
 
 void thread_pool_queue_push(Thread *thread, WorkerTask task) {

src/threading.cpp

@@ -48,30 +48,22 @@ gb_internal void futex_wait(Futex *addr, Footex val);
 gb_internal void futex_signal(Futex *addr);
 gb_internal void futex_broadcast(Futex *addr);
 
-gb_internal void mutex_init    (BlockingMutex *m);
-gb_internal void mutex_destroy (BlockingMutex *m);
 gb_internal void mutex_lock    (BlockingMutex *m);
 gb_internal bool mutex_try_lock(BlockingMutex *m);
 gb_internal void mutex_unlock  (BlockingMutex *m);
-gb_internal void mutex_init    (RecursiveMutex *m);
-gb_internal void mutex_destroy (RecursiveMutex *m);
+
 gb_internal void mutex_lock    (RecursiveMutex *m);
 gb_internal bool mutex_try_lock(RecursiveMutex *m);
 gb_internal void mutex_unlock  (RecursiveMutex *m);
 
-gb_internal void semaphore_init   (Semaphore *s);
-gb_internal void semaphore_destroy(Semaphore *s);
 gb_internal void semaphore_post   (Semaphore *s, i32 count);
 gb_internal void semaphore_wait   (Semaphore *s);
 gb_internal void semaphore_release(Semaphore *s) { semaphore_post(s, 1); }
 
 
-gb_internal void condition_init(Condition *c);
-gb_internal void condition_destroy(Condition *c);
 gb_internal void condition_broadcast(Condition *c);
 gb_internal void condition_signal(Condition *c);
 gb_internal void condition_wait(Condition *c, BlockingMutex *m);
-gb_internal void condition_wait_with_timeout(Condition *c, BlockingMutex *m, u32 timeout_in_ms);
 
 gb_internal u32  thread_current_id(void);
 
@@ -122,12 +114,7 @@ struct RecursiveMutex {
 	Futex owner;
 	i32   recursion;
 };
-gb_internal void mutex_init(RecursiveMutex *m) {
 
-}
-gb_internal void mutex_destroy(RecursiveMutex *m) {
-
-}
 gb_internal void mutex_lock(RecursiveMutex *m) {
 	Futex tid = cast(i32)thread_current_id();
 	for (;;) {
@@ -166,12 +153,6 @@ struct Semaphore {
 	Futex count;
 };
 
-gb_internal void semaphore_init(Semaphore *s) {
-
-}
-gb_internal void semaphore_destroy(Semaphore *s) {
-
-}
 gb_internal void semaphore_post(Semaphore *s, i32 count) {
 	s->count.fetch_add(count, std::memory_order_release);
 	if (s->count == 1) {
@@ -198,10 +179,6 @@ gb_internal void semaphore_wait(Semaphore *s) {
 	struct BlockingMutex {
 		SRWLOCK srwlock;
 	};
-	gb_internal void mutex_init(BlockingMutex *m) {
-	}
-	gb_internal void mutex_destroy(BlockingMutex *m) {
-	}
 	gb_internal void mutex_lock(BlockingMutex *m) {
 		AcquireSRWLockExclusive(&m->srwlock);
 	}
@@ -229,10 +206,6 @@ gb_internal void semaphore_wait(Semaphore *s) {
 	gb_internal void condition_wait(Condition *c, BlockingMutex *m) {
 		SleepConditionVariableSRW(&c->cond, &m->srwlock, INFINITE, 0);
 	}
-	gb_internal void condition_wait_with_timeout(Condition *c, BlockingMutex *m, u32 timeout_in_ms) {
-		SleepConditionVariableSRW(&c->cond, &m->srwlock, timeout_in_ms, 0);
-	}
-
 #else
 	enum Internal_Mutex_State : i32 {
 		Internal_Mutex_State_Unlocked = 0,
@@ -251,9 +224,6 @@ gb_internal void semaphore_wait(Semaphore *s) {
 		}
 	};
 
-	gb_internal void mutex_init(BlockingMutex *m) {};
-	gb_internal void mutex_destroy(BlockingMutex *m) {};
-
 	gb_no_inline gb_internal void mutex_lock_slow(BlockingMutex *m, i32 curr_state) {
 		i32 new_state = curr_state;
 		for (i32 spin = 0; spin < 100; spin++) {
@@ -323,9 +293,6 @@ gb_internal void semaphore_wait(Semaphore *s) {
 		}
 	};
 
-	gb_internal void condition_init(Condition *c) {}
-	gb_internal void condition_destroy(Condition *c) {}
-
 	gb_internal void condition_broadcast(Condition *c) {
 		c->state().fetch_add(1, std::memory_order_release);
 		futex_broadcast(&c->state());

src/types.cpp

@@ -808,10 +808,6 @@ gb_internal void type_path_pop(TypePath *tp) {
 #define FAILURE_SIZE      0
 #define FAILURE_ALIGNMENT 0
 
-gb_internal void init_type_mutex(void) {
-	mutex_init(&g_type_mutex);
-}
-
 gb_internal bool type_ptr_set_update(PtrSet<Type *> *s, Type *t) {
 	if (ptr_set_exists(s, t)) {
 		return true;