Struct unbounded_spsc::Sender

pub struct Sender<T> { /* private fields */ }

Implementations

impl<T> Sender<T>

pub fn send(&self, t: T) -> Result<(), SendError<T>>

Non-blocking send.

Examples found in repository

examples/sequential-recv.rs (line 20)

fn sendfun (sender : unbounded_spsc::Sender <Mystruct>) {
  let mut counter = 0;
  let start_time = std::time::SystemTime::now();
  while counter < MESSAGE_COUNT {
    sender.send (Mystruct { x: counter as f64, y: 1.5, z: 2.0 }).unwrap();
    counter += 1;
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("sendfun duration ns: {}", duration_ns);
  println!("sendfun ns per message: {}", duration_ns / MESSAGE_COUNT);
}

examples/sequential-try_recv.rs (line 20)

fn sendfun (sender : unbounded_spsc::Sender <Mystruct>) {
  let mut counter = 0;
  let start_time = std::time::SystemTime::now();
  while counter < MESSAGE_COUNT {
    sender.send (Mystruct { x: counter as f64, y: 1.5, z: 2.0 }).unwrap();
    counter += 1;
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("sendfun duration ns: {}", duration_ns);
  println!("sendfun ns per message: {}", duration_ns / MESSAGE_COUNT);
}

examples/parallel-recv.rs (line 28)

fn sendfun (sender : unbounded_spsc::Sender <Mystruct>) {
  let mut counter = 0;
  SENDER_STARTED.store (true, std::sync::atomic::Ordering::SeqCst);
  // spin until receiver is started
  while !RECEIVER_STARTED.load (std::sync::atomic::Ordering::SeqCst) {}
  let start_time = std::time::SystemTime::now();
  while counter < MESSAGE_COUNT {
    sender.send (Mystruct { x: counter as f64, y: 1.5, z: 2.0 }).unwrap();
    counter += 1;
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("sendfun duration ns: {}", duration_ns);
  println!("sendfun ns per message: {}", duration_ns / MESSAGE_COUNT);
}

examples/parallel-try_recv.rs (line 28)

fn sendfun (sender : unbounded_spsc::Sender <Mystruct>) {
  let mut counter = 0;
  SENDER_STARTED.store (true, std::sync::atomic::Ordering::SeqCst);
  // spin until receiver is started
  while !RECEIVER_STARTED.load (std::sync::atomic::Ordering::SeqCst) {}
  let start_time = std::time::SystemTime::now();
  while counter < MESSAGE_COUNT {
    sender.send (Mystruct { x: counter as f64, y: 1.5, z: 2.0 }).unwrap();
    counter += 1;
  }
  let duration = start_time.elapsed().unwrap();
  let duration_ns
    = (duration.as_secs() * 1_000_000_000) + duration.subsec_nanos() as u64;
  println!("sendfun duration ns: {}", duration_ns);
  println!("sendfun ns per message: {}", duration_ns / MESSAGE_COUNT);
}

Trait Implementations

impl<T> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.