Skip to content

Commit 43e0d91

Browse files
sdzx-1sdzx-1
committed
Use new io interface
1 parent e2efc4f commit 43e0d91

File tree

7 files changed

+66
-53
lines changed

7 files changed

+66
-53
lines changed

‎build.zig‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -74,9 +74,9 @@ pub fn addGraphFile(
7474
polysession: *std.Build.Module,
7575
target: std.Build.ResolvedTarget,
7676
) std.Build.LazyPath {
77-
const options = b.addOptions();
77+
var options = b.addOptions();
7878

79-
const writer = options.contents.writer(b.allocator);
79+
// const writer = options.contents.writer(b.allocator);
8080

8181
const stdio_writer_setup =
8282
\\var stdout_buffer: [1024]u8 = undefined;
@@ -85,7 +85,7 @@ pub fn addGraphFile(
8585
\\defer writer.flush() catch @panic("Failed to flush");
8686
;
8787

88-
writer.print(
88+
options.contents.print(b.allocator,
8989
\\const std = @import("std");
9090
\\const ps = @import("polysession");
9191
\\const Target = @import("{s}");
@@ -116,7 +116,7 @@ pub fn addGraphFile(
116116
.root_module = opt_mod,
117117
});
118118
const run = b.addRunArtifact(opt_exe);
119-
return run.captureStdOut();
119+
return run.captureStdOut(.{});
120120
}
121121

122122
pub fn addInstallGraphFile(

‎examples/2pc.zig‎

Lines changed: 13 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -36,39 +36,42 @@ pub fn main() !void {
3636
var gpa_instance = std.heap.DebugAllocator(.{}).init;
3737
const gpa = gpa_instance.allocator();
3838

39-
var mvar_channel_map: MvarChannelMap = .init();
39+
var threaded = std.Io.Threaded.init(gpa);
40+
const io = threaded.io();
41+
42+
var mvar_channel_map: MvarChannelMap = try .init();
4043
try mvar_channel_map.generate_all_MvarChannel(gpa, 10);
4144

4245
const alice = struct {
43-
fn run(mcm: *MvarChannelMap) !void {
46+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
4447
var alice_context: AliceContext = undefined;
4548
const fill_ptr: []u8 = @ptrCast(&alice_context.xoshiro256.s);
4649
std.crypto.random.bytes(fill_ptr);
4750

48-
try Runner.runProtocol(.alice, false, mcm, curr_id, &alice_context);
51+
try Runner.runProtocol(io_, .alice, false, mcm, curr_id, &alice_context);
4952
}
5053
};
5154

5255
const bob = struct {
53-
fn run(mcm: *MvarChannelMap) !void {
56+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
5457
var bob_context: BobContext = undefined;
5558
const fill_ptr: []u8 = @ptrCast(&bob_context.xoshiro256.s);
5659
std.crypto.random.bytes(fill_ptr);
5760

58-
try Runner.runProtocol(.bob, false, mcm, curr_id, &bob_context);
61+
try Runner.runProtocol(io_, .bob, false, mcm, curr_id, &bob_context);
5962
}
6063
};
6164

6265
const charlie = struct {
63-
fn run(mcm: *MvarChannelMap) !void {
66+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
6467
var charlie_context: CharlieContext = .{};
65-
try Runner.runProtocol(.charlie, false, mcm, curr_id, &charlie_context);
68+
try Runner.runProtocol(io_, .charlie, false, mcm, curr_id, &charlie_context);
6669
}
6770
};
6871

69-
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{&mvar_channel_map});
70-
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{&mvar_channel_map});
71-
const charlie_thread = try std.Thread.spawn(.{}, charlie.run, .{&mvar_channel_map});
72+
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{ io, &mvar_channel_map });
73+
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{ io, &mvar_channel_map });
74+
const charlie_thread = try std.Thread.spawn(.{}, charlie.run, .{ io, &mvar_channel_map });
7275

7376
alice_thread.join();
7477
bob_thread.join();

