नामांकन

पी-हाई के लिए स्वीकार किया, # 10183 के रूप में एक ही तर्क

मुझे नहीं लगता कि यह भाषा के स्तर पर असंगत है। यह उस कोड का कारण नहीं होगा जो काम करना बंद करने के लिए ठीक काम कर रहा था। नामांकित।

पी-हाई में बदलना, # 10183 के समान तर्क

हम इसे और # 10185 को हल करने का प्रस्ताव कैसे देते हैं? चूंकि व्यवहार को परिभाषित किया गया है या नहीं, डाली जा रही संख्या के गतिशील मूल्य पर निर्भर करता है, ऐसा लगता है कि एकमात्र समाधान गतिशील चेक सम्मिलित करना है। हम सहमत लगते हैं कि हम अंकगणित के अतिप्रवाह के लिए ऐसा नहीं करना चाहते हैं, क्या हम इसे कास्ट ओवरफ्लो के लिए खुश हैं?

हम LLVM के लिए एक आंतरिक जोड़ सकते हैं जो "सुरक्षित रूपांतरण" करता है। @zwarich के अन्य विचार हो सकते हैं।

AFAIK फिलहाल एकमात्र उपाय है लक्ष्य-विशिष्ट आंतरिकता का उपयोग करना। जावास्क्रिप्ट यही करता है, कम से कम मेरे द्वारा पूछे गए किसी व्यक्ति के अनुसार।

ओह, यह काफी आसान है।

ping @pnkfelix क्या यह नए अतिप्रवाह जाँच सामान से आच्छादित है?

इन जातियों को डीबग अभिकथन के साथ जंग द्वारा चेक नहीं किया जाता है।

मैं इसे संभालकर खुश हूं, लेकिन मुझे ठोस समाधान की जरूरत है। मुझे व्यक्तिगत रूप से लगता है कि इसे पूर्णांक अंकगणित के साथ-साथ चेक किया जाना चाहिए, क्योंकि यह बहुत ही समान मुद्दा है। मैं वास्तव में बुरा नहीं मानता कि हम क्या करते हैं।

ध्यान दें कि वर्तमान में कुछ स्थिर अभिव्यक्तियों में उपयोग किए जाने पर यह समस्या एक ICE पैदा कर रही है।

यह सुरक्षित जंग में स्मृति सुरक्षा का उल्लंघन करने की अनुमति देता है, इस मंच पोस्ट से उदाहरण:

अनडू, हुह? अनफ्स मज़ेदार हैं। वे प्रचार करते हैं। कुछ मिनटों की तकरार के बाद ।।

#[inline(never)]
pub fn f(ary: &[u8; 5]) -> &[u8] {
    let idx = 1e100f64 as usize;
    &ary[idx..]
}

fn main() {
    println!("{}", f(&[1; 5])[0xdeadbeef]);
}

मेरे सिस्टम पर segfaults (नवीनतम रात्रिकालीन) -O के साथ।

सुरक्षित जंग में स्मृति सुरक्षा के उल्लंघन को देखते हुए I-unsound के साथ अंकन।

@bluss , यह मेरे लिए अलग नहीं है, बस एक जोरदार त्रुटि देता है। जब से मैंने इसे जोड़ा था, तब से मैं नहीं जानता था

आह, मैं -O, फिर से टैगिंग भूल गया।

पी-हाई के लिए फिर से नामांकित करना जाहिरा तौर पर यह कुछ बिंदु पी-उच्च पर था लेकिन समय के साथ कम हो गया। यह शुद्धता के लिए बहुत महत्वपूर्ण लगता है।

संपादित करें: मैन्युअल रूप से लेबल जोड़कर, टिप्पणी पर प्रतिक्रिया न करें।

ऐसा लगता है कि अतिप्रवाह सामग्री (उदाहरण के लिए स्थानांतरण) से मिसाल सिर्फ कुछ व्यवहार पर बसने के लिए है। जावा परिणाम modulo रेंज का उत्पादन करने के लिए लगता है, जो अनुचित नहीं लगता है; मुझे यकीन नहीं है कि हमें किस तरह का LLVM कोड संभालना होगा।

Https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls -5.1.3 के अनुसार जावा इस बात की भी गारंटी देता है कि NaN मानों को 0 पर रखा गया है और शिशुओं को न्यूनतम / अधिकतम प्रतिनिधित्व योग्य पूर्णांक के लिए। इसके अलावा रूपांतरण के लिए जावा नियम केवल रैपिंग की तुलना में अधिक जटिल है, यह संतृप्ति ( int या long के लिए रूपांतरण) और रैपिंग के लिए हो सकता है (छोटे अभिन्न प्रकार के रूपांतरण के लिए) , अगर जरुरत हो)। जावा से पूरे रूपांतरण एल्गोरिथ्म की पुनरावृत्ति करना निश्चित रूप से संभव है, लेकिन इसके लिए प्रत्येक कलाकारों के लिए उचित मात्रा में संचालन की आवश्यकता होगी। विशेष रूप से, यह सुनिश्चित करने के लिए कि एलएलवीएम में fpto[us]i संचालन का परिणाम अपरिभाषित व्यवहार प्रदर्शित नहीं करता है, एक रेंज चेक की आवश्यकता होगी।

एक विकल्प के रूप में, मैं सुझाव दूंगा कि फ्लोट-> इंट कास्ट्स को केवल तभी मान्य होने की गारंटी दी जाती है जब मूल मूल्य के ट्रंकेशन को गंतव्य प्रकार के मान के रूप में दर्शाया जा सकता है (या शायद [iu]size ?) और डिबग पर जोर दिया है कि जब विश्वास का प्रतिनिधित्व नहीं किया गया है, तो आतंक का कारण बनता है।

जावा दृष्टिकोण का मुख्य लाभ यह है कि रूपांतरण फ़ंक्शन कुल है, लेकिन इसका मतलब यह भी है कि अप्रत्याशित व्यवहार में कमी हो सकती है: यह अपरिभाषित व्यवहार को रोक देगा, लेकिन यह जांचना आसान नहीं होगा कि क्या वास्तव में कलाकारों को कोई मतलब नहीं है (यह दुर्भाग्य से अन्य जातियों के लिए भी सच है: चिंतित:)।

अन्य दृष्टिकोण वर्तमान में अंकगणितीय आपरेशनों के लिए उपयोग किए जाने वाले एक से मेल खाता है: रिलीज में सरल और कुशल कार्यान्वयन, डीबग में रेंज की जाँच से उत्पन्न पैनिक। दुर्भाग्य से अन्य as जातियों के विपरीत, यह ऐसे रूपांतरण की जाँच करेगा, जो उपयोगकर्ता को आश्चर्यचकित कर सकता है (हालाँकि शायद अंकगणित संचालन की उपमा यहाँ मदद कर सकती है)। यह कुछ कोड को भी तोड़ देगा, लेकिन AFAICT यह केवल उस कोड के लिए होना चाहिए जो वर्तमान में अपरिभाषित व्यवहार पर निर्भर है (यानी यह अपरिभाषित व्यवहार को बदल देगा "चलो किसी भी पूर्णांक को वापस करें, आप स्पष्ट रूप से परवाह नहीं करते हैं" जो एक आतंक के साथ है)।

समस्या यह नहीं है "चलो किसी भी पूर्णांक को वापस करते हैं, आप स्पष्ट रूप से परवाह नहीं करते हैं", यह है कि यह एक अनिर्दिष्ट कारण बनता है जो एक यादृच्छिक मूल्य नहीं है, बल्कि एक नासिक दानव मूल्य और एलएलवीएम को यह मानने की अनुमति दी जाती है कि अपरिभाषित कभी नहीं होता है उन आशाओं को सक्षम करना जो भयानक गलत काम करते हैं। यदि यह एक यादृच्छिक मूल्य था, लेकिन महत्वपूर्ण रूप से अपराजित नहीं है, तो यह ध्वनि मुद्दों को ठीक करने के लिए पर्याप्त होगा। हमें यह परिभाषित करने की आवश्यकता नहीं है कि कैसे अप्राप्य मूल्यों का प्रतिनिधित्व किया जाता है, हमें बस अपराजित को रोकने की आवश्यकता है।

@ जंग-लंग / संकलक बैठक में चर्चा की गई। कार्रवाई का सबसे सुसंगत पाठ्यक्रम बना हुआ है:

1. जब अतिप्रवाह चेक सक्षम होते हैं, तो अवैध जातियों और आतंक के लिए जाँच करें।
2. अन्यथा, हमें एक गिरावट वाले व्यवहार की आवश्यकता है, यह कुछ ऐसा होना चाहिए जिसमें मान्य मूल्यों के लिए न्यूनतम (आदर्श, शून्य) रनटाइम लागत हो, लेकिन सटीक व्यवहार उतना महत्वपूर्ण नहीं है, जब तक कि यह एलएलवीएम अपरिभाषित न हो।

मुख्य समस्या यह है कि हमें विकल्प 2 के लिए एक ठोस सुझाव की आवश्यकता है।

triage: पी-मीडियम

@nikomatsakis डिबग बिल्ड में as वर्तमान में आतंक है? यदि ऐसा नहीं होता है, तो स्थिरता और पूर्वानुमान के लिए यह इस तरह से रखना बेहतर लगता है। (मुझे लगता है कि यह _should है_, अंकगणित की तरह है, लेकिन यह एक अलग और अतीत, बहस है।)

अन्यथा, हमें एक गिरावट वाले व्यवहार की आवश्यकता है, यह कुछ ऐसा होना चाहिए जिसमें मान्य मूल्यों के लिए न्यूनतम (आदर्श, शून्य) रनटाइम लागत हो, लेकिन सटीक व्यवहार उतना महत्वपूर्ण नहीं है, जब तक कि यह एलएलवीएम अपरिभाषित न हो।

ठोस सुझाव: प्रतिपादक द्वारा u64 और बिटशिफ्ट अंक के रूप में अंक और घातांक निकालें।

fn f64_as_u64(f: f64) -> u64 {
    let (mantissa, exponent, _sign) = f.integer_decode();
    mantissa >> ((-exponent) & 63)
}

हाँ, यह शून्य लागत नहीं है, लेकिन यह कुछ हद तक अनुकूलन योग्य है (बेहतर होगा यदि हम पूर्णांक_डबल inline ) और कम से कम निर्धारक के रूप में चिह्नित करें। एक भविष्य एमआईआर-पास जो फ्लोट का विस्तार करता है-> इंट कास्ट शायद विश्लेषण कर सकता है कि क्या फ्लोट को इस भारी रूपांतरण को छोड़ने और छोड़ने के लिए ठीक होने की गारंटी है।

क्या एलएलवीएम में रूपांतरण कार्यों के लिए मंच आंतरिक नहीं है?

EDIT : @zwarich ने कहा (बहुत समय पहले):

AFAIK फिलहाल एकमात्र उपाय है लक्ष्य-विशिष्ट आंतरिकता का उपयोग करना। जावास्क्रिप्ट यही करता है, कम से कम मेरे द्वारा पूछे गए किसी व्यक्ति के अनुसार।

यहां तक ​​कि घबराहट क्यों? AFAIK, @glaebhoerl सही है, as को छोटा / विस्तारित करना, _not_ ऑपरेंड की जाँच करना है।

शनि, मार्च 05, 2016 को 03:47:55 पूर्वाह्न -0800 पर, गैबर लेहेल ने लिखा:

@nikomatsakis डिबग बिल्ड में as वर्तमान में आतंक है? यदि ऐसा नहीं होता है, तो स्थिरता और पूर्वानुमान के लिए यह इस तरह से रखना बेहतर लगता है। (मुझे लगता है कि यह _should है_, अंकगणित की तरह है, लेकिन यह एक अलग और अतीत, बहस है।)

सच। मुझे वह प्रेरक लगता है।

बुध पर, मार्च 09, 2016 को 02:31:05 पूर्वाह्न -0800, एडुआर्ड-मिहाई बर्टेस्कु ने लिखा:

क्या एलएलवीएम में रूपांतरण कार्यों के लिए मंच आंतरिक नहीं है?

संपादित करें :

AFAIK फिलहाल एकमात्र उपाय है लक्ष्य-विशिष्ट आंतरिकता का उपयोग करना। जावास्क्रिप्ट यही करता है, कम से कम मेरे द्वारा पूछे गए किसी व्यक्ति के अनुसार।

यहां तक ​​कि घबराहट क्यों? AFAIK, @glaebhoerl सही है, as को छोटा / विस्तारित करना, _not_ ऑपरेंड की जाँच करना है।

हां, मुझे लगता है कि मुझसे पहले गलत हुआ था। as "अनियंत्रित छंटनी" है
ऑपरेटर, बेहतर या बदतर के लिए, और सुसंगत रहना सबसे अच्छा लगता है
उस दर्शन के साथ। लक्ष्य-विशेष आंतरिक का उपयोग करना पूरी तरह से हो सकता है
हालांकि ठीक समाधान?

@nikomatsakis : ऐसा लगता है कि व्यवहार अभी तक परिभाषित नहीं किया गया है? क्या आप उस बारे में योजना के बारे में कोई अपडेट दे सकते हैं?

बस इसमें बहुत कम संख्या के साथ भाग गया

    let x: f64 = -1.0;
    x as u8

अनुकूलन के आधार पर 0, 16, आदि में परिणाम, मुझे उम्मीद थी कि इसे 255 के रूप में परिभाषित किया जाएगा इसलिए मुझे x as i16 as u8 लिखना नहीं है।

@gmorenz क्या आपने !0u8 ?

इस संदर्भ में, इससे कोई मतलब नहीं होगा, मुझे [-255, 255] की सीमा के साथ नेटवर्क पर भेजे गए डेटा पर परिवर्तन से f64 मिल रहा था। मैं उम्मीद कर रहा था कि यह अच्छी तरह से लपेटेगा (सटीक तरीके से कि <i32> as u8 wraps)।

यहाँ "undef मारने" के लिए हाल ही में एक LLVM प्रस्ताव है http://lists.llvm.org/pipermail/llvm-dev/2016-October/106182.html , हालांकि मैं शायद ही पर्याप्त जानकार पता करने के लिए कर रहा हूँ या नहीं, यह स्वतः होगा संकल्प इस मुद्दे।

वे जहर के साथ अपराजित की जगह ले रहे हैं, शब्दार्थ थोड़ा अलग है। यह int -> फ्लोट कास्ट परिभाषित व्यवहार करने वाला नहीं है।

हमें शायद एक संतृप्त कास्ट करने के लिए कुछ स्पष्ट तरीका प्रदान करना चाहिए? मुझे वह सटीक व्यवहार अभी चाहिए था।

ऐसा लगता है कि मुझे आई-क्रैश चिह्नित किया जाना चाहिए, https://github.com/rust-lang/rust/issues/10184#issuecomment -139858153।

हमारे पास #rust-beginners में इस बारे में एक सवाल था, आज कोई जंगली में भाग गया।

मैं जो किताब @jimblandy ,

कई प्रकार की जातियों की अनुमति है।

• संख्याएँ बिल्ट-इन न्यूमेरिक प्रकारों से किसी अन्य में डाली जा सकती हैं।

  (...)

  हालांकि, इस लेखन के रूप में, एक बड़े फ्लोटिंग-पॉइंट वैल्यू को एक पूर्णांक प्रकार में कास्टिंग करना जो कि यह प्रतिनिधित्व करने के लिए बहुत छोटा है, अपरिभाषित व्यवहार का कारण बन सकता है। यह सुरक्षित जंग में भी दुर्घटना का कारण बन सकता है। यह संकलक, github.com/rust-lang/rust/issues/10184 में एक बग है।

इस अध्याय के लिए हमारी समय सीमा 19 मई है। मैं उस आखिरी पैराग्राफ को हटाना पसंद करूंगा, लेकिन मुझे लगता है कि हमें कम से कम किसी तरह की योजना पहले से बना लेनी चाहिए।

जाहिरा तौर पर वर्तमान JavaScriptCore x86 पर

ईमानदारी से मुझे लगता है कि हमें as साथ सांख्यिक जातियों को चित्रित करना चाहिए और From और TryFrom या इसके बजाय कॉन्टे क्रेट की तरह कुछ करना चाहिए।

हो सकता है कि ऐसा हो, लेकिन यह मुझे ओर्थोगोनल लगता है।

ठीक है, मैंने अभी पूरी बातचीत फिर से पढ़ी है। मुझे लगता है कि इस समझौते से घबराहट नहीं होनी चाहिए ( as साथ सामान्य स्थिरता के लिए)। इस व्यवहार के लिए दो प्रमुख दावेदार हैं:

• परिभाषित परिणाम के कुछ प्रकार
  
  
  
  • प्रो: मुझे लगता है कि यह हमारे सामान्य दर्शन के साथ अधिकतम संगत है ।
  
  
  • Con: इस मामले में किसी विशेष परिभाषित परिणाम का उत्पादन करने के लिए वास्तव में पोर्टेबल तरीका प्रतीत नहीं होता है। इसका तात्पर्य यह है कि हम प्लेटफ़ॉर्म-स्पेसिफिक इंट्रिंसिक्स का उपयोग रेंज वैल्यू से बाहर करने के लिए कुछ प्रकार के कमबैक के साथ करेंगे (उदाहरण के लिए, संतृप्ति पर वापस गिरना, यह कार्य जो @ oli-obk ने प्रस्तावित किया , जावा की परिभाषा में , या जो भी "सी + +" JSC का उपयोग करता है ।
  
  
  • सबसे कम, हम "सीमा के बाहर" मामलों के लिए कुछ ifs सम्मिलित कर सकते हैं।
  
  
• एक अपरिभाषित मूल्य (अपरिभाषित व्यवहार नहीं)
  
  
  
  • प्रो: यह हमें प्लेटफ़ॉर्म-विशिष्ट आंतरिक का उपयोग करने देता है जो प्रत्येक प्लेटफ़ॉर्म पर उपलब्ध हैं।
  
  
  • Con: यह एक पोर्टेबिलिटी खतरा है। सामान्य तौर पर, मुझे ऐसा लगता है कि हमने अपरिभाषित परिणामों का उपयोग बहुत बार नहीं किया है, कम से कम भाषा में (मुझे यकीन है कि हम विभिन्न स्थानों पर काम कर रहे हैं)।
  
  

यह मेरे लिए स्पष्ट नहीं है अगर पहले मामले में क्या परिणाम होना चाहिए , इसके लिए एक स्पष्ट मिसाल है?

यह लिखने के बाद, मेरी प्राथमिकता एक निर्धारक परिणाम बनाए रखने की होगी। मुझे हर जगह ऐसा लगता है कि हम नियतत्ववाद पर लाइन पकड़ सकते हैं यह एक जीत है। मैं वास्तव में निश्चित नहीं हूं कि परिणाम क्या होना चाहिए।

मुझे संतृप्ति पसंद है क्योंकि मैं इसे समझ सकता हूं और यह उपयोगी लगता है, लेकिन यह किसी भी तरह से असंगत लगता है कि u64 as u32 ट्रंकेशन करता है। इसलिए शायद ट्रंकेशन पर आधारित किसी प्रकार का परिणाम समझ में आता है, जो मुझे लगता है कि शायद @ ओली-ओब्क प्रस्तावित है - मुझे पूरी तरह से समझ में नहीं आता है कि उस कोड का क्या करना है। =)

मेरा कोड 0..2 ^ 64 की सीमा में चीजों के लिए सही मूल्य देता है और बाकी सभी चीजों के लिए नियतात्मक लेकिन फर्जी मूल्य है।

फ़्लोट्स का प्रतिनिधित्व मंटिसा ^ एक्सपोनेंट द्वारा किया जाता है, उदाहरण के लिए 1.0 (2 << 52) ^ -52 और चूंकि बिटशिफ्ट्स और एक्सपोज़र बाइनरी में एक ही चीज़ हैं, इसलिए हम शिफ्ट को उल्टा कर सकते हैं (इस तरह घातांक और अधिकार की उपेक्षा) खिसक जाना)।

नियतत्ववाद के लिए +1।

मुझे दो शब्दार्थ दिखाई देते हैं, जो मनुष्यों के लिए अच्छा अर्थ रखते हैं, और मुझे लगता है कि हमें उन मूल्यों में से किसी एक को चुनना चाहिए जो

• संतृप्ति (आउट-ऑफ़-रेंज मान IntType::max_value() / min_value() ) हो जाते हैं
• मोडुलो (आउट-ऑफ-रेंज मानों का इलाज किया जाता है जैसे कि पहले एक बिगिंट में परिवर्तित करके, फिर ट्रंकटिंग)

नीचे दी गई तालिका दोनों विकल्पों को पूरी तरह से निर्दिष्ट करने के लिए है। T किसी भी मशीन पूर्णांक प्रकार है। Tmin और Tmax T::min_value() और T::max_value() । RTZ (v) का अर्थ है गणितीय पूर्णांक प्राप्त करने के लिए v और राउंड टोवर्ड ज़ीरो का गणितीय मान लें।

v | v as T (संतृप्ति) | v as T (मोडुलो)
---- | ---- | ----
in रेंज (Tmin <= v <= Tmax) | RTZ (v) | RTZ (v)
नकारात्मक शून्य | 0 | 0
NaN | 0 | 0
अनंत | Tmax | 0
-इनफिनिटी | टमिन | 0
v> Tmax | Tmax | RTZ (v) टी को फिट करने के लिए छोटा किया गया
v <तमिन | टमिन | RTZ (v) टी को फिट करने के लिए छोटा किया गया

ECMAScript मानक TOInt32 , ToUint32, ToInt16, ToUint16, ToInt8, ToUint8, और ऊपर दिए गए "modulo" विकल्प के साथ मेरे इरादे को निर्दिष्ट

ECMAScript भी ToInt8Clamp को निर्दिष्ट नहीं खाती है: यह "राउंड टू टू" के बजाय "फ्रैक्शनल वैल्यूज पर राउंडिंग" को "राउंड हाफ" करता है।

@ ओली-ओब्क का सुझाव एक तीसरा तरीका है, यह विचार करने के लायक है कि क्या यह गणना करने के लिए तेज़ है, मूल्यों के लिए जो सीमा में हैं।

@ oli-obk हस्ताक्षरित पूर्णांक प्रकारों के बारे में क्या?

संबंधित https://github.com/rust-lang/rust/issues/41799

मिश्रण में एक और प्रस्ताव फेंकना: मार्क u128 असुरक्षित के रूप में तैरता है और लोगों को स्पष्ट रूप से इसे संभालने का एक तरीका चुनने के लिए मजबूर करता है। वर्तमान में u128 बहुत दुर्लभ है।

@ मैं करता हूँ → फ़्लोट के रूप में तैरता है → पूर्णांक। चूंकि दोनों यूबी-फुल हैं, और हम फ्लोट → पूर्णांक असुरक्षित नहीं बना सकते हैं, हमें संभवतः पूर्णांक → फ्लोट असुरक्षित भी बनाने से बचना चाहिए।

फ्लोट के लिए → पूर्णांक संतृप्त तेजी से AFAICT होगा (परिणामस्वरूप and अनुक्रम में, टेस्ट + जंप फ्लोट तुलना और कूद, सभी आधुनिक मेहराब पर 0.66 या 0.5 2-3 चक्र के लिए)। मैं व्यक्तिगत रूप से इस बात के लिए कम परवाह नहीं कर सकता कि हम कितने सटीक व्यवहार का निर्णय लेते हैं जब तक कि इन-रेंज मान उतने ही तेज़ होते हैं जितने संभवतः वे हो सकते हैं।

यह अतिप्रवाह की तरह व्यवहार करने के लिए समझ में नहीं आएगा? यदि आप अपरिभाषित व्यवहार के साथ कास्ट करते हैं तो एक डिबग बिल्ड में यह घबराहट होगी। तब आपके पास 1.04E+17.saturating_cast::<u8>() , unsafe { 1.04E+17.unsafe_cast::<u8>() } और संभवतः अन्य जैसे कास्टिंग व्यवहार को निर्दिष्ट करने के तरीके हो सकते थे।

ओह, मुझे लगा कि मुद्दा केवल u128 के लिए था, और हम उस असुरक्षित दोनों तरीकों से बना सकते हैं।

@ कोड को सुरक्षित कोड में रिलीज मोड में भी मौजूद नहीं होना चाहिए। अतिप्रवाह सामान अभी भी परिभाषित व्यवहार है।

कहा कि, डीबग पर आतंक, औररिलीज पर बहुत अच्छा होगा।

यह प्रभावित करता है:

• f32 -> u8, u16, u32, u64, u128, usize ( -1f32 as _ सभी के लिए, f32::MAX as _ सभी के लिए लेकिन u128)
• f32 -> i8, i16, i32, i64, i128, isize ( f32::MAX as _ सभी के लिए)
• f64 -> सभी ints ( f64::MAX as _ सभी के लिए)

f32::INFINITY as u128 भी UB है

@CryZe

यह अतिप्रवाह की तरह व्यवहार करने के लिए समझ में नहीं आएगा? यदि आप अपरिभाषित व्यवहार के साथ कास्ट करते हैं तो एक डिबग बिल्ड में यह घबराहट होगी।

यह वही है जो मैंने शुरू में सोचा था, लेकिन मुझे याद दिलाया गया था कि as रूपांतरण कभी भी घबराहट नहीं करते हैं (हम बेहतर या बदतर के लिए as साथ ओवरफ्लो जाँच नहीं करते हैं)। तो सबसे अनुरूप बात यह है कि "कुछ परिभाषित करना" है।

एफडब्ल्यूआईडब्ल्यू, "मार अनडेफ" चीज, वास्तव में, स्मृति को अनिश्चितता को ठीक करने का एक तरीका प्रदान करेगी, लेकिन परिणाम को छोड़कर। प्रमुख घटकों में से एक है:

3) एक नया निर्देश बनाएं, '% y = फ्रीज% x', जिससे इसका प्रसार रुक जाता है
ज़हर। यदि इनपुट जहर है, तो यह एक मनमाना रिटर्न देता है, लेकिन निश्चित है,
मूल्य। (पुराने अपरिभाषित की तरह, लेकिन प्रत्येक उपयोग को समान मूल्य मिलता है), अन्यथा यह
बस इसका इनपुट मान लौटाता है।

स्मृति सुरक्षा का उल्लंघन करने के लिए undefs का उपयोग आज किया जा सकता है, क्योंकि वे जादुई रूप से उपयोग के बीच मूल्यों को बदल सकते हैं: विशेष रूप से, एक सीमा की जाँच और बाद के सूचक अंकगणितीय के बीच। अगर हर खतरनाक कास्ट के बाद रस्टक ने फ्रीज जोड़ दिया, तो आपको बस एक अज्ञात लेकिन अन्यथा अच्छी तरह से व्यवहार किया जाने वाला मूल्य मिलेगा। प्रदर्शन के लिहाज से, फ्रीज मूल रूप से यहां मुफ्त है, क्योंकि निश्चित रूप से कलाकारों के अनुरूप मशीन निर्देश एकल मूल्य पैदा करता है, उतार-चढ़ाव वाला नहीं; भले ही ऑप्टिमाइज़र किसी कारण के लिए कास्ट इंस्ट्रक्शन को डुप्लिकेट करने की तरह महसूस करता है, यह ऐसा करने के लिए सुरक्षित होना चाहिए क्योंकि आउट-ऑफ-रेंज इनपुट के लिए परिणाम आमतौर पर किसी दिए गए आर्किटेक्चर पर निर्धारक होता है।

