• Stars
    star
    329
  • Rank 128,030 (Top 3 %)
  • Language
    Rust
  • License
    Apache License 2.0
  • Created over 4 years ago
  • Updated over 1 year ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Portable interface to epoll, kqueue, event ports, and wepoll

polling

Build License Cargo Documentation

Portable interface to epoll, kqueue, event ports, and IOCP.

Supported platforms:

  • epoll: Linux, Android
  • kqueue: macOS, iOS, tvOS, watchOS, FreeBSD, NetBSD, OpenBSD, DragonFly BSD
  • event ports: illumos, Solaris
  • poll: VxWorks, Fuchsia, other Unix systems
  • IOCP: Windows, Wine (version 7.13+)

Polling is done in oneshot mode, which means interest in I/O events needs to be reset after an event is delivered if we're interested in the next event of the same kind.

Only one thread can be waiting for I/O events at a time.

Examples

use polling::{Event, Poller};
use std::net::TcpListener;

// Create a TCP listener.
let socket = TcpListener::bind("127.0.0.1:8000")?;
socket.set_nonblocking(true)?;
let key = 7; // Arbitrary key identifying the socket.

// Create a poller and register interest in readability on the socket.
let poller = Poller::new()?;
poller.add(&socket, Event::readable(key))?;

// The event loop.
let mut events = Vec::new();
loop {
    // Wait for at least one I/O event.
    events.clear();
    poller.wait(&mut events, None)?;

    for ev in &events {
        if ev.key == key {
            // Perform a non-blocking accept operation.
            socket.accept()?;
            // Set interest in the next readability event.
            poller.modify(&socket, Event::readable(key))?;
        }
    }
}

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

More Repositories

1

smol

A small and fast async runtime for Rust
Rust
2,871
star
2

async-channel

Async multi-producer multi-consumer channel
Rust
524
star
3

async-io

Async I/O and timers
Rust
330
star
4

futures-lite

Futures, streams, and async I/O combinators.
Rust
293
star
5

fastrand

A simple and fast random number generator
Rust
287
star
6

blocking

A thread pool for isolating blocking I/O in async programs
Rust
278
star
7

event-listener

Notify async tasks or threads
Rust
274
star
8

async-task

Task abstraction for building executors
Rust
255
star
9

async-lock

Async synchronization primitives
Rust
193
star
10

concurrent-queue

Concurrent multi-producer multi-consumer queue
Rust
180
star
11

async-executor

Async executor
Rust
179
star
12

async-process

Async interface for working with processes
Rust
124
star
13

async-compat

Compatibility adapter between tokio and futures
Rust
120
star
14

async-net

Async networking primitives for TCP/UDP/Unix communication
Rust
112
star
15

async-fs

Async filesystem primitives
Rust
110
star
16

easy-parallel

Run closures in parallel
Rust
100
star
17

async-broadcast

Async broadcast channels
Rust
96
star
18

parking

Thread parking and unparking
Rust
55
star
19

cache-padded

Prevent false sharing by padding and aligning to the length of a cache line
Rust
50
star
20

waker-fn

Convert closures into wakers
Rust
38
star
21

vec-arena

[DEPRECATED] A simple object arena
Rust
38
star
22

async-rustls

Async TLS/SSL streams using rustls
Rust
32
star
23

async-dup

Duplicate an async I/O handle
Rust
31
star
24

atomic-waker

futures::task::AtomicWaker extracted into its own crate
Rust
18
star
25

nb-connect

[DEPRECATED] Non-blocking TCP or Unix connect
Rust
15
star
26

async-signal

Asynchronous signal handling
Rust
14
star
27

piper

An asynchronous single-consumer single-producer pipe for bytes
Rust
8
star
28

fastrand-contrib

Extension functionality for the fastrand crate
Rust
5
star
29

smol-macros

Macros for using smol-rs
Rust
1
star