‎examples/channel.zig‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -91,13 +91,13 @@ pub fn MvarChannelMap(Role: type) type {
9191
return struct {
9292
hashmap: std.AutoArrayHashMapUnmanaged([2]u8, MvarChannel),
9393
log: bool = true,
94-
msg_delay: ?u64 = 10, //ms
95-
start_timestamp: i64,
94+
msg_delay: ?i64 = 10, //ms
95+
start_timestamp: std.time.Instant,
9696

97-
pub fn init() @This() {
97+
pub fn init() !@This() {
9898
return .{
9999
.hashmap = .empty,
100-
.start_timestamp = std.time.milliTimestamp(),
100+
.start_timestamp = try std.time.Instant.now(),
101101
};
102102
}
103103

@@ -131,16 +131,16 @@ pub fn MvarChannelMap(Role: type) type {
131131
}
132132
}
133133

134-
pub fn recv(self: @This(), curr_role: Role, other: Role, state_id: anytype, T: type) !T {
134+
pub fn recv(self: @This(), io: std.Io, curr_role: Role, other: Role, state_id: anytype, T: type) !T {
135135
const mvar_channel = self.hashmap.get(.{ @intFromEnum(curr_role), @intFromEnum(other) }).?;
136136
const res = try mvar_channel.recv(state_id, T);
137-
if (self.msg_delay) |delay| std.Thread.sleep(std.time.ns_per_ms * delay);
137+
if (self.msg_delay) |delay| try io.sleep(.fromMilliseconds(delay), .awake);
138138
return res;
139139
}
140140

141141
pub fn send(self: @This(), curr_role: Role, other: Role, state_id: anytype, val: anytype) !void {
142142
if (self.log) std.debug.print("[{D}] statd_id: {d}, {t} send to {t}: {any}\n", .{
143-
(std.time.milliTimestamp() - self.start_timestamp) * std.time.ns_per_ms,
143+
(try std.time.Instant.now()).since(self.start_timestamp),
144144
state_id,
145145
curr_role,
146146
other,

‎examples/pingpong.zig‎

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -29,25 +29,28 @@ pub fn main() !void {
2929
var gpa_instance = std.heap.DebugAllocator(.{}).init;
3030
const gpa = gpa_instance.allocator();
3131

32-
var mvar_channel_map: MvarChannelMap = .init();
32+
var mvar_channel_map: MvarChannelMap = try .init();
3333
try mvar_channel_map.generate_all_MvarChannel(gpa, 10);
3434

35+
var threaded = std.Io.Threaded.init(gpa);
36+
const io = threaded.io();
37+
3538
const alice = struct {
36-
fn run(mcm: *MvarChannelMap) !void {
39+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
3740
var alice_context: AliceContext = .{};
38-
try Runner.runProtocol(.alice, false, mcm, curr_id, &alice_context);
41+
try Runner.runProtocol(io_, .alice, false, mcm, curr_id, &alice_context);
3942
}
4043
};
4144

4245
const bob = struct {
43-
fn run(mcm: *MvarChannelMap) !void {
46+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
4447
var bob_context: BobContext = .{};
45-
try Runner.runProtocol(.bob, false, mcm, curr_id, &bob_context);
48+
try Runner.runProtocol(io_, .bob, false, mcm, curr_id, &bob_context);
4649
}
4750
};
4851

49-
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{&mvar_channel_map});
50-
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{&mvar_channel_map});
52+
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{ io, &mvar_channel_map });
53+
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{ io, &mvar_channel_map });
5154

5255
alice_thread.join();
5356
bob_thread.join();

‎examples/random_pingpong_2pc.zig‎

Lines changed: 16 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -10,53 +10,56 @@ pub fn main() !void {
1010
var gpa_instance = std.heap.DebugAllocator(.{}).init;
1111
const gpa = gpa_instance.allocator();
1212

13-
var mvar_channel_map: MvarChannelMap = .init();
13+
var threaded = std.Io.Threaded.init(gpa);
14+
const io = threaded.io();
15+
16+
var mvar_channel_map: MvarChannelMap = try .init();
1417
try mvar_channel_map.generate_all_MvarChannel(gpa, 10);
1518

1619
const alice = struct {
17-
fn run(mcm: *MvarChannelMap) !void {
20+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
1821
var alice_context: AliceContext = .{};
1922
const fill_ptr: []u8 = @ptrCast(&alice_context.xoshiro256.s);
2023
std.crypto.random.bytes(fill_ptr);
2124

22-
try Runner.runProtocol(.alice, false, mcm, curr_id, &alice_context);
25+
try Runner.runProtocol(io_, .alice, false, mcm, curr_id, &alice_context);
2326
}
2427
};
2528

2629
const bob = struct {
27-
fn run(mcm: *MvarChannelMap) !void {
30+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
2831
var bob_context: BobContext = .{};
2932
const fill_ptr: []u8 = @ptrCast(&bob_context.xoshiro256.s);
3033
std.crypto.random.bytes(fill_ptr);
3134

32-
try Runner.runProtocol(.bob, false, mcm, curr_id, &bob_context);
35+
try Runner.runProtocol(io_, .bob, false, mcm, curr_id, &bob_context);
3336
}
3437
};
3538

3639
const charlie = struct {
37-
fn run(mcm: *MvarChannelMap) !void {
40+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
3841
var charlie_context: CharlieContext = .{};
3942
const fill_ptr: []u8 = @ptrCast(&charlie_context.xoshiro256.s);
4043
std.crypto.random.bytes(fill_ptr);
4144

42-
try Runner.runProtocol(.charlie, false, mcm, curr_id, &charlie_context);
45+
try Runner.runProtocol(io_, .charlie, false, mcm, curr_id, &charlie_context);
4346
}
4447
};
4548

4649
const selector = struct {
47-
fn run(mcm: *MvarChannelMap) !void {
50+
fn run(io_: std.Io, mcm: *MvarChannelMap) !void {
4851
var charlie_context: SelectorContext = .{};
4952
const fill_ptr: []u8 = @ptrCast(&charlie_context.xoshiro256.s);
5053
std.crypto.random.bytes(fill_ptr);
5154

52-
try Runner.runProtocol(.selector, false, mcm, curr_id, &charlie_context);
55+
try Runner.runProtocol(io_, .selector, false, mcm, curr_id, &charlie_context);
5356
}
5457
};
5558

56-
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{&mvar_channel_map});
57-
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{&mvar_channel_map});
58-
const charlie_thread = try std.Thread.spawn(.{}, charlie.run, .{&mvar_channel_map});
59-
const selector_thread = try std.Thread.spawn(.{}, selector.run, .{&mvar_channel_map});
59+
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{ io, &mvar_channel_map });
60+
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{ io, &mvar_channel_map });
61+
const charlie_thread = try std.Thread.spawn(.{}, charlie.run, .{ io, &mvar_channel_map });
62+
const selector_thread = try std.Thread.spawn(.{}, selector.run, .{ io, &mvar_channel_map });
6063

6164
alice_thread.join();
6265
bob_thread.join();

‎examples/sendfile.zig‎

Lines changed: 11 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,9 @@ pub fn main() !void {
3939
var gpa_instance = std.heap.DebugAllocator(.{}).init;
4040
const gpa = gpa_instance.allocator();
4141

42+
var threaded = std.Io.Threaded.init(gpa);
43+
const io = threaded.io();
44+
4245
//create tmp dir
4346
var tmp_dir_instance = std.testing.tmpDir(.{});
4447
defer tmp_dir_instance.cleanup();
@@ -53,30 +56,30 @@ pub fn main() !void {
5356
}
5457
}
5558

56-
var mvar_channel_map: MvarChannelMap = .init();
59+
var mvar_channel_map: MvarChannelMap = try .init();
5760
try mvar_channel_map.generate_all_MvarChannel(gpa, 2 * 1024 * 1024);
5861

5962
const alice = struct {
60-
fn run(mcm: *MvarChannelMap, tmp_dir_: std.fs.Dir) !void {
63+
fn run(io_: std.Io, mcm: *MvarChannelMap, tmp_dir_: std.fs.Dir) !void {
6164
var file_reader_buf: [1024 * 2]u8 = undefined;
6265

6366
const read_file = try tmp_dir_.openFile("test_read", .{});
6467
defer read_file.close();
6568

66-
var file_reader = read_file.reader(&file_reader_buf);
69+
var file_reader = read_file.reader(io_, &file_reader_buf);
6770

6871
var alice_context: AliceContext = .{
6972
.sendfile = .{
7073
.reader = &file_reader.interface,
7174
.file_size = (try read_file.stat()).size,
7275
},
7376
};
74-
try Runner.runProtocol(.alice, false, mcm, curr_id, &alice_context);
77+
try Runner.runProtocol(io_, .alice, false, mcm, curr_id, &alice_context);
7578
}
7679
};
7780

7881
const bob = struct {
79-
fn run(mcm: *MvarChannelMap, tmp_dir_: std.fs.Dir) !void {
82+
fn run(io_: std.Io, mcm: *MvarChannelMap, tmp_dir_: std.fs.Dir) !void {
8083
const write_file = try tmp_dir_.createFile("test_write", .{});
8184
defer write_file.close();
8285

@@ -85,12 +88,12 @@ pub fn main() !void {
8588
var file_writer = write_file.writer(&file_writer_buf);
8689

8790
var bob_context: BobContext = .{ .sendfile = .{ .writer = &file_writer.interface } };
88-
try Runner.runProtocol(.bob, false, mcm, curr_id, &bob_context);
91+
try Runner.runProtocol(io_, .bob, false, mcm, curr_id, &bob_context);
8992
}
9093
};
9194

92-
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{ &mvar_channel_map, tmp_dir });
93-
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{ &mvar_channel_map, tmp_dir });
95+
const alice_thread = try std.Thread.spawn(.{}, alice.run, .{ io, &mvar_channel_map, tmp_dir });
96+
const bob_thread = try std.Thread.spawn(.{}, bob.run, .{ io, &mvar_channel_map, tmp_dir });
9497

9598
alice_thread.join();
9699
bob_thread.join();

‎src/root.zig‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -357,6 +357,7 @@ pub fn Runner(
357357
}
358358
}
359359
pub fn runProtocol(
360+
io: std.Io,
360361
comptime curr_role: Role,
361362
comptime mult_channel_static_index_role: bool,
362363
mult_channel: anytype,
@@ -382,9 +383,9 @@ pub fn Runner(
382383
//It ensures that the sender and receiver of the notification can be determined by the state machine.
383384
const notify: Notify =
384385
if (mult_channel_static_index_role)
385-
try @field(mult_channel, @tagName(internal_roles[0])).recv(state_id, Notify)
386+
try @field(mult_channel, @tagName(internal_roles[0])).recv(io, state_id, Notify)
386387
else
387-
try mult_channel.recv(curr_role, internal_roles[0], state_id, Notify);
388+
try mult_channel.recv(io, curr_role, internal_roles[0], state_id, Notify);
388389

389390
const next_state_id: StateId = @enumFromInt(notify.polysession_notify);
390391
continue :sw next_state_id;
@@ -417,9 +418,9 @@ pub fn Runner(
417418
//curr_role is the receiver
418419
const result =
419420
if (mult_channel_static_index_role)
420-
try @field(mult_channel, @tagName(sender)).recv(state_id, State)
421+
try @field(mult_channel, @tagName(sender)).recv(io, state_id, State)
421422
else
422-
try mult_channel.recv(curr_role, sender, state_id, State);
423+
try mult_channel.recv(io, curr_role, sender, state_id, State);
423424

424425
//If the receiver needs to notify an external actor,
425426
// it should do so as soon as possible,

0 commit comments

Comments
 (0)