... लेकिन आर्किटेक्चर के पार निर्धारक नहीं, अगर कोई सोच रहा था। x86 सभी खराब सूचनाओं के लिए 0x80000000 देता है; एआरएम आउट-ऑफ-रेंज इनपुट के लिए संतृप्त करता है और (यदि मैं इस छद्मकोड सही पढ़ रहा हूं) NaN के लिए 0 देता है। इसलिए यदि लक्ष्य एक नियतात्मक और प्लेटफ़ॉर्म-स्वतंत्र परिणाम का उत्पादन करना है, तो यह केवल प्लेटफ़ॉर्म के fp-to-int आंतरिक का उपयोग करने के लिए पर्याप्त नहीं है; कम से कम एआरएम पर आपको अपवाद के लिए स्थिति रजिस्टर की जांच करने की भी आवश्यकता है। यह अपने आप में कुछ ओवरहेड हो सकता है, और निश्चित रूप से अप्रत्याशित घटना में ऑटोवेराइजेशन को रोकता है कि आंतरिक का उपयोग करना पहले से ही नहीं था। वैकल्पिक रूप से, मुझे लगता है कि आप नियमित रूप से तुलना संचालन का उपयोग करके इन-रेंज मानों के लिए स्पष्ट रूप से परीक्षण कर सकते हैं और फिर एक नियमित फ्लोट-टू-इंट का उपयोग कर सकते हैं। आशावादी पर बहुत अच्छा लग रहा है ...

as रूपांतरण वर्तमान में कभी नहीं घबराते हैं

कुछ बिंदु पर हमने पैनिक (डिबग मोड पर) + बदल दिया। मैं उन मामलों में as घबराहट नहीं देखूंगा जो पहले UB थे।

अगर हम जाँच करने के बारे में परवाह करते हैं (जो हमें करना चाहिए), तो हमें या तो as (क्या कोई उपयोग मामला है जहां यह एकमात्र अच्छा विकल्प है?) या कम से कम इसका उपयोग करने के खिलाफ सलाह देना चाहिए, और लोगों को इस तरह की चीजों पर स्थानांतरित करना चाहिए TryFrom और TryInto इसके बजाय, जो हमने कहा है कि हम वापस करने की योजना बना रहे थे जब as रूप में छोड़ने का फैसला किया गया था। मुझे नहीं लगता कि चर्चा के अंतर्गत आने वाले मामले गुणात्मक रूप से भिन्न होते हैं, अमूर्त में , उन मामलों से जहां as को पहले से ही चेक करने के लिए परिभाषित नहीं किया गया है। अंतर सिर्फ इतना है कि व्यवहार में इन मामलों के लिए कार्यान्वयन वर्तमान में अपूर्ण है और यूबी है। एक ऐसी दुनिया जहां आप as चेक पर भरोसा नहीं कर सकते हैं (क्योंकि अधिकांश प्रकार के लिए, यह नहीं करता है), और आप इस पर भरोसा नहीं कर सकते हैं कि यह घबराहट नहीं है (क्योंकि कुछ प्रकार के लिए, यह), और यह सुसंगत नहीं है, और हम अभी भी नहीं गए हैं यह मुझे उन सभी में से सबसे बुरा लगता है।

इसलिए, मुझे लगता है कि इस बिंदु पर @jorendorff ने मूल रूप से यह कहा कि मुझे सबसे अच्छी योजना क्या लगती है :

• as कुछ नियतात्मक व्यवहार होगा;
• हम इस बात के संयोजन के आधार पर एक व्यवहार करेंगे कि यह कितना समझदार है और यह कितना कुशल है

उन्होंने तीन संभावनाओं की गणना की। मुझे लगता है कि शेष कार्य उन संभावनाओं की जांच करना है - या कम से कम उनमें से एक की जांच करना। यही है, वास्तव में इसे लागू करें, और यह कैसे "धीमा" या "तेज" है के लिए कुछ महसूस करने की कोशिश करें।

वहाँ कोई है जो वहाँ पर एक छुरा लेने के लिए प्रेरित महसूस करता है? मैं इसे किसी व्यक्ति को आकर्षित करने की उम्मीद में E-help-wanted रूप में टैग करने जा रहा हूं। (@ ओली-OBK?)

उह, मैं इसके बजाय क्रॉस-प्लेटफॉर्म संगतता के लिए मूल्य का भुगतान नहीं करूंगा: / यह कचरा-इन है, मुझे परवाह नहीं है कि कचरा क्या निकलता है (हालांकि एक डीबग अभिकथन सुपर सहायक होगा)।

वर्तमान में रस्ट में सभी राउंडिंग / ट्रंकिंग फ़ंक्शन बहुत धीमे हैं (फ़ंक्शन श्रमसाध्य सटीक कार्यान्वयन के साथ कॉल करता है), इसलिए as फास्ट फ्लोट राउंडिंग के लिए मेरा अंतिम उपाय हैक है।

यदि आप as नंगे cvttss2si से अधिक कुछ भी बनाने जा रहे हैं, तो कृपया एक स्थिर विकल्प भी जोड़ें जो कि बस है।

@ हाइपेल यह

@ est31 मैं सहमत हूं कि इसे यूबी के रूप में छोड़ना गलत है, लेकिन मैंने यूबी के समाधान के रूप में freeze प्रस्तावित किया है। AFAIK जो इसे एक परिभाषित नियतात्मक मूल्य बनाता है, आपको सिर्फ यह कहने के लिए नहीं मिलता है। वह व्यवहार मेरे साथ ठीक है।

तो मैं ठीक हो जाऊंगा अगर u128::MAX as f32 नियत रूप से x86 पर 17.5 उत्पादन किया, और 999.0 x86-64 पर, और -555 ARM पर।

freeze परिभाषित, निर्धारक, अनिर्दिष्ट मूल्य का उत्पादन नहीं करेगा। इसका परिणाम अभी भी "किसी भी बिट पैटर्न को कंपाइलर पसंद करता है", और यह केवल एक ही ऑपरेशन के उपयोग के अनुरूप है। यह उन UB- उत्पादक उदाहरणों को दरकिनार कर सकता है जिन्हें लोगों ने ऊपर एकत्र किया है, लेकिन यह इसे नहीं देगा:

u128 :: MAX के रूप में f32 नियतात्मक रूप से x86 पर 17.5, और x86-64 पर 999.0, और ARM पर -555 का उत्पादन किया गया।

उदाहरण के लिए, अगर LLVM ने u128::MAX as f32 अधिक का नोटिस दिया और freeze poison साथ इसे बदल दिया, तो x86_64 पर fn foo() -> f32 { u128::MAX as f32 } का एक वैध कम होना यह हो सकता है:

foo:
  ret

(यानी, रिटर्न रजिस्टर में जो कुछ भी अंतिम रूप से संग्रहीत किया गया था)

समझा। यह मेरे उपयोगों के लिए अभी भी स्वीकार्य है (उन मामलों के लिए जहां मैं सीमा मूल्यों से बाहर होने की उम्मीद करता हूं, मैं पहले से ही क्लैंपिंग करता हूं। जहां मैं सीमा में मूल्यों की उम्मीद करता हूं, लेकिन वे नहीं हैं, तो मैं एक सही परिणाम प्राप्त करने जा रहा हूं कोई फर्क नहीं पड़ता) ।

मुझे तब तक कोई समस्या नहीं है जब तक कि फ़्लोट कास्ट्स मनमानी मूल्यों को वापस नहीं कर देते हैं जब तक कि मान जमे हुए हैं ताकि वे और अधिक अपरिहार्य व्यवहार का कारण न बन सकें।

क्या एलएलवीएम पर freeze तरह कुछ उपलब्ध है? मुझे लगा कि यह विशुद्ध सैद्धांतिक निर्माण था।

@nikomatsakis मैंने कभी भी इसका इस्तेमाल नहीं देखा है ( poison विपरीत) - यह जहर / अपवित्र की एक योजनाबद्ध सुधार है।

आज एलएलवीएम में freeze मौजूद नहीं है। यह केवल प्रस्तावित किया गया है ( यह PLDI पेपर एक स्व-निहित संस्करण है, लेकिन मेलिंग सूची में इसकी बहुत चर्चा की गई है)। प्रस्ताव में काफी खरीद-फरोख्त होती दिख रही है, लेकिन निश्चित रूप से इसकी कोई गारंटी नहीं है कि इसे अपनाया जाएगा, समयबद्ध तरीके से बहुत कम अपनाया गया है। (पॉइंटर प्रकारों को पॉइंटर प्रकारों से हटाने को वर्षों से स्वीकार किया गया है और यह अभी भी नहीं किया गया है।)

क्या हम यहां प्रस्तावित परिवर्तनों पर अधिक व्यापक चर्चा प्राप्त करने के लिए RFC खोलना चाहते हैं? IMO, जो कुछ भी संभावित रूप से as के प्रदर्शन को प्रभावित करता है वह विवादास्पद होने जा रहा है, लेकिन यह दोगुना विवादास्पद होगा यदि हम लोगों को उनकी आवाज सुनने का मौका नहीं देते हैं।

मैं जूलिया डेवलपर हूं, और मैं इस मुद्दे पर कुछ समय से चल रहा हूं, क्योंकि हम एक ही एलएलवीएम बैकएंड साझा करते हैं और इसी तरह के मुद्दे हैं। यदि यह रूचि है, तो यहाँ पर हमने अपनी मशीन पर किसी एक कार्य के लिए (लगभग समय के साथ) समझौता कर लिया है:

• unsafe_trunc(Int64, x) नक्शे संगत LLVM के लिए सीधे आंतरिक fptosi (1.5 ns)
• trunc(Int64, x) रेंज मानों के लिए एक अपवाद फेंकता है (3 ns)
• convert(Int64, x) सीमा या गैर-पूर्णांक मानों (6 ns) के लिए एक अपवाद फेंकता है

इसके अलावा, मैंने अपरिभाषित व्यवहार को थोड़ा और परिभाषित करने के बारे में मेलिंग सूची पर पूछा है, लेकिन बहुत आशाजनक प्रतिक्रिया नहीं मिली।

@ मैं एक RFC के साथ ठीक हूँ, लेकिन मुझे लगता है कि यह निश्चित रूप से डेटा के लिए उपयोगी होगा! हालाँकि , उस संबंध में

मैंने JS शब्दार्थ (modulo @jorendorff का उल्लेख किया है) और जावा शब्दार्थ के साथ खिलवाड़ किया है जो "संतृप्ति" कॉलम प्रतीत होता है। यदि वे लिंक समाप्त हो जाते हैं तो यह JS और Java है ।

मैंने रस्ट में संतृप्ति के त्वरित कार्यान्वयन पर भी ज़ोर दिया, जो मुझे लगता है कि (?) सही है। और कुछ बेंचमार्क नंबर भी मिले। दिलचस्प बात यह है कि मैं देख रहा हूं कि संतृप्त कार्यान्वयन आंतरिक की तुलना में 2-3 गुना धीमा है, जो कि

मुझे पूरी तरह से यकीन नहीं है कि रस्ट में "मॉड" शब्दार्थ को कैसे लागू किया जाए ...

मेरे लिए, हालांकि, यह स्पष्ट है कि हमें f32::as_u32_unchecked() विधियों और ऐसे लोगों की आवश्यकता होगी जिन्हें प्रदर्शन की आवश्यकता है।

यह स्पष्ट लगता है कि हमें प्रदर्शन की आवश्यकता वाले f32::as_u32_unchecked() विधियों और ऐसे लोगों की आवश्यकता होगी।

यह एक बुमेर है - या क्या आपका मतलब एक सुरक्षित लेकिन कार्यान्वयन-परिभाषित संस्करण है?

क्या एक कार्यान्वयन परिभाषित तेज डिफ़ॉल्ट के लिए कोई विकल्प नहीं है?

@eddyb मैं सोच रहा था कि हमारे पास unsafe fn as_u32_unchecked(self) -> u32 f32 और जो कि as लिए एक सीधा एनालॉग है वह आज है।

मैं निश्चित रूप से यह दावा नहीं करने जा रहा हूं कि मैंने जो रस्ट कार्यान्वयन लिखा है वह इष्टतम है, लेकिन मैं इस धारणा के तहत था कि जब इस थ्रेड निर्धारकवाद और सुरक्षा को पढ़ना इस संदर्भ में गति से अधिक महत्वपूर्ण था। unsafe एस्केप हैच बाड़ के दूसरी तरफ उन लोगों के लिए है।

तो कोई सस्ता प्लेटफ़ॉर्म-निर्भर संस्करण नहीं है? मैं कुछ ऐसा चाहता हूं जो तेज हो, सीमा से बाहर होने पर अनिर्दिष्ट मूल्य देता है और सुरक्षित रहता है। मैं कुछ जानकारी के लिए यूबी नहीं चाहता और मुझे लगता है कि यह आम उपयोग के लिए बहुत खतरनाक है, अगर हम बेहतर कर सकते हैं।

जहां तक ​​मुझे जानकारी है, यदि इस रूपांतरण को लागू करने के लिए सभी प्लेटफ़ॉर्म कैनोनिकल तरीके से नहीं हैं, तो यह आउट-ऑफ-रेंज इनपुट्स के लिए कुछ करता undef / poison " परिणाम नहीं दे सकता है, तो हम इसका उपयोग कर सकते हैं।

लेकिन मुझे लगता है कि इस थ्रेड में किसी को एक आश्वस्त RFC (llvm-dev सूची पर) लिखना होगा, खरीदना-इन करना होगा और इसे लागू करना होगा (बैकेंड्स के बारे में हम परवाह करते हैं, और अन्य के लिए गिरावट-वापस कार्यान्वयन के साथ) लक्ष्य)। संभवतः मौजूदा कलाकारों को न-यूबी बनाने के लिए llvm-dev को समझाने की तुलना में आसान है (क्योंकि यह "किसी भी C और C ++ प्रोग्राम को धीमा कर देगा" जैसे साइड-स्टेप प्रश्न), लेकिन फिर भी बहुत आसान नहीं है।

बस अगर आप इन के बीच चयन करेंगे:

