Glommio Documentation

Glommio allows fine-grained scheduling within a single thread using task queues. You can create task queues with specific Shares to define how much CPU time they receive relative to other queues.

• Shares::Static(n): Assigns a fixed number of shares to a queue.
• Latency: Defines if a queue is latency-sensitive (Latency::Matters(Duration)) or not (Latency::NotImportant).

Use glommio::spawn_local_into to run a task within a specific queue.

use glommio::{executor, Latency, LocalExecutorBuilder, Placement, Shares};

LocalExecutorBuilder::new(Placement::Fixed(0))
    .spawn(|| async move {
        let tq1 = 
            executor().create_task_queue(Shares::Static(2), Latency::NotImportant, "test1");
        let tq2 = 
            executor().create_task_queue(Shares::Static(1), Latency::NotImportant, "test2");
        
        let t1 = glommio::spawn_local_into(
            async move {
                // your code here
            },
            tq1,
        )
        .unwrap();
        let t2 = glommio::spawn_local_into(
            async move {
                // your code here
            },
            tq2,
        )
        .unwrap();

        t1.await;
        t2.await;
    })
    .unwrap();

If you want to perform manual load balancing instead of relying on the OS ReusePort behavior, use TcpListener::shared_accept. This returns an AcceptedTcpStream, which implements Send and can be passed to a different executor via a channel. Once received by the target executor, call bind_to_executor() to convert it into a standard TcpStream.

use glommio::{
    channels::shared_channel,
    net::TcpListener,
    LocalExecutor,
    LocalExecutorBuilder,
};

let ex = LocalExecutor::default();
ex.run(async move {
    let (sender, receiver) = shared_channel::new_bounded(1);
    let sender = sender.connect().await;

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();

    // Accept connection and send it to another executor
    let accepted = listener.shared_accept().await.unwrap();
    sender.try_send(accepted).unwrap();

    let ex1 = LocalExecutorBuilder::default()
        .spawn(move || async move {
            let receiver = receiver.connect().await;
            let accepted = receiver.recv().await.unwrap();
            // Bind the stream to this new executor
            let _stream = accepted.bind_to_executor();
        })
        .unwrap();

    ex1.join().unwrap();
});

If you want to perform custom load balancing instead of relying on OS-level ReusePort, use UnixListener::shared_accept(). This returns an AcceptedUnixStream which can be sent across threads/executors. To use the connection on a new executor, call bind_to_executor() on the received object.

use glommio::{
    channels::shared_channel,
    net::UnixListener,
    LocalExecutor,
    LocalExecutorBuilder,
};

let ex = LocalExecutor::default();
ex.run(async move {
    let (sender, receiver) = shared_channel::new_bounded(1);
    let sender = sender.connect().await;

    let listener = UnixListener::bind("/tmp/named").unwrap();

    // Accept connection and send it to another executor
    let accepted = listener.shared_accept().await.unwrap();
    sender.try_send(accepted).unwrap();

    let ex1 = LocalExecutorBuilder::default()
        .spawn(move || async move {
            let receiver = receiver.connect().await;
            let accepted = receiver.recv().await.unwrap();
            // Bind the connection to the new executor
            let _stream = accepted.bind_to_executor();
        })
        .unwrap();

    ex1.join().unwrap();
});