सस्ते लूपिंग में 'लूप' परिणामों के अंदर जंग की त्रुटियों का उपयोग करना, लेकिन क्यों?

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 */ }, 
     } 
    } 
} 

उपरोक्त जंग कोड के टुकड़े पर विचार करें। मेरे लिए दिलचस्प क्या है Ok शाखा नहीं है, बल्कि ErrorKind::ConnectionRefused उप-शाखा loop के साथ मिलकर है: यह बहुत सस्ता है, सीपीयू-वार, 1% से कम CPU का उपभोग करता है। यह बहुत अच्छा है, मैं यही चाहता हूं।

लेकिन मुझे समझ नहीं आता क्यों यह सस्ती है: सी में तुलनीय कोड की संभावना 100% मूल रूप से एनओपी आईएनजी (ठीक नहीं लेकिन काफी करीब) की खपत होगी। क्या कोई मुझे समझने में मदद कर सकता है कि यह इतना सस्ता क्यों है?

Answer 1

यह काफी संभावना है कि कनेक्ट() अपराधी है; कनेक्शन प्राप्त करने के लिए कनेक्शन ने त्रुटि से इंकार कर दिया, इसे पहले पता (जो स्थानीयहोस्ट के लिए सस्ता होना चाहिए) को देखने की आवश्यकता है, फिर कनेक्ट करें, और कनेक्शन के लिए प्रतीक्षा करें प्रतिक्रिया से इनकार कर दिया।

जबकि स्थानीय नेटवर्क निश्चित रूप से दूरस्थ नेटवर्क सेवाओं के विरोध में काफी तेज है, फिर भी बहुत अधिक उपर है।

पिंग लोकलहोस्ट मेरे लिए लगभग 0.9ms की विलंबता है। इसका मतलब है कि आपका लूप केवल प्रति सेकंड 1000 से 10000 पुनरावृत्तियों के क्रम पर करता है, जो वास्तविक की तुलना में बहुत अधिक नहीं है जबकि सही {} पाश।