Struct NetTransport 

pub struct NetTransport { /* private fields */ }

Full-mesh TCP transport implementing both Transport (two-sided send/recv) and SymmetricTransport (one-sided put/get/barrier). Construct via TcpTransport::bind or ThunderboltTransport::bind.

Implementations

impl NetTransport

pub fn from_listener( rank: u32, world: u32, listener: TcpListener, peers: Vec<SocketAddr>, heap_size: usize, ) -> Result<Self>

Build a transport from an already-bound listener. Ranks above us we connect to; ranks below us we accept from (each connector announces itself with a HELLO). peers[r] is rank r’s listen address; peers[rank] must match listener.

Public so callers (and multi-rank tests) can pre-bind ephemeral ports, exchange the addresses out-of-band, then construct the mesh — avoiding the fixed-port races TcpTransport::bind is subject to.

impl NetTransport

pub fn coordinator_listen( world: u32, listener: TcpListener, heap_size: usize, ) -> Result<Self>

Coordinator side of a star topology: bind listener (rank 0’s address) and accept world - 1 worker connections, each announcing its rank with a HELLO. Workers connect only to the coordinator (no worker↔worker links), so a worker needs no inbound port — the NAT/mobile-friendly shape for iOS, phones, and Pis behind a router.

pub fn worker_dial( rank: u32, world: u32, coord_addr: SocketAddr, heap_size: usize, ) -> Result<Self>

Worker side of a star topology: dial the coordinator at coord_addr and announce this rank. No listener — the worker only needs outbound connectivity, so it works from behind NAT / on mobile.

Trait Implementations

impl Drop for NetTransport

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl SymmetricTransport for NetTransport

fn num_ranks(&self) -> u32

How many ranks participate.

fn this_rank(&self) -> Rank

This process’s rank.

fn put(&self, buf: SymmetricBuffer, src: &[u8]) -> Result<(), CollectiveError>

Write src into buf. Errors on length mismatch.

fn get( &self, buf: SymmetricBuffer, dst: &mut [u8], ) -> Result<(), CollectiveError>

Read from buf into dst. Errors on length mismatch.

fn barrier(&self) -> Result<(), CollectiveError>

Block until every rank has reached this barrier. Local emulation is a memory fence + a counter; real transports implement their own.

impl Transport for NetTransport

fn rank(&self) -> u32

This process’s rank in 0..world_size.

fn world_size(&self) -> u32

Total number of participating ranks.

fn send_bytes( &self, to: u32, tag: u32, bytes: &[u8], ) -> Result<(), CollectiveError>

Send bytes to rank to, tagged tag. Returns once the bytes are handed to the transport (not necessarily delivered).

fn recv_bytes(&self, from: u32, tag: u32) -> Result<Vec<u8>, CollectiveError>

Block until a message with matching (from, tag) arrives, and return its payload.

fn recv_bytes_timeout( &self, from: u32, tag: u32, timeout: Duration, ) -> Result<Option<Vec<u8>>, CollectiveError>

Like Self::recv_bytes but gives up after timeout, returning Ok(None). The default blocks (transports with no deadline support ignore the timeout); crate::NetTransport overrides it with a real wait_timeout. This is the basis for not letting a slow or offline edge node stall a collective (bounded staleness).

fn barrier(&self) -> Result<(), CollectiveError>

Block until every rank has reached this barrier.