package core:thread

Source

Pool :: struct {
	allocator:         runtime.Allocator,
	mutex:             sync.Mutex,
	sem_available:     sync.Sema,
	// the following values are atomic
	num_waiting:       int,
	num_in_processing: int,
	num_outstanding:   int,
	// num_waiting + num_in_processing
	num_done:          int,
	is_running:        bool,
	threads:           []^Thread,
	tasks:             [dynamic]Task,
	tasks_done:        [dynamic]Task,
}

Task :: struct {
	procedure:  Task_Proc,
	data:       rawptr,
	user_index: int,
	allocator:  runtime.Allocator,
}

Task_Proc :: proc(task: Task)

Thread :: struct {
	using specific:     Thread_Os_Specific,
	flags:              bit_set[Thread_State; u8],
	id:                 int,
	procedure:          Thread_Proc,
	// 		These are values that the user can set as they wish, after the thread has been created.
	// 		This data is easily available to the thread proc.
	// 
	// 		These fields can be assigned to directly.
	// 
	// 		Should be set after the thread is created, but before it is started.
	data:               rawptr,
	user_index:         int,
	user_args:          [8]rawptr,
	// 		The context to be used as 'context' in the thread proc.
	// 
	// 		This field can be assigned to directly, after the thread has been created, but __before__ the thread has been started.
	// 		This field must not be changed after the thread has started.
	// 
	// 		NOTE: If you __don't__ set this, the temp allocator will be managed for you;
	// 		      If you __do__ set this, then you're expected to handle whatever allocators you set, yourself.
	// 
	// 		IMPORTANT:
	// 		By default, the thread proc will get the same context as `main()` gets.
	// 		In this situation, the thread will get a new temporary allocator which will be cleaned up when the thread dies.
	// 		***This does NOT happen when you set `init_context`.***
	// 		This means that if you set `init_context`, but still have the `temp_allocator` field set to the default temp allocator,
	// 		then you'll need to call `runtime.default_temp_allocator_destroy(auto_cast the_thread.init_context.temp_allocator.data)` manually,
	// 		in order to prevent any memory leaks.
	// 		This call ***must*** be done ***in the thread proc*** because the default temporary allocator uses thread local state!
	init_context:       runtime.Maybe($T=Context),
	creation_allocator: runtime.Allocator,
}

Thread_Priority :: enum int {
	Normal, 
	Low, 
	High, 
}

Thread_Proc :: proc(_: ^Thread)

Thread_State :: enum u8 {
	Started, 
	Joined, 
	Done, 
	Self_Cleanup, 
}

MAX_USER_ARGUMENTS :: 8

create :: proc(procedure: Thread_Proc, priority: Thread_Priority = Thread_Priority.Normal) -> ^Thread {…}

create_and_start :: proc(fn: proc(), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal, self_cleanup: bool = false) -> ^Thread {…}

create_and_start_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal, self_cleanup: bool = false) -> ^Thread {…}

create_and_start_with_poly_data :: proc(data: $T, fn: proc(data: $T), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal, self_cleanup: bool = false) -> ^Thread {…}

create_and_start_with_poly_data2 :: proc(
	arg1:         $T, 
	arg2:         $T, 
	fn:           proc(_: $T, _: $T), 
	init_context: runtime.Maybe($T=Context) = nil, 
	priority:     Thread_Priority = Thread_Priority.Normal, 
	self_cleanup: bool = false, 
) -> ^Thread {…}

create_and_start_with_poly_data3 :: proc(
	arg1:         $T, 
	arg2:         $T, 
	arg3:         $T, 
	fn:           proc(arg1: $T, arg2: $T, arg3: $T), 
	init_context: runtime.Maybe($T=Context) = nil, 
	priority:     Thread_Priority = Thread_Priority.Normal, 
	self_cleanup: bool = false, 
) -> ^Thread {…}

create_and_start_with_poly_data4 :: proc(
	arg1:         $T, 
	arg2:         $T, 
	arg3:         $T, 
	arg4:         $T, 
	fn:           proc(arg1: $T, arg2: $T, arg3: $T, arg4: $T), 
	init_context: runtime.Maybe($T=Context) = nil, 
	priority:     Thread_Priority = Thread_Priority.Normal, 
	self_cleanup: bool = false, 
) -> ^Thread {…}

destroy :: proc(thread: ^Thread) {…}

is_done :: proc(thread: ^Thread) -> bool {…}

join :: proc(thread: ^Thread) {…}

join_multiple :: proc(.. threads: ..^Thread) {…}

pool_add_task :: proc(pool: ^Pool, allocator: runtime.Allocator, procedure: Task_Proc, data: rawptr, user_index: int = 0) {…}

pool_destroy :: proc(pool: ^Pool) {…}

pool_do_work :: proc(pool: ^Pool, task: Task) {…}

pool_finish :: proc(pool: ^Pool) {…}

pool_init :: proc(pool: ^Pool, allocator: runtime.Allocator, thread_count: int) {…}

pool_is_empty :: proc(pool: ^Pool) -> bool {…}

pool_join :: proc(pool: ^Pool) {…}

pool_num_done :: proc(pool: ^Pool) -> int {…}

pool_num_in_processing :: proc(pool: ^Pool) -> int {…}

pool_num_outstanding :: proc(pool: ^Pool) -> int {…}

pool_num_waiting :: proc(pool: ^Pool) -> int {…}

pool_pop_done :: proc(pool: ^Pool) -> (task: Task, got_task: bool) {…}

pool_pop_waiting :: proc(pool: ^Pool) -> (task: Task, got_task: bool) {…}

pool_start :: proc(pool: ^Pool) {…}

run :: proc(fn: proc(), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal) {…}

run_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal) {…}

run_with_poly_data :: proc(data: $T, fn: proc(data: $T), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal) {…}

run_with_poly_data2 :: proc(arg1: $T, arg2: $T, fn: proc(_: $T, _: $T), init_context: runtime.Maybe($T=Context) = nil, priority: Thread_Priority = Thread_Priority.Normal) {…}

run_with_poly_data3 :: proc(
	arg1:         $T, 
	arg2:         $T, 
	arg3:         $T, 
	fn:           proc(arg1: $T, arg2: $T, arg3: $T), 
	init_context: runtime.Maybe($T=Context) = nil, 
	priority:     Thread_Priority = Thread_Priority.Normal, 
) {…}

run_with_poly_data4 :: proc(
	arg1:         $T, 
	arg2:         $T, 
	arg3:         $T, 
	arg4:         $T, 
	fn:           proc(arg1: $T, arg2: $T, arg3: $T, arg4: $T), 
	init_context: runtime.Maybe($T=Context) = nil, 
	priority:     Thread_Priority = Thread_Priority.Normal, 
) {…}

start :: proc(thread: ^Thread) {…}

terminate :: proc(thread: ^Thread, exit_code: int) {…}

yield :: proc() {…}