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
|
const ThreadPool = @import("root").bun.ThreadPool;
const std = @import("std");
pub const Batch = ThreadPool.Batch;
pub const Task = ThreadPool.Task;
pub fn NewWorkPool(comptime max_threads: ?usize) type {
return struct {
var pool: ThreadPool = undefined;
var loaded: bool = false;
fn create() *ThreadPool {
@setCold(true);
pool = ThreadPool.init(.{
.max_threads = max_threads orelse @max(@truncate(u32, std.Thread.getCpuCount() catch 0), 2),
.stack_size = 2 * 1024 * 1024,
});
return &pool;
}
pub inline fn get() *ThreadPool {
// lil racy
if (loaded) return &pool;
loaded = true;
return create();
}
pub fn scheduleBatch(batch: ThreadPool.Batch) void {
get().schedule(batch);
}
pub fn schedule(task: *ThreadPool.Task) void {
get().schedule(ThreadPool.Batch.from(task));
}
pub fn go(allocator: std.mem.Allocator, comptime Context: type, context: Context, comptime function: fn (Context) void) !void {
const TaskType = struct {
task: Task,
context: Context,
allocator: std.mem.Allocator,
pub fn callback(task: *Task) void {
var this_task = @fieldParentPtr(@This(), "task", task);
function(this_task.context);
this_task.allocator.destroy(this_task);
}
};
var task_ = try allocator.create(TaskType);
task_.* = .{
.task = .{ .callback = TaskType.callback },
.context = context,
.allocator = allocator,
};
schedule(&task_.task);
}
};
}
pub const WorkPool = NewWorkPool(null);
|
