L'uso degli errori di Rust all'interno di un `ciclo` comporta un blocco economico, ma perché?

Question

use std::io::ErrorKind; 
use std::net::TcpStream; 

fn main() { 
    let address = "localhost:7000"; 

    loop { 
     match TcpStream::connect(address.clone()) { 
      Err(err) => { match err.kind() { 
       ErrorKind::ConnectionRefused => { continue; }, 
       kind => panic!("Error occurred: {:?}", kind), 
      }; }, 
      Ok(_stream) => { /* do some stuff here */ }, 
     } 
    } 
} 

Considerare il pezzo di codice Rust sopra. Ciò che è interessante per me qui non è il ramo Ok, ma piuttosto il ramo secondario ErrorKind::ConnectionRefused accoppiato con lo loop: è molto economico, CPU-wise, consumando meno dell'1% della CPU. È grandioso, è quello che voglio.

Ma io non capisco il motivo per cui è a buon mercato: il codice paragonabile in C sarebbe probabilmente consumano 100% fondamentalmente NOP ING (non proprio, ma abbastanza vicino). Qualcuno può aiutarmi a capire perché è così economico?

Answer 1

È molto probabile che connect() sia il colpevole; per ricevere l'errore Connection rifiutato, è necessario prima cercare l'indirizzo (che dovrebbe essere economico per localhost), quindi connettersi, e attendere la risposta con risposta.

Mentre localhost è certamente abbastanza veloce rispetto ai servizi di rete remoti, c'è ancora un sacco di spese generali.

ping localhost ha una latenza di circa 0,9 ms per me. Ciò significa che il tuo ciclo funziona solo nell'ordine da 1000 a 10000 iterazioni al secondo, il che non è molto paragonato a un effettivo mentre è vero il ciclo {}.