mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 06:13:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

std.Io: delete asyncParallel

Browse Source
This commit is contained in:
Andrew Kelley 2025-07-18 09:41:48 -07:00
parent 363d7deb8a
commit b70f12fc40
3 changed files with 10 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
lib/std/Io.zig
View File

@ -934,8 +934,6 @@ pub const VTable = struct {
context_alignment: std.mem.Alignment,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
) ?*AnyFuture,
/// Returning `null` indicates resource allocation failed.
///
/// Thread-safe.
asyncConcurrent: *const fn (
/// Corresponds to `Io.userdata`.
@ -947,19 +945,6 @@ pub const VTable = struct {
context_alignment: std.mem.Alignment,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
) error{OutOfMemory}!*AnyFuture,
/// Returning `null` indicates resource allocation failed.
///
/// Thread-safe.
asyncParallel: *const fn (
/// Corresponds to `Io.userdata`.
userdata: ?*anyopaque,
result_len: usize,
result_alignment: std.mem.Alignment,
/// Copied and then passed to `start`.
context: []const u8,
context_alignment: std.mem.Alignment,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
) error{OutOfMemory}!*AnyFuture,
/// Executes `start` asynchronously in a manner such that it cleans itself
/// up. This mode does not support results, await, or cancel.
///
@ -1519,8 +1504,8 @@ pub fn Queue(Elem: type) type {
/// not guaranteed to be available until `await` is called.
///
/// `function` *may* be called immediately, before `async` returns. This has
/// weaker guarantees than `asyncConcurrent` and `asyncParallel`, making it the
/// most portable and reusable among the async family functions.
/// weaker guarantees than `asyncConcurrent`, making more portable and
/// reusable.
///
/// See also:
/// * `asyncDetached`
@ -1551,13 +1536,12 @@ pub fn async(
}
/// Calls `function` with `args`, such that the return value of the function is
/// not guaranteed to be available until `await` is called, passing control
/// flow back to the caller while waiting for any `Io` operations.
/// not guaranteed to be available until `await` is called, allowing the caller
/// to progress while waiting for any `Io` operations.
///
/// This has a weaker guarantee than `asyncParallel`, making it more portable
/// and reusable, however it has stronger guarantee than `async`, placing
/// restrictions on what kind of `Io` implementations are supported. By calling
/// `async` instead, one allows, for example, stackful single-threaded blocking I/O.
/// This has stronger guarantee than `async`, placing restrictions on what kind
/// of `Io` implementations are supported. By calling `async` instead, one
/// allows, for example, stackful single-threaded blocking I/O.
pub fn asyncConcurrent(
io: Io,
function: anytype,
@ -1584,44 +1568,6 @@ pub fn asyncConcurrent(
return future;
}
/// Simultaneously calls `function` with `args` while passing control flow back
/// to the caller. The return value of the function is not guaranteed to be
/// available until `await` is called.
///
/// This has the strongest guarantees of all async family functions, placing
/// the most restrictions on what kind of `Io` implementations are supported.
/// By calling `asyncConcurrent` instead, one allows, for example, stackful
/// single-threaded non-blocking I/O.
///
/// See also:
/// * `asyncConcurrent`
/// * `async`
pub fn asyncParallel(
io: Io,
function: anytype,
args: std.meta.ArgsTuple(@TypeOf(function)),
) error{OutOfMemory}!Future(@typeInfo(@TypeOf(function)).@"fn".return_type.?) {
const Result = @typeInfo(@TypeOf(function)).@"fn".return_type.?;
const Args = @TypeOf(args);
const TypeErased = struct {
fn start(context: *const anyopaque, result: *anyopaque) void {
const args_casted: *const Args = @alignCast(@ptrCast(context));
const result_casted: *Result = @ptrCast(@alignCast(result));
result_casted.* = @call(.auto, function, args_casted.*);
}
};
var future: Future(Result) = undefined;
future.any_future = try io.vtable.asyncParallel(
io.userdata,
@sizeOf(Result),
.of(Result),
@ptrCast((&args)[0..1]),
.of(Args),
TypeErased.start,
);
return future;
}
/// Calls `function` with `args` asynchronously. The resource cleans itself up
/// when the function returns. Does not support await, cancel, or a return value.
///

18
lib/std/Io/EventLoop.zig
View File

@ -140,7 +140,6 @@ pub fn io(el: *EventLoop) Io {
.vtable = &.{
.async = async,
.asyncConcurrent = asyncConcurrent,
.asyncParallel = asyncParallel,
.await = await,
.asyncDetached = asyncDetached,
.select = select,
@ -938,23 +937,6 @@ fn asyncConcurrent(
return @ptrCast(fiber);
}
fn asyncParallel(
userdata: ?*anyopaque,
result_len: usize,
result_alignment: Alignment,
context: []const u8,
context_alignment: Alignment,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
) error{OutOfMemory}!*std.Io.AnyFuture {
_ = userdata;
_ = result_len;
_ = result_alignment;
_ = context;
_ = context_alignment;
_ = start;
@panic("TODO");
}
const DetachedClosure = struct {
event_loop: *EventLoop,
fiber: *Fiber,

7
lib/std/Io/ThreadPool.zig
View File

@ -86,8 +86,7 @@ pub fn io(pool: *Pool) Io {
.userdata = pool,
.vtable = &.{
.async = async,
.asyncConcurrent = asyncParallel,
.asyncParallel = asyncParallel,
.asyncConcurrent = asyncConcurrent,
.await = await,
.asyncDetached = asyncDetached,
.cancel = cancel,
@ -220,7 +219,7 @@ fn async(
}
const pool: *Pool = @alignCast(@ptrCast(userdata));
const cpu_count = pool.cpu_count catch {
return asyncParallel(userdata, result.len, result_alignment, context, context_alignment, start) catch {
return asyncConcurrent(userdata, result.len, result_alignment, context, context_alignment, start) catch {
start(context.ptr, result.ptr);
return null;
};
@ -284,7 +283,7 @@ fn async(
return @ptrCast(closure);
}
fn asyncParallel(
fn asyncConcurrent(
userdata: ?*anyopaque,
result_len: usize,
result_alignment: std.mem.Alignment,