1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
package thread
import "core:runtime"
import "core:mem"
import "intrinsics"
_ :: intrinsics;
Thread_Proc :: #type proc(^Thread);
MAX_USER_ARGUMENTS :: 8;
Thread :: struct {
using specific: Thread_Os_Specific,
procedure: Thread_Proc,
data: rawptr,
user_index: int,
user_args: [MAX_USER_ARGUMENTS]rawptr,
init_context: Maybe(runtime.Context),
creation_allocator: mem.Allocator,
}
#assert(size_of(Thread{}.user_index) == size_of(uintptr));
Thread_Priority :: enum {
Normal,
Low,
High,
}
create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread {
return _create(procedure, priority);
}
destroy :: proc(thread: ^Thread) {
_destroy(thread);
}
start :: proc(thread: ^Thread) {
_start(thread);
}
is_done :: proc(thread: ^Thread) -> bool {
return _is_done(thread);
}
join :: proc(thread: ^Thread) {
_join(thread);
}
join_mulitple :: proc(threads: ..^Thread) {
_join_multiple(..threads);
}
terminate :: proc(thread: ^Thread, exit_code: int) {
_terminate(thread, exit_code);
}
yield :: proc() {
_yield();
}
run :: proc(fn: proc(), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal) {
thread_proc :: proc(t: ^Thread) {
fn := cast(proc())t.data;
fn();
destroy(t);
}
t := create(thread_proc, priority);
t.data = rawptr(fn);
t.init_context = init_context;
start(t);
}
run_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal) {
thread_proc :: proc(t: ^Thread) {
fn := cast(proc(rawptr))t.data;
assert(t.user_index >= 1);
data := t.user_args[0];
fn(data);
destroy(t);
}
t := create(thread_proc, priority);
t.data = rawptr(fn);
t.user_index = 1;
t.user_args = data;
t.init_context = init_context;
start(t);
}
run_with_poly_data :: proc(data: $T, fn: proc(data: T), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
where size_of(T) <= size_of(rawptr) {
thread_proc :: proc(t: ^Thread) {
fn := cast(proc(T))t.data;
assert(t.user_index >= 1);
data := (^T)(&t.user_args[0])^;
fn(data);
destroy(t);
}
t := create(thread_proc, priority);
t.data = rawptr(fn);
t.user_index = 1;
data := data;
mem.copy(&t.user_args[0], &data, size_of(data));
t.init_context = init_context;
start(t);
}
run_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
where size_of(T1) <= size_of(rawptr),
size_of(T2) <= size_of(rawptr) {
thread_proc :: proc(t: ^Thread) {
fn := cast(proc(T1, T2))t.data;
assert(t.user_index >= 2);
arg1 := (^T1)(&t.user_args[0])^;
arg2 := (^T2)(&t.user_args[1])^;
fn(arg1, arg2);
destroy(t);
}
t := create(thread_proc, priority);
t.data = rawptr(fn);
t.user_index = 2;
arg1, arg2 := arg1, arg2;
mem.copy(&t.user_args[0], &arg1, size_of(arg1));
mem.copy(&t.user_args[1], &arg2, size_of(arg2));
t.init_context = init_context;
start(t);
}
run_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: proc(arg1: T1, arg2: T2, arg3: T3), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
where size_of(T1) <= size_of(rawptr),
size_of(T2) <= size_of(rawptr),
size_of(T3) <= size_of(rawptr) {
thread_proc :: proc(t: ^Thread) {
fn := cast(proc(T1, T2, T3))t.data;
assert(t.user_index >= 3);
arg1 := (^T1)(&t.user_args[0])^;
arg2 := (^T2)(&t.user_args[1])^;
arg3 := (^T3)(&t.user_args[2])^;
fn(arg1, arg2, arg3);
destroy(t);
}
t := create(thread_proc, priority);
t.data = rawptr(fn);
t.user_index = 3;
arg1, arg2, arg3 := arg1, arg2, arg3;
mem.copy(&t.user_args[0], &arg1, size_of(arg1));
mem.copy(&t.user_args[1], &arg2, size_of(arg2));
mem.copy(&t.user_args[2], &arg3, size_of(arg3));
t.init_context = init_context;
start(t);
}
run_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4: $T4, fn: proc(arg1: T1, arg2: T2, arg3: T3, arg4: T4), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
where size_of(T1) <= size_of(rawptr),
size_of(T2) <= size_of(rawptr),
size_of(T3) <= size_of(rawptr) {
thread_proc :: proc(t: ^Thread) {
fn := cast(proc(T1, T2, T3, T4))t.data;
assert(t.user_index >= 4);
arg1 := (^T1)(&t.user_args[0])^;
arg2 := (^T2)(&t.user_args[1])^;
arg3 := (^T3)(&t.user_args[2])^;
arg4 := (^T4)(&t.user_args[3])^;
fn(arg1, arg2, arg3, arg4);
destroy(t);
}
t := create(thread_proc, priority);
t.data = rawptr(fn);
t.user_index = 4;
arg1, arg2, arg3, arg4 := arg1, arg2, arg3, arg4;
mem.copy(&t.user_args[0], &arg1, size_of(arg1));
mem.copy(&t.user_args[1], &arg2, size_of(arg2));
mem.copy(&t.user_args[2], &arg3, size_of(arg3));
mem.copy(&t.user_args[3], &arg4, size_of(arg4));
t.init_context = init_context;
start(t);
}
create_and_start :: proc(fn: Thread_Proc, init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal) -> ^Thread {
t := create(fn, priority);
t.init_context = init_context;
start(t);
return t;
}
|