संतृप्ति (आउट-ऑफ-रेंज मान बन जाते हैं
मोडुलो (आउट-ऑफ-रेंज मानों का इलाज किया जाता है जैसे कि पहले एक बिगिंट में परिवर्तित करके, फिर ट्रंकटिंग)

IMO केवल संतृप्ति का अर्थ होता है, क्योंकि फ्लोटिंग पॉइंट की पूर्ण परिशुद्धता जल्दी से मानों के रूप में बड़ी हो जाती है, इसलिए कुछ बिंदु पर मॉडुलो सभी शून्य की तरह बेकार हो जाएगा।

मैंने इसे E-needs-mentor चिह्नित किया है और इसे WG-compiler-middle साथ टैग किया है क्योंकि ऐसा लगता है कि इस अवधि की जाँच करने के लिए एक महान समय हो सकता है! हालांकि , नोट्स बहुत विरल हैं , इसलिए यह बहुत अच्छा होगा यदि कोई @ रस्ट-लेंग / कंपाइलर किसी को थोड़ा और विस्तृत करने में मदद करना चाहता है!

@nikomatsakis

IIRC LLVM अंततः freeze लागू करने की योजना बना रहा है, जो हमें freeze कर यूबी से निपटने की अनुमति देनी चाहिए।

अब तक के मेरे परिणाम: https://gist.github.com/s3bk/4bdfbe2acca30fcf587006ebb4811744

_Array वेरिएंट 1024 मानों का एक लूप चलाता है।
_cast: x as i32
_clip: x.min (MAX) .max (MIN) i32 के रूप में
_पैनिक: अगर x सीमा से बाहर है, तो दहशत
_zero: सीमा से बाहर होने पर परिणाम को शून्य पर सेट करता है

test bench_array_cast       ... bench:       1,840 ns/iter (+/- 37)
test bench_array_cast_clip  ... bench:       2,657 ns/iter (+/- 13)
test bench_array_cast_panic ... bench:       2,397 ns/iter (+/- 20)
test bench_array_cast_zero  ... bench:       2,671 ns/iter (+/- 19)
test bench_cast             ... bench:           2 ns/iter (+/- 0)
test bench_cast_clip        ... bench:           2 ns/iter (+/- 0)
test bench_cast_panic       ... bench:           2 ns/iter (+/- 0)
test bench_cast_zero        ... bench:           2 ns/iter (+/- 0)

शायद आपको अलग-अलग संचालन के लिए पूर्णांक के परिणामों को गोल करने की आवश्यकता नहीं है। स्पष्ट रूप से इन 2 ns / iter के पीछे कुछ अंतर होना चाहिए। या यह वास्तव में ऐसा है, सभी 4 वेरिएंट के लिए _exactly_ 2 ns?

@ सपा 1234 मुझे आश्चर्य है कि अगर यह आंशिक रूप से अनुकूलित है।

@ sp-1234 यह मापने के लिए बहुत तेज़ है। गैर-सरणी बेंचमार्क मूल रूप से बेकार हैं।
यदि आप एकल-मूल्य के कार्यों को #[inline(never)] माध्यम से करने के लिए बाध्य करते हैं, तो आपको 2ns बनाम 3ns मिलते हैं।

@ arielb1
मेरे पास freeze संबंध में कुछ आरक्षण हैं। अगर मैं सही ढंग से समझूं, तो एक जमे हुए undef अभी भी कोई मनमाना मूल्य हो सकता है, यह सिर्फ उपयोगों के बीच नहीं बदलेगा। व्यवहार में, कंपाइलर शायद एक रजिस्टर या स्टैक स्लॉट का पुन: उपयोग करेगा।

हालाँकि इसका मतलब यह है कि अब हम सुरक्षित कोड से अनइंस्टॉल की गई मेमोरी को पढ़ सकते हैं। इससे गुप्त डेटा लीक हो सकता है, कुछ हद तक हार्टबेल्ड की तरह। यह बहस का विषय है कि क्या यह वास्तव में रुस्ट के दृष्टिकोण से यूबी माना जाता है, लेकिन यह स्पष्ट रूप से अवांछनीय लगता है।

मैंने स्थानीय स्तर पर @ s3bk का मानदंड चलाया। मैं पुष्टि कर सकता हूं कि स्केलर संस्करणों को पूरी तरह से अनुकूलित किया गया है, और सरणी वेरिएंट के लिए एएसएम भी संदिग्ध रूप से अच्छी तरह से अनुकूलित दिखता है: उदाहरण के लिए, छोरों को सदिश किया जाता है, जो अच्छा है लेकिन यह स्केलर कोड के प्रदर्शन को एक्सट्रपलेट करने के लिए कठिन बनाता है।

दुर्भाग्य से, black_box स्पैमिंग मदद करने के लिए प्रतीत नहीं होता है। मैं देख रहा हूँ कि उपयोगी काम कर रहे हैं, लेकिन बेंचमार्क चलाने के लिए अभी भी लगातार स्केलर बेंचमार्क के लिए 0ns देता है ( cast_zero , जो 1ns दिखाता है)। मैं देखता हूं कि @alexcrichton ने अपने बेंचमार्क में तुलना 100 बार की, इसलिए मैंने वही हैक अपनाया। अब मैं इन नंबरों ( स्रोत कोड ) को देख रहा हूं:

test bench_cast             ... bench:          53 ns/iter (+/- 0)
test bench_cast_clip        ... bench:         164 ns/iter (+/- 1)
test bench_cast_panic       ... bench:         172 ns/iter (+/- 2)
test bench_cast_zero        ... bench:         100 ns/iter (+/- 0)

मेरे लिए उन पर भरोसा करने के लिए सरणी बेंचमार्क बहुत अधिक भिन्न होते हैं। खैर, सच कहा जाए तो, मुझे test बेंचमार्किंग इन्फ्रास्ट्रक्चर पर वैसे भी संदेह है, खासकर उपरोक्त संख्याओं को देखने के बाद जो फ्लैट 0ns मुझे पहले मिले थे। इसके अलावा, यहां तक ​​कि black_box(x); (एक आधार रेखा के रूप में) के केवल 100 पुनरावृत्तियों में 34ns लगते हैं, जिससे उन नंबरों की मज़बूती से व्याख्या करना और भी कठिन हो जाता है।

ध्यान देने योग्य दो बिंदु:

• NaN को विशेष रूप से नहीं संभालने के बावजूद (यह 0 के बजाय रिटर्न देता है?), cast_clip कार्यान्वयन @alexcrichton के संतृप्त कलाकारों की तुलना में धीमा प्रतीत होता है (ध्यान दें कि उनके रन और माइन में as लगभग समान समय है
• @ S3bk के सरणी परिणामों के विपरीत, मैं cast_panic को अन्य जाँच की गई जातियों की तुलना में धीमा देख रहा हूं। मुझे ऐरे बेंचमार्क पर और भी अधिक मंदी दिखाई देती है। हो सकता है कि ये बातें केवल सूक्ष्म-वैज्ञानिक विवरण और / या आशावादी मनोदशा पर अत्यधिक निर्भर हों?

रिकॉर्ड के लिए, मैंने हल्के लोड के तहत एक i7-6700K पर 1.21.0-रात (d692a91fa 2017-08-04), -C opt-level=3 , के साथ मापा है।

निष्कर्ष में, मेरा निष्कर्ष है कि अभी तक विश्वसनीय डेटा नहीं है और अधिक विश्वसनीय डेटा प्राप्त करना कठिन लगता है। इसके अलावा, मैं दृढ़ता से संदेह करता हूं कि कोई भी वास्तविक एप्लिकेशन इस ऑपरेशन पर अपनी दीवार घड़ी के समय का 1% भी खर्च करता है। इसलिए, मैं एक -Z ध्वज के पीछे, जंग में as जातियों को दूंगा , और फिर इस झंडे के साथ और बिना कुछ गैर-कृत्रिम बेंचमार्क चलाकर यथार्थवादी प्रभाव को निर्धारित करूंगा। अनुप्रयोग।

संपादित करें: मैं ऐसे आर्किटेक्चर की विभिन्न किस्मों (जैसे एआरएम सहित) और माइक्रोआर्किटेक्चर पर ऐसे बेंचमार्क चलाने की सलाह दूंगा, यदि संभव हो तो।

मैं मानता हूं कि मैं जंग से परिचित नहीं हूं, लेकिन मुझे लगता है कि यह रेखा बिल्कुल गलत है: std::i32::MAX (2 ^ 31-1) फ्लोट 32 के रूप में बिल्कुल प्रतिनिधित्व नहीं है, इसलिए std::i32::MAX as f32 होगा निकटतम प्रतिनिधित्व योग्य मूल्य (2 ^ 31) के लिए गोल। यदि यह मान x तर्क के रूप में उपयोग किया जाता है, तो परिणाम तकनीकी रूप से अपरिभाषित है। एक सख्त असमानता के साथ इस मामले को ठीक करना चाहिए।

हाँ, हम पहले सर्वो में यही समस्या थी। अंतिम समाधान f64 के लिए डाली गई और फिर क्लैंप किया गया।

वहाँ अन्य समाधान कर रहे हैं, लेकिन वे बहुत मुश्किल है और जंग इस अच्छी तरह से निपटने के लिए अच्छा एपीआई का खुलासा नहीं करता है।

ऊपरी सीमा के रूप में 0x7FFF_FF80i32 और -0x8000_0000i32 का उपयोग कर इसे f64 के लिए कास्टिंग के बिना हल करना चाहिए।
संपादित करें: सही मूल्य का उपयोग करें।

मुझे लगता है कि आपका मतलब 0x7fff_ff80 , लेकिन बस एक सख्त असमानता का उपयोग करने से शायद कोड स्पष्ट हो जाएगा।

x < 0x8000_0000u32 as f32 ? यह शायद एक अच्छा विचार होगा।

मैं सभी सुझाए गए निर्धारक विकल्पों के बारे में सोचता हूं, क्लैम्पिंग आनुवंशिक रूप से सबसे उपयोगी है क्योंकि मुझे लगता है कि यह वैसे भी अक्सर होता है। यदि रूपांतरण प्रकार वास्तव में संतृप्त होने के लिए प्रलेखित किया जाएगा, तो मैनुअल क्लैम्पिंग अनावश्यक हो जाएगी।

मैं सुझाए गए कार्यान्वयन के बारे में थोड़ा चिंतित हूं क्योंकि यह मशीन के निर्देशों का ठीक से अनुवाद नहीं करता है और यह ब्रांचिंग पर बहुत निर्भर करता है। शाखाकरण प्रदर्शन को विशिष्ट डेटा पैटर्न पर निर्भर करता है। सब कुछ ऊपर दिए गए परीक्षण मामलों में (तुलनात्मक रूप से) तेजी से दिखता है क्योंकि एक ही शाखा हमेशा ली जाती है और प्रोसेसर में कई पिछले लूप पुनरावृत्तियों से अच्छा शाखा पूर्वानुमान डेटा होता है। असली दुनिया शायद ऐसी नहीं दिखेगी। इसके अतिरिक्त ब्रांचिंग कोड को वेक्टर करने के लिए कंपाइलर की क्षमता को नुकसान पहुंचाती है। मैं @rkruppe की राय से असहमत वैश्वीकरण के साथ संयोजन में परीक्षण नहीं किया जाना चाहिए। उच्च प्रदर्शन कोड में वैश्वीकरण महत्वपूर्ण है और सामान्य आर्किटेक्चर पर सरल जातियों को वेक्टर करने में सक्षम होना एक महत्वपूर्ण आवश्यकता होनी चाहिए।

ऊपर दिए गए कारणों के लिए, मैंने संतृप्ति शब्दार्थ और @simonbyrne के फिक्स के साथ @alexcrichton कास्ट के एक वैकल्पिक शाखा रहित और डेटा प्रवाह उन्मुख संस्करण के साथ खेला। मैंने इसे u16 , i16 और i32 के लिए लागू किया क्योंकि इन सभी को कुछ अलग मामलों को कवर करना पड़ता है जिसके परिणामस्वरूप अलग-अलग प्रदर्शन होते हैं।

परिणाम:

test i16_bench_array_cast       ... bench:          99 ns/iter (+/- 2)
test i16_bench_array_cast_clip  ... bench:         197 ns/iter (+/- 3)
test i16_bench_array_cast_clip2 ... bench:         113 ns/iter (+/- 3)
test i16_bench_cast             ... bench:          76 ns/iter (+/- 1)
test i16_bench_cast_clip        ... bench:         218 ns/iter (+/- 25)
test i16_bench_cast_clip2       ... bench:         148 ns/iter (+/- 4)
test i16_bench_rng_cast         ... bench:       1,181 ns/iter (+/- 17)
test i16_bench_rng_cast_clip    ... bench:       1,952 ns/iter (+/- 27)
test i16_bench_rng_cast_clip2   ... bench:       1,287 ns/iter (+/- 19)

test i32_bench_array_cast       ... bench:         114 ns/iter (+/- 1)
test i32_bench_array_cast_clip  ... bench:         200 ns/iter (+/- 3)
test i32_bench_array_cast_clip2 ... bench:         128 ns/iter (+/- 3)
test i32_bench_cast             ... bench:          74 ns/iter (+/- 1)
test i32_bench_cast_clip        ... bench:         168 ns/iter (+/- 3)
test i32_bench_cast_clip2       ... bench:         189 ns/iter (+/- 3)
test i32_bench_rng_cast         ... bench:       1,184 ns/iter (+/- 13)
test i32_bench_rng_cast_clip    ... bench:       2,398 ns/iter (+/- 41)
test i32_bench_rng_cast_clip2   ... bench:       1,349 ns/iter (+/- 19)

test u16_bench_array_cast       ... bench:          99 ns/iter (+/- 1)
test u16_bench_array_cast_clip  ... bench:         136 ns/iter (+/- 3)
test u16_bench_array_cast_clip2 ... bench:         105 ns/iter (+/- 3)
test u16_bench_cast             ... bench:          76 ns/iter (+/- 2)
test u16_bench_cast_clip        ... bench:         184 ns/iter (+/- 7)
test u16_bench_cast_clip2       ... bench:         110 ns/iter (+/- 0)
test u16_bench_rng_cast         ... bench:       1,178 ns/iter (+/- 22)
test u16_bench_rng_cast_clip    ... bench:       1,336 ns/iter (+/- 26)
test u16_bench_rng_cast_clip2   ... bench:       1,207 ns/iter (+/- 21)

परीक्षण एक इंटेल हसवेल i5-4570 सीपीयू और रस्ट 1.22.0-रात्रि में चलाया गया था।
clip2 नई शाखा रहित कार्यान्वयन है। यह सभी 2 ^ 32 संभावित f32 इनपुट मूल्यों पर clip सहमत है।

rng बेंचमार्क के लिए, यादृच्छिक इनपुट मानों का उपयोग किया जाता है जो अक्सर विभिन्न मामलों को हिट करते हैं। यह _extreme_ प्रदर्शन लागत (लगभग 10 गुना सामान्य लागत !!!) को हटा देता है जो शाखा भविष्यवाणी विफल होने पर होती है। मुझे लगता है कि इस पर विचार करना महत्वपूर्ण है। यह औसत वास्तविक विश्व प्रदर्शन भी नहीं है, लेकिन यह अभी भी एक संभव मामला है और कुछ एप्लिकेशन इसे हिट करेंगे। लोगों को लगातार प्रदर्शन के लिए f32 कास्ट की उम्मीद होगी।

X86 पर पूरी तरह से तुलना करें :
शाखा रहित संस्करण बहुत अच्छी तरह से minss / maxss निर्देशों के लिए मैप करता है।

दुर्भाग्य से मैं Rust से एआरएम असेंबली बनाने के लिए गॉडबोल्ट बनाने में सक्षम नहीं था, लेकिन यहाँ क्लैम के साथ एआरएम की तुलना तरीकों से की गई है: https://godbolt.org/g/s7ronw
कोड का परीक्षण करने में सक्षम होने और एआरएम के बहुत कुछ जानने के बिना: कोड का आकार बहुत छोटा लगता है और एलएलवीएम ज्यादातर vmax / vmin उत्पन्न करता है जो आशाजनक दिखता है। हो सकता है कि LLVM को अंततः एक ही निर्देश में अधिकांश कोड को मोड़ना सिखाया जा सके?

@ActuallyaDeviloper asm और बेंचमार्क परिणाम बहुत अच्छे लगते हैं! इसके अलावा, आपके जैसे शाखाविहीन कोड को शायद rustc में अन्य समाधानों की नेस्टेड सशर्तियों से उत्पन्न करना आसान है (रिकॉर्ड के लिए, मैं मान रहा हूं कि हम लैंग आइटम फ़ंक्शन को कॉल करने के बजाय इनलाइन आईआर उत्पन्न करना चाहते हैं)। इस लेखन के लिए बहुत बहुत धन्यवाद।

मैं u16_cast_clip2 के बारे में एक सवाल है: यह NaN को संभालने के लिए प्रतीत नहीं होता है ?! NaN के बारे में बात करते हुए एक टिप्पणी है, लेकिन मेरा मानना ​​है कि यह फ़ंक्शन NaN को अनमॉडिफाइड के माध्यम से पास करेगा और इसे f32 करने का प्रयास करेगा (और यदि ऐसा नहीं भी हुआ, तो यह 0 के बजाय सीमा मानों में से एक का उत्पादन करेगा। )।

पुनश्च: स्पष्ट होने के लिए, मैं यह साबित करने की कोशिश नहीं कर रहा था कि यह महत्वहीन है कि क्या कलाकारों को वेक्टर किया जा सकता है। यह स्पष्ट रूप से महत्वपूर्ण है अगर आसपास का कोड अन्यथा वेक्टर है। लेकिन स्केलर का प्रदर्शन भी महत्वपूर्ण है, क्योंकि वैश्वीकरण अक्सर लागू नहीं होता है, और मैं जिन बेंचमार्क पर टिप्पणी कर रहा था, वे स्केलर के प्रदर्शन के बारे में कोई बयान नहीं दे रहे थे। रुचि से बाहर, क्या आपने *array* बेंचमार्क की जांच की है कि क्या वे अभी भी आपके कार्यान्वयन से सदिश हैं?

@rkruppe आप सही हैं, मैंने गलती से if के किनारों की अदला-बदली कर ली और उस बारे में भूल गया। f32 as u16 ऊपरी 0x8000 को दूर करके सही काम करने के लिए खुश होते हैं, इसलिए परीक्षण इसे पकड़ नहीं पाए। मैंने शाखाओं को फिर से स्वैप करके और इस समय if (y.is_nan()) { panic!("NaN"); } साथ सभी तरीकों का परीक्षण करके समस्या को ठीक कर दिया है।

मैंने अपनी पिछली पोस्ट अपडेट की। X86 कोड में बिल्कुल बदलाव नहीं हुआ लेकिन दुर्भाग्य से यह बदलाव किसी कारण से vmax u16 ARM केस में उत्पन्न होने से LLVM को रोकता है। मुझे लगता है कि यह एआरएम निर्देश के NaN हैंडलिंग के बारे में कुछ विवरण के साथ करना है या शायद यह एक LLVM सीमा है।

यह क्यों काम करता है, इस बात पर ध्यान दें कि निचली सीमा मूल्य वास्तव में अहस्ताक्षरित मानों के लिए है। तो NaN और लोअर बाउंड को एक ही समय में पकड़ा जा सकता है।

सरणी संस्करण सदिश हैं।
Godbolt: https://godbolt.org/g/HnmsSV

पुन :: एआरएम asm , मुझे विश्वास है कि कारण vmax किसी भी अधिक उपयोग नहीं किया जाता है कि यह NaN देता है अगर या तो ऑपरेंड NaN है । कोड अभी भी शाखाहीन है, हालांकि, यह केवल पूर्ववर्ती vcmp 0 के साथ परिणाम का हवाला देते हुए, चालित चालों ( vmovgt ) का उपयोग करता है।

यह क्यों काम करता है, इस बात पर ध्यान दें कि निचली सीमा मूल्य वास्तव में अहस्ताक्षरित मानों के लिए है। तो NaN और लोअर बाउंड को एक ही समय में पकड़ा जा सकता है।

ओह्ह, ठीक है। अच्छा लगा।

मैं एक -Z झंडे के पीछे, जंग में संतृप्त के रूप में संतृप्ति को लागू करके आगे बढ़ने का सुझाव दूंगा

मैंने इसे लागू कर दिया है और एक पीआर दर्ज करूँगा जब मैंने भी # 41799 तय किया है और बहुत अधिक परीक्षण किए हैं।

45134 ने एक कोड पथ बताया है जो मुझे याद था (LLVM निरंतर अभिव्यक्ति की पीढ़ी - यह रस्टक के अपने निरंतर मूल्यांकन से अलग है)। मैं उसी पीआर में इसके लिए एक फिक्स रोल करूंगा, लेकिन इसमें थोड़ा समय लगेगा।

@rkruppe आपको @ oli-obk के साथ समन्वय करना चाहिए ताकि miri समान परिवर्तनों के साथ समाप्त हो जाए।

पुल अनुरोध है: # 45205

45205 को मिला दिया गया है, इसलिए अब कोई भी (अच्छी तरह से, अगली रात के साथ शुरू कर सकता है) -Z saturating-float-casts माध्यम से RUSTFLAGS -Z saturating-float-casts पारित करके संतृप्ति के प्रदर्शन प्रभाव को मापता है । [१] इस तरह की माप इस मुद्दे पर आगे बढ़ने के लिए बहुत मूल्यवान होगी।

[१] कड़ाई से बोलते हुए, यह मानक पुस्तकालय के गैर-सामान्य, गैर- #[inline] भागों को प्रभावित नहीं करेगा, इसलिए १००% सटीक होने के लिए आप स्थानीय रूप से Xargo के साथ std बनाना चाहते हैं। हालांकि, मुझे उम्मीद नहीं है कि इससे बहुत अधिक कोड प्रभावित होंगे (उदाहरण के लिए, विभिन्न रूपांतरण लक्षण निहितार्थ #[inline] )।

@rkruppe मेरा सुझाव है कि डेटा इकट्ठा करने के लिए एक इंटर्नल / यूजर्स पेज शुरू करें, एक ही नस में https://internals.rust-lang.org/t/help-us-benchmark-incremental-compilation/6th3/ (हम तब भी कर सकते हैं) हमारे मुद्दे ट्रैकर में कुछ यादृच्छिक टिप्पणियों के बजाय लोगों को उससे लिंक करें)

@rkruppe आपको एक ट्रैकिंग मुद्दा बनाना चाहिए। यह चर्चा पहले से ही दो मुद्दों में विभाजित है। यह अच्छा नहीं है!

@Gankro हाँ मैं सहमत हूँ, लेकिन यह कुछ दिन पहले हो सकता है कि मुझे उस पोस्ट को ठीक से लिखने का समय मिल जाए, इसलिए मुझे लगा कि मैं इस समय इस मुद्दे पर सब्सक्राइब किए गए लोगों से प्रतिक्रिया लेना चाहूंगा।

@ est31 हम्म। हालाँकि, -Z ध्वज दोनों कास्ट दिशाओं को कवर करता है (जो एक गलती हो सकती है, रेट्रोस्पेक्ट में), ऐसा लगता नहीं है कि हम एक ही समय में दोनों पर स्विच को फ्लिप करेंगे, और दोनों के बीच थोड़ा ओवरलैप होना चाहिए जो कि चाहिए चर्चा की जा सकती है (उदाहरण के लिए, यह मुद्दा संतृप्ति के प्रदर्शन पर टिका है, जबकि # 41799 में इस पर सहमति है कि सही समाधान क्या है)।
यह थोड़ा पागल है कि मानक के मुख्य रूप से इस मुद्दे पर लक्षित भी # 41,799 को ठीक कर के प्रभाव को मापने होता है, लेकिन, प्रदर्शन प्रतिगमन की overreporting तो मैं उस के साथ ठीक की तरह कर रहा हूँ करने के लिए सबसे नेतृत्व में है कि कर सकते हैं। (लेकिन अगर किसी को -Z ध्वज को दो में विभाजित करने के लिए प्रेरित किया जाता है, तो आगे बढ़ें।)

मैंने झंडे को हटाने के कार्य के लिए एक ट्रैकिंग मुद्दे पर विचार किया है, क्योंकि इसकी उपयोगिता को रेखांकित किया है, लेकिन मुझे यहाँ और # 41799 में होने वाली चर्चाओं को विलय करने की आवश्यकता नहीं है।

मैंने एक आंतरिक पद का मसौदा तैयार किया है: https://gist.github.com/Gankro/feab9fb0c42881984caf93c7ad494ebd

इसे कॉपी करने के लिए बेझिझक, या बस मुझे नोट्स दें ताकि मैं इसे पोस्ट कर सकूं। (नोट मैं const fn व्यवहार के बारे में थोड़ा भ्रमित हूं)

एक अतिरिक्त टिडबिट यह है कि फ्लोट की लागत>> अंतर रूपांतरण मौलिक होने के बजाय वर्तमान कार्यान्वयन के लिए विशिष्ट है। 86 पर, cvtss2si cvttss2si रिटर्न भी कम में 0x80000000, भी उच्च है, और नेन मामलों, एक को लागू कर सकता है तो -Zsaturating-float-casts एक साथ cvtss2si cvttss2si 0x80000000 मामले में विशेष कोड द्वारा पीछा किया जाता है, इसलिए यह सामान्य मामले में केवल एक तुलना और पूर्वानुमान लगाने वाली शाखा हो सकती है। ARM पर, vcvt.s32.f32 पास -Zsaturating-float-casts शब्दार्थ पहले से ही हैं। एलएलवीएम वर्तमान में किसी भी मामले में अतिरिक्त जांचों का अनुकूलन नहीं करता है।

@Gankro

बहुत बढ़िया, बहुत बहुत धन्यवाद! मैंने गिस्ट पर कुछ नोट्स छोड़ दिए। इसे पढ़ने के बाद, मैं -Z ध्वज से u128-> f32 जातियों को अलग करने पर एक स्टैब लेना चाहता हूं। सिर्फ दो ओर्थोगोनल विशेषताओं को कवर करने वाले ध्वज के बारे में ध्यान भंग करने वाले कैविएट से छुटकारा पाने के लिए।

(मैंने -Z झंडे को फिर से शुरू करने के लिए # 45900 दर्ज किया है ताकि यह केवल फ्लोट को कवर करे-> int मुद्दा)

यह अच्छा होगा यदि हम बड़े पैमाने पर बेंचमार्किंग के लिए मंच-विशिष्ट कार्यान्वयनों को ला @ sunfishcode (कम से कम x86) के लिए पूछ सकते हैं। यह बहुत मुश्किल नहीं होना चाहिए।

समस्या यह है कि एलएलवीएम वर्तमान में ऐसा करने का एक तरीका प्रदान नहीं करता है, जहां तक ​​मुझे पता है, शायद इनलाइन एएसएम के अलावा जो मैं जरूरी नहीं कि रिलीज के लिए सुझाएगा।

मैंने चर्चा को प्रतिबिंबित करने के लिए मसौदे को अपडेट किया है (मूल रूप से u128 के किसी भी इनलाइन उल्लेख को समाप्त करना -> अंत में एक अतिरिक्त अनुभाग के लिए f32)।

@sunfishcode क्या आप सुनिश्चित हैं? क्या llvm.x86.sse.cvttss2si आंतरिक जो आप खोज रहे हैं?

यहाँ एक खेल का मैदान लिंक है जो इसका उपयोग करता है:

https://play.rust-lang.org/?gist=33cf9e0871df2eb2475b845af4f1b574&version=nightly

रिलीज़ मोड में, float_to_int_with_intrinsic और float_to_int_with_as दोनों एक निर्देश के लिए संकलित हैं। (डिबग मोड में, float_to_int_with_intrinsic कुछ निर्देश उच्च में शून्य डालते हैं, लेकिन यह बहुत बुरा नहीं है।)

यहां तक ​​कि यह सही ढंग से निरंतर तह करने के लिए भी लगता है। उदाहरण के लिए,

float_to_int_with_intrinsic(42.0)

हो जाता है

movl    $42, %eax

लेकिन एक आउट-ऑफ-द-रेंज मान,

float_to_int_with_intrinsic(42.0e33)

मुड़ा नहीं है:

cvttss2si   .LCPI2_0(%rip), %eax

(आदर्श रूप से यह निरंतर 0x80000000 की ओर बढ़ेगा, लेकिन यह कोई बड़ी बात नहीं है। महत्वपूर्ण बात यह है कि यह अपराजित नहीं है।)

ओह बढ़िया। ऐसा लगता है कि काम करेगा!

यह जानना अच्छा है कि हम करते हैं, आखिरकार, cvttss2si का निर्माण करने का एक तरीका है। हालाँकि, मैं इस बात से सहमत नहीं हूँ कि बेंचमार्क के लिए कॉल करने से पहले इसका उपयोग करने के लिए कार्यान्वयन को बदलने के लिए स्पष्ट रूप से बेहतर है:

अधिकांश लोग x86 पर बेंचमार्क करेंगे, इसलिए यदि हम विशेष केस x86 हैं, तो हम सामान्य कार्यान्वयन पर बहुत कम डेटा प्राप्त करेंगे, जिसका उपयोग अभी भी अधिकांश अन्य लक्ष्यों पर किया जाएगा। बेशक, पहले से ही अन्य आर्किटेक्चर के बारे में कुछ भी अनुमान लगाना मुश्किल है, लेकिन पूरी तरह से अलग कार्यान्वयन इसे असंभव बनाता है।

दूसरा, यदि हम "सरल" समाधान के साथ अब बेंचमार्क इकट्ठा करते हैं, और पाते हैं कि वास्तविक कोड में कोई प्रदर्शन प्रतिगमन नहीं है (और मुझे उम्मीद है कि tbh), तो हमें कोशिश करने की परेशानी से गुजरने की ज़रूरत नहीं है इस कोड पथ को और अनुकूलित करें।

अंत में, मुझे यकीन नहीं है कि हम cvttss2si निर्माण कर रहे हैं, जो अब हमारे पास है (हालांकि एआरएम पर, उचित निर्देश का उपयोग करने से स्पष्ट रूप से बेहतर है):

• आपको यह देखने के लिए तुलना की आवश्यकता है कि रूपांतरण 0x80000000 वापस करता है, और यदि ऐसा है तो आपको अभी भी एक और तुलना (इनपुट मान के) की आवश्यकता है, यह जानने के लिए कि क्या आपको int :: MIN या int :: MAX वापस करना चाहिए। और अगर यह एक हस्ताक्षरित पूर्णांक प्रकार है, तो मैं नहीं देखता कि एनएएन को भेद करने के लिए तीसरे की तुलना कैसे करें। तो सबसे खराब स्थिति में:
  
  
  
  • आप तुलना / चयन की संख्या में नहीं बचा है
  
  
  • आप एक फ्लोट की तुलना एक int तुलना के लिए कर रहे हैं, जो OoO कोर के लिए अच्छा हो सकता है (यदि आप FUs पर अड़चन डाल रहे हैं जो तुलना कर सकता है, जो अपेक्षाकृत बड़ा लगता है), लेकिन यह तुलना फ्लोट पर भी निर्भर है -> इंट तुलना, जबकि वर्तमान कार्यान्वयन में तुलना सभी स्वतंत्र हैं, इसलिए यह स्पष्ट है कि यह एक जीत है।
  
  
• वैश्वीकरण शायद अधिक कठिन या असंभव हो जाता है। मुझे उम्मीद नहीं है कि लूप वेक्टराइज़र इस आंतरिक को पूरी तरह से संभालता है।
• यह भी ध्यान देने योग्य है कि (AFAIK) यह रणनीति केवल कुछ पूर्णांक प्रकारों पर लागू होती है। f32 -> u8, उदाहरण के लिए, परिणाम के अतिरिक्त फिक्सअप की आवश्यकता होगी, जो इस रणनीति को बहुत स्पष्ट रूप से लाभहीन बनाते हैं। मुझे पूरा यकीन नहीं है कि कौन से प्रकार इससे प्रभावित होते हैं (उदाहरण के लिए, मुझे नहीं पता कि क्या f32 -> u32 के लिए कोई निर्देश है), लेकिन एक एप्लिकेशन जो केवल उन प्रकारों का उपयोग करता है, उन्हें बिल्कुल फायदा नहीं होगा।
• आप खुश पथ में केवल एक की तुलना के साथ एक शाखा समाधान कर सकते हैं (जैसा कि दो या तीन तुलना के विपरीत है, और इस प्रकार शाखाएं, पिछले समाधान के रूप में)। हालाँकि, जैसा कि @ActuallyaDeviloper ने पहले तर्क दिया था, ब्रांचिंग वांछनीय नहीं हो सकती है: प्रदर्शन अब और भी अधिक कार्यभार-निर्भर और शाखा-भविष्यवाणी पर निर्भर हो जाता है।

क्या यह मान लेना सुरक्षित है कि हमें बेंचमार्किंग शो की परवाह किए बिना unsafe fn as_u32_unchecked(self) -> u32 और दोस्तों की जरूरत पड़ने वाली है? अगर वे अंत था एक मंदी को देख किसी को क्या अन्य संभावित सहारा होगा?

@bstrie मुझे लगता है कि यह अधिक समझ में आता है, इस तरह के मामले में, सिंटैक्स को as <type> [unchecked] तक पहुंचाने और unchecked आवश्यकता के समान कुछ करने के लिए unsafe में मौजूद होना चाहिए संदर्भों।

जैसा कि मैं इसे देखता हूं, _unchecked as कास्टिंग के वेरिएंट के रूप में फ़ॉरेस्ट एक वार्ट होगा, जहां तक ​​इंटुइटनेस जाता है, और जब यह स्वच्छ, प्रयोग करने योग्य प्रलेखन उत्पन्न करने की बात आती है।

@ssokolow सिंटैक्स जोड़ना हमेशा एक अंतिम उपाय होना चाहिए, खासकर अगर यह सब सिर्फ दस रटे कार्यों के साथ ध्यान रखा जा सकता है। यहां तक ​​कि एक सामान्य foo.as_unchecked::<u32>() का वाक्य-विन्यास में परिवर्तन (और सहवर्ती अंतर्विरोधित बिकेशेड) के लिए बेहतर होगा, खासकर जब से हमें कम करना चाहिए, बढ़ाना नहीं चाहिए, उन चीजों की संख्या जो unsafe अनलॉक करती है।

बिंदु। विकल्पों पर विचार करते समय अशांति ने मेरा दिमाग खिसका दिया और, मैं सोच रहा था कि मैं आज शाम या तो सभी सिलेंडरों पर गोलीबारी नहीं कर रहा हूं, इसलिए मुझे डिजाइन निर्णयों पर टिप्पणी करने के बारे में अधिक सतर्क रहना चाहिए था।

उस ने कहा, गंतव्य प्रकार को फंक्शन नाम में बेक करना गलत लगता है ... भाषा के भविष्य के विकास पर असंगत और संभावित बोझ। टर्बोफिश एक बेहतर विकल्प की तरह लगता है।

एक सामान्य विधि UncheckedFrom / UncheckedInto unsafe fn विधियों के साथ एक नए सेट द्वारा समर्थित हो सकती है, जो From / Into जुड़ती है। TryFrom / TryInto संग्रह।

@bstrie उन लोगों के लिए एक वैकल्पिक समाधान जिसका कोड धीमा हो गया है, अंतर्निहित हार्डवेयर निर्देश का उपयोग करने के लिए एक आंतरिक (जैसे, stdsimd के माध्यम से) का उपयोग कर सकता है। मैंने पहले तर्क दिया कि यह ऑप्टिमाइज़र के लिए डाउनसाइड है - ऑटो-वैरिएशन की संभावना ग्रस्त है, और एलएलवीएम इसका फायदा नहीं उठा सकता undef आउट-ऑफ-रेंज इनपुट पर - लेकिन यह बिना कलाकारों को करने का एक तरीका प्रदान करता है रन टाइम पर कोई अतिरिक्त काम। मैं तय नहीं कर सकता कि यह काफी अच्छा है, लेकिन यह कम से कम प्रशंसनीय है कि यह हो सकता है।

X86 अनुदेश सेट में रूपांतरण पर कुछ नोट्स:

SSE2 वास्तव में अपेक्षाकृत सीमित है जिसमें रूपांतरण प्रक्रियाएं आपको देती हैं। आपके पास:

• 32-बिट रजिस्टर के साथ CVTTSS2SI परिवार: एकल फ्लोट को i32 परिवर्तित करता है
• 64-बिट रजिस्टर के साथ CVTTSS2SI परिवार: एकल फ्लोट को i64 (x86-64) में कनवर्ट करता है
• CVTTPS2PI परिवार: दो फ़्लोट्स को दो i32s कनवर्ट करता है

उनमें से प्रत्येक के पास f32 और f64 (और साथ ही ऐसे वेरिएंट हैं जो रौंदने के बजाय गोल करते हैं, लेकिन यहां बेकार है)।

लेकिन अहस्ताक्षरित पूर्णांक के लिए कुछ भी नहीं है, 32 से छोटे आकार के लिए कुछ भी नहीं है, और यदि आप 32-बिट x86 पर हैं, तो 64-बिट के लिए कुछ भी नहीं है। बाद में निर्देश सेट एक्सटेंशन अधिक कार्यक्षमता जोड़ते हैं, लेकिन ऐसा लगता है कि कोई भी मुश्किल से उन लोगों के लिए संकलित करता है।

परिणामस्वरूप, मौजूदा ('असुरक्षित') व्यवहार:

• U32 में बदलने के लिए, कंपाइलर i64 में परिवर्तित होते हैं और परिणामस्वरूप पूर्णांक को काटते हैं। (यह आउट-ऑफ-रेंज मूल्यों के लिए अजीब व्यवहार पैदा करता है, लेकिन यह यूबी है जो परवाह करता है।)
• कुछ भी 16-बिट या 8-बिट में बदलने के लिए, कंपाइलर i64 या i32 में परिवर्तित हो जाते हैं और परिणामी पूर्णांक को काट देते हैं।
• U64 में बदलने के लिए, कंपाइलर निर्देशों का एक समूह उत्पन्न करते हैं। F32 से u64 के लिए GCC और LLVM एक बराबर उत्पन्न करते हैं:

fn f32_to_u64(f: f32) -> u64 {
    const CUTOFF: f32 = 0x8000000000000000 as f32; // 2^63 exactly
    if !(f >= CUTOFF) { // less, or NaN
        // just use the signed conversion
        f as i64 as u64
    } else {
        0x8000000000000000u64 + ((f - CUTOFF) as i64 as u64)
    }
}

असंबंधित मजेदार तथ्य: "कन्वर्ट-थ्रू-ट्रंकट" कोड पीढ़ी वह है जो सुपर मारियो 64 में " समानांतर ब्रह्मांड " गड़बड़ का कारण बनती है। टकराव का पता लगाने वाला कोड पहले MIPS निर्देश को i32 में i32 में परिवर्तित करता है, फिर i16 को ट्रुनेट करता है; इस प्रकार, वह निर्देशांक जो i16 में फिट होता है, लेकिन i32 'रैप' में नहीं, उदाहरण के लिए 65536.0 में समन्वय करने पर आपको 0.0 से टकराव का पता चलता है।

वैसे भी, निष्कर्ष:

• "0x80000000 के लिए परीक्षण और विशेष हैंडलर है" केवल i32 और i64 के रूपांतरणों के लिए काम करता है।
• U32, u / i16, और u / i8 के रूपांतरणों के लिए, हालांकि, "परीक्षण यदि ट्रंकिट / साइन-विस्तारित आउटपुट मूल से अलग है" एक समकक्ष है। (यह दोनों पूर्णांक को मूल रूपांतरण के लिए सीमा में बदल देगा, लेकिन अंतिम प्रकार के लिए सीमा से बाहर, और 0x8000000000000000, संकेतक था कि फ्लोट NaN था या मूल रूपांतरण के लिए सीमा से बाहर था।)
• लेकिन एक शाखा की लागत और उस मामले के लिए अतिरिक्त कोड का एक गुच्छा शायद ओवरकिल है। यह ठीक हो सकता है अगर शाखाओं से बचा जा सकता है।

• @ActallyaDeviloper की minss / maxss आधारित एप्रोच इतनी बुरी नहीं है! न्यूनतम रूप,

minss %xmm2, %xmm1
maxss %xmm3, %xmm1
cvttss2si %rax, %xmm1

केवल तीन निर्देश हैं (जिनमें सभ्य कोड आकार और थ्रूपुट / विलंबता है) और कोई शाखा नहीं है।

तथापि:

• शुद्ध-जंग संस्करण को NaN के लिए एक अतिरिक्त परीक्षण की आवश्यकता है। 32-बिट या उससे छोटे रूपांतरण के लिए, जिसे 64-बिट cvttss2si का उपयोग करके और परिणाम को छोटा करके, आंतरिक का उपयोग करके बचा जा सकता है। यदि इनपुट NaN नहीं था, तो न्यूनतम / अधिकतम यह सुनिश्चित करता है कि पूर्णांक ट्रंकेशन द्वारा अपरिवर्तित है। यदि इनपुट NaN था, तो पूर्णांक 0x8000000000000000 है जो कि 0 से कम हो जाता है।
• मैं 2147483647.0 और -2148473648.0 को रजिस्टर में लोड करने की लागत को शामिल नहीं करता था, आमतौर पर प्रत्येक मेमोरी से एक mov।
• F32 के लिए, 2147483647.0 का वास्तव में प्रतिनिधित्व नहीं किया जा सकता है, इसलिए यह वास्तव में काम नहीं करता है: आपको एक और चेक की आवश्यकता है। इससे चीजें बहुत खराब होती हैं। F64 से u / i64 के लिए Ditto, लेकिन f64 से u / i32 में यह समस्या नहीं है।

मैं दो दृष्टिकोणों के बीच समझौता करने का सुझाव देता हूं:

• F32 / f64 से u / i16 और u / i8 के लिए, और f64 से u / i32 के लिए, मिनट / अधिकतम + छंटनी के साथ ऊपर, जैसे:

    let f = if f > 32767.0 { 32767.0 } else { f };
    let f = if f < -32768.0 { -32768.0 } else { f };
    cvttss2si(f) as i16

(U / i16 और u / i8 के लिए, मूल रूपांतरण i32 के लिए हो सकता है; f64 से u / i32 के लिए, इसे i64 करने की आवश्यकता है।)

• F32 / 64 से u32 के लिए,

    let r = cvttss2si64(f) as u32;
    if f >= 4294967296.0 { 4294967295 } else { r }

केवल कुछ निर्देश और कोई शाखा नहीं है:

    cvttss2si   %xmm0, %rcx
    ucomiss .LCPI0_0(%rip), %xmm0
    movl    $-1, %eax
    cmovbl  %ecx, %eax

• F32 / 64 से i64 के लिए, हो सकता है

    let r = cvttss2si64(f);
    if f >= 9223372036854775808. {
        9223372036854775807 
    } else if f != f {
        0
    } else {
        r
    }

यह एक लंबा (अभी भी शाखा रहित) क्रम उत्पन्न करता है:

    cvttss2si   %xmm0, %rax
    xorl    %ecx, %ecx
    ucomiss %xmm0, %xmm0
    cmovnpq %rax, %rcx
    ucomiss .LCPI0_0(%rip), %xmm0
    movabsq $9223372036854775807, %rax
    cmovbq  %rcx, %rax

... लेकिन कम से कम हम भोली दृष्टिकोण की तुलना में एक तुलना बचाते हैं, जैसे कि f बहुत छोटा है, 0x8000000000000000 पहले से ही सही उत्तर है (यानी i64 :: MIN)।

• F32 से i32 के लिए, यह निश्चित नहीं है कि क्या यह पिछले जैसा ही करना बेहतर होगा, या बस पहले f64 में परिवर्तित करें और फिर छोटी मिनट / अधिकतम करें।

• u64 एक गड़बड़ है जिसके बारे में मैं ऐसा नहीं सोचता। : p

बेंचमार्क के लिए कॉल ऊपर है: https://internals.rust-lang.org/t/help-us-benchmark-saturating-float-casts/6231

Https://internals.rust-lang.org/t/help-us-benchmark-saturating-float-casts/6231/14 में किसी ने छवि के साथ जेपीईजी एन्कोडिंग पर एक औसत दर्जे का और महत्वपूर्ण मंदी की सूचना दी। मैंने प्रोग्राम को छोटा कर दिया है ताकि यह स्व-निहित हो और ज्यादातर उन हिस्सों पर केंद्रित हो जो मंदी से संबंधित हैं: https://gist.github.com/rkruppe/4e7972a209f74654ebd872eb4cc57722 (यह कार्यक्रम मेरे लिए संतृप्तता के साथ ~ 15% मंदी दिखाता है डाले)।

ध्यान दें कि जातियां समान अनुपात में f32-> u8 ( rgb_to_ycbcr ) और f32-> i32 ( encode_rgb , "क्वांटिज़ेशन" लूप) हैं। यह भी लगता है कि इनपुट्स सभी रेंज में हैं, यानी, संतृप्ति वास्तव में कभी नहीं गिरती है, लेकिन f32-> u8 के मामले में यह केवल एक बहुपद की न्यूनतम और अधिकतम की गणना करके और गोल त्रुटि के लिए लेखांकन द्वारा सत्यापित किया जा सकता है, जो बहुत कुछ पूछना है। I32 के लिए f32-> i32 की सीमाएं अधिक स्पष्ट हैं, लेकिन केवल इसलिए कि self.tables के तत्व नॉनज़रो हैं, जो कि (जाहिर है?) दिखाने के लिए ऑप्टिमाइज़र के लिए आसान नहीं है, खासकर मूल कार्यक्रम में। tl; dr: रहने के लिए संतृप्ति जाँचें हैं, एकमात्र आशा उन्हें और तेज़ कर रही है।

मैंने एलएलवीएम आईआर में कुछ भी डाला है - यह प्रतीत होता है कि वास्तव में एकमात्र अंतर तुलनात्मक हैं और संतृप्त जातियों से चयन करते हैं। एक त्वरित रूप से संकेत मिलता है कि आसम के पास समान निर्देश हैं और निश्चित रूप से अधिक जीवित मूल्यों का एक गुच्छा है (जो अधिक फैलता है)।

@ Welcomex क्या आपको लगता है कि f32-> u8 और f32-> i32 जातियों को CVTTSS2SI के साथ तेजी से बनाया जा सकता है?

मामूली अद्यतन, rustc 1.28.0-nightly (952f344cd 2018-05-18) , -Zsaturating-float-casts ध्वज अभी भी https://github.com/rust-lang/rust/issues/10184#issuecomment -345479698 में कोड का कारण बनता है ~ 20 x86_64 पर% धीमा। जिसका मतलब है कि LLVM 6 में कुछ भी बदलाव नहीं हुआ है।

| झंडे | समय |
| ------- | -------: |
| -चोट-स्तर = 3 -कर्गेट-सीपीयू = देशी | 325,699 ns / iter (+/- 7,607) |
| -सीट-लेवल = 3 -कर्गेट-सीपीयू = देशी -सर्जेटिंग-फ्लोट-कास्ट | 386,962 ns / iter (+/- 11,601)
(19% धीमी) |
| -चोट-स्तर = ३ | 331,521 ns / iter (+/- 14,096) |
| -पत्थर-स्तर = ३ -सृजन-फ्लोट-कास्ट | 413,572 ns / iter (+/- 19,183)
(25% धीमी) |

@kennytm क्या हमें उम्मीद है कि LLVM 6 में कुछ बदलाव होगा? क्या वे किसी विशेष वृद्धि पर चर्चा कर रहे हैं जिससे इस उपयोग के मामले में लाभ होगा? यदि हां, तो टिकट संख्या क्या है?

@insanitybit यह ... अभी भी खुला प्रतीत होता है ...?

वेल्ड, कोई सुराग नहीं जो मैं देख रहा था। धन्यवाद!

@rkruppe हमने यह सुनिश्चित नहीं किया कि फ्लोटिंग इंट
(डॉक्स बदलकर)?

जुलाई 20, 2018 4:31 पूर्वाह्न पर, "कॉलिन" सूचनाएं @github.com ने लिखा:

वेल्ड, कोई सुराग नहीं जो मैं देख रहा था।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपको इस धागे की सदस्यता दी गई है।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/rust-lang/rust/issues/10184#issuecomment-406462053 ,
या मूक
सूत्र
https://github.com/notifications/unsubscribe-auth/AApc0v3rJHhZMD7Kv7RC8xkGOiIhkGB1ks5uITMHgaJpZM4BJ45C
।

@ नगीसा शायद आप f32::from_bits(v: u32) -> f32 (और इसी तरह f64 ) सोच रहे हैं? यह NaNs के कुछ सामान्यीकरण करता था, लेकिन अब सिर्फ transmute ।

यह मुद्दा as रूपांतरणों का है जो संख्यात्मक मान को अनुमानित करने का प्रयास करते हैं।

@ नगीसा आप फ्लोट-> फ्लोट कास्ट के बारे में सोच रहे होंगे, # 15536 ​​और https://github.com/rust-lang-nursery/nomicon/pull/65 देखें।

आह, हाँ, जो तैरने के लिए तैर रहा था।

शुक्र पर, जुलाई 20, 2018, 12:24 रॉबिन क्रुपे सूचनाएँ @github.com ने लिखा:

@nagisa https://github.com/nagisa आप सोच रहे होंगे फ्लोट-> फ्लोट
जाति, # 15536 https://github.com/rust-lang/rust/issues/15536 और देखें
जंग-lang-नर्सरी / nomicon # 65
https://github.com/rust-lang-nursery/nomicon/pull/65

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें
https://github.com/rust-lang/rust/issues/10184#issuecomment-406542903 ,
या धागा म्यूट करें
https://github.com/notifications/unsubscribe-auth/AApc0gA24Hz8ndnYhRXCyacd3HdUSZjYks5uIaHegaJpZM4BJ45C
।

LLVM 7 रिलीज़ नोटों में कुछ का उल्लेख है:

फ्लोटिंग-पॉइंट कास्ट्स के अनुकूलन में सुधार हुआ है। यह कोड के लिए आश्चर्यजनक परिणाम पैदा कर सकता है जो अतिप्रवाहित जातियों के अपरिभाषित व्यवहार पर निर्भर है। अनुकूलन को एक फ़ंक्शन विशेषता निर्दिष्ट करके अक्षम किया जा सकता है: "सख्त-फ्लोट-कास्ट-ओवरफ़्लो" = "गलत"। यह विशेषता क्लैंग विकल्प -fno- सख्त-फ्लोट-कास्ट-ओवरफ्लो द्वारा बनाई जा सकती है। प्रभावित पैटर्न का पता लगाने के लिए कोड सैनिटाइज़र का उपयोग किया जा सकता है। अकेले इस समस्या का पता लगाने के लिए क्लैंग विकल्प है -fsanitize = फ्लोट-कास्ट-ओवरफ़्लो:

क्या इस मुद्दे पर कोई असर पड़ता है?

हमें परवाह नहीं करनी चाहिए कि एलएलवीएम अतिप्रवाहित जातियों के लिए क्या करता है, जब तक कि यह अपरिभाषित व्यवहार नहीं करता है। इसका परिणाम तब तक कचरा हो सकता है जब तक कि यह अकारण व्यवहार न कर सके।

क्या इस मुद्दे पर कोई असर पड़ता है?

ज़रुरी नहीं। यूबी नहीं बदला, एलएलवीएम इसे शोषण करने के बारे में और भी आक्रामक हो गया, जिससे अभ्यास में इसे प्रभावित करना आसान हो जाता है, लेकिन ध्वनि मुद्दा अपरिवर्तित है। विशेष रूप से, नई विशेषता यूबी को दूर नहीं करती है या एलएलवीएम 7 से पहले मौजूद किसी भी अनुकूलन को प्रभावित नहीं करती है।

@rkruppe जिज्ञासा से बाहर, इस तरह के रास्ते से गिर गया है? ऐसा लगता है कि https://internals.rust-lang.org/t/help-us-benchmark-saturating-float-casts/6231/14 काफी अच्छी तरह से चला गया और कार्यान्वयन में बहुत अधिक कीड़े नहीं हैं। ऐसा लगता है कि एक मामूली प्रदर्शन प्रतिगमन हमेशा अपेक्षित था, लेकिन सही ढंग से संकलित करने के लिए एक सार्थक ट्रेडऑफ जैसा लगता है।

क्या यह सिर्फ फिनिश लाइन के पार होने का इंतजार है? या अन्य ज्ञात अवरोधक हैं?

अधिकतर मैं अन्य चीजों से विचलित / व्यस्त रहा हूं, लेकिन आरबीजी जेपीईजी एन्कोडिंग में एक x0.82 प्रतिगमन "मामूली" से अधिक लगता है, निगलने के लिए एक कड़वी गोली (हालांकि यह आश्वस्त है कि अन्य प्रकार के कार्यभार प्रभावित होते हैं) । यह पर्याप्त गंभीर नहीं है कि मैं संतृप्ति को डिफ़ॉल्ट रूप से चालू करने पर आपत्ति जताऊंगा, लेकिन पर्याप्त है कि मैं खुद इसके लिए धक्का देने से पहले संकोच कर रहा हूं "हमने एक रूपांतरण फ़ंक्शन भी प्रदान किया है जो संतृप्ति की तुलना में तेज़ है, लेकिन (सुरक्षित) कचरा उत्पन्न कर सकता है "विकल्प पर पहले चर्चा की गई। मैं उस के लिए नहीं मिला है, और जाहिरा तौर पर किसी और को भी नहीं है, तो यह रास्ते से गिर गया है।

अपडेट @rkruppe के लिए ठीक ठाक धन्यवाद! मैं उत्सुक हूँ अगर वहाँ वास्तव में सुरक्षित कचरा विकल्प के कार्यान्वयन है? मैं हमें आसानी से unsafe fn i32::unchecked_from_f32(...) और जैसे कुछ प्रदान करने की कल्पना कर सकता था, लेकिन ऐसा लगता है कि आप सोच रहे हैं कि एक सुरक्षित फ़ंक्शन होना चाहिए। क्या आज एलएलवीएम के साथ यह संभव है?

अभी तक कोई freeze नहीं है, लेकिन फ़्लोटर्स को पूर्णांक में कनवर्ट करने के लिए लक्ष्य आर्किटेक्चर के निर्देश तक पहुँचने के लिए इनलाइन असेंबली का उपयोग करना संभव है (उदाहरण के लिए as संतृप्त करने के लिए एक कमबैक के साथ)। हालांकि यह कुछ अनुकूलन को बाधित कर सकता है, लेकिन यह कुछ बेंचमार्क में प्रतिगमन को ठीक करने के लिए पर्याप्त हो सकता है।

एक unsafe फ़ंक्शन जो यूबी को रखता है कि यह मुद्दा है (और as रूप में उसी तरह से कोड है) आज एक और विकल्प है, लेकिन बहुत कम आकर्षक एक, मैं ' d सुरक्षित कार्य को प्राथमिकता दें यदि वह काम कर सके।

सुरक्षित संतृप्त फ्लोट-टू-इंट अनुक्रम में सुधार के लिए भी महत्वपूर्ण जगह है। LLVM के पास इसके लिए विशेष रूप से कुछ भी नहीं है, लेकिन अगर इनलाइन asm समाधान टेबल पर हैं, तो यह करना मुश्किल नहीं होगा:

     cvttsd2si %xmm0, %eax   # x86's cvttsd2si returns 0x80000000 on overflow and invalid cases
     cmp $1, %eax            # a compact way to test whether %eax is equal to 0x80000000
     jno ok
     ...  # slow path: check for and handle overflow and invalid cases
ok:

वर्तमान में जो उससे अधिक तेजी से होनी चाहिए।

ठीक है मैं सिर्फ स्पष्ट करना चाहता था, धन्यवाद! मुझे लगा कि इनलाइन असॉल्ट सॉल्यूशंस डिफॉल्ट के रूप में कारगर नहीं हैं क्योंकि यह अन्य ऑप्टिमाइज़ेशन को बहुत अधिक बाधित करेगा, लेकिन मैंने खुद के लिए प्रयास नहीं किया है। मैं व्यक्तिगत रूप से पसंद करूंगा कि हम कुछ उचित व्यवहार (जैसे आज के संतृप्त जातियों) को परिभाषित करके इस बिना छेद वाले छेद को बंद कर दें। यदि आवश्यक हो, तो हम हमेशा आज के तेज / बिना कार्यान्वयन के असुरक्षित फ़ंक्शन के रूप में संरक्षित कर सकते हैं, और अनंत संसाधनों को दिए गए समय की सीमा में, हम डिफ़ॉल्ट रूप से भी सुधार कर सकते हैं और / या अन्य विशेष रूपांतरण कार्यों को जोड़ सकते हैं (जैसे एक सुरक्षित रूपांतरण जहां सीमा से बाहर है।) 'टी यूबी लेकिन सिर्फ एक कचरा बिट पैटर्न)

क्या अन्य लोग इस तरह की रणनीति का विरोध करेंगे? क्या हमें लगता है कि इस बीच में इसे ठीक करना महत्वपूर्ण नहीं है?

मुझे लगता है कि इनलाइन असेंबली cvttsd2si (या इसी तरह के निर्देशों) के लिए सहन करने योग्य होनी चाहिए, क्योंकि विशेष रूप से इनलाइन एएसएम मेमोरी तक पहुंच नहीं होगी या इसके साइड इफेक्ट्स नहीं होंगे, इसलिए यह सिर्फ एक अपारदर्शी ब्लैक बॉक्स है जिसे अप्रयुक्त और हटाया नहीं जा सकता है इसके चारों ओर अनुकूलन को रोकें, LLVM केवल इनरेल और इनलाइन asm के परिणाम मूल्य के बारे में कारण नहीं बता सकता। यह आखिरी बिट है, इसलिए मुझे इस बारे में संदेह होगा कि कोड अनुक्रम @sunfishcode के लिए इनलाइन asm का उपयोग करना संतृप्ति के लिए सुझाव देता है: संतृप्ति के लिए शुरू किए गए चेक आज कभी-कभी हटाए जा सकते हैं यदि वे निरर्थक हैं, लेकिन इनलाइन इन ब्लॉक ब्लॉक में शाखाएँ ' टी सरलीकृत किया जाए।

क्या अन्य लोग इस तरह की रणनीति का विरोध करेंगे? क्या हमें लगता है कि इस बीच में इसे ठीक करना महत्वपूर्ण नहीं है?

मुझे अब संतृप्त करने और संभवतः बाद में विकल्प जोड़ने पर कोई आपत्ति नहीं है, मैं सिर्फ ऐसा नहीं होना चाहता, जिसे इसके लिए आम सहमति बनानी पड़े और इसे उन उपयोगकर्ताओं के लिए उचित ठहराया जाए, जिनका कोड धीमा हो गया है fl

मैंने एलएलवीएम में इंट कास्ट को फ्लोट करने के लिए इंट्रेंसिक्स लागू करने के लिए कुछ काम शुरू किया है: https://reviews.llvm.org/D54749

यदि वह कहीं भी जाता है, तो वह संतृप्त शब्दार्थ प्राप्त करने का अपेक्षाकृत कम उपरि तरीका प्रदान करेगा।

यह अपरिभाषित व्यवहार कैसे पुन: पेश करता है? मैंने टिप्पणी में उदाहरण की कोशिश की लेकिन परिणाम 255 , जो मुझे ठीक लगता है:

println!("{}", 1.04E+17 as u8);

अपरिभाषित व्यवहार को विश्वसनीय तरीके से नहीं देखा जा सकता है, कभी-कभी यह आपको वह देता है जो आप उम्मीद करते हैं लेकिन अधिक जटिल परिस्थितियों में टूट जाता है।

संक्षेप में, हमारे द्वारा उपयोग किए जाने वाले कोड जनरेशन इंजन (LLVM) को यह मानने की अनुमति है कि ऐसा नहीं होता है, और इस प्रकार यह खराब कोड उत्पन्न कर सकता है यदि यह कभी भी इस धारणा पर निर्भर करता है।

@ AaronM04 प्रतिलिपि प्रस्तुत करने योग्य अपरिभाषित व्यवहार का एक उदाहरण आज reddit पर पोस्ट किया गया था:

fn main() {
    let a = 360.0f32;
    println!("{}", a as u8);

    let a = 360.0f32 as u8;
    println!("{}", a);

    println!("{}", 360.0f32 as u8);
}

( खेल का मैदान देखें)

मुझे लगता है कि पिछली टिप्पणी @ AaronM04 के लिए थी, उनकी पिछली टिप्पणी के संदर्भ में।

"ओह, यह तो काफी आसान है।"

• @ पीसीवल्टन , २०१४

क्षमा करें, मैंने अच्छे इरादों के इस 6 साल के इतिहास को बहुत ध्यान से पढ़ा है। लेकिन, गंभीरता से, 10 में से 6 लंबे साल !!! अगर यह एक राजनेता मंच होता, तो कुछ इधर-उधर धधकती तोड़फोड़ की आशंका होती।

तो, कृपया, किसी को भी, सरल शब्दों में समझा सकते हैं, क्या यह समाधान की तलाश की प्रक्रिया को समाधान से अधिक दिलचस्प बनाता है?

क्योंकि यह शुरू से ही कठिन था और एलएलवीएम में बदलाव की जरूरत है।

ठीक है, लेकिन यह भगवान नहीं था जिसने इस एलएलवीएम को अपने दूसरे सप्ताह में बनाया है, और उसी दिशा में आगे बढ़ते हुए इस मूलभूत समस्या को हल करने में 15 साल लग सकते हैं।

वास्तव में, मुझे किसी को चोट पहुंचाने का कोई ध्यान नहीं है, और मैं अचानक मदद करने के लिए जंग बुनियादी ढांचे के लिए नया हूं लेकिन जब मुझे इस मामले के बारे में पता चला है तो मैं स्तब्ध रह गया।

यह मुद्दा ट्रैकर इस समस्या को हल करने के तरीके के बारे में चर्चा करने के लिए है, और स्पष्ट बताते हुए कि उस दिशा में कोई प्रगति नहीं हुई है। इसलिए यदि आप समस्या को हल करने में मदद करना चाहते हैं या योगदान करने के लिए कुछ नई जानकारी चाहते हैं, तो कृपया करें, लेकिन अन्यथा आपकी टिप्पणी जादुई रूप से तय नहीं हो रही है। :)

मुझे लगता है कि एलएलवीएम में बदलाव के लिए यह धारणा समय से पहले है।

मुझे लगता है कि हम इसे भाषा में न्यूनतम प्रदर्शन लागत के साथ कर सकते हैं। क्या यह ब्रेकिंग परिवर्तन होगा * * हाँ, लेकिन यह किया जा सकता है, और किया जाना चाहिए।

समाधान के लिए मेरा जाना फ्लोट को इंट कास्ट में unsafe रूप में परिभाषित करना होगा, फिर Result प्रकारों में बंधे हुए परिणाम प्रदान करने के लिए कुछ मानक सहायक प्रदान करेगा।

यह एक अनदेखा फिक्स है और यह एक ब्रेकिंग बदलाव है, लेकिन आखिरकार यह है कि हर डेवलपर को पहले से मौजूद यूबी के आसपास काम करने के लिए खुद को कोड करना होगा। यह सही जंग दृष्टिकोण है।

धन्यवाद, @RalfJung , मुझे इसे समझने के लिए। मेरा इरादा किसी का अपमान करने या उत्पादक बुद्धिशीलता प्रक्रिया में हस्तक्षेप करने का नहीं था। जंग में नया होना, यह सच है, इतना कुछ नहीं है जो मैं कर सकता हूं। फिर भी, यह मेरी और शायद दूसरों की मदद करता है, जो जंग में प्रवेश करने की कोशिश करते हैं, इसकी अनसुलझी खामियों के बारे में अधिक सीखते हैं और प्रासंगिक आउटपुट बनाते हैं: क्या यह गहरी खुदाई के लायक है या अब के लिए कुछ और चुनना बेहतर है। लेकिन मुझे पहले से ही खुशी है कि "मेरी बेकार टिप्पणियों" को हटाना बहुत आसान होगा।

जैसा कि पहले धागे में उल्लेख किया गया है, यह धीरे-धीरे है लेकिन निश्चित रूप से आवश्यक शब्दार्थों का समर्थन करने के लिए llvm को ठीक करके सही रास्ता तय किया जा रहा है, क्योंकि संबंधित टीमें बहुत पहले सहमत हो चुकी हैं।

इस चर्चा में और कुछ नहीं जोड़ा जा सकता है।

https://reviews.llvm.org/D54749

@ मैकेनिक लगता है कि

क्या संतृप्त कलाकारों को एक लाइब्रेरी फ़ंक्शन के रूप में लागू किया जा सकता है जो उपयोगकर्ता चुन सकते हैं, अगर वे ध्वनि प्राप्त करने के लिए कुछ प्रीफ़ रिग्रेशन लेने के लिए तैयार हैं? मैं संकलक के कार्यान्वयन को पढ़ रहा हूं लेकिन यह काफी सूक्ष्म है:

https://github.com/rust-lang/rust/blob/625451e376bb2e5283fc4741caa0a3e8a2ca4d54/src/librustc_code_ssa/mir/rvalue.rs#L774 -L901

हम एक आंतरिक को उजागर कर सकते हैं जो संतृप्ति के लिए LLVM IR उत्पन्न करता है (चाहे वह वर्तमान ओपन-कोडेड IR हो या भविष्य में llvm.fpto[su]i.sat हो) -Z ध्वज से स्वतंत्र। ऐसा करना बिल्कुल भी मुश्किल नहीं है।

हालांकि, मैं चिंतित हूं कि क्या यह कार्रवाई का सबसे अच्छा कोर्स है। जब (यदि?) संतृप्ति as जातियों का डिफ़ॉल्ट शब्दार्थ बन जाती है, तो ऐसा API निरर्थक हो जाता है। यह उपयोगकर्ताओं को यह बताने में भी असंगत लगता है कि उन्हें अपने लिए चुनना चाहिए या नहीं, चाहे वे ध्वनि या प्रदर्शन चाहते हों, भले ही यह केवल अस्थायी हो।

इसी समय, वर्तमान स्थिति स्पष्ट रूप से और भी बदतर है। यदि हम लाइब्रेरी API जोड़ने के बारे में सोच रहे हैं, तो मैं डिफ़ॉल्ट रूप से संतृप्ति को सक्षम करने के लिए अधिक से अधिक चेतावनी दे रहा हूं और unsafe आंतरिक प्रदान करता हूं जिसमें NaN और आउट-ऑफ-रेंज नंबर (और निम्न) पर UB है एक सादा fpto[su]i )। यह अभी भी मूल रूप से एक ही विकल्प की पेशकश करेगा, लेकिन ध्वनि के लिए डिफ़ॉल्ट, और नए एपीआई संभवतः भविष्य में अनावश्यक नहीं बनेंगे।

डिफ़ॉल्ट रूप से ध्वनि पर स्विच करना अच्छा लगता है। मुझे लगता है कि हम गेट-गो की बजाय अनुरोध पर आंतरिक आंतरिक प्रस्ताव दे सकते हैं। इसके अलावा, क्या कॉन्स्टल इवैल्यूशन इस मामले में भी संतृप्ति करेगा? (cc @RalfJung @eddyb @ oli-obk)

हमें पहले से ही संतृप्ति करने के लिए कास्ट eval और उम्र के लिए ऐसा किया है, मुझे लगता है कि पहले भी miri (मैं इसे पुराने llvm::Constant -आधारित मूल्यांकन में बदलते हुए याद रखना)।

@rkruppe बहुत बढ़िया! चूंकि आप प्रश्न में कोड से परिचित हैं, क्या आप डिफॉल्टरों को स्विच करना चाहेंगे?

@rkruppe

हम एक आंतरिक को उजागर कर सकते हैं जो संतृप्ति के लिए एलएलवीएम आईआर उत्पन्न करता है

स्रोत और गंतव्य प्रकार के प्रत्येक संयोजन के लिए यह 10 या 12 अलग-अलग आंतरिक होने की आवश्यकता हो सकती है।

@Centril

डिफ़ॉल्ट रूप से ध्वनि पर स्विच करना अच्छा लगता है। मुझे लगता है कि हम गेट-गो की बजाय अनुरोध पर आंतरिक आंतरिक प्रस्ताव दे सकते हैं।

मुझे लगता है कि अन्य टिप्पणियों के विपरीत, आपकी टिप्पणी में "आंतरिक" का मतलब कुछ ऐसा है जिसमें as संतृप्ति होने पर कम प्रीफ़्रेशन प्रतिगमन होगा।

मुझे नहीं लगता कि ज्ञात महत्वपूर्ण रजिस्टरों से निपटने के लिए यह एक अच्छा तरीका है। कुछ उपयोगकर्ताओं के लिए प्रदर्शन हानि एक वास्तविक समस्या हो सकती है, जबकि उनका एल्गोरिथ्म सुनिश्चित करता है कि इनपुट हमेशा सीमा में हो। यदि वे इस धागे की सदस्यता नहीं लेते हैं तो वे केवल महसूस कर सकते हैं कि परिवर्तन स्थिर चैनल पर पहुंचने पर वे प्रभावित होते हैं। उस समय वे 6 से 12 सप्ताह तक अटके रह सकते हैं, भले ही हम अनुरोध पर तुरंत एक असुरक्षित एपीआई लें।

मैं बहुत कुछ करना चाहता हूं क्योंकि हम पहले से ही पदावनति चेतावनियों के लिए स्थापित पैटर्न का पालन करते हैं: केवल कुछ समय के लिए स्थिर में उपलब्ध होने के बाद नाइटली में स्विच करें।

स्रोत और गंतव्य प्रकार के प्रत्येक संयोजन के लिए यह 10 या 12 अलग-अलग आंतरिक होने की आवश्यकता हो सकती है।

ठीक है, तुम मुझे मिल गए, लेकिन मैं नहीं देखता कि यह कैसे प्रासंगिक है? इसे 30 आंतरिक होने दें, इन्हें जोड़ने के लिए यह तुच्छ है। लेकिन वास्तव में, एन पतली आवरणों द्वारा उपयोग किए जाने वाले एक एकल सामान्य आंतरिक को रखना और भी आसान है। यदि हम " as ध्वनि का चयन करते हैं और unsafe कास्ट API" विकल्प चुनते हैं तो भी संख्या नहीं बदलती है।

मुझे नहीं लगता कि यह _ogn_ महत्वपूर्ण प्रतिगमन से निपटने के लिए एक अच्छा तरीका है। कुछ उपयोगकर्ताओं के लिए प्रदर्शन हानि एक वास्तविक समस्या हो सकती है, जबकि उनका एल्गोरिथ्म सुनिश्चित करता है कि इनपुट हमेशा सीमा में हो। यदि वे इस धागे की सदस्यता नहीं लेते हैं तो वे केवल महसूस कर सकते हैं कि परिवर्तन स्थिर चैनल पर पहुंचने पर वे प्रभावित होते हैं। उस समय वे 6 से 12 सप्ताह तक अटके रह सकते हैं, भले ही हम अनुरोध पर तुरंत एक असुरक्षित एपीआई लें।

+1

मुझे यकीन नहीं है कि रिप्लेसमेंट चेतावनियों के लिए प्रक्रिया (केवल रात में एक बार प्रतिस्थापन स्थिर है) आवश्यक है क्योंकि यह सभी रिलीज चैनलों में पूर्ण-प्रतिगमन-मुक्त रहने के लिए कम महत्वपूर्ण लगता है क्योंकि सभी रिलीज चैनलों पर चेतावनी-मुक्त रहने के लिए , लेकिन फिर से, 12 और हफ्तों का इंतजार करना मूल रूप से एक गोल करने वाली त्रुटि है कि यह मुद्दा कितने समय तक रहा है।

हम -Zsaturating-float-casts आसपास (बस डिफ़ॉल्ट को बदल रहे हैं) छोड़ सकते हैं, जिसका अर्थ है कि कोई भी रात्रिकालीन उपयोगकर्ता अभी भी थोड़ी देर के लिए कैन से बाहर निकल सकता है।

(हाँ, आंतरिकों की संख्या केवल एक कार्यान्वयन विवरण है और इसका मतलब किसी भी चीज़ के लिए या तर्क के रूप में नहीं था।)

@rkruppe मैं टिप्पणियों के सभी यहाँ पचा का दावा नहीं कर सकता, लेकिन मैं छाप LLVM कि के तहत कर रहा हूँ अब एक फ्रीज अनुदेश, जो आइटम यहां यूबी को नष्ट करने के लिए "कम से कम पथ" अवरुद्ध हो गया था, सही है?

हालाँकि मुझे लगता है कि freeze इतना नया है कि यह LLVM के अपने संस्करण में उपलब्ध नहीं हो सकता है, है ना? फिर भी, कुछ ऐसा लगता है जैसे हमें विकास की खोज करनी चाहिए, शायद 2020 की पहली छमाही के दौरान?

टी-कंपाइलर बैठक में चर्चा के लिए नामांकित करना, इस बिंदु पर हमारे इच्छित पथ पर आम सहमति प्राप्त करने का प्रयास करना।

यहाँ संदर्भित सभी कारणों से freeze का उपयोग करना अभी भी समस्याग्रस्त है । मुझे यकीन नहीं है कि इन जातियों के लिए फ्रीज का उपयोग करने के साथ इस तरह की चिंताएं कितनी यथार्थवादी हैं, लेकिन सिद्धांत रूप में वे लागू होते हैं। मूल रूप से, जो भी बदतर है, यादृच्छिक कचरा या आपकी गुप्त कुंजी वापस करने के लिए freeze अपेक्षा करें। (मैंने इसे कहीं ऑनलाइन पढ़ा और वास्तव में इसका सारांश है।: D)

और वैसे भी, बेतरतीब कचरा लौटाना भी as कास्ट के लिए बुरा लगता है। यह unchecked_add समान आवश्यक गति के लिए तेज संचालन करने के लिए समझ में आता है, लेकिन यह सुनिश्चित करना कि डिफ़ॉल्ट रस्ट की भावना के खिलाफ काफी दृढ़ता से लगता है।

@SimonSapin आपने पहले विपरीत दृष्टिकोण का प्रस्ताव रखा था (डिफ़ॉल्ट / "अजीब" शब्दार्थ के लिए और स्पष्ट रूप से ध्वनि विधि प्रदान करने के लिए); मैं आपके बाद की टिप्पणियों से यह नहीं बता सकता कि क्या आपको लगता है कि डिफ़ॉल्टता (उपयुक्त संक्रमण अवधि के बाद) भी उचित / बेहतर है?

@pnkfelix

मैं इस धारणा के तहत हूं कि एलएलवीएम में अब फ्रीज निर्देश है, जो कि यूबी को खत्म करने के लिए "सबसे छोटा रास्ता" को अवरुद्ध करने वाला आइटम था, है ना?

कुछ कैविएट हैं। सबसे महत्वपूर्ण बात, यहां तक ​​कि अगर हम परवाह करते हैं कि हम यूबी से छुटकारा पा रहे हैं और हम अपने बंडल किए गए एलएलवीएम को freeze (जो हम किसी भी समय कर सकते हैं) को शामिल करने के लिए अपडेट करते हैं, हम कई पुराने संस्करणों (एलएलवीएम 6 पर वापस) का समर्थन करते हैं पल) और हमें उन सभी उपयोगकर्ताओं के लिए वास्तव में यूबी से छुटकारा पाने के लिए कुछ कमबैक कार्यान्वयन की आवश्यकता होगी।

दूसरा, निश्चित रूप से, यह सवाल है कि क्या "बस यूबी नहीं" है, जबकि हम इसके बारे में परवाह करते हैं। विशेष रूप से, मैं फिर से उजागर करना चाहता हूं कि एक freeze(fptosi %x) बेहद प्रति-सहजता से व्यवहार करता है: यह गैर-निर्धारक है और एक अलग परिणाम (यहां तक ​​कि संवेदनशील मेमोरी से @RalfJung ने कहा कि) को हर बार निष्पादित किए जाने पर वापस कर सकता है। मैं अब इस पर फिर से बहस नहीं करना चाहता हूं, लेकिन बैठक में विचार करने लायक है कि क्या हम संतृप्ति को डिफ़ॉल्ट और अनियंत्रित (या तो असुरक्षित या freeze -उपयोगी) रूपांतरण बनाने के लिए थोड़ा और काम करेंगे गैर-डिफ़ॉल्ट विकल्प।

@RalfJung मेरी स्थिति यह है कि as को इस मुद्दे की परवाह किए बिना पूरी तरह से बचा जाता है, क्योंकि इसमें इनपुट और आउटपुट प्रकार के आधार पर बेतहाशा अलग-अलग शब्दार्थ (ट्रंकिंग, सैचुरेटिंग, राउंडिंग,…) हो सकते हैं और ये हमेशा नहीं होते हैं कोड पढ़ते समय स्पष्ट। (यहां तक ​​कि उत्तरार्द्ध को foo as _ साथ अनुमान लगाया जा सकता है।) तो मेरे पास विभिन्न स्पष्ट रूप से नामित रूपांतरण विधियों के प्रस्ताव के लिए पूर्व-आरएफसी है जो उन मामलों को कवर करते हैं जो as आज करते हैं (और शायद) ।

मुझे लगता है कि as को निश्चित रूप से UB नहीं होना चाहिए, क्योंकि इसका उपयोग unsafe बाहर किया जा सकता है। कचरा लौटाना अच्छा नहीं लगता। लेकिन शायद हमें संतृप्त कलाकारों के कारण प्रदर्शन प्रतिगमन के ज्ञात मामलों के लिए किसी प्रकार का शमन / संक्रमण / विकल्प होना चाहिए। मैंने केवल उस बदलाव पर इस ड्राफ्ट RFC को ब्लॉक नहीं करने के लिए संतृप्त कलाकारों के एक पुस्तकालय कार्यान्वयन के बारे में पूछा।

@SimonSapin

मेरी स्थिति यह है कि जैसा कि इस मुद्दे की परवाह किए बिना पूरी तरह से बचा जाता है, क्योंकि इसमें बेतहाशा अलग-अलग शब्दार्थ हो सकते हैं (ट्रंकटिंग, सैचुरेटिंग, राउंडिंग,…)

माना। लेकिन यह वास्तव में इस मुद्दे के साथ हमारी मदद नहीं करता है।

(इसके अलावा, मुझे खुशी है कि आप as आवश्यक नहीं होने की दिशा में काम कर रहे हैं। आगे देख रहे हैं: D:

मुझे लगता है कि निश्चित रूप से यूबी नहीं होना चाहिए, क्योंकि इसका उपयोग असुरक्षित के बाहर किया जा सकता है। कचरा लौटाना अच्छा नहीं लगता। लेकिन शायद हमें संतृप्त कलाकारों के कारण प्रदर्शन प्रतिगमन के ज्ञात मामलों के लिए किसी प्रकार का शमन / संक्रमण / विकल्प होना चाहिए। मैंने केवल उस बदलाव पर इस ड्राफ्ट RFC को ब्लॉक नहीं करने के लिए संतृप्त कलाकारों के एक पुस्तकालय कार्यान्वयन के बारे में पूछा।

तो हम इस बात से सहमत प्रतीत होते हैं कि अंतिम स्थिति यह होनी चाहिए कि फ्लोट-टू-इंट as संतृप्त हो? जब तक हम जिस लक्ष्य की ओर बढ़ रहे हैं, मैं किसी भी संक्रमण योजना से खुश हूं।

वह अंतिम लक्ष्य मुझे अच्छा लगता है।

मुझे नहीं लगता कि यह _ogn_ महत्वपूर्ण प्रतिगमन से निपटने के लिए एक अच्छा तरीका है। कुछ उपयोगकर्ताओं के लिए प्रदर्शन हानि एक वास्तविक समस्या हो सकती है, जबकि उनका एल्गोरिथ्म सुनिश्चित करता है कि इनपुट हमेशा सीमा में हो। यदि वे इस धागे की सदस्यता नहीं लेते हैं तो वे केवल महसूस कर सकते हैं कि परिवर्तन स्थिर चैनल पर पहुंचने पर वे प्रभावित होते हैं। उस समय वे 6 से 12 सप्ताह तक अटके रह सकते हैं, भले ही हम अनुरोध पर तुरंत एक असुरक्षित एपीआई लें।

मेरे विचार में, यह दुनिया का अंत नहीं होगा यदि वे उपयोगकर्ता 6-12 सप्ताह के लिए अपने जंग को अपग्रेड करने के साथ प्रतीक्षा करते हैं - उन्हें या तो मामले में आगामी रिलीज से कुछ भी ज़रूरत नहीं हो सकती है, या उनके पुस्तकालयों में एमएसआरवी की कमी हो सकती है को बनाए रखने।

इस बीच, उपयोगकर्ता, जो थ्रेड के लिए सब्सक्राइब नहीं किए जाते हैं, उन्हें गलतफहमी हो सकती है जैसे उन्हें प्रदर्शन हानि हो रही है। हमें किसे प्राथमिकता देनी चाहिए? हम स्थिरता के बारे में गारंटी देते हैं और हम सुरक्षा के बारे में गारंटी देते हैं - लेकिन मेरी जानकारी के अनुसार, प्रदर्शन के बारे में ऐसी कोई गारंटी नहीं दी जाती है (उदाहरण के लिए RFC 1122 पूर्णता का उल्लेख नहीं करता है)।

मैं बहुत कुछ करना चाहता हूं क्योंकि हम पहले से ही पदावनति चेतावनियों के लिए स्थापित पैटर्न का पालन करते हैं: केवल कुछ समय के लिए स्थिर में उपलब्ध होने के बाद नाइटली में स्विच करें।

पदावनति चेतावनियों के मामले में, पदावनति के साथ प्रतीक्षा करने का परिणाम जब तक एक स्थिर विकल्प नहीं है, कम से कम जहां तक ​​मुझे पता है, प्रतीक्षा अवधि के दौरान ध्वनि छेद। (इसके अलावा, जबकि अंतःविषय यहां प्रदान किया जा सकता है, सामान्य स्थिति में, हम ध्वनि छेद को ठीक करते समय यथोचित रूप से विकल्प नहीं दे सकते हैं। इसलिए मुझे नहीं लगता कि स्थिर पर विकल्प होने के लिए एक कठिन आवश्यकता हो सकती है।)

ठीक है, तुम मुझे मिल गए, लेकिन मैं नहीं देखता कि यह कैसे प्रासंगिक है? इसे 30 आंतरिक होने दें, इन्हें जोड़ने के लिए यह तुच्छ है। लेकिन वास्तव में, एन पतली आवरणों द्वारा उपयोग किए जाने वाले एक एकल सामान्य आंतरिक को रखना और भी आसान है। यदि हम " as ध्वनि का चयन करते हैं और unsafe कास्ट API" विकल्प चुनते हैं तो भी संख्या नहीं बदलती है।

नहीं होगा कि एकल जेनेरिक इंट्रेंसिक को उन 12/30 विशिष्ट मोनोमोर्फिक इंस्टेंटिएशन के लिए कंपाइलर में अलग-अलग कार्यान्वयन की आवश्यकता होती है?

यह संकलक में आंतरिक जोड़ने के लिए तुच्छ हो सकता है, क्योंकि एलएलवीएम पहले से ही अधिकांश काम कर चुका है, लेकिन वह भी पूरी लागत से दूर है। इसके अलावा, वहाँ Miri, Cranelift में कार्यान्वयन है, साथ ही एक विनिर्देश में आवश्यक अंतिम कार्य भी है। इसलिए मुझे नहीं लगता कि हमें किसी को उनकी जरूरत के मौके पर आंतरिक संबंध जोड़ना चाहिए।

मैं हालांकि अधिक आंतरिकता को उजागर करने का विरोध नहीं कर रहा हूं, लेकिन अगर किसी को उनकी आवश्यकता है, तो उन्हें एक प्रस्ताव बनाना चाहिए (जैसे कि कुछ विस्तृत विवरण के साथ एक पीआर के रूप में), और कुछ बेंचमार्किंग संख्याओं या कुछ ऐसे के साथ जोड़ को सही ठहराना।

हम -Zsaturating-float-casts आसपास (बस डिफ़ॉल्ट को बदल रहे हैं) छोड़ सकते हैं, जिसका अर्थ है कि कोई भी रात्रिकालीन उपयोगकर्ता अभी भी थोड़ी देर के लिए कैन से बाहर निकल सकता है।

यह मुझे ठीक लगता है, लेकिन मैं इस ध्वज का नाम बदलने का सुझाव दूंगा -Zunsaturating-float-casts जो पहले से ही इस झंडे का उपयोग करते हैं, उनके लिए बदनामी के प्रति बदलते शब्दार्थ से बचने के लिए।

@Centril

नहीं होगा कि एकल जेनेरिक इंट्रेंसिक को उन 12/30 विशिष्ट मोनोमोर्फिक इंस्टेंटिएशन के लिए कंपाइलर में अलग-अलग कार्यान्वयन की आवश्यकता होती है?

नहीं, अधिकांश कार्यान्वयन स्रोत और गंतव्य बिट चौड़ाई पर पैरामीरिज़िंग द्वारा पहले से ही साझा और किए जा सकते हैं। केवल कुछ बिट्स के मामले में अंतर की आवश्यकता होती है। यही बात गिरिजाघर में लागू करने वाले पर भी लागू होती है और सबसे ज्यादा संभावना अन्य कार्यान्वयन और विनिर्देशों पर भी।

(संपादित करें: स्पष्ट होने के लिए, यह साझाकरण हो सकता है भले ही एन अलग आंतरिक हों, लेकिन प्रति-आंतरिक आवश्यक बायलरप्लेट पर एक एकल सामान्य आंतरिक कट जाता है।)

इसलिए मुझे नहीं लगता कि हमें किसी को उनकी जरूरत के मौके पर आंतरिक संबंध जोड़ना चाहिए।

मैं हालांकि अधिक आंतरिकता को उजागर करने का विरोध नहीं कर रहा हूं, लेकिन अगर किसी को उनकी आवश्यकता है, तो उन्हें एक प्रस्ताव बनाना चाहिए (जैसे कि कुछ विस्तृत विवरण के साथ एक पीआर के रूप में), और कुछ बेंचमार्किंग संख्याओं या कुछ ऐसे के साथ जोड़ को सही ठहराना। मुझे नहीं लगता कि इस बीच ध्वनि छेद को ठीक करना बंद कर देना चाहिए।

हमारे पास पहले से ही कुछ बेंचमार्किंग नंबर हैं। हम बेंचमार्क के लिए कॉल से बहुत पहले से जानते हैं कि जेपीईजी एन्कोडिंग संतृप्त x86_64 पर काफी धीमी हो जाती है । कोई उन्हें फिर से चला सकता है, लेकिन मुझे विश्वास है कि यह अनुमान लगाया गया है कि यह परिवर्तित नहीं हुआ है (हालांकि निश्चित रूप से विशिष्ट संख्याएं समान नहीं होंगी) और कोई कारण नहीं है कि भविष्य में परिवर्तन कैसे संतृप्ति को लागू किया जाता है (जैसे इनलाइन asm पर स्विच करना) एलएलवीएम इंट्रेंसिक्स @ मिनिक ने काम किया) मौलिक रूप से इसे बदल देगा। हालांकि भविष्य के बारे में सुनिश्चित होना मुश्किल है, मेरा शिक्षित अनुमान यह है कि उस प्रदर्शन को वापस पाने का एकमात्र प्रशंसनीय तरीका कुछ ऐसा उपयोग करना है जो बिना रेंज चेक के कोड उत्पन्न करता है, जैसे unsafe रूपांतरण या freeze का उपयोग करके कुछ।

मौजूदा बेंचमार्किंग नंबरों से ठीक है, ऐसा लगता है कि उक्त अंतर्ज्ञान के लिए एक सक्रिय इच्छा है। यदि हां, तो मैं निम्नलिखित कार्य योजना प्रस्तावित करूंगा:

1. इसके साथ-साथ:
   
   
   
   • #[unstable(...)] कार्यों के माध्यम से रात में उजागर किए गए आंतरिकता का परिचय दें।
   
   
   • निकालें -Zsaturating-float-casts और परिचय -Zunsaturating-float-casts ।
   
   
   • डिफ़ॉल्ट को -Zsaturating-float-casts क्या पर स्विच करें।
   
   
2. हम कुछ समय बाद आंतरिकता को स्थिर करते हैं; हम तेजी से थोड़ा ट्रैक कर सकते हैं।
3. थोड़ी देर बाद -Zunsaturating-float-casts निकालें।

बढ़िया है। सिवाय इसके कि इंट्रिनिक्स कुछ सार्वजनिक एपीआई के कार्यान्वयन विवरण हैं, शायद f32 और f64 तरीकों पर। वे या तो हो सकते हैं:

• जेनेरिक विशेषता के तरीके (रूपांतरण के पूर्णांक रिटर्न प्रकार के लिए एक पैरामीटर के साथ), वैकल्पिक रूप से प्रस्तावना में
• विभिन्न वापसी प्रकारों का समर्थन करने के लिए एक सहायक विशेषता के साथ निहित तरीके ( str::parse और FromStr )
• नाम में लक्ष्य प्रकार के साथ कई गैर-जेनेरिक अंतर्निहित तरीके

हाँ, मेरा मतलब है कि तरीकों या कुछ इस तरह से आंतरिक को उजागर करना।

नाम में लक्ष्य प्रकार के साथ कई गैर-जेनेरिक अंतर्निहित तरीके

ऐसा लगता है कि सामान्य बात है कि हम क्या करते हैं - इस विकल्प पर कोई आपत्ति?

हालांकि यह है? मुझे लगता है कि जब एक प्रकार का नाम (हस्ताक्षर का) एक विधि के नाम के रूप में होता है, तो यह "एक तरह का" रूपांतरणों में से एक होता है (जैसे Vec::as_slice और [T]::to_vec ) , या रूपांतरणों की एक श्रृंखला जहां अंतर एक प्रकार नहीं है (जैसे to_ne_bytes , to_be_bytes , to_le_bytes )। लेकिन std::convert लिए प्रेरणा का हिस्सा u8::to_u16 , u8::to_u32 , u8::to_u64 , आदि जैसे दर्जनों अलग-अलग तरीकों से बचने के लिए था।

मेरा आश्चर्य यह है कि क्या यह स्वाभाविक रूप से एक विशेषता के लिए सामान्यीकरण योग्य होगा जो कि दिए गए तरीकों को unsafe fn । यदि हम निहित विधियों को जोड़ते हैं, तो आप हमेशा उन लोगों को गुण कार्यान्वयन और whatnot में प्रतिनिधि कर सकते हैं।

मुझे असुरक्षित रूपांतरण के लिए लक्षण जोड़ने के लिए यह अजीब लगता है, लेकिन मुझे लगता है कि साइमन शायद इस तथ्य के बारे में सोच रहे हैं कि हमें फ्लोटिंग पॉइंट और पूर्णांक प्रकार के प्रत्येक संयोजन के लिए एक अलग विधि की आवश्यकता होगी (जैसे f32::to_u8_unsaturated , f32::to_u16_unsaturated , आदि)।

एक लंबे धागे पर तौलना नहीं, जिसे मैंने कुल अज्ञानता में नहीं पढ़ा है, लेकिन क्या यह वांछित है या यह पर्याप्त है जैसे f32::to_integer_unsaturated जो u32 या कुछ में परिवर्तित हो? क्या असुरक्षित रूपांतरण के लिए लक्ष्य प्रकार के लिए एक स्पष्ट विकल्प है?

केवल i32 / u32 (उदाहरण के लिए) के लिए असुरक्षित रूपांतरण प्रदान करना पूरी तरह से उन सभी पूर्णांक प्रकारों को बाहर करता है जिनकी मूल्य सीमा कड़ाई से छोटी नहीं है, और निश्चित रूप से कभी-कभी इसकी आवश्यकता होती है। छोटे (u8 के नीचे, JPEG एन्कोडिंग के रूप में) भी अक्सर जरूरत होती है, लेकिन एक व्यापक पूर्णांक प्रकार में परिवर्तित करके और as (जो आमतौर पर सस्ता नहीं है, हालांकि सस्ता है) के साथ छोटा करके अनुकरण किया जा सकता है।

लेकिन हम बहुत अच्छी तरह से केवल सबसे बड़े पूर्णांक आकार में रूपांतरण प्रदान नहीं कर सकते हैं। वे हमेशा मूल रूप से समर्थित नहीं होते हैं (इसलिए, धीमी गति से) और अनुकूलन ठीक नहीं कर सकते हैं: यह "बड़े इंट में कन्वर्ट करने के लिए" का अनुकूलन करने के लिए अस्वाभाविक है, फिर "छोटे से सीधे इंट में कनवर्ट करें" में काट दें क्योंकि बाद में यूबी है (एलएलवीएम आईआर में) / अलग-अलग परिणाम (मशीन कोड स्तर पर, अधिकांश आर्किटेक्चर पर) उन मामलों में जहां ट्रंक करते समय मूल रूपांतरण परिणाम चारों ओर लिपटा होता।

ध्यान दें कि यहां तक ​​कि व्यावहारिक रूप से 128 बिट पूर्णांक को छोड़कर और 64 बिट पूर्णांक पर ध्यान केंद्रित करना अभी भी सामान्य 32 बिट लक्ष्य के लिए बुरा होगा।

मैं इस बातचीत के लिए नया हूं, लेकिन प्रोग्रामिंग के लिए नहीं। मैं इस बात के लिए उत्सुक हूं कि लोग क्यों सोचते हैं कि रूपांतरण पर चर्चा हो रही है और NaN को शून्य में बदलना उचित डिफ़ॉल्ट व्यवहार है। मैं समझता हूं कि जावा ऐसा करता है (हालांकि चारों ओर लपेटना बहुत अधिक सामान्य लगता है), लेकिन कोई पूर्णांक मूल्य नहीं है जिसके लिए NaN को वास्तव में एक सही रूपांतरण कहा जा सकता है। इसी तरह, 1000000.0 को 65535 (u16) में बदलना, उदाहरण के लिए, गलत लगता है। बस कोई यू 16 नहीं है जो स्पष्ट रूप से सही उत्तर है। कम से कम, मैं इसे १६ ९ ६० में परिवर्तित करने के वर्तमान व्यवहार से बेहतर नहीं मानता, जो कि कम से कम C / C ++, C #, गो और अन्य लोगों के साथ साझा किया गया व्यवहार है, और इस प्रकार कम से कम कुछ हद तक अनिश्चित है।

विभिन्न लोगों ने अतिप्रवाह जाँच के साथ समानता पर टिप्पणी की है, और मैं उनसे सहमत हूँ। यह शून्य से पूर्णांक विभाजन के समान है। मुझे लगता है कि अमान्य रूपांतरणों को अमान्य अंकगणित की तरह ही घबराना चाहिए। NaN -> 0 और 1000000.0 -> 65535 (या 16960) पर भरोसा करना ठीक उसी तरह लगता है जैसे पूर्णांक अतिप्रवाह या एक काल्पनिक n / 0 == पर निर्भर होने के कारण त्रुटि है। यह एक ऐसी चीज है जिसे डिफ़ॉल्ट रूप से त्रुटि उत्पन्न करनी चाहिए। (रिलीज़ बिल्ड में, जंग त्रुटि जाँच को समाप्त कर सकती है, जैसा कि पूर्णांक अंकगणित के साथ होता है।) और दुर्लभ मामलों में जब आप NaN को शून्य में बदलने के लिए _want_ करते हैं या फ्लोटिंग पॉइंट संतृप्ति होती है, तो आपको इसे पसंद करना चाहिए, जैसे आपको पूर्णांक ओवरफ़्लो में चुनना होगा।

प्रदर्शन के लिए, ऐसा लगता है कि उच्चतम सामान्य प्रदर्शन एक सादे रूपांतरण करने और हार्डवेयर दोषों पर निर्भर होने से आएगा। उदाहरण के लिए, x86 और ARM दोनों ही हार्डवेयर अपवादों को बढ़ाते हैं, जब एक फ्लोटिंग-पॉइंट-टू-पूर्णांक रूपांतरण को सही ढंग से प्रस्तुत नहीं किया जा सकता है (NaN और आउट-ऑफ-रेंज मामलों सहित)। यह समाधान अमान्य रूपांतरणों को छोड़कर शून्य-लागत है, सिवाय इसके जब डिबग बिल्ड में छोटे-से-पूर्णांक प्रकार के फ़्लोटिंग-पॉइंट से सीधे कनवर्ट करना - एक दुर्लभ मामला - जहां यह अभी भी तुलनात्मक रूप से सस्ता होना चाहिए। (सैद्धांतिक हार्डवेयर पर जो इन अपवादों का समर्थन नहीं करता है, तो इसे सॉफ्टवेयर में अनुकरण किया जा सकता है, लेकिन फिर से केवल डिबग बिल्ड में।) मुझे लगता है कि हार्डवेयर अपवाद वास्तव में शून्य द्वारा पूर्णांक विभाजन का पता लगाने के लिए लागू किया गया है। मैंने एलएलवीएम की बहुत सारी बातें देखीं, इसलिए शायद आप यहाँ विवश हैं, लेकिन यह स्वाभाविक रूप से हर अस्थायी बिंदु रूपांतरण में सॉफ़्टवेयर इम्यूलेशन के लिए दुर्भाग्यपूर्ण होगा, यहां तक ​​कि रिलीज में निर्मित होने के कारण अंतर्निहित अमान्य रूपांतरणों के लिए संदिग्ध वैकल्पिक व्यवहार प्रदान करने के लिए।

@admilazz हम LLVM क्या कर सकते हैं, और वर्तमान में LLVM अपरिभाषित व्यवहार के जोखिम के बिना पूर्णांकों के लिए

संतृप्ति इसलिए है क्योंकि भाषा हमेशा सफल होने के लिए as कास्ट को परिभाषित करती है, और इसलिए हम ऑपरेटर को बदले में आतंकित करने के लिए नहीं बदल सकते।

इसी तरह, 1000000.0 को 65535 (u16) में बदलना, उदाहरण के लिए, गलत लगता है। बस कोई यू 16 नहीं है जो स्पष्ट रूप से सही उत्तर है। कम से कम, मैं इसे १६ ९ ६० में परिवर्तित करने के मौजूदा व्यवहार से बेहतर नहीं देखता,

यह मेरे लिए स्पष्ट नहीं था इसलिए मुझे लगता है कि यह इंगित करने लायक है: 16960 1000000.0 को पर्याप्त रूप से विस्तृत पूर्णांक में बदलने का परिणाम है, फिर 16 निचले बिट्स को रखने के लिए ट्रंकटिंग।

यह ~ नहीं है एक विकल्प जो इस धागे में पहले सुझाया गया है, और यह है ~ (संपादित करें: मैं यहां गलत था, क्षमा करें मुझे यह नहीं मिला) वर्तमान व्यवहार भी नहीं। रस्ट में वर्तमान व्यवहार यह है कि आउट-ऑफ-द-रेंज फ्लोट-टू-पूर्णांक रूपांतरण अपरिभाषित व्यवहार है। व्यवहार में यह अक्सर एक कचरा मूल्य की ओर जाता है, सिद्धांत पर यह गलतफहमी और कमजोरियों का कारण बन सकता है। यह धागा सब ठीक करने वाला है। जब मैं नीचे रुस्त 1.39.0 में कार्यक्रम चलाता हूं तो मुझे हर बार एक अलग मूल्य मिलता है:

fn main() {
    dbg!(1000000.0 as u16);
}

खेल का मैदान । उदाहरण आउटपुट:

[src/main.rs:2] 1000000.0 as u16 = 49072

मुझे व्यक्तिगत रूप से लगता है कि पूर्णांक की तरह ट्रंकेशन संतृप्ति से बेहतर या बदतर नहीं है, वे दोनों आउट-ऑफ-रेंज मानों के लिए संख्यात्मक रूप से गलत हैं। एक अचूक रूपांतरण का अपना स्थान है, जब तक कि यह नियतात्मक नहीं है और यूबी नहीं है। आप पहले से ही अपने एल्गोरिथ्म से जान सकते हैं कि मूल्य सीमा में हैं, या ऐसे मामलों की परवाह नहीं की जा सकती है।

मुझे लगता है कि हमें एक Result वापसी करने वाले परिवर्तनीय रूपांतरण API भी जोड़ना चाहिए, लेकिन मुझे अभी भी उस ड्राफ्ट के पूर्व RFC लेखन को समाप्त करने की आवश्यकता है :)

