Struct Socket 

pub struct Socket { /* private fields */ }

An owned, non-blocking socket. Closed on drop.

Implementations

impl Socket

pub fn new(family: i32, ty: i32) -> Result<Socket, Error>

Creates a raw non-blocking socket.

pub fn tcp_listen( addr: SocketAddr, opts: &ListenOptions, ) -> Result<Socket, Error>

A non-blocking TCP listener bound to addr.

pub fn udp_bind(addr: SocketAddr, opts: &UdpOptions) -> Result<Socket, Error>

A non-blocking UDP socket bound to addr.

pub fn tcp_connect(addr: SocketAddr) -> Result<Socket, Error>

Connects a TCP socket to addr, waiting for the handshake, and returns it non-blocking with TCP_NODELAY set. Meant for clients and tests.

Examples found in repository

examples/loadgen.rs (line 108)

fn main() {
    let mut addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
    let (mut conns, mut threads, mut secs, mut pipeline) = (64usize, 4usize, 10u64, 1usize);
    let mut cpus: Option<Vec<usize>> = None;
    let v: Vec<String> = std::env::args().skip(1).collect();
    let mut i = 0;
    while i < v.len() {
        let val = v.get(i + 1).cloned().unwrap_or_default();
        match v[i].as_str() {
            "--addr" => addr = val.parse().expect("--addr"),
            "--conns" => conns = val.parse().expect("--conns"),
            "--threads" => threads = val.parse().expect("--threads"),
            "--secs" => secs = val.parse().expect("--secs"),
            "--pipeline" => pipeline = val.parse().expect("--pipeline"),
            "--cpus" => cpus = Some(val.split(',').map(|s| s.trim().parse().expect("--cpus")).collect()),
            other => panic!("unknown argument {other}"),
        }
        i += 2;
    }
    let rt = Runtime::builder()
        .configure(|c| {
            c.threads = threads;
            c.thread_name = "loadgen".into();
            if let Some(cpus) = cpus {
                c.pin_threads = true;
                c.cpus = Some(cpus);
            }
        })
        .start()
        .expect("start");
    let (htx, hrx) = mpsc::channel::<ConnHandle>();
    for k in 0..conns {
        let sock = Socket::tcp_connect(addr).expect("connect");
        let htx = htx.clone();
        rt.loops()[k % threads].run(move |lcx| {
            let h = lcx.adopt(sock, Box::new(Client { pipeline })).expect("adopt");
            htx.send(h).unwrap();
        });
    }
    drop(htx);
    let handles: Vec<ConnHandle> = hrx.iter().take(conns).collect();
    for h in &handles {
        h.send(Box::new(()));
    }
    let count = |rt: &simoom_rt::RuntimeHandle| -> (u64, u64) {
        let (tx, rx) = mpsc::channel();
        for l in rt.loops() {
            let tx = tx.clone();
            l.run(move |_| tx.send((DONE.with(|c| c.get()), ERRORS.with(|c| c.get()))).unwrap());
        }
        drop(tx);
        rx.iter().fold((0, 0), |a, b| (a.0 + b.0, a.1 + b.1))
    };
    std::thread::sleep(Duration::from_secs(1));
    let (r0, _) = count(&rt);
    let s0 = rt.stats().total().driver;
    let t0 = Instant::now();
    std::thread::sleep(Duration::from_secs(secs));
    let (r1, errors) = count(&rt);
    let el = t0.elapsed().as_secs_f64();
    let s1 = rt.stats().total().driver;
    let rps = (r1 - r0) as f64 / el;
    let lat_us = (conns * pipeline) as f64 / rps * 1e6;
    println!(
        "{conns} conns x {pipeline} pipelined, {threads} threads: {rps:.0} req/s, mean latency {lat_us:.1} us (Little), closed connections {errors}, client syscalls/req {:.2}",
        (s1.syscalls() - s0.syscalls()) as f64 / (r1 - r0).max(1) as f64
    );
    rt.stop(Duration::ZERO);
    rt.join();
}

