lithdew

const std = @import("std");

const os = std.os;
const net = std.net;
const mem = std.mem;
const log = std.log.scoped(.server);

const assert = std.debug.assert;

pub const io_mode = .evented;

lithdew

$ go test -bench=. -run=NONE
goos: linux
goarch: amd64
cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkOneShotEvent-8          3904360               306.8 ns/op             8 B/op          1 allocs/op
BenchmarkChannel-8               3139602               381.7 ns/op            96 B/op          1 allocs/op
BenchmarkWaitGroup-8             2958838               408.5 ns/op            16 B/op          1 allocs/op

lithdew

const std = @import("std");

const os = std.os;
const builtin = std.builtin;
const testing = std.testing;

const assert = std.debug.assert;

/// A simple cancellation framework for blocking/non-blocking tasks.
pub const Cancellation = struct {

lithdew

1. A listening socket blocked on accept() can be unblocked by calling shutdown(socket_fd, SHUT_RD) on Linux. On Mac, calling shutdown(socket_fd, SHUT_RD) on a listening socket that is blocked on accept() will return an error ENOTCONN. To unblock a listening socket blocked on accept() on Mac requires calling close(socket_fd), which will cause the blocking accept() call to return an error EBADF.

Therefore, in order to unblock a socket on accept() on both Mac/Linux, shutdown() should not be relied on. Rather, an async cancellation scheme (such as cancellation tokens in .NET) should be used instead to unblock the call to accept().

2. When a socket is instantiated and subsequently registered to epoll, or when a socket is shut down (via. shutdown() or setsockopt(SO_LINGER)) on Linux, epoll will be notified with EPOLLHUP on the socket. On Mac, kqueue will only notify when a socket is shut down (via. shutdown() or setsockopt(SO_LINGER)) by sending a EV_EOF notification on filters EVFILT_READ, and EVFILT_WRITE.

Thi

lithdew

• Include std.x.os.Reactor.

A high-level I/O event reactor interface that wraps over event notification systems like epoll, kqueue.

Plan is to get epoll done first, kqueue second, select third, then iocp/afd fourth.

• Include std.x.os.Socket.setLinger(linger_for_num_seconds: ?u16) !void.
• Include std.x.os.Socket.getRemoteAddress() !std.x.Socket.Address.
• Include std.x.os.Socket.setKeepAlive(enabled bool) !void.
• Include std.x.os.Socket.(r|R)eader(flags) and std.x.os.Socket.(w|W)riter(flags).

lithdew

const std = @import("std");

const os = std.os;
const mem = std.mem;
const testing = std.testing;

pub fn Channel(comptime T: type) type {
    return struct {
        const Self = @This();

lithdew

const std = @import("std");

const mem = std.mem;
const math = std.math;

const VACANT = math.maxInt(usize);

pub fn RingBuffer(comptime T: type, comptime num_readers: comptime_int, comptime capacity: comptime_int) type {
    return struct {
        const Self = @This();

lithdew

// zig run benchmark.zig -lc -O ReleaseFast

const std = @import("std");

usingnamespace @import("hashmap.zig");

pub fn main() !void {
    const allocator = std.heap.c_allocator;

    var map = try HashMap(

lithdew

const std = @import("std");

const mem = std.mem;
const fmt = std.fmt;
const sort = std.sort;
const testing = std.testing;

pub fn Trie(comptime S: []const u8, comptime V: type) type {
    return struct {
        const Self = @This();

lithdew

const std = @import("std");
const Pool = @import("Pool.zig");
const List = @import("DoublyLinkedList.zig");

const mem = std.mem;
const testing = std.testing;

const Group = @This();

const Child = struct {