या "wraparound" अर्थ विज्ञान "परिवर्तित गणितीय पूर्णांक है, तो लक्ष्य चौड़ाई को काटना" इस सूत्र (https://github.com/rust-lang/rust/issues/10184#issuecomment-299229143) में से पहले सुझाव दिया गया है। मुझे यह विशेष रूप से पसंद नहीं है:

• मुझे लगता है कि यह संतृप्ति की तुलना में थोड़ा कम समझदार है। संतृप्ति आमतौर पर सीमा से बाहर संख्या के लिए समझदार परिणाम नहीं देती है, लेकिन:
  
  
  
  • जब संख्या थोड़ी सीमा से बाहर हो (जैसे संचित गोलाई त्रुटि के कारण), तो यह रैपराउंड की तुलना में अधिक समझदारी से व्यवहार करता है। इसके विपरीत, एक कास्ट जो चारों ओर लपेटता है वह फ्लोट गणना में एक पूर्णांक त्रुटि को पूर्णांक डोमेन में अधिकतम संभावित त्रुटि के लिए बढ़ा सकता है।
  
  
  • यह आमतौर पर डिजिटल सिग्नल प्रोसेसिंग में कुछ हद तक उपयोग किया जाता है, इसलिए कम से कम कुछ एप्लिकेशन हैं जहां यह वास्तव में वांछित है। इसके विपरीत, मुझे एक भी एल्गोरिथ्म का पता नहीं है जो रैपराउंड शब्दार्थ से लाभान्वित करता है।
  
  
• एएफएआईके केवल रैपराउंड शब्दार्थ को पसंद करने का एकमात्र कारण सॉफ्टवेयर अनुकरण की प्रभावशीलता है, लेकिन यह मेरे लिए एक अप्रमाणित धारणा की तरह लगता है। मुझे गलत साबित होने में खुशी होगी, लेकिन सरसरी नज़र से लपेटने के लिए एएलयू निर्देशों की इतनी लंबी श्रृंखला की आवश्यकता लगती है (साथ ही शिशुओं और NaN को अलग से संभालने के लिए शाखाएं), मुझे नहीं लगता कि यह स्पष्ट है कि यह स्पष्ट रूप से बेहतर होगा दूसरे की तुलना में प्रदर्शन।
• जबकि NaN लिए क्या करना है इसका प्रश्न पूर्णांक के किसी भी रूपांतरण के लिए एक बदसूरत समस्या है, कम से कम संतृप्ति को किसी विशेष आवरण (न तो शब्दार्थ में और न ही अधिकांश कार्यान्वयन में) की आवश्यकता होती है। लेकिन रैपराउंड के लिए, पूर्णांक समतुल्य +/- अनंत माना जाता है? जावास्क्रिप्ट का कहना है कि यह 0 है, और मुझे लगता है कि अगर हमने NaN पर as घबराहट की तो यह अनंतता पर भी आतंकित कर सकता है, लेकिन इस तरह से ऐसा लगता है कि सामान्य और असामान्य संख्याओं की तुलना में तेजी से बनाने के लिए रैपराउंड को कठिन बना देगा। अकेले ही सुझाव देगा।

मुझे संदेह है कि रूपांतरण के लिए संतृप्ति शब्दार्थ द्वारा प्राप्त अधिकांश कोड SIMD का उपयोग करने से बेहतर होगा। इसलिए दुर्भाग्यपूर्ण होने पर, यह परिवर्तन उच्च-प्रदर्शन कोड को लिखे जाने से नहीं रोकेगा (विशेषकर यदि अलग-अलग शब्दार्थों के साथ आंतरिक प्रदान किया जाता है), और कुछ परियोजनाओं को तेजी से (यदि कम पोर्टेबल) कार्यान्वयन की ओर ले भी जाए।

यदि हां, तो कुछ मामूली प्रदर्शन प्रतिगमन को एक ध्वनि छेद को बंद करने से बचने के औचित्य के रूप में उपयोग नहीं किया जाना चाहिए।

https://github.com/rust-lang/rust/pull/66841 एलएलवीएम के fptoui और fptosi साथ unsafe fn तरीके जोड़ते हैं, उन मामलों के लिए जहां मूल्यों को जाना जाता है सीमा में होना और संतृप्त होना एक औसत दर्जे का प्रदर्शन प्रतिगमन है।

उस भूमि के बाद मुझे लगता है कि as लिए डिफ़ॉल्ट स्विच करना ठीक है (और शायद एक और -Z ध्वज को ऑप्ट आउट करने के लिए?), हालांकि यह शायद एक औपचारिक लैंग टीम निर्णय होना चाहिए।

उस भूमि के बाद मुझे लगता है कि as लिए डिफ़ॉल्ट स्विच करना ठीक है (और शायद एक और -Z फ्लैग को ऑप्ट आउट करने के लिए?), हालांकि यह शायद एक औपचारिक लैंग टीम निर्णय होना चाहिए।

इसलिए हमने (भाषा टीम, कम से कम वहां मौजूद लोगों के साथ) https://github.com/rust-lang/lang-team/blob/master/minutes/2019-11-21.md में इस बारे में चर्चा की और हमने सोचा नए आंतरिक जोड़ + -Zunsaturated-float-casts जोड़ना अच्छा पहला कदम होगा।

मुझे लगता है कि डिफ़ॉल्ट को उस के हिस्से के रूप में या इसके तुरंत बाद, संभवतः के साथ स्विच करना अच्छा होगा FCP यदि आवश्यक हो।

मेरा मानना ​​है कि नए आंतरिक विचारों से आपका मतलब कुछ वैसा ही है जैसे https://github.com/rust-lang/rust/pull/66841

डिफ़ॉल्ट बदलने के बिना -Z unsaturated-float-casts जोड़ने का क्या मतलब है? "त्रुटि: अज्ञात डिबगिंग विकल्प" को छोड़ने के बजाय इसे नो-ऑप के रूप में स्वीकार करें?

मुझे लगता है कि नई आंतरिकता से आपका मतलब # 66841 से कुछ है

हां thanks - यह जानने के लिए धन्यवाद।

डिफ़ॉल्ट बदलने के बिना -Z unsaturated-float-casts जोड़ने का क्या मतलब है? "त्रुटि: अज्ञात डिबगिंग विकल्प" को छोड़ने के बजाय इसे नो-ऑप के रूप में स्वीकार करें?

हाँ मूल रूप से। वैकल्पिक रूप से, हम -Z saturated-float-casts -Z unsaturated-float-casts पक्ष में हटाते हैं और डिफ़ॉल्ट रूप से सीधे स्विच करते हैं, लेकिन यह कम PRs पर समान परिणाम की ओर ले जाता है।

मैं वास्तव में "असंतृप्त" सुझाव नहीं समझता। यदि लक्ष्य केवल नए डिफ़ॉल्ट से बाहर निकलने के लिए एक घुंडी प्रदान करना है, तो मौजूदा ध्वज के डिफ़ॉल्ट को बदलना आसान है और अधिक कुछ नहीं करना है। यदि लक्ष्य एक नया नाम चुनना है जो व्यापार-बंद (निराधारता) के बारे में अधिक स्पष्ट है, तो उस पर "असंतृप्त" भयानक है - मैं इसके बजाय एक नाम सुझाता हूं जिसमें "असुरक्षित" या "यूबी" या एक समान शामिल है। डरावना शब्द, उदाहरण के लिए -Z fix-float-cast-ub ।

unchecked एपीआई नामों में कुछ मिसाल के साथ शब्द है।

@admilazz हम LLVM क्या कर सकते हैं, और वर्तमान में LLVM अपरिभाषित व्यवहार के जोखिम के बिना पूर्णांकों के लिए

लेकिन संभवतः आप डिबग बिल्ड में रनटाइम चेक जोड़ सकते हैं, जैसा कि आप पूर्णांक ओवरफ्लो के लिए करते हैं।

एएफएआईके केवल रैपराउंड शब्दार्थों को पसंद करने का एकमात्र कारण सॉफ्टवेयर इम्यूलेशन की प्रभावशीलता है

मुझे नहीं लगता कि हमें गलत या संतृप्ति पसंद करना चाहिए, क्योंकि दोनों गलत हैं, लेकिन कम से कम रैपपराउंड को जंग के समान कई भाषाओं द्वारा उपयोग की जाने वाली विधि का लाभ है: C / C ++, C #, go, संभवतः D, और निश्चित रूप से। अधिक, और भी जंग के वर्तमान व्यवहार (कम से कम कभी-कभी) होने के नाते। मैंने कहा, मुझे लगता है कि "अमान्य रूपांतरण (संभवतः डिबग बिल्ड में केवल) पर घबराहट" आदर्श है, जैसे हम पूर्णांक अतिप्रवाह और अमान्य अंकगणित जैसे विभाजन शून्य से करते हैं।

(दिलचस्प बात यह है कि खेल के

संतृप्ति इसलिए है क्योंकि भाषा हमेशा सफल होने के लिए कलाकारों के रूप में परिभाषित करती है, और इसलिए हम ऑपरेटर को बदले में आतंकित करने के लिए नहीं बदल सकते।

यह बदलते हुए कि ऑपरेशन का मूल्यांकन क्या है, पहले से ही एक ब्रेकिंग परिवर्तन है, जैसा कि हम पहले से ही ऐसा कर रहे लोगों के परिणामों की परवाह करते हैं। यह नो-पैनिक व्यवहार भी बदल सकता था।

मुझे लगता है कि अगर हम NaN पर आतंक के रूप में बना तो यह अनंत पर भी आतंक हो सकता है, लेकिन किसी भी तरह से ऐसा लगता है जैसे यह रैपराउंड बनाने के लिए तेजी से कठिन बना देगा

यदि यह केवल डिबग बिल्ड में जांचा जाता है, जैसा कि पूर्णांक अतिप्रवाह है, तो मुझे लगता है कि हम दोनों दुनिया के सर्वश्रेष्ठ प्राप्त कर सकते हैं: रूपांतरण सही होने की गारंटी है (डिबग बिल्ड में), उपयोगकर्ता त्रुटियों को पकड़े जाने की अधिक संभावना है, आप इसमें चुन सकते हैं यदि आप चाहें तो रैपराउंड और / या संतृप्ति जैसे अजीब व्यवहार, और प्रदर्शन उतना ही अच्छा है।

इसके अलावा, कमांड-लाइन स्विच के माध्यम से इस सामान को नियंत्रित करना अजीब लगता है। वह बड़ा हथौड़ा है। निश्चित रूप से एक आउट-ऑफ-रेंज रूपांतरण का वांछित व्यवहार एल्गोरिथ्म की बारीकियों पर निर्भर करता है, इसलिए यह ऐसा कुछ है जिसे प्रति-रूपांतरण के आधार पर नियंत्रित किया जाना चाहिए। मैं सुझाव देता हूं कि f.to_u16_sat () और f.to_u16_wrap () या ऑप्ट-इन्स के समान, और कोई कमांड-लाइन विकल्प नहीं होना चाहिए जो कोड के शब्दार्थ को बदलता है। इससे कोड के विभिन्न टुकड़ों का मिश्रण और मिलान करना मुश्किल हो जाएगा, और आप समझ नहीं सकते कि इसे पढ़ने से क्या होता है ...

और, अगर यह वास्तव में अस्वीकार्य है कि "आतंक यदि अवैध" डिफ़ॉल्ट व्यवहार करने के लिए, यह एक आंतरिक तरीका है जो इसे लागू करता है अच्छा होगा, लेकिन केवल डिबग बिल्ड में वैधता की जांच करता है ताकि हम यह सुनिश्चित कर सकें कि हमारा रूपांतरण सही है (विशाल) बहुमत;) मामलों में जब हम रूपांतरण के बाद समान संख्या प्राप्त करने की उम्मीद करते हैं, लेकिन रिलीज में कोई जुर्माना दिए बिना बनाता है।

दिलचस्प बात यह है कि मुझे खेल के मैदान में 16960 मिले।

यह है कि अपरिभाषित व्यवहार कैसे काम करता है: कार्यक्रम के सटीक निरूपण और सटीक संकलक संस्करण और सटीक संकलन झंडे के आधार पर, आपको निर्धारक व्यवहार, या हर मूल्य, या गलतफहमी पर बदलने वाला कचरा मूल्य मिल सकता है। संकलक को कुछ भी करने की अनुमति है।

रैपराउंड में कम से कम जंग के समान कई भाषाओं द्वारा उपयोग की जाने वाली विधि का लाभ होता है: सी / सी ++, सी #, गो, संभवतः डी, और निश्चित रूप से अधिक,

क्या यह वास्तव में है? कम से कम सी और सी ++ में नहीं, उनके पास जंग के समान ही अपरिभाषित व्यवहार है। यह एक संयोग नहीं है, हम एलएलवीएम का उपयोग करते हैं जो मुख्य रूप से सी और सी ++ को लागू करने के लिए बनाया गया है। क्या आप C # के बारे में निश्चित हैं और जाते हैं?

C11 मानक https://port70.net/~nsz/c/c11/n1570.html#6.3.1.4

जब वास्तविक फ़्लोटिंग प्रकार का एक अंतिम मान _Bool के अलावा पूर्णांक प्रकार में परिवर्तित हो जाता है, तो आंशिक भाग को छोड़ दिया जाता है (यानी, मान शून्य की ओर छोटा हो जाता है)। यदि इंटीग्रल भाग के मान को पूर्णांक प्रकार से दर्शाया नहीं जा सकता है, तो व्यवहार अपरिभाषित है।

जब पूर्णांक प्रकार के मान को अहस्ताक्षरित प्रकार में परिवर्तित किया जाता है, तब किया जाने वाला शेष संचालन तब नहीं किया जाता है जब वास्तविक अस्थायी प्रकार का मान अहस्ताक्षरित प्रकार में परिवर्तित हो जाता है। इस प्रकार, पोर्टेबल वास्तविक फ्लोटिंग मानों की सीमा है (-1, यूटाइप_मैक्स + 1)।

C ++ 17 मानक http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf#section.7.10

फ़्लोटिंग-पॉइंट प्रकार के एक प्रवल्यू को एक पूर्णांक प्रकार के एक प्रचलन में परिवर्तित किया जा सकता है। रूपांतरण छोटा हो जाता है, अर्थात भिन्नात्मक भाग छूट जाता है। यदि गंतव्य प्रकार में काट-छाँट किए गए मान का प्रतिनिधित्व नहीं किया जा सकता है तो व्यवहार अपरिभाषित है।

C # संदर्भ https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/numeric-conversions

जब आप एक डबल या फ्लोट मान को एक अभिन्न प्रकार में परिवर्तित करते हैं, तो यह मान शून्य से निकटतम अभिन्न मूल्य तक होता है। यदि परिणामी अभिन्न मूल्य गंतव्य प्रकार की सीमा के बाहर है, तो परिणाम अतिप्रवाह जाँच संदर्भ पर निर्भर करता है। एक चेक किए गए संदर्भ में, एक OverflowException को फेंक दिया गया है, जबकि एक अनियंत्रित संदर्भ में, परिणाम गंतव्य प्रकार का एक अनिर्दिष्ट मूल्य है।

तो यह यूबी नहीं है, सिर्फ एक "अनिर्दिष्ट मूल्य" है।

@admilazz इस और पूर्णांक ओवरफ़्लो के बीच एक बड़ा अंतर है: पूर्णांक ओवरफ़्लो अवांछनीय है लेकिन अच्छी तरह से परिभाषित है । फ़्लोटिंग पॉइंट कास्ट अपरिभाषित व्यवहार हैं ।

आप जो पूछ रहे हैं, वह रिलीज़ मोड में Vec सीमा को बंद करने के समान है, लेकिन यह गलत होगा क्योंकि यह अपरिभाषित व्यवहार की अनुमति देगा।

सुरक्षित कोड में अपरिभाषित व्यवहार की अनुमति देना स्वीकार्य नहीं है, भले ही यह केवल रिलीज़ मोड में हो। तो कोई भी रिलीज़ और डिबग मोड दोनों पर लागू होना चाहिए।

बेशक डिबग मोड में अधिक प्रतिबंधात्मक सुधार होना संभव है, लेकिन रिलीज मोड के लिए फिक्स को अभी भी अच्छी तरह से परिभाषित किया जाना चाहिए।

@admilazz इस और पूर्णांक ओवरफ़्लो के बीच एक बड़ा अंतर है: पूर्णांक ओवरफ़्लो अवांछनीय है लेकिन अच्छी तरह से परिभाषित है। फ्लोटिंग पॉइंट कास्ट अपरिभाषित व्यवहार हैं।

ज़रूर, लेकिन यह धागा व्यवहार को परिभाषित करने के बारे में है। यदि इसे "गंतव्य प्रकार के एक अनिर्दिष्ट मूल्य" के उत्पादन के रूप में परिभाषित किया गया था, जैसा कि सी # कल्पना में है कि अमनियू ने उपर्युक्त संदर्भित किया है, तो यह अब अपरिभाषित नहीं होगा (किसी भी खतरनाक तरीके से)। आप आसानी से व्यावहारिक कार्यक्रमों में पूर्णांक ओवरफ़्लो की अच्छी तरह से परिभाषित प्रकृति का उपयोग नहीं कर सकते क्योंकि यह अभी भी डिबग बिल्ड में घबराएगा। इसी तरह, रिलीज़ बिल्ड में एक अमान्य कलाकार द्वारा उत्पादित मूल्य की उम्मीद नहीं की जा सकती है या विशेष रूप से उपयोगी है क्योंकि प्रोग्राम व्यावहारिक रूप से वैसे भी इसका उपयोग नहीं कर सकते हैं अगर यह डिबग बिल्ड में घबरा जाता है। यह वास्तव में अनुकूलन के लिए संकलक को अधिकतम गुंजाइश देता है, जबकि संतृप्ति की तरह एक व्यवहार को संकलक बनाता है और देशी संतृप्ति रूपांतरण निर्देशों के बिना हार्डवेयर पर काफी धीमा हो सकता है। (और ऐसा नहीं है कि संतृप्ति स्पष्ट रूप से सही है।)

आप जो पूछ रहे हैं, वह रिलीज़ मोड में वीईसी सीमा को बंद करने के समान है, लेकिन यह गलत होगा क्योंकि यह अपरिभाषित व्यवहार की अनुमति देगा। सुरक्षित कोड में अपरिभाषित व्यवहार की अनुमति स्वीकार्य नहीं है ...

सभी अपरिभाषित व्यवहार एक जैसे नहीं हैं। अपरिभाषित व्यवहार का अर्थ है कि यह तय करने के लिए कंपाइलर कार्यान्वयनकर्ता तक है। जब तक एक फ्लोट को एक इंट को कास्टिंग करके जंग की सुरक्षा की गारंटी का उल्लंघन करने का कोई तरीका नहीं है, तब तक मुझे नहीं लगता कि यह लोगों को मनमाने ढंग से स्मृति स्थानों पर लिखने की अनुमति देने के समान है। बहरहाल, निश्चित रूप से मैं सहमत हूं कि इसे सुरक्षित होने की गारंटी देने के अर्थ में परिभाषित किया जाना चाहिए, भले ही जरूरी न हो कि पूर्वानुमेय हो।

क्या यह वास्तव में है? कम से कम C और C ++ में नहीं, उनके पास Rust के समान ही अपरिभाषित व्यवहार है ... क्या आप C # के बारे में निश्चित हैं और जाते हैं?

काफी उचित। मैंने उनके सारे चश्मे नहीं पढ़े; मैंने सिर्फ विभिन्न कंपाइलरों का परीक्षण किया। आप सही कह रहे हैं कि "सभी संकलक मैंने इसे इस तरह करने की कोशिश की" यह कहने से अलग है कि "भाषा विनिर्देश इसे इस तरह परिभाषित करते हैं"। लेकिन मैं वैसे भी अतिप्रवाह के पक्ष में बहस नहीं कर रहा हूं, केवल यह इंगित करता हूं कि यह सबसे आम लगता है। मैं वास्तव में एक रूपांतरण के पक्ष में तर्क दे रहा हूं कि 1) "गलत" परिणामों से बचाता है जैसे कि 1000000.0 65535 या 16960 हो जाता है इसी कारण से हम पूर्णांक अतिप्रवाह के खिलाफ रक्षा करते हैं - यह सबसे अधिक संभावना है कि उपयोगकर्ताओं को इसमें चयन करना चाहिए , और 2) रिलीज़ बिल्ड में अधिकतम प्रदर्शन की अनुमति देता है।