pub fn accept(&self) -> Result<(Socket, Option<SocketAddr>), Error>

Accepts one pending connection without blocking. The new socket is non-blocking.

pub fn recv(&self, buf: &mut [u8]) -> Result<usize, Error>

Receives into buf without blocking. Ok(0) means the peer closed its side.

pub fn recv_into(&self, buf: &mut Vec<u8>) -> Result<usize, Error>

Receives into the spare capacity of buf and extends its length by the bytes read.

pub fn send(&self, buf: &[u8]) -> Result<usize, Error>

Sends from buf without blocking (never raises SIGPIPE).

pub fn send_vectored(&self, bufs: &[&[u8]]) -> Result<usize, Error>

Sends several buffers with one call (sendmsg / WSASend) without blocking. At most 64 buffers are sent per call.

pub fn shutdown(&self, how: Shutdown) -> Result<(), Error>

Shuts down one or both directions.

pub fn set_nodelay(&self, on: bool) -> Result<(), Error>

Sets or clears TCP_NODELAY.

pub fn nodelay(&self) -> Result<bool, Error>

Whether TCP_NODELAY is set.

pub fn set_nonblocking(&self, on: bool) -> Result<(), Error>

Switches non-blocking mode.

pub fn local_addr(&self) -> Result<SocketAddr, Error>

The local address.

pub fn peer_addr(&self) -> Result<SocketAddr, Error>

The peer address.

pub fn take_error(&self) -> Result<Option<Error>, Error>

Reads and clears the pending socket error (SO_ERROR).

pub fn setsockopt_int( &self, level: i32, name: i32, value: i32, ) -> Result<(), Error>

Sets an integer socket option.

pub fn getsockopt_int(&self, level: i32, name: i32) -> Result<i32, Error>

Reads an integer socket option.

pub fn raw(&self) -> i32

The raw handle (still owned by this Socket).

pub unsafe fn from_raw(raw: i32) -> Socket

Takes ownership of a raw handle.

Safety

raw must be an open socket that nothing else owns or will close.

pub fn into_raw(self) -> i32

Gives up ownership of the raw handle.

pub fn into_tcp_stream(self) -> TcpStream

Converts into a std TCP stream (it stays non-blocking).

pub fn into_tcp_listener(self) -> TcpListener

Converts into a std TCP listener (it stays non-blocking).

pub fn into_udp_socket(self) -> UdpSocket

Converts into a std UDP socket (it stays non-blocking).

pub fn try_clone(&self) -> Result<Socket, Error>

An independent handle to the same socket (dup / WSADuplicateSocket).

impl Socket

pub fn recv_msgs( &self, bufs: &mut [Vec<u8>], meta: &mut [RecvMeta], ) -> Result<usize, Error>

Receives up to bufs.len() (at most BATCH) datagrams without blocking. Each buffer is cleared and filled up to its capacity; meta[i] describes bufs[i]. Returns how many were received, or a WouldBlock error when none was waiting.

pub fn send_msgs(&self, msgs: &[Transmit<'_>]) -> Result<usize, Error>

Sends up to BATCH transmits without blocking. Returns how many were handed to the kernel; a WouldBlock error means none was (the socket buffer is full).

Trait Implementations

impl Debug for Socket

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<TcpListener> for Socket

fn from(s: TcpListener) -> Socket

Takes over a std socket. Call set_nonblocking(true) on it first if it will be driven by an event loop.

impl From<TcpStream> for Socket

fn from(s: TcpStream) -> Socket

Takes over a std socket. Call set_nonblocking(true) on it first if it will be driven by an event loop.

impl From<UdpSocket> for Socket

fn from(s: UdpSocket) -> Socket

Takes over a std socket. Call set_nonblocking(true) on it first if it will be driven by an event loop.