सभी अपरिभाषित व्यवहार एक जैसे नहीं हैं। अपरिभाषित व्यवहार का अर्थ है कि यह तय करने के लिए कंपाइलर कार्यान्वयनकर्ता तक है। जब तक एक फ्लोट को एक इंट को कास्टिंग करके जंग की सुरक्षा की गारंटी का उल्लंघन करने का कोई तरीका नहीं है, तब तक मुझे नहीं लगता कि यह लोगों को मनमाने ढंग से स्मृति स्थानों पर लिखने की अनुमति देने के समान है। बहरहाल, निश्चित रूप से मैं मानता हूं कि इसे परिभाषित किया जाना चाहिए: परिभाषित किया गया है, लेकिन जरूरी नहीं कि यह अनुमानित हो।

अपरिभाषित व्यवहार का अर्थ है ऑप्टिमाइज़र (जो सी और सी ++ पर केंद्रित एलएलवीएम डेवलपर्स द्वारा प्रदान किए जाते हैं) यह मानने के लिए स्वतंत्र हैं कि ऐसा कभी नहीं हो सकता है और कोड को उस धारणा के आधार पर रूपांतरित किया जा सकता है, जिसमें कोड को हटा देना शामिल है जो केवल अपरिभाषित कलाकारों के माध्यम से गुजरने से पहुंच योग्य हैं। या, के रूप में इस उदाहरण से पता चलता है, यह सोचते हैं कि एक काम बुलाया गया है चाहिए, भले ही यह वास्तव में नहीं था, क्योंकि कोड है कि कहा जाता है लागू पहले बुला यह अनिर्धारित व्यवहार किया जाएगा बिना।

यहां तक कि अगर यह साबित होता है कि विभिन्न अनुकूलन रचना गुजरता खतरनाक आकस्मिक व्यवहार का उत्पादन नहीं करता उचित थे, LLVM डेवलपर्स कि संरक्षित करने के लिए किसी भी सचेत प्रयास नहीं करेंगे।

मेरा तर्क है कि उस आधार पर सभी अपरिभाषित व्यवहार एक जैसे हैं।

यहां तक ​​कि अगर यह साबित करना उचित था कि विभिन्न अनुकूलन पास की रचना खतरनाक उद्भव व्यवहार पैदा नहीं करती है, तो एलएलवीएम डेवलपर्स इसे संरक्षित करने के लिए कोई सचेत प्रयास नहीं करेंगे।

खैर, यह दुर्भाग्यपूर्ण है कि एलएलवीएम जंग के डिजाइन पर इस तरह से थोपता है, लेकिन मैंने सिर्फ एलएलवीएम अनुदेश के कुछ संदर्भों को पढ़ा है और इसमें ऊपर उल्लेखित "फ्रीज" ऑपरेशन का उल्लेख है ("... एक और फ्रीज जोड़ने के लिए एलएलवीएम का इंतजार करना है अवधारणा ... ") जो एलएलवीएम स्तर पर अपरिभाषित व्यवहार को रोक देगा। क्या जंग एलएलवीएम के पुराने संस्करण से जुड़ी है? यदि नहीं, तो हम इसका उपयोग कर सकते हैं। उनका दस्तावेज़ सटीक व्यवहार के बारे में स्पष्ट नहीं है, हालांकि।

यदि तर्क अपरिभाषित है या जहर है, तो 'फ्रीज' एक मनमाना, लेकिन निश्चित, प्रकार 'ty' का मान देता है। अन्यथा, यह निर्देश एक नो-ऑप है और इनपुट तर्क देता है। एक ही 'फ्रीज' निर्देश द्वारा लौटाए गए मूल्य के सभी उपयोगों को हमेशा एक ही मूल्य का पालन करने की गारंटी दी जाती है, जबकि अलग-अलग 'फ्रीज' निर्देशों में अलग-अलग मूल्य मिल सकते हैं।

मुझे नहीं पता कि वे "निश्चित मूल्य" या "समान 'फ्रीज़' निर्देश" से क्या मतलब रखते हैं। मुझे लगता है कि आदर्श रूप से यह नो-ऑप से संकलित होगा और अप्रत्याशित पूर्णांक देगा, लेकिन ऐसा लगता है कि यह संभवतः कुछ महंगा हो सकता है। क्या किसी ने इस फ्रीज ऑपरेशन की कोशिश की है?

खैर, यह दुर्भाग्यपूर्ण है कि एलएलवीएम इस तरह से जंग के डिजाइन पर थोपता है

यह सिर्फ इतना नहीं है कि एलएलवीएम डेवलपर्स आशावादी लिखते हैं। यह है कि, भले ही देहाती डेवलपर्स ने ऑप्टिमाइज़र्स को लिखा हो, अपरिभाषितता के साथ छेड़खानी करना स्वाभाविक रूप से एक बड़ा फुटगन है क्योंकि ऑप्टिमाइज़र्स के पीछा के उभरते गुणों के कारण। मानव मस्तिष्क बस "गोलाई त्रुटि की संभावित परिमाण को विकसित करने" के लिए विकसित नहीं हुआ, जब प्रश्न में गोलाई अनुकूलन के दौर से गुजरता हुआ आकस्मिक व्यवहार है।

मैं वहां आपसे असहमत नहीं हूं। :-) मुझे उम्मीद है कि यह LLVM "फ्रीज" निर्देश इस अपरिभाषित व्यवहार से बचने के लिए एक शून्य-लागत तरीका प्रदान करता है।

ऊपर चर्चा की गई थी और निष्कर्ष यह था कि कास्टिंग-फिर-फ्रीजिंग को परिभाषित व्यवहार कहा जाता है, यह बिल्कुल उचित व्यवहार नहीं है। रिलीज़ मोड में, इस तरह के कलाकार आउट-ऑफ-बाउंड इनपुट (पूरी तरह से सुरक्षित कोड में) के लिए मनमाना परिणाम लौटाएंगे। यह as रूप में निर्दोष दिखने वाले कुछ के लिए एक अच्छा शब्दार्थ नहीं है।

IMO इस तरह के शब्दार्थ भाषा का बुरा डिजाइन होगा जिसे हम टालेंगे।

मेरी स्थिति यह है कि as को इस मुद्दे की परवाह किए बिना पूरी तरह से बचा जाता है, क्योंकि इसमें इनपुट और आउटपुट प्रकार के आधार पर बेतहाशा अलग-अलग शब्दार्थ हो सकते हैं (ट्रंकटिंग, सैचुरेटिंग, राउंडिंग,…) और वे हमेशा स्पष्ट नहीं होते हैं जब कोड पढ़ना। (यहां तक ​​कि उत्तरार्द्ध को foo as _ साथ अनुमान लगाया जा सकता है।) तो मेरे पास विभिन्न स्पष्ट रूप से नामित रूपांतरण विधियों के प्रस्ताव के लिए पूर्व-आरएफसी है जो उन मामलों को कवर करते हैं जो as आज करते हैं (और शायद) ।

मैंने वह ड्राफ्ट खत्म कर दिया! https://internals.rust-lang.org/t/pre-rfc-add-explicitly-named-numeric-conversion-apis/11395

किसी भी प्रतिक्रिया बहुत स्वागत है, लेकिन कृपया इसे यहां के बजाय आंतरिक सूत्र में दें।

रिलीज़ मोड में, इस तरह के कलाकार आउट-ऑफ-बाउंड इनपुट (पूरी तरह से सुरक्षित कोड में) के लिए मनमाना परिणाम लौटाएंगे। यह कुछ के लिए एक अच्छा शब्दार्थ नहीं है जितना कि निर्दोष दिखने वाला।

अपने आप को दोहराने के लिए क्षमा करें, लेकिन मुझे लगता है कि यही तर्क पूर्णांक ओवरफ़्लो पर लागू होता है। यदि आप कुछ संख्याओं और परिणाम को ओवरफ्लो करते हैं, तो आपको एक बेतहाशा गलत परिणाम प्राप्त होने वाला है, जो निश्चित रूप से उस गणना को अमान्य कर देगा जिसे आप प्रदर्शन करने की कोशिश कर रहे थे, लेकिन यह डिबग बिल्ड में घबराहट करता है और इसलिए बग को पकड़े जाने की संभावना है। मैं कहूंगा कि एक संख्यात्मक रूपांतरण जो बेतहाशा गलत परिणाम देता है, उसे भी घबराना चाहिए क्योंकि बहुत अधिक संभावना है कि यह उपयोगकर्ता के कोड में बग का प्रतिनिधित्व करता है। (सामान्य फ़्लोटिंग-पॉइंट अशुद्धि का मामला पहले से ही संभाला हुआ है। यदि एक गणना 65535.3 का उत्पादन करती है, तो यह पहले से ही इसे u16 में परिवर्तित करने के लिए वैध है। आउट-ऑफ-बाउंड रूपांतरण प्राप्त करने के लिए आपको आमतौर पर आपके कोड में बग की आवश्यकता होती है, और यदि मेरे पास है बग मैं अधिसूचित होना चाहता हूं ताकि मैं इसे ठीक कर सकूं।)

रिलीज के लिए क्षमता अमान्य रूपांतरणों के लिए मनमाने लेकिन परिभाषित परिणाम देने की क्षमता बनाती है, जो अधिकतम महत्वपूर्ण प्रदर्शन की अनुमति देता है, जो कि मेरी राय में, संख्यात्मक रूपांतरण के रूप में कुछ के लिए महत्वपूर्ण है। हमेशा संतृप्त करने का एक महत्वपूर्ण प्रदर्शन प्रभाव होता है, बग को छुपाता है, और शायद ही कभी एक गणना करता है जो अप्रत्याशित रूप से सामना करता है यह सही परिणाम देता है।

अपने आप को दोहराने के लिए क्षमा करें, लेकिन मुझे लगता है कि यही तर्क पूर्णांक ओवरफ़्लो पर लागू होता है। यदि आप कुछ संख्याओं और परिणाम को ओवरफ्लो करते हैं, तो आप एक बेतहाशा गलत परिणाम प्राप्त करने जा रहे हैं, जो निश्चित रूप से उस गणना को अमान्य कर देगा जिसे आप प्रदर्शन करने की कोशिश कर रहे थे।

हम गुणा के बारे में बात नहीं कर रहे हैं, हम जातियों के बारे में बात कर रहे हैं। और हाँ, पूर्णांक ओवरफ़्लो पर भी यही बात लागू होती है: इंट-टू-इंट कास्ट कभी नहीं घबराते हैं, भले ही वे ओवरफ़्लो हों। इसका कारण यह है कि as , डिजाइन द्वारा, कभी पैनिक नहीं, डिबग बिल्ड में भी नहीं। फ्लोटिंग पॉइंट कास्ट्स के लिए इससे विचलन करना सबसे अच्छा और खतरनाक रूप से सबसे खराब है, क्योंकि असुरक्षित कोड पर शुद्धता और सुरक्षा कुछ ऑपरेशनों पर निर्भर कर सकती है, न कि घबराहट में।

यदि आप यह तर्क देना चाहते हैं कि as का डिज़ाइन त्रुटिपूर्ण है क्योंकि यह उन प्रकारों के बीच अचूक रूपांतरण प्रदान करता है जहाँ उचित रूपांतरण हमेशा संभव नहीं होता है, मुझे लगता है कि हम में से अधिकांश सहमत होंगे। लेकिन यह पूरी तरह से इस धागे के दायरे से बाहर है, जो as कलाकारों के मौजूदा ढांचे के अंदर फ्लोट-टू-इंट रूपांतरण को ठीक करने के बारे में है। इन्हें अचूक होना पड़ता है, उन्हें घबराना नहीं चाहिए, डिबग बिल्ड में भी नहीं। तो कृपया या तो कुछ उचित प्रस्ताव दें ( freeze शामिल नहीं), फ्लोट-टू-इंट कास्ट के लिए गैर-पैनिकिंग शब्दार्थ, या फिर पैनिकिंग की अनुमति देने के लिए as को फिर से डिज़ाइन करने के बारे में एक नई चर्चा शुरू करने का प्रयास करें। जब कास्ट हानिपूर्ण होता है (और इंट-टू-इंट और फ्लोट-टू-इंट कास्ट के लिए लगातार ऐसा करते हैं) - लेकिन इस मुद्दे में उत्तरार्द्ध ऑफ-टॉपिक है, इसलिए कृपया एक नया थ्रेड खोलें (प्री-आरएफसी-शैली) उसके लिए।

कैसे हम यूबी को ठीक करने के लिए अब freeze शब्दार्थों को लागू करने से शुरू करते हैं, और फिर हमारे पास दुनिया में हर समय इस बात पर सहमत होने के लिए हो सकता है कि हम वास्तव में जो भी शब्दार्थ चुनते हैं वह freeze के साथ संगत होगा।

यूबी को ठीक करने के लिए हम freeze अर्थार्थी _now_ को लागू करने के बारे में कैसे शुरू करते हैं, और फिर हमारे पास दुनिया में हर समय इस बात पर सहमत होने के लिए हो सकता है कि हम वास्तव में किसी भी शब्दार्थ के बाद से जो हम चुनते हैं, वह freeze के साथ संगत होगा।

1. पैंटिंग ठंड के साथ पीछे की ओर संगत नहीं है, इसलिए हमें कम से कम उन सभी प्रस्तावों को अस्वीकार करने की आवश्यकता होगी, जिनमें पैनिकिंग शामिल है। यूबी से पैनिंग में जाना कम स्पष्ट रूप से असंगत है, हालांकि जैसा कि ऊपर चर्चा की गई है कि as आतंक न करने के कुछ अन्य कारण हैं।
2. जैसा कि मैंने पहले लिखा था ,
   > हम इस समय कई पुराने संस्करणों (एलएलवीएम 6 पर वापस) का समर्थन करते हैं और हमें उन सभी उपयोगकर्ताओं के लिए वास्तव में यूबी से छुटकारा पाने के लिए कुछ कमबैक कार्यान्वयन की आवश्यकता होगी।

मैं @RalfJung से सहमत as कास्ट्स की पैन्चिंग अत्यधिक अवांछनीय है, लेकिन इसके अलावा मुझे नहीं लगता कि यह @admilazz बनाया गया यह स्पष्ट रूप से सही है:

(सामान्य फ़्लोटिंग-पॉइंट अशुद्धि का मामला पहले से ही संभाला हुआ है। यदि एक गणना 65535.3 का उत्पादन करती है, तो यह पहले से ही इसे u16 में परिवर्तित करने के लिए वैध है। आउट-ऑफ-बाउंड रूपांतरण प्राप्त करने के लिए आपको आमतौर पर आपके कोड में बग की आवश्यकता होती है, और यदि मेरे पास है बग मैं अधिसूचित होना चाहता हूं ताकि मैं इसे ठीक कर सकूं।)

F32-> u16 के लिए यह सच हो सकता है कि आपको केवल राउंडिंग त्रुटि से u16 श्रेणी से बाहर करने के लिए असाधारण रूप से बड़ी गोलाई की त्रुटि की आवश्यकता है, लेकिन f32 से 32 बिट पूर्णांकों के रूपांतरणों के लिए जो इतना स्पष्ट रूप से सच नहीं है। i32::MAX f32 में प्रतिनिधित्व योग्य नहीं है, निकटतम प्रतिनिधित्व योग्य संख्या i32::MAX से 47 है। इसलिए यदि आपके पास एक गणना है जो गणितीय रूप से i32::MAX तक की संख्या में होनी चाहिए, तो कोई भी त्रुटि> = 1 ULP शून्य से दूर आपको सीमा से बाहर कर देगा। और यह बहुत बुरा हो जाता है जब हम कम परिशुद्धता फ्लोट (IEEE 754 बाइनरी 16, या गैर-मानक bfloat16) पर विचार करते हैं।

हम गुणन के बारे में बात नहीं कर रहे हैं, हम जातियों के बारे में बात कर रहे हैं

खैर, पूर्णांक रूपांतरण के लिए फ़्लोटिंग-पॉइंट का उपयोग लगभग विशेष रूप से गुणन के रूप में एक ही संदर्भ में किया जाता है: संख्यात्मक गणना, और मुझे लगता है कि पूर्णांक ओवरफ़्लो के व्यवहार के साथ एक उपयोगी समानांतर है।

और हाँ, पूर्णांक ओवरफ़्लो पर भी यही बात लागू होती है: इंट-टू-इंट कास्ट कभी भी घबराते नहीं हैं, जब वे ओवरफ़्लो होते हैं ... फ़्लोटिंग पॉइंट कास्ट के लिए इस से विचलन करना सबसे अच्छा और खतरनाक है, क्योंकि असुरक्षित कोड पर शुद्धता और सुरक्षा सबसे खराब है कुछ संचालन पर निर्भर हो सकता है न कि घबराहट में।

मैं तर्क दूंगा कि यहां असंगतता सामान्य व्यवहार से उचित है और यह बहुत आश्चर्यजनक नहीं होगा। शिफ्ट, मास्क और कास्ट के साथ पूर्णांकों को काट-छाँट कर काटना - बिट्स एंड प्लस के आकार में परिवर्तन के रूप में प्रभावी ढंग से कास्ट का उपयोग करना - सिस्टम प्रोग्रामिंग में एक लंबा इतिहास है और इसका एक लंबा इतिहास है। यह कुछ ऐसा है जो मैं सप्ताह में कम से कम कई बार करता हूं। लेकिन पिछले 30+ वर्षों में, मैं कभी भी NaN, Infinity, या एक आउट-ऑफ-द-रेंज फ़्लोटिंग-पॉइंट मान को पूर्णांक में परिवर्तित करने के लिए एक उचित परिणाम प्राप्त करने की उम्मीद नहीं कर सकता। (इसका हर उदाहरण मैं याद कर सकता हूं कि गणना में एक बग है जो मूल्य का उत्पादन करता है।) इसलिए मुझे नहीं लगता कि पूर्णांक के मामले -> पूर्णांक जातियां और अस्थायी बिंदु -> पूर्णांक जातियों को पहचान के साथ व्यवहार किया जाना चाहिए। उस ने कहा, मैं समझ सकता हूं कि कुछ निर्णय पहले ही पत्थर में सेट हो चुके हैं।

कृपया ... कुछ उचित (फ्रीज को शामिल नहीं) प्रस्तावित करें, फ्लोट-टू-इंट कास्ट के लिए गैर-पैनिकिंग शब्दार्थ

खैर, मेरा प्रस्ताव है:

1. वैश्विक संकलन स्विच का उपयोग न करें, जो शब्दार्थ में महत्वपूर्ण परिवर्तन को प्रभावित करते हैं। (मुझे लगता है -Zsaturating- फ्लोट-कास्ट एक कमांड-लाइन पैरामीटर या समान है।) कोड जो संतृप्ति व्यवहार पर निर्भर करता है, कहते हैं, अगर इसके बिना संकलित किया जाएगा तो टूट जाएगा। संभवतः विभिन्न उम्मीदों के साथ कोड को एक ही परियोजना में एक साथ नहीं मिलाया जा सकता है। वांछित शब्दार्थ निर्दिष्ट करने के लिए गणना के लिए कुछ स्थानीय तरीका होना चाहिए, शायद यह पूर्व-आरएफसी जैसा कुछ हो।
2. as जातियों का डिफ़ॉल्ट रूप से अधिकतम प्रदर्शन होता है, जैसा कि किसी कलाकार से अपेक्षित होगा।
   
   
   
   • मुझे लगता है कि यह एलएलवीएम संस्करणों पर फ्रीज के माध्यम से किया जाना चाहिए जो इसे समर्थन करते हैं और एलएलवीएम संस्करणों पर किसी भी अन्य रूपांतरण शब्दार्थ का समर्थन करते हैं (जैसे ट्रंकेशन, संतृप्ति, आदि) नहीं। मुझे उम्मीद है कि 'फ्रीज संवेदनशील स्मृति से मूल्यों को लीक कर सकता है' का दावा पूरी तरह से काल्पनिक है। (या, यदि y = freeze(fptosi(x)) केवल y अपरिवर्तित हो जाता है, तो इस तरह से बिनती की गई मेमोरी लीक हो जाती है, जिसे y पहले साफ़ करके तय किया जा सकता है।)
   
   
   • यदि as डिफ़ॉल्ट रूप से अपेक्षाकृत धीमा होगा (जैसे कि यह संतृप्त होता है), अधिकतम प्रदर्शन प्राप्त करने के लिए कुछ तरीका प्रदान करें (जैसे एक विधि - असुरक्षित यदि आवश्यक हो - जो फ्रीज का उपयोग करता है)।
   
   

1. वैश्विक संकलन स्विच का उपयोग न करें, जो शब्दार्थ में महत्वपूर्ण परिवर्तन को प्रभावित करते हैं। (मुझे लगता है -Zsaturating-float-casts एक कमांड-लाइन पैरामीटर या समान है।)

स्पष्ट होने के लिए, मुझे नहीं लगता कि कोई असहमत है। इस झंडे को कभी प्रदर्शन के प्रतिगमन के आसपास और अधिक आसानी से मापने और काम करने के लिए एक अल्पकालिक उपकरण के रूप में प्रस्तावित किया गया था जबकि पुस्तकालयों को उन प्रतिगमन को ठीक करने के लिए अद्यतन किया जा रहा है।

F32-> u16 के लिए यह सच हो सकता है कि आपको केवल राउंडिंग त्रुटि से u16 श्रेणी से बाहर करने के लिए असाधारण रूप से बड़ी गोलाई की त्रुटि की आवश्यकता है, लेकिन f32 से 32 बिट पूर्णांकों के रूपांतरणों के लिए जो इतना स्पष्ट रूप से सच नहीं है। i32 :: MAX f32 में प्रतिनिधित्व योग्य नहीं है, निकटतम प्रतिनिधित्व संख्या i32 :: MAX से 47 दूर है। इसलिए यदि आपके पास एक गणना है जो गणितीय रूप से i32 :: MAX तक की संख्या में होनी चाहिए, तो कोई त्रुटि> = 1 शून्य से दूर ULP आपको सीमा से बाहर कर देगा।

यह थोड़ा ऑफ-टॉपिक हो रहा है, लेकिन मान लीजिए कि आपके पास यह काल्पनिक एल्गोरिथम है जो गणितीय रूप से 2 ^ 31-1 तक f32s का उत्पादन करने वाला है (लेकिन संभवत: गोल त्रुटि के कारण छोड़कर _ 2_ 31 या अधिक उत्पादन करना चाहिए)। यह पहले से ही त्रुटिपूर्ण लगता है।

1. मुझे लगता है कि निकटतम प्रतिनिधित्व योग्य i32 वास्तव में i32 :: MAX से नीचे 127 है, इसलिए यहां तक ​​कि एक सही दुनिया में भी कोई फ़्लोटिंग-पॉइंट नहीं है एल्गोरिथ्म जो आप 2 ^ 31-1 तक मानों का उत्पादन करने की उम्मीद करते हैं, वास्तव में केवल उत्पादन कर सकते हैं (कानूनी ) मान 2 ^ 31-128 तक। शायद वह बग पहले से ही है। मुझे यकीन नहीं है कि 2 ^ 31-1 से मापी गई त्रुटि के बारे में बात करना समझ में आता है जब उस संख्या का प्रतिनिधित्व करना संभव नहीं है। सीमाओं से बाहर निकलने के लिए आपको निकटतम प्रतिनिधित्व योग्य संख्या (गोलाई पर विचार) से 64 से दूर होना होगा। जब आप 2 ^ 32 के पास हों, तो यह बहुत प्रतिशत-वार नहीं है।
2. आपको उन मानों के भेदभाव की उम्मीद नहीं करनी चाहिए जो 1 अलग हैं (यानी 2 ^ 31-1 लेकिन 2 ^ 31) जब निकटतम प्रतिनिधित्व योग्य मान 128 अलग न हों। इसके अलावा, i32s का केवल 3.5% f32 (और <2% का u32s) के रूप में प्रतिनिधित्व योग्य है। आप f32 के साथ उस तरह की परिशुद्धता रखते हुए भी उस तरह की सीमा प्राप्त नहीं कर सकते। एल्गोरिथ्म लगता है कि यह काम के लिए गलत उपकरण का उपयोग कर रहा है।

मुझे लगता है कि आप जो भी वर्णन करते हैं वह व्यावहारिक रूप से किसी भी तरह पूर्णांक से बंधे होंगे। उदाहरण के लिए, यदि आप एक यादृच्छिक i32 को f32 और पीछे में परिवर्तित करते हैं, तो यह विफल हो सकता है यदि यह i32 :: MAX-64 से ऊपर है। लेकिन यह आपकी सटीकता को बुरी तरह से नीचा दिखाता है और मुझे नहीं पता कि आप ऐसा क्यों करेंगे। बहुत अधिक किसी भी i32 -> f32 -> i32 गणना जो पूर्ण i32 श्रेणी को आउटपुट करती है, पूर्णांक गणित के साथ तेजी से और अधिक सटीक रूप से व्यक्त की जा सकती है, और यदि नहीं तो एफ 64।

वैसे भी, जब मुझे यकीन है कि कुछ मामलों को ढूंढना संभव है, जहां एल्गोरिदम, जो आउट-ऑफ-बाउंड रूपांतरण करते हैं, संतृप्ति द्वारा तय किए जाएंगे, मुझे लगता है कि वे दुर्लभ हैं - काफी दुर्लभ हैं कि हमें उन्हें समायोजित करने के लिए _all_ रूपांतरण धीमा नहीं करना चाहिए । और, मेरा तर्क है कि इस तरह के एल्गोरिदम शायद अभी भी त्रुटिपूर्ण हैं और इन्हें ठीक किया जाना चाहिए। और अगर एक एल्गोरिथ्म तय नहीं किया जा सकता है, तो यह संभवतः संभवतः-आउट-ऑफ-बाउंड रूपांतरण (या एक संतृप्त रूपांतरण फ़ंक्शन को कॉल करने से पहले) की जाँच कर सकता है। इस तरह से परिणाम को बाध्य करने का खर्च केवल उसी जगह भुगतान किया जाता है जहां जरूरत होती है।

पीएस ने सभी को धन्यवाद दिया।

स्पष्ट होने के लिए, मुझे नहीं लगता कि कोई असहमत है। इस ध्वज को केवल एक अल्पकालिक उपकरण के रूप में प्रस्तावित किया गया था ...

मैं मुख्य रूप से -Zsaturated-float-casts को प्रतिस्थापित करने के प्रस्ताव का उल्लेख कर रहा था -Zsaturated-float-casts। भले ही संतृप्ति डिफ़ॉल्ट हो जाती है, लेकिन -sunsaturated-float-cast जैसे झंडे संगतता के लिए खराब लगते हैं, लेकिन अगर यह भी अस्थायी होने का इरादा है, तो ठीक है, कभी भी मन नहीं। :-)

वैसे भी, मुझे यकीन है कि सभी को उम्मीद है कि मैंने इस मुद्दे पर पर्याप्त कहा है - खुद को शामिल किया। मुझे पता है कि रुस्त टीम ने परंपरागत रूप से चीजों को करने के लिए कई तरीके प्रदान करने की मांग की है ताकि लोग प्रदर्शन और सुरक्षा के बीच अपनी पसंद बना सकें। मैंने अपना दृष्टिकोण और विश्वास साझा किया है कि आप लोग अंत में एक अच्छा समाधान लेकर आएंगे। ख्याल रखना!

मैंने मान लिया कि -Zunsaturated-float-casts केवल अस्थायी रूप से मौजूद रहेंगे, और कुछ बिंदु पर हटा दिए जाएंगे। यह -Z विकल्प (केवल रात में उपलब्ध) के बजाय -C है, यह कम से कम सुझाव देता है।

इसके लायक क्या है, संतृप्ति और यूबी एकमात्र विकल्प नहीं हैं। एक और संभावना है कि एलएलवीएम को बदलने के लिए fptosi का एक संस्करण जोड़ा जाए जो CPU के मूल अतिप्रवाह व्यवहार का उपयोग करता है - अर्थात अतिप्रवाह का व्यवहार आर्किटेक्चर में पोर्टेबल नहीं होगा, लेकिन यह किसी भी वास्तुकला पर अच्छी तरह से परिभाषित होगा ( उदाहरण के लिए x86 पर 0x80000000 वापस करना), और यह कभी भी जहर या अनअनुकूलित मेमोरी नहीं लौटाएगा। यहां तक ​​कि अगर डिफ़ॉल्ट संतृप्त हो जाता है, तो भी विकल्प के रूप में ऐसा करना अच्छा होगा। आखिरकार, जबकि संतृप्त जातियों ने आर्किटेक्चर पर अंतर्निहित ओवरहेड किया है, जहां वे डिफ़ॉल्ट व्यवहार नहीं करते हैं, "सीपीयू क्या करता है" केवल ओवरहेड होता है अगर यह कुछ विशिष्ट संकलक अनुकूलन को रोकता है। मुझे यकीन नहीं है, लेकिन मुझे संदेह है कि फ्लोट-टू-इंट ओवरफ़्लो का इलाज करके कोई भी अनुकूलन सक्षम है क्योंकि यूबी आला हैं और अधिकांश कोड के लिए लागू नहीं हैं।

यदि एक आर्किटेक्चर में कई फ्लोट-टू-इंट निर्देश हैं, जो अतिप्रवाह पर अलग-अलग मान लौटाता है, तो यह समस्या हो सकती है। इस मामले में, एक या दूसरे का चयन करने वाला कंपाइलर देखने योग्य व्यवहार को प्रभावित करेगा, जो अपने आप में कोई समस्या नहीं है, लेकिन एक एकल fptosi डुप्लिकेट होने पर एक हो सकता है और दो प्रतियाँ अलग-अलग व्यवहार करना समाप्त करती हैं। लेकिन मुझे यकीन नहीं है कि क्या इस तरह का विचलन वास्तव में किसी भी लोकप्रिय आर्किटेक्चर पर मौजूद है। और फ़्लोटिंग पॉइंट संकुचन सहित अन्य फ़्लोटिंग पॉइंट ऑप्टिमाइज़ेशन पर भी यही समस्या लागू होती है ...

const fn (miri) ने पहले से ही रुस्त 1.26 के बाद से संतृप्त-कास्ट व्यवहार को चुना है (हालांकि हम यह चाहते हैं कि CTFE और RTFE परिणाम सुसंगत हों) (1.26 से पहले ओवरफ्लो संकलन समय-समय पर रिटर्न देता है)

const fn g(a: f32) -> i32 {
    a as i32
}

const Q: i32 = g(1e+12);

fn main() {
    println!("{}", Q); // always 2147483647
    println!("{}", g(1e+12)); // unspecified value, but always 2147483647 in miri
}

मिरी / CTFE रूपांतरण करने के लिए अपफ़्लोत के to_u128 / to_i128 विधियों का उपयोग करती है। लेकिन मुझे यकीन नहीं है कि यह एक स्थिर गारंटी है - विशेष रूप से यह देखते हुए कि यह पहले बदल गया है (जो कि मिरी में उस सामान को लागू करते समय हमें पता नहीं था)।

मुझे लगता है कि जो कुछ भी कोडगेन समाप्त होता है, उसे हम समायोजित कर सकते हैं। लेकिन यह तथ्य कि एलएलवीएम का अपफ्लोट (जिसमें से रस्ट संस्करण एक सीधा पोर्ट है) संतृप्ति का उपयोग करता है एक अच्छा संकेतक है कि यह किसी प्रकार का "उचित डिफ़ॉल्ट" है।

अवलोकन योग्य व्यवहार का एक समाधान संकलक या परिणामी बाइनरी के निर्माण के समय उपलब्ध तरीकों में से एक को बेतरतीब ढंग से चुनना हो सकता है।
तब उपयोगकर्ताओं के लिए a.saturating_cast::<i32>() जैसे कार्य होते हैं जिनके लिए एक विशिष्ट व्यवहार की आवश्यकता होती है।

@ dns2utf8

शब्द "बेतरतीब ढंग से" प्रतिलिपि प्रस्तुत करने योग्य बिल्ड प्राप्त करने के प्रयास के लिए काउंटर चलाएगा और, यदि यह एक संकलक संस्करण के भीतर अनुमानित है, तो आप जानते हैं कि कोई व्यक्ति यह तय करेगा कि यह नहीं बदल रहा है।

IMO ने जो @comex वर्णित किया है (इस थ्रेड IIRC के लिए उपन्यास नहीं, पुराना सब कुछ फिर से नया है) यह अगला सबसे अच्छा विकल्प है यदि हम संतृप्ति नहीं चाहते हैं। ध्यान दें कि हमें उस परीक्षण के लिए किसी LLVM परिवर्तन की भी आवश्यकता नहीं है, हम इनलाइन asm (आर्किटेक्चर पर जहां ऐसे निर्देश मौजूद हैं) का उपयोग कर सकते हैं।

यदि एक आर्किटेक्चर में कई फ्लोट-टू-इंट निर्देश हैं, जो अतिप्रवाह पर अलग-अलग मान लौटाता है, तो यह समस्या हो सकती है। इस मामले में, एक या दूसरे का चयन करने वाला कंपाइलर देखने योग्य व्यवहार को प्रभावित करेगा, जो अपने आप में कोई समस्या नहीं है, लेकिन एक एकल fptosi डुप्लिकेट होने पर एक हो सकता है और दो प्रतियाँ अलग-अलग व्यवहार करना समाप्त करती हैं।

IMO इस तरह के गैर-नियतत्ववाद freeze की तुलना में लगभग सभी व्यावहारिक लाभ देगा। यदि हम ऐसा करते हैं, तो हमें प्रति आर्किटेक्चर के लिए एक निर्देश चुनना चाहिए और इसे निर्धारित करने के लिए दोनों को छड़ी करना चाहिए ताकि प्रोग्राम वास्तव में निर्देश के व्यवहार पर भरोसा कर सकें जब यह उनके लिए समझ में आता है। यदि यह कुछ वास्तुकला पर संभव नहीं है, तो हम एक सॉफ्टवेयर कार्यान्वयन पर वापस आ सकते हैं (लेकिन जैसा कि आप कहते हैं कि यह पूरी तरह से काल्पनिक है)।

यह आसान है अगर हम इस निर्णय को LLVM को नहीं सौंपते हैं, लेकिन इनलाइन asm के बजाय ऑपरेशन को लागू करते हैं। कौन सा गुप्त रूप से एलएलवीएम को बदलने से ज्यादा आसान होगा ताकि हर बैकएंड में उनके लिए नए इंट्रस्टिक्स और लोअरिंग को जोड़ा जा सके।

@rkruppe

[...] कौन सा गुप्त रूप से एलएलवीएम को बदलने से ज्यादा आसान होगा ताकि हर बैकेंड में उनके लिए नए इंट्रस्टिक्स और लोअरिंग को जोड़ा जा सके।

इसके अतिरिक्त, LLVM लक्ष्य-निर्भर शब्दार्थ के साथ आंतरिकता के बारे में बिल्कुल खुश नहीं है:

हालांकि, यदि आप चाहते हैं कि जातियों को अच्छी तरह से परिभाषित किया जाए, तो आपको उनके व्यवहार को परिभाषित करना चाहिए। "कुछ तेज़ काम करो" वास्तव में एक परिभाषा नहीं है, और मुझे विश्वास नहीं है कि हमें लक्ष्य-स्वतंत्र निर्माण को लक्ष्य-निर्भर व्यवहार देना चाहिए।

https://groups.google.com/forum/m/#/msg/llvm -dev / cgDFaBmCnDQ / CZAIMj4IBAA

मैं पूरी तरह से टी लैंग के रूप में ReTag # 10,184 जा रहा हूँ: मुझे लगता है समस्या नहीं होने के बारे में क्या अर्थ विकल्प हैं हल किया जाना float as int साधन

(यानी क्या हम इसे पैनिक शब्दार्थ बताने के लिए तैयार हैं या नहीं, क्या हम इसे freeze -आधारित अंडरस्क्रिफिकेशन देने के लिए तैयार हैं या नहीं, आदि)

ये टी-लैंग टीम के लिए बेहतर प्रश्न हैं, न कि टी-कंपाइलर, कम से कम प्रारंभिक चर्चा के लिए, आईएमओ

बस इस मुद्दे को चलाने में परिणाम है कि रन के बीच _irreproducible_ भी recompiling बिना कर रहे हैं। as ऑपरेटर ऐसे मामलों में स्मृति से कुछ कचरा लाने के लिए लगता है।

मेरा सुझाव है कि "फ्लोट इनटू" के लिए as का उपयोग करना पूरी तरह से अस्वीकार कर दें और इसके बजाय विशिष्ट गोलाई विधियों पर भरोसा करें। तर्क: as अन्य प्रकारों के लिए हानिप्रद नहीं है।

तर्क: जैसा कि अन्य प्रकार के लिए हानिपूर्ण नहीं है।

क्या यह?

रस्ट बुक के आधार पर मैं यह मान सकता हूं कि यह केवल कुछ मामलों में दोषरहित है (अर्थात ऐसे मामलों में जहां From<X> को एक प्रकार Y के लिए परिभाषित किया गया है), अर्थात आप u8 से u32 कास्ट कर सकते हैं From u32 का उपयोग करते हुए, लेकिन आस-पास के अन्य तरीके से नहीं।

"हानिपूर्ण नहीं" से मेरा मतलब उन मूल्यों की कास्टिंग से है जो फिट होने के लिए काफी छोटे हैं। उदाहरण: 1_u64 as u8 हानिपूर्ण नहीं है, इस प्रकार u8 as u64 as u8 हानिपूर्ण नहीं है। तैरता के लिए वहाँ के बाद से "फिट" का कोई सरल परिभाषा है 20000000000000000000000000000_u128 as f32 है नहीं हानिपूर्ण जबकि 20000001_u32 as f32 है, इसलिए न float as int और न ही int as float दोषरहित हैं।

256u64 as u8 हानिपूर्ण है।

लेकिन <anything>_u8 as u64 as u8 नहीं है।

मुझे लगता है कि कलाकारों के साथ सौहार्द सामान्य और अपेक्षित है, न कि कोई समस्या। कलाकारों के साथ पूर्णांक पूर्णांक बनाना (जैसे u32 as u8 ) एक सामान्य ऑपरेशन है जिसका अर्थ है कि सभी C- जैसी भाषाओं में संगत है जो कि मुझे कम से कम (आर्किटेक्चर पर जो दो पूरक पूर्णांक अभ्यावेदन का उपयोग करते हैं, के बारे में पता है इन दिनों मूल रूप से उन सभी) है। मान्य फ़्लोटिंग-पॉइंट रूपांतरण (यानी जहां गंतव्य में अभिन्न अंग फिट बैठता है) भी अच्छी तरह से समझा और सहमत-शब्दार्थ पर आधारित है। 1.6 as u32 हानिपूर्ण है, लेकिन सभी सी-लाइक भाषाएं जिन्हें मैं जानता हूं कि इस बात से सहमत होना चाहिए कि परिणाम 1 होना चाहिए। उन दोनों मामलों को हार्डवेयर निर्माताओं के बीच आम सहमति से प्रवाहित किया जाता है कि उन रूपांतरणों को कैसे काम करना चाहिए और सी में सम्मेलन। -जैसी भाषाएं जो उच्च कोटि की होनी चाहिए, "मुझे पता है कि मैं क्या कर रहा हूं" आपरेटरों के प्रकार।

इसलिए मुझे नहीं लगता कि हमें उन समस्याग्रस्तों पर उसी तरह से विचार करना चाहिए, जो अमान्य फ़्लोटिंग-पॉइंट रूपांतरण हैं, क्योंकि सी-लाइक भाषाओं में या हार्डवेयर में कोई सहमति-युक्त शब्द नहीं है (लेकिन वे आम तौर पर त्रुटि स्थिति में परिणाम करते हैं। या हार्डवेयर अपवाद) और लगभग हमेशा बग (मेरे अनुभव में) इंगित करते हैं और इसलिए आमतौर पर सही कोड में कोई नहीं होता है।

बस इस मुद्दे को चलाने में परिणाम है कि recompiling बिना भी रन के बीच अपूरणीय परिणाम हैं। as ऑपरेटर ऐसे मामलों में स्मृति से कुछ कचरा लाने के लिए लगता है।

व्यक्तिगत रूप से मुझे लगता है कि यह तब तक ठीक है जब तक कि यह केवल तब होता है जब रूपांतरण अमान्य है और इसके पास कचरा मूल्य पैदा करने के अलावा कोई दुष्प्रभाव नहीं है। यदि आपको वास्तव में कोड के एक टुकड़े में एक अन्यथा अमान्य रूपांतरण की आवश्यकता है, तो आप जो कुछ भी शब्दार्थ के बारे में सोचते हैं, उसके साथ खुद को अमान्य मामला संभाल सकते हैं।

और इसके पास कचरा मूल्य पैदा करने के अलावा कोई दुष्प्रभाव नहीं है

दुष्प्रभाव यह है कि कचरा मूल्य स्मृति में कहीं उत्पन्न होता है और कुछ (संभवतः संवेदनशील) डेटा को प्रकट करता है। पूरी तरह से फ्लोट से गणना की गई "यादृच्छिक" मान लौटना ठीक होगा, लेकिन वर्तमान व्यवहार नहीं है।

मान्य फ़्लोटिंग-पॉइंट रूपांतरण (यानी जहां गंतव्य में अभिन्न अंग फिट बैठता है) भी अच्छी तरह से समझा और सहमत-शब्दार्थ पर आधारित है।

क्या स्पष्ट trunc() , round() , floor() या ceil() साथ फ्लोट-टू-इंट कन्वर्सेशन के कोई उपयोग के मामले नहीं हैं? as की मौजूदा गोलाई रणनीति "अपरिभाषित" है, जिससे as नॉन-राउंडेड नंबरों के लिए उपयोग करने योग्य है। मेरा मानना ​​है कि ज्यादातर मामलों में जो x as u32 लिखता है वह वास्तव में x.round() as u32 चाहता है।

मुझे लगता है कि कलाकारों के साथ सौहार्द सामान्य और अपेक्षित है, न कि कोई समस्या।

मैं सहमत हूं, लेकिन केवल अगर हानिरहितता आसानी से अनुमानित है। पूर्णांक के लिए, हानिपूर्ण रूपांतरण की स्थिति स्पष्ट है। झांकियों के लिए वे अस्पष्ट हैं। वे कुछ बहुत बड़ी संख्याओं के लिए दोषरहित हैं लेकिन कुछ छोटे लोगों के लिए हानिपूर्ण, भले ही वे गोल हों। दोषपूर्ण और दोषरहित रूपांतरण के लिए मेरी व्यक्तिगत प्राथमिकता दो अलग-अलग संचालकों की है, जो गलती से हानिपूर्ण रूपांतरण शुरू करने से बचते हैं, लेकिन मैं केवल एक ही ऑपरेटर के साथ ठीक हूं, बशर्ते कि मैं बताऊं कि यह हानिपूर्ण है या नहीं।

दुष्प्रभाव यह है कि कचरा मूल्य स्मृति में कहीं उत्पन्न होता है और कुछ (संभवतः संवेदनशील) डेटा को प्रकट करता है।

मैं यह उम्मीद करूंगा कि यह गंतव्य को अपरिवर्तित या जो भी हो, छोड़ दे, लेकिन अगर यह वास्तव में एक समस्या है तो इसे पहले शून्य किया जा सकता है।

क्या स्पष्ट ट्रंक (), दौर (), मंजिल () या छत () के साथ फ्लोट-टू-इंट-कन्वर्सेशन के कोई उपयोग के मामले नहीं हैं? as की वर्तमान दौर की रणनीति "अपरिभाषित" है, जो गैर-गोल संख्याओं के लिए मुश्किल से उपयोग करने योग्य है।

यदि राउंडिंग रणनीति वास्तव में अपरिभाषित है, तो यह मेरे लिए आश्चर्य की बात होगी, और मैं सहमत हूं कि ऑपरेटर मुश्किल से उपयोगी है जब तक कि आप इसे पहले से ही पूर्णांक नहीं दे रहे हैं। मुझे उम्मीद है कि यह शून्य की ओर बढ़ जाएगा।

मेरा मानना ​​है कि ज्यादातर मामलों में जो x as u32 लिखता है वह वास्तव में x.round() as u32 चाहता है।

मुझे लगता है कि यह डोमेन पर निर्भर करता है, लेकिन मुझे उम्मीद है कि x.trunc() as u32 भी काफी आम तौर पर वांछित है।

मैं सहमत हूं, लेकिन केवल अगर हानिरहितता आसानी से अनुमानित है।

मैं निश्चित रूप से सहमत हूं। उदाहरण के लिए, क्या 1.6 as u32 1 या 2 अपरिभाषित नहीं होना चाहिए।

https://doc.rust-lang.org/nightly/reference/expressions/operator-expr.html#type -cast- भाव

फ्लोट से पूर्णांक तक कास्टिंग फ्लोट को शून्य की ओर ले जाएगा
नोट: यदि वर्तमान में लक्ष्य पूर्णांक प्रकार के द्वारा गोल मान का प्रतिनिधित्व नहीं किया जा सकता है तो यह अनिर्धारित व्यवहार का कारण बनेगा। इसमें Inf और NaN शामिल हैं। यह एक बग है और इसे ठीक कर दिया जाएगा।

नोट यहां लिंक करता है।

"फिट" मानों की गोलाई को अच्छी तरह से परिभाषित किया गया है, यह इस मुद्दे के बारे में नहीं है। यह धागा पहले से ही लंबा है, यह अच्छा होगा कि इसे पहले से स्थापित और प्रलेखित तथ्यों के बारे में स्पर्शरेखाओं में अटकलें न लगाएं। धन्यवाद।

निम्नलिखित मामलों में f as $Int को परिभाषित करने का तरीका कैसे तय करना है:

• f.trunc() > $Int::MAX (सकारात्मक अनंत सहित)
• f.trunc() < $Int::MIN (नकारात्मक अनंत सहित)
• f.is_nan()

रात में -Z saturating-casts संकलक ध्वज के साथ पहले से ही लागू किया गया एक विकल्प उन्हें क्रमशः वापस लौटने के लिए परिभाषित करने के लिए है: $Int::MAX , $Int::MIN , और शून्य। लेकिन यह अभी भी संभव है कुछ अन्य व्यवहार उठाओ।

मेरा विचार है कि व्यवहार निश्चित रूप से निर्धारक होना चाहिए और कुछ पूर्णांक मान (उदाहरण के लिए घबराहट के बजाय) वापस करना चाहिए, लेकिन सटीक मूल्य बहुत महत्वपूर्ण नहीं है और इन मामलों की परवाह करने वाले उपयोगकर्ताओं को रूपांतरण विधियों का उपयोग करना चाहिए जो मैं अलग से प्रस्तावित कर रहा हूं। जोड़ें: https://internals.rust-lang.org/t/pre-rfc-add-explicitly- name-numeric-conversion- apis/

मुझे लगता है कि यह डोमेन पर निर्भर करता है, लेकिन मुझे उम्मीद है कि x.trunc() as u32 भी काफी आम तौर पर वांछित है।

सही बात। सामान्य तौर पर, x.anything() as u32 , सबसे अधिक संभावना round() , लेकिन trunc() , floor() , ceil() । ठोस राउंडिंग प्रक्रिया को निर्दिष्ट किए बिना सिर्फ x as u32 सबसे अधिक संभावना एक गलती है।

मेरा विचार है कि व्यवहार निश्चित रूप से निश्चित होना चाहिए और कुछ पूर्णांक मान (उदाहरण के लिए घबराहट के बजाय) वापस करना चाहिए, लेकिन सटीक मूल्य बहुत महत्वपूर्ण नहीं है

मैं व्यक्तिगत रूप से "अपरिभाषित" मूल्य के साथ भी ठीक हूं, बशर्ते कि यह किसी भी चीज पर निर्भर न हो, लेकिन खुद को तैरता है और सबसे महत्वपूर्ण, किसी भी असंबंधित रजिस्टर और मेमोरी सामग्री को उजागर नहीं करता है।

एक विकल्प जो पहले से ही लागू है और रात में -Z saturating-casts संकलक ध्वज के साथ उपलब्ध है, उन्हें क्रमशः वापस लौटने के लिए परिभाषित करना है: $Int::MAX , $Int::MIN , और शून्य। लेकिन यह अभी भी संभव है कुछ अन्य व्यवहार उठाओ।

व्यवहार मैं f.trunc() > $Int::MAX और f.trunc() < $Int::MIN लिए प्राप्त करने की उम्मीद करूंगा, जब फ्लोटिंग पॉइंट नंबर काल्पनिक अनंत आकार के पूर्णांक संख्या में परिवर्तित हो जाता है और उसके बाद के सबसे महत्वपूर्ण बिट्स वापस आ जाते हैं ( पूर्णांक प्रकारों के रूपांतरण में)। तकनीकी रूप से यह घातांक के आधार पर बाईं ओर स्थानांतरित किए गए महत्वपूर्ण बिट्स में से कुछ होगा (सकारात्मक संख्याओं के लिए, नकारात्मक संख्याओं को दो के पूरक के अनुसार व्युत्क्रम की आवश्यकता होती है)।

इसलिए उदाहरण के लिए, मैं वास्तव में बड़ी संख्या में 0 परिवर्तित होने की उम्मीद करूंगा।

ऐसा लगता है कि अनंत और NaN किस रूप में परिवर्तित होते हैं, इसे परिभाषित करना कठिन / अधिक मनमाना लगता है।

WebAssembly निम्नलिखित संतृप्त के साथ सिर्फ संतृप्त जातियों को स्थिर करता है:

https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md#design

@CryZe तो अगर मैं इसे सही ढंग से पढ़ता हूं, तो यह -Z saturating-casts मेल खाता है (और मिरी पहले से ही क्या लागू करता है)?

@ राल्फजंग यह सही है।

बहुत बढ़िया, मैं मिरि के परीक्षण सूट के लिए https://github.com/WebAssembly/testsuite/blob/master/conversions.wast (निर्दिष्ट परिणामों के बदले जाल के साथ) की नकल करूंगा। :)

@RalfJung कृपया रूपांतरणों के नवीनतम संस्करण में अपडेट करें। केवल जो कि नए संतृप्त रूपांतरण ऑपरेटरों के लिए परीक्षण शामिल करने के लिए अपडेट किया गया था। नए ऑपरेटरों के नाम में "_sat" है, और उनके पास फँसाने की ज़रूरत नहीं है इसलिए आपको कुछ भी बदलने की आवश्यकता नहीं होनी चाहिए।

@sunfishcode अपडेट करने के लिए धन्यवाद! मुझे वैसे भी रस्ट के लिए परीक्षणों का अनुवाद करना है इसलिए मुझे अभी भी कई चीजों को बदलना होगा। ;)

क्या _sat परीक्षण किए जा रहे मूल्यों के संदर्भ में कोई भिन्न है? (संपादित करें: वहाँ एक टिप्पणी है जिसमें कहा गया है कि मान समान हैं।) रस्ट की संतृप्त जातियों के लिए मैंने इनमें से कई मान लिए और उन्हें https://github.com/rust-lang/miri/pull/1321 में जोड़ा

यूबी आंतरिक के लिए, ततैया की तरफ जाल फिर Miri मुझे लगता है में संकलन-असफल परीक्षण बन जाना चाहिए।

इनपुट मान सभी समान हैं, केवल अंतर यह है कि _sat ऑपरेटरों ने इनपुट पर आउटपुट मानों की अपेक्षा की है, जहां फंसने वाले ऑपरेटरों ने ट्रैप की अपेक्षा की है।

मिरी (और इस तरह रस्ट CTFE इंजन) के लिए टेस्ट https://github.com/rust-lang/miri/pull/1321 में जोड़े गए थे rustc -Zmir-opt-level=0 -Zsaturating-float-casts भी उस फ़ाइल में परीक्षण पास करते हैं।
मैंने अब मिरी में अनियंत्रित आंतरिकता को भी लागू किया, देखें https://github.com/rust-lang/miri/pull/1325।

मैंने https://github.com/rust-lang/rust/pull/71269#issuecomment -615537137 पोस्ट किया है जो वर्तमान स्थिति के दस्तावेज हैं जैसा कि मैंने इसे समझा और पीआर भी संतृप्त -Z ध्वज के व्यवहार को स्थिर करने के लिए आगे बढ़ता है।

इस धागे की लंबाई को देखते हुए मुझे लगता है कि अगर लोगों को लगता है कि मैंने उस टिप्पणी में कुछ भी याद किया है, तो मैं पीआर को कमेंट्री निर्देशित करूंगा, या, अगर यह मामूली है, तो मुझे जूलिप या डिस्कोर्ड (सिमुलैक्रम) पर पिंग करने के लिए स्वतंत्र महसूस करें और मैं कर सकता हूं पीआर धागे पर अनावश्यक शोर से बचने के लिए चीजों को ठीक करें।

मुझे उम्मीद है कि भाषा टीम पर कोई व्यक्ति संभवतः एक पीआर प्रस्ताव शुरू करेगा, जल्द ही पीआर उस पर विलय कर देगा और स्वचालित रूप से इस मुद्दे को बंद कर देगा :)

क्या चेक किए गए रूपांतरणों की योजना है? fn i32::checked_from(f64) -> Result<i32, DoesntFit> जैसा कुछ?

आपको यह विचार करने की आवश्यकता होगी कि i32::checked_from(4.5) रिटर्न क्या होना चाहिए।