Rust: RFC 1892 के लिए ट्रैकिंग मुद्दा, "एक नया हो सकता है के पक्ष में एकतरफा अनारक्षित"

cc @RalfJung

[] RFC को लागू करें

मैं RFC को लागू करने में मदद कर सकता हूं।

बहुत बढ़िया, मैं समीक्षा करने में मदद कर सकता हूँ :)

मुझे RFC के इस हिस्से पर कुछ स्पष्टीकरण चाहिए:

एक खाली प्रकार पर अनधिकृत रूप से कॉल करना एक रनटाइम आतंक को ट्रिगर करता है जो कि अपचयन संदेश को प्रिंट करता है।

क्या केवल mem::uninitialized::<!>() घबराहट होनी चाहिए? या क्या इसे भी रिक्त स्थान (और शायद एनम?) को कवर करना चाहिए जिसमें खाली प्रकार (जैसे (!, u8) ) शामिल हैं?

AFAIK हम केवल ! लिए वास्तव में हानिकारक कोड जनरेशन करते हैं। mem::uninitialized अधिकांश अन्य उपयोग केवल गलत हैं, लेकिन संकलक उनका शोषण करने के लिए नहीं होता है।

तो मैं इसे ! ही करूंगा, लेकिन mem::zeroed । (जब मैं RFC में zeroed जोड़ा, तो उस हिस्से में संशोधन करना भूल गया, ऐसा लगता है।)

हम इसे बनाकर शुरू कर सकते हैं:
https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a2167945/src/librustc_codegen_llvm/intrunic.rs#L184 -L198

जाँच करें कि क्या fn_ty.ret.layout.abi Abi::Uninhabited और बहुत कम से कम एक जाल का उत्सर्जन करता है, उदाहरण के लिए: https://github.com/rust-lang/rust/blob/8928de74394f320d110b110676731b12631a2167945/src/librustc_codegen_llvmmir operand.rs # L400 -L403

एक बार जब आप ट्रैप (यानी intrinsics::abort ) कार्रवाई में दिखाई देते हैं, तो आप देख सकते हैं कि क्या आतंक को ट्रिगर करने का कोई अच्छा तरीका है। यह अनिच्छुक होने के कारण मुश्किल हो सकता है, हमें उन्हें यहाँ विशेष-मामला करने की आवश्यकता होगी: https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a216445/src/librustc_codegen_llvm/mir/rs.rs#L445 L447

वास्तव में घबराने के लिए, आपको कुछ इस तरह की आवश्यकता होगी: https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a2167945/src/librustc-codegen_llvm/mir/block.rs#L360 -L407
(आप EvalErrorKind::BoundsCheck आर्म को अनदेखा कर सकते हैं)

@eddyb संकेतकर्ताओं के लिए धन्यवाद।

अब मैं (कई) डिप्रेशन चेतावनियाँ ठीक कर रहा हूँ और मुझे लगता है (बहुत) सिर्फ sed -i s/mem::uninitialized()/mem::MaybeUninit::uninitialized().into_inner()/g चलाने का प्रलोभन देता हूँ लेकिन मुझे लगता है कि यह बात याद आती होगी ... या यह ठीक है कि अगर मुझे पता है कि मूल्य एक ठोस है (कॉपी) प्रकार? जैसे let x: [u8; 1024] = mem::uninitialized(); ।

यह बिल्कुल बिंदु को याद करेगा, हाँ। ^ ^

कम से कम अभी के लिए, मैं सभी गैर-संघ प्रकारों के लिए mem::MaybeUninit::uninitialized().into_inner() UB पर विचार करना चाहूंगा। ध्यान दें कि Copy निश्चित रूप से पर्याप्त नहीं है; दोनों bool और &'static i32 Copy और आपके स्निपेट का उद्देश्य उनके लिए इंस्टा-यूबी होना है। हम "प्रकार जहां सभी बिट पैटर्न ठीक हैं" (प्रकार पूर्णांक, अनिवार्य रूप से) के लिए एक अपवाद चाहते हो सकता है, लेकिन मैं इस तरह के एक अपवाद बना क्योंकि करने का विरोध किया जाएगा undef एक सामान्य सा पैटर्न नहीं है। इसीलिए RFC का कहना है कि आपको into_inner कॉल करने से पहले पूरी तरह से इनिशियलाइज़ करना होगा।

यह भी कहता है कि get_mut , लेकिन RFC चर्चा ने कुछ लोगों द्वारा यहां प्रतिबंध को आराम करने के लिए वांछित लाया। यह एक विकल्प है जिसके साथ मैं रह सकता हूं। लेकिन into_inner ।

मुझे डर है कि uninitialized इन सभी उपयोगों को और अधिक ध्यान से समीक्षा करनी होगी, और वास्तव में यह RFC के इरादों में से एक था। हम चाहते हैं कि व्यापक पारिस्थितिकी तंत्र यहां अधिक सावधानी बरतें, अगर हर कोई तुरंत into_inner का उपयोग करता है तो RFC बेकार है।

हम चाहते हैं कि व्यापक पारिस्थितिकी तंत्र यहां और अधिक सावधानी बरतें, अगर हर कोई तुरंत into_inner का उपयोग करता है तो RFC बेकार है।

यह मुझे एक विचार देता है ... शायद हमें इस तरह के कोड के लिए एक प्रकार का वृक्ष (समूह: "शुद्धता") चाहिए? cc @ ओली-ओब्क

अब मैं (कई) डिप्रेशन चेतावनियाँ ठीक कर रहा हूँ

हमें केवल उन चेतावनियों के साथ रात को जहाज करना चाहिए जब अनुशंसित प्रतिस्थापन कम से कम स्थिर पर उपलब्ध हो। इसी तरह की चर्चा https://github.com/rust-lang/rust/pull/52994#issuecomment -42813133 पर

@RalfJung

हम "प्रकार जहां सभी बिट पैटर्न ठीक हैं" के लिए एक अपवाद चाहते हैं (पूर्णांक प्रकार, अनिवार्य रूप से)

आपने पहले इस बारे में चर्चा में भाग लिया है, लेकिन मैं यहां और अधिक व्यापक रूप से प्रसारित करने के लिए पोस्ट करूंगा: यह पहले से ही कुछ है हमारे पास फुकिया में कई मौजूदा उपयोग-मामले हैं, और हमारे पास इसके लिए एक विशेषता है ( FromBytes ) और इन प्रकारों के लिए एक व्युत्पन्न मैक्रो। इन्हें मानक पुस्तकालय (cc @gnzlbg @joshlf) में जोड़ने के लिए एक आंतरिक पूर्व RFC भी था।

मैं इस तरह का अपवाद बनाने का विरोध करूंगा क्योंकि अपरिभाषित एक सामान्य सा पैटर्न नहीं है।

हाँ, यह एक पहलू है जिसमें mem::zeroed() mem::uninitialized() से काफी भिन्न है।

@cramertj

आपने पहले इस बारे में चर्चा में भाग लिया है, लेकिन मैं यहां और अधिक व्यापक रूप से प्रसारित करने के लिए पोस्ट करूंगा: यह पहले से ही कुछ है जो हमारे पास फुकिया में कई मौजूदा उपयोग-मामले हैं, और हमारे पास इसके (FromBytes) और एक व्युत्पन्न मैक्रो के लिए एक विशेषता है इन प्रकारों के लिए। इन्हें मानक पुस्तकालय (cc @gnzlbg @joshlf) में जोड़ने के लिए एक आंतरिक पूर्व RFC भी था।

उन चर्चाओं के बारे में memcpy की अनुमति देने के तरीकों के बारे में थे, लेकिन मुझे लगता है कि स्मृति की नकल की जा रही है या नहीं, यह बहुत ज्यादा ओर्थोगोनल है - यदि आप अनइंस्टॉल किए गए मेमोरी में डालते हैं, तो आप अनइंस्टॉल मेमोरी को बाहर निकालते हैं।

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

IIRC, वहां किसी ने भी ऐसा कोई सुझाव नहीं दिया और न ही चर्चा की, जिसमें आप अनधिकृत मेमोरी डाल सकते हैं और मेमोरी को इनिशियलाइज़ कर सकते हैं, इसलिए मैं इस बात का पालन नहीं करता कि उन चर्चाओं का इससे क्या लेना-देना है। मेरे लिए वे पूरी तरह से ऑर्थोगोनल हैं।

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

सही है, क्षमा करें, मुझे स्पष्ट करना चाहिए कि मेरा क्या मतलब था। मैं यह कहने की कोशिश कर रहा था कि "प्रकार जहां सभी बिट पैटर्न ठीक हैं" पहले से ही कुछ ऐसा है जिसे हम अन्य कारणों से परिभाषित करने में रुचि रखते हैं। जैसे @RalfJung ने ऊपर कहा,

मैं इस तरह का अपवाद बनाने का विरोध करूंगा क्योंकि अपरिभाषित एक सामान्य सा पैटर्न नहीं है।

भगवान का शुक्र है जो लोग पढ़ सकते हैं, क्योंकि जाहिर है मैं नहीं कर सकता ...

ठीक है, तो मेरे कहने का मतलब यह है: हमारे पास निश्चित रूप से ऐसे प्रकार हैं जहां सभी प्रारंभिक बिट पैटर्न ठीक हैं - सभी i* और u* प्रकार, कच्चे संकेत, मुझे लगता है कि f* रूप में अच्छी तरह से और फिर tuples / संरचनाएं केवल इस प्रकार के होते हैं।

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

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

MaybeUninit<u8> रूप में पैडिंग बाइट्स पढ़ना ठीक होना चाहिए।

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

शायद गद्दी के रूप में पैडिंग बाइट्स पढ़नाठीक होना चाहिए।

संक्षेप में चर्चा एक विशेषता है, प्रदान करने के बारे में था Compatible<T> , एक सुरक्षित विधि के साथ fn safe_transmute(self) -> T है कि "reinterprets" / "memcpys" के टुकड़े self में एक T । इस पद्धति की गारंटी यह है कि यदि self का ठीक से इनिशियलाइज़ेशन किया जाता है, तो परिणामी T । यह संकलक के लिए संक्रमणीय क्रियान्वयन को स्वतः भरने के लिए प्रस्तावित किया गया था, उदाहरण के लिए, यदि impl Compatible<V> for U , और impl Compatible<W> for V तो एक impl Compatible<W> for U (या तो क्योंकि यह प्रदान किया गया था) मैन्युअल रूप से, या कंपाइलर ऑटो इसे उत्पन्न करता है - यह कैसे लागू किया जा सकता है पूरी तरह से हाथ लगाया गया था)।

यह प्रस्तावित किया गया था कि इसे लागू करने के लिए unsafe होना चाहिए: यदि आप इसे T लिए कार्यान्वित करते हैं जिसमें पैडिंग बाइट्स हैं जहाँ Self फ़ील्ड हैं, तो सब कुछ ठीक है जब तक आप T का उपयोग करने का प्रयास नहीं करते हैं और आपके कार्यक्रम का व्यवहार असमान स्मृति की सामग्री के आधार पर समाप्त होता है।

मुझे नहीं पता कि इसमें से किसी का MaybeUninit<u8> , हो सकता है कि आप इस बारे में विस्तार से बता सकें?

केवल एक चीज जिसकी मैं कल्पना कर सकता हूं कि हम एक कंबल जोड़ सकते हैं: unsafe impl<T> Compatible<[MaybeUninit<u8>; size_of::<T>()]> for T { ... } किसी भी प्रकार को [MaybeUninit<u8>; N] में स्थानांतरित करने के बाद से इसका आकार सभी प्रकारों के लिए सुरक्षित है। मुझे नहीं पता कि इस तरह का एक इम्प्लान्ट कितना उपयोगी होगा, यह देखते हुए कि MaybeUninit एक यूनियन है, और जो कोई भी [MaybeUninit<u8>; N] का उपयोग करता है, उसे इस बात का कोई पता नहीं है कि ऐरे का कोई विशेष तत्व इनिशियलाइज़ है या नहीं ।

@gnzlbg वापस तो आप FromBits<T> for [u8] बारे में बात कर रहे थे । यही कारण है कि मैं कहता हूं कि हमें इसके बजाय [MaybeUninit<u8>] उपयोग करना होगा।

मैंने RustConf में @nikomatsakis के साथ इस प्रस्ताव पर चर्चा की, और उन्होंने मुझे RFC के साथ आगे बढ़ने के लिए प्रोत्साहित किया। मैं इसे कुछ हफ्तों में करने जा रहा था, लेकिन अगर इसमें दिलचस्पी है, तो मैं इस सप्ताह के अंत में एक कोशिश कर सकता हूं। क्या इस चर्चा के लिए यह उपयोगी होगा?

@ जोशफेल आप किस प्रस्ताव की बात कर रहे हैं?

@RalfJung

@gnzlbg तब आप FromBits के बारे में बात कर रहे थे[u8] के लिए। यही वह जगह है जहां मैं कहता हूं कि हमें [शायद यूनीनिट का उपयोग करना है] बजाय।

गोत्र, यहाँ पूरी तरह से सहमत हैं। पूरी तरह से भूल गया था कि हम भी उस also करना चाहते थे

@ जोशफेल आप किस प्रस्ताव की बात कर रहे हैं?

एक FromBits / IntoBits प्रस्ताव। TLDR: T: FromBits<U> का मतलब है कि किसी भी बिट पैटर्न, जिसमें एक मान्य है U एक वैध से मेल खाती है T । U: IntoBits<T> मतलब वही है। कंपाइलर स्वचालित रूप से कुछ नियमों को दिए गए सभी प्रकार के जोड़े के लिए दोनों को संक्रमित करता है, और यह बहुत सारी मजेदार अच्छाई को अनलॉक करता है, जिसके लिए वर्तमान में unsafe आवश्यकता होती है। यहाँ इस RFC का एक प्रारूप

@ जोशफाइल मुझे लगता है कि इस तरह की एक जोड़ी इस चर्चा के शीर्ष पर अधिक हिस्सा

• क्या यह संदर्भों से नीचे आता है? मैं अधिक से अधिक दृढ़ता से सोचता हूं कि यह नहीं करना चाहिए, क्योंकि हम अधिक उदाहरण देखते हैं। तो संभावना है कि हमें तदनुसार MaybeUninit::get_mut डॉक्स को अनुकूलित करना चाहिए (यह आरंभीकरण पूरा करने से पहले उपयोग करने के लिए वास्तव में यूबी नहीं है, लेकिन यह आरबीबी है जो आरंभीकरण पूरा करने से पहले इसे
• क्या u8 (और अन्य पूर्णांक प्रकार, फ़्लोटिंग पॉइंट, रॉ पॉइंटर) को इनिशियलाइज़ किया जाना है, यानी MaybeUinit<u8>::uninitialized().into_inner() इंस्टा-यूबी है? मुझे ऐसा लगता है, लेकिन ज्यादातर एक आंत भावना पर आधारित है कि हम उन जगहों को रखना चाहते हैं जहां हम poison / undef न्यूनतम करने की अनुमति देते हैं। हालाँकि, मुझे इस बात के लिए राजी किया जा सकता है, अगर इस पद्धति के बहुत सारे उपयोग हैं (और मैं इसे निर्धारित करने में मदद करने के लिए मीरी का उपयोग करने की उम्मीद करता हूं)।

क्या यह संदर्भों से नीचे आता है?

@RalfJung क्या आप इसका उदाहरण दिखा सकते हैं कि आपके पास "संदर्भों के नीचे आने" का क्या मतलब है?

क्या एक u8 (और अन्य पूर्णांक प्रकार, फ्लोटिंग पॉइंट, रॉ पॉइंटर) को इनिशियलाइज़ किया जाना है, अर्थात, हो सकता है:: uninitialized () .k_inner () इंस्टा-यूबी?

यदि यह तत्काल यूबी नहीं है तो क्या होगा? मैं उस मूल्य के साथ क्या कर सकता हूं? क्या मैं इस पर मेल कर सकता हूं? यदि ऐसा है, तो कार्यक्रम व्यवहार निर्धारक है?

मुझे लगता है कि अगर मैं यूबी को शुरू किए बिना मूल्य पर मेल नहीं खा सकता हूं, तो हमने mem::uninitialized आविष्कार किया है। यदि मैं मूल्य पर मेल कर सकता हूं और एक ही शाखा को हमेशा सभी आर्किटेक्चर, ऑप्ट-स्तर, आदि में ले जाया जाता है, तो हमने mem::zeroed का फिर से आविष्कार किया है (और MaybeUninit का उपयोग करने की तरह है

क्या एक u8 (और अन्य पूर्णांक प्रकार, फ़्लोटिंग पॉइंट, रॉ पॉइंटर) को आरंभीकृत किया जाना है, यानी MaybeUinit<u8>::uninitialized().into_inner() इंस्टा-यूबी है? मुझे ऐसा लगता है, लेकिन ज्यादातर एक आंत की भावना पर आधारित है कि हम उन जगहों को रखना चाहते हैं जहां हम poison / undef न्यूनतम करने की अनुमति देते हैं। हालाँकि, मुझे इस बात के लिए राजी किया जा सकता है, अगर इस पद्धति के बहुत सारे उपयोग हैं (और मैं इसे निर्धारित करने में मदद करने के लिए मीरी का उपयोग करने की उम्मीद करता हूं)।

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

यदि यह तत्काल यूबी नहीं है तो क्या होगा? मैं उस मूल्य के साथ क्या कर सकता हूं? क्या मैं इस पर मेल कर सकता हूं? यदि ऐसा है, तो कार्यक्रम व्यवहार निर्धारक है?

मुझे लगता है कि अगर मैं यूबी को शुरू किए बिना मूल्य पर मेल नहीं खा सकता हूं, तो हमने mem::uninitialized का फिर से आविष्कार किया है। अगर मैं मूल्य पर मेल कर सकता हूं और एक ही शाखा को हमेशा सभी आर्किटेक्चर, ऑप्ट-स्तर, आदि में ले जाया जाता है, तो हमने mem::zeroed आविष्कार किया है (और MaybeUninit का उपयोग करने की तरह है

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

आप उस चीज़ पर मिलान क्यों करना चाहेंगे जो कि अनधिकृत है?

मैंने यह नहीं कहा कि मैं चाहता था, मैंने कहा कि अगर ऐसा नहीं किया जा सकता है, तो मुझे MaybeUinit<u8>::uninitialized().into_inner() और सिर्फ mem::uninitialized() बीच का अंतर समझ में नहीं आता है।

@RalfJung क्या आप इसका उदाहरण दिखा सकते हैं कि आपके पास "संदर्भों के नीचे आने" का क्या मतलब है?

अनिवार्य रूप से, सवाल यह है कि क्या हम निम्नलिखित की अनुमति देते हैं:

let mut b = MaybeUninit::<bool>::uninitialized();
let bref = b.get_mut(); // insta-UB?

यदि हम यह तय करते हैं कि एक संदर्भ केवल तभी मान्य होता है जब यह किसी मान्य वस्तु की ओर इशारा करता है (यानी "संदर्भों से नीचे आने का मतलब है"), यह कोड यूबी है।

यदि यह तत्काल यूबी नहीं है तो क्या होगा? मैं उस मूल्य के साथ क्या कर सकता हूं? क्या मैं इस पर मेल कर सकता हूं? यदि ऐसा है, तो कार्यक्रम व्यवहार निर्धारक है?

आप किसी भी तरह से एक u8 का निरीक्षण नहीं कर सकते। match कई चीजें कर सकते हैं, दोनों बाध्यकारी नाम और वास्तव में समानता के लिए परीक्षण; पूर्व ठीक है लेकिन उत्तरार्द्ध नहीं है। लेकिन आप इसे वापस मेमोरी में लिख सकते हैं ।

अनिवार्य रूप से, यह वही है जो वर्तमान में लागू होता है।

मुझे लगता है कि अगर मैं यूबी को शुरू किए बिना मूल्य पर मेल नहीं खा सकता हूं, तो हमारे पास मेम का आविष्कार किया गया है :: अनइंस्टॉलिज्ड।

यह क्यों? mem::uninitialized साथ सबसे बड़ी समस्या उन प्रकारों के आस-पास थी जो उनके वैध मूल्यों के लिए प्रतिबंध हैं। हम तय कर सकते हैं कि u8 में ऐसी कोई पाबंदी नहीं है, इसलिए mem::uninitialized() u8 लिए ठीक था। जेनेरिक कोड में सही ढंग से उपयोग करना लगभग असंभव था, इसलिए पूरी तरह से छुटकारा पाने के लिए बेहतर है।
किसी भी तरह, सुरक्षित कोड के लिए एक u8 पास करना अभी भी ठीक नहीं है, लेकिन असुरक्षित कोड में सावधानीपूर्वक इसका उपयोग करना ठीक हो सकता है।

आप अवैध डेटा की ओर इशारा करते हुए &mut पर "मैच" नहीं कर सकते। IOW, मुझे लगता है कि मेरे द्वारा दिया गया bool उदाहरण ठीक है, लेकिन निम्नलिखित निश्चित रूप से नहीं है:

let mut b = MaybeUninit::<bool>::uninitialized();
let bref = b.get_mut();
match bref {
  &b => // insta-UB! We have a bad bool in scope.
}

यह एक सामान्य पॉइंटर डेरेफेरेंस करने के लिए match का उपयोग कर रहा है।

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

यह कौन से अनुकूलन की अनुमति देगा?
ध्यान दें कि LLVM अनिवार्य रूप से अनकैप्ड कोड पर अनुकूलन करता है, इसलिए इसमें से कोई भी चिंता का विषय नहीं है। हम यहां केवल MIR अनुकूलन के बारे में बात कर रहे हैं।

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

यदि हम यह तय करते हैं कि एक संदर्भ केवल तभी मान्य होता है जब यह किसी मान्य वस्तु की ओर इशारा करता है (यानी "संदर्भों से नीचे आने का मतलब है"), यह कोड यूबी है।

पकड़ लिया।

मेम के साथ सबसे बड़ी समस्या :: अनइंस्टॉलिज्ड उन प्रकारों के आस-पास थी जो उनके वैध मूल्यों के लिए प्रतिबंध हैं।

mem::uninitialized भी वह समस्या है जो आपने ऊपर बताई है: जो कि एक असंक्रमित मूल्य का संदर्भ बनाते हुए अपरिभाषित व्यवहार (या नहीं) हो सकती है। तो निम्नलिखित यूबी है?

let mut b = MaybeUninit::<u8>::uninitialized().into_inner();
let bref = &mut b; // Insta UB ?

मैंने सोचा था कि MaybeUninit शुरू करने के कारणों में से एक था इस समस्या से बचने के लिए हमेशा यूनियन इनिशियलाइज़्ड (जैसे यूनिट), जो आपको इसका संदर्भ लेने की अनुमति देता है, और इसकी सामग्री को म्यूट कर देता है, जैसे सेटिंग u8 लिए सक्रिय फ़ील्ड और इसे UB को प्रस्तुत किए बिना ptr::write माध्यम से एक मूल्य दे रहा है।

तो इस कारण मैं थोड़ा भ्रमित हूं। मैं नहीं देखता कि कैसे into_inner किसी भी तुलना में बेहतर है:

let mut b: u8 = uninitialized();
let bref = &mut b; // Insta UB ? 

दोनों अपरिभाषित व्यवहार समय बम की तरह लग रहे हो मुझे।

यह कौन से अनुकूलन की अनुमति देगा?
ध्यान दें कि LLVM अनिवार्य रूप से अनकैप्ड कोड पर अनुकूलन करता है, इसलिए इसमें से कोई भी चिंता का विषय नहीं है। हम यहां केवल MIR अनुकूलन के बारे में बात कर रहे हैं।

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

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

सही है।

उस ने कहा, बाइट स्लाइस के कुछ अच्छे उपयोग जो किसी भी डेटा को पुराना कर सकते हैं, हाल ही में सामने आए हैं, जो कम से कम u* और i* लिए ऐसा करने के लिए एक तर्क के लिए पर्याप्त हो सकता है।

क्या इनमें से किसी भी उपयोग के मामलों में बाइट की स्लाइसें शामिल हैं जो असमान मूल्यों को रखती हैं?

एक जगह है कि एक uninitialized-but-not-poison &mut [u8] मूल्यवान हो सकता है Read::read - हम बफर शून्य करने की आवश्यकता से बचने में सक्षम होना चाहते हैं क्योंकि कुछ अजीब Read निहितार्थ इसमें लिखने के बजाय इसे पढ़ सकता है।

एक जगह है कि एक uninitialized-but-not-poison &mut [u8] मूल्यवान हो सकता है Read::read - हम बफर शून्य करने की आवश्यकता से बचने में सक्षम होना चाहते हैं क्योंकि कुछ अजीब Read निहितार्थ इसमें लिखने के बजाय इसे पढ़ सकता है।

मैं देख रहा हूं, इसलिए यह विचार है कि MaybeUninit एक प्रकार का प्रतिनिधित्व करेगा जो कि आरंभिक है, लेकिन अपरिभाषित सामग्री के साथ है, जबकि अन्य प्रकार के असंवैधानिक डेटा (जैसे, पैडिंग फ़ील्ड) अभी भी एलएलवीएम जहर के अर्थ में पूरी तरह से निर्विवाद होंगे?

मुझे नहीं लगता है कि इसे आम तौर पर आईफिनिट पर लागू करने की आवश्यकता होगी। सिद्धांत में कुछ एपीआई को परिभाषित से सामग्री को "फ्रीज" करने के लिए परिभाषित-लेकिन-मनमाने ढंग से किया जा सकता है।

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

वह कभी प्रस्ताव नहीं था। यह poison पर शाखा के लिए UB रहेगा।

सवाल यह है कि क्या यह केवल स्थानीय u8 " poison " का UB है।

क्या इनमें से किसी भी उपयोग के मामलों में बाइट की स्लाइसें शामिल हैं जो असमान मूल्यों को रखती हैं?

स्लाइस संदर्भ की तरह होते हैं, इसलिए &mut [u8] अनविज्ञानीकृत डेटा तब तक ठीक है जब तक कि इसे केवल लिखा जाता है (यह मानते हुए कि हम संदर्भ वैधता के लिए जो समाधान लेते हैं)।

@sfackler

एक जगह है कि एक uninitialized-but-not-poison और mut [u8] मूल्यवान हो सकता है पढ़ने के लिए :: पढ़ें - हम बफर शून्य करने की आवश्यकता से बचने में सक्षम होना चाहते हैं, क्योंकि कुछ अजीब पढ़ें प्रत्यारोपण इसे से बाहर पढ़ सकते हैं बल्कि इसमें लिखने के बजाय।

ठीक है, &out बिना आप केवल ऐसा ही कर पाएंगे, यदि आप निहित को जानते हैं। सवाल सुरक्षित कोड को संभालने के लिए है नहीं है कि poison में u8 (यदि ऐसा नहीं होता, कि सुरक्षित कोड के ठीक उपयोग नहीं है!), सवाल है कि क्या असुरक्षित कोड ध्यान से इसे संभाल कर सकते हैं इस तरफ। (उस ब्लॉग पोस्ट को देखें जिसे मैं आज सुरक्षा आक्रमणकारियों और वैधता के अंतर के बारे में लिखना चाहता था ...)

हो सकता है कि मुझे देर हो रही है, लेकिन मैं के हस्ताक्षर बदलने का सुझाव था set() विधि वापस जाने के लिए &mut T । इस तरह, MaybeUninit (कम से कम कुछ स्थितियों में) के साथ काम करने वाले पूरी तरह से सुरक्षित कोड लिखना सुरक्षित होगा।

fn init(dest: &mut MaybeUninit<u8>) -> &mut u8 {
    dest.set(produce_value())
}

यह व्यावहारिक रूप से एक स्थिर गारंटी है कि init() या तो मूल्य या डायवर्ज को आरंभ करेगा। (यदि इसने कुछ और वापसी करने की कोशिश की, तो जीवनकाल गलत होगा और &'static mut u8 सुरक्षित कोड में असंभव है।) हो सकता है कि इसे भविष्य में placer API के एक भाग के रूप में इस्तेमाल किया जा सके।

@Kixunil यह उस तरह से पहले किया गया है, और मैं मानता हूं कि यह अच्छा है। मुझे बस एक फ़ंक्शन के लिए set भ्रमित करना है जो कुछ देता है।

@Kixunil

यह व्यावहारिक रूप से एक स्थिर गारंटी है कि init() या तो मूल्य या डायवर्ज को आरंभ करेगा। (यदि इसने कुछ और वापसी करने की कोशिश की, तो जीवनकाल गलत होगा और &'static mut u8 सुरक्षित कोड में असंभव है।)

काफी नहीं; आप Box::leak साथ एक प्राप्त कर सकते हैं।

हाल ही में लिखे एक कोडबेस में, मैं इसी तरह की योजना के साथ आया था; यह थोड़ा अधिक जटिल है, लेकिन एक वास्तविक स्थैतिक गारंटी प्रदान करता है कि प्रदान किए गए संदर्भ को आरंभीकृत किया गया था। के बजाय

fn init(dest: &mut MaybeUninit<u8>) -> &mut u8

मेरे पास है

fn init<'a>(dest: Uninitialized<'a, u8>) -> DidInit<'a, u8>

चाल यह है कि Uninitialized और DidInit दोनों अपने जीवनकाल के मापदंडों पर अपरिवर्तनीय हैं, इसलिए DidInit को एक अलग जीवनकाल पैरामीटर के साथ पुन: उपयोग करने का कोई तरीका नहीं है, यहां तक ​​कि 'static ।

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

struct Foo {
    a: i32,
    b: u8,
}

fn init_foo<'a>(dest: Uninitialized<'a, Foo>,
                init_a: impl for<'x> FnOnce(Uninitialized<'x, i32>) -> DidInit<'x, i32>,
                init_b: impl for<'x> FnOnce(Uninitialized<'x, u8>) -> DidInit<'x, u8>)
                -> &'a mut DidInit<'a, Foo> {
    let ptr: *mut Foo = dest.ptr;
    unsafe {
        init_a(Uninitialized::new(&mut (*ptr).a));
        init_b(Uninitialized::new(&mut (*ptr).b));
        dest.did_init()
    }
}

यह फ़ंक्शन उपयोगकर्ता द्वारा प्रदान किए गए आरंभीकरण कॉलबैक का उपयोग करके, बारी-बारी से अपने प्रत्येक क्षेत्र को आरंभ करके Foo एक सूचक को इनिशियलाइज़ करता है। यह आवश्यक है कि कॉलबैक DidInit s लौटे, लेकिन अपने मूल्यों के बारे में परवाह नहीं करता है; तथ्य यह है कि वे मौजूद हैं पर्याप्त है। एक बार सभी क्षेत्रों को आरंभ करने के बाद, यह जानता है कि संपूर्ण Foo वैध है - इसलिए यह did_init() को Uninitialized<'a, Foo> पर कॉल करता है, जो कि एक असुरक्षित विधि है जो सिर्फ इसे डालती है इसी DidInit प्रकार, जो init_foo फिर लौटता है।

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

वैसे भी, मुझे आश्चर्य है कि अगर मानक पुस्तकालय में ऐसा कुछ लागू किया जा सकता है।

खेल का मैदान लिंक

(नोट: DidInit<'a, T> वास्तव में के लिए एक प्रकार का अन्य नाम है &'a mut _DidInitMarker<'a, T> , के साथ से बचने के जीवनकाल मुद्दों के लिए DerefMut ।)

वैसे, जबकि ऊपर से जुड़ा दृष्टिकोण विनाशकों की उपेक्षा करता है, थोड़ा अलग दृष्टिकोण DidInit<‘a, T> T विध्वंसक चलाने के लिए जिम्मेदार बनाने के लिए होगा। इस मामले में यह एक संरचना होना चाहिए, एक उपनाम नहीं; और यह केवल के लिए संदर्भ हाथ बाहर कर सकता है T कि लाइव रूप में लंबे समय के रूप में DidInit ही है, नहीं सभी के लिए ’a (अन्यथा जब से तुम विनाश के बाद यह पहुंच बनाए रखने के सकता है)।

+1 ने पहले मुझे set में जो व्यवहार करने के लिए कहा था, उसे देने के लिए एक विधि को शामिल करने के लिए, लेकिन मैं इसे दूसरे नाम से उपलब्ध होने के साथ ठीक हूं।

उस नाम के लिए कोई अच्छा विचार हो सकता है? set_and_as_mut ? ^ ^

set_and_borrow_mut ?

insert / insert_mut ? Entry प्रकार में कुछ समान or_insert विधि है (लेकिन OccupiedEntry भी insert जो पुराना मूल्य लौटाता है, इसलिए यह समान नहीं है)।

क्या दो अलग-अलग विधियाँ होने का वास्तव में सम्मोहक कारण है? यह रिटर्न मान को अनदेखा करने के लिए पर्याप्त सरल लगता है, और मुझे लगता है कि फ़ंक्शन को #[inline] के रूप में चिह्नित किया जाएगा ताकि मैं किसी भी वास्तविक रनटाइम लागत की उम्मीद न करूं।

क्या दो अलग-अलग विधियाँ होने का वास्तव में सम्मोहक कारण है? रिटर्न मान को नजरअंदाज करना काफी सरल लगता है

मुझे लगता है कि केवल यही कारण है कि set रिटर्न देखकर कुछ आश्चर्य की बात है।

शायद मुझे कुछ याद आ रहा है, लेकिन क्या हमें अवैध मूल्य होने से बचा सकता है? मेरा मतलब है अगर हम

let mut foo: MaybeUninit<T> = MaybeUninit {
    uninit: (),
};
let mut foo_ref = &mut foo as *mut MaybeUninit<T>;

unsafe {
    some_native_function(&mut (*foo_ref).value, val);
}

क्या होगा यदि some_native_function न-ओप है और वास्तव में मूल्य का लाभ नहीं उठाता है? क्या यह अभी भी यूबी है? इसे कैसे संभाला जा सकता था?

@Pixix यह सभी एपीआई प्रलेखन द्वारा MaybeUninit लिए कवर किया गया है।

यदि some_native_function एक एनओपी है, तो कुछ नहीं होता है; आप तो बाद में उपयोग करता है, तो foo_ref.value (या बल्कि ऐसा foo_ref.as_mut() के रूप में आप केवल सार्वजनिक एपीआई का उपयोग कर सकते हैं), यूबी है कि इसकी वजह समारोह केवल एक बार सब कुछ आरंभ नहीं हो जाता बुलाया जा सकता है।

MaybeUninit अमान्य मान रखने से नहीं रोकता है - यदि यह हो सकता है, तो यह सुरक्षित होगा, लेकिन यह संभव नहीं है। हालाँकि, यह फ़ुटगुन के कम अमान्य मानों के साथ काम करता है क्योंकि अब यह जानकारी कि मूल्य अमान्य हो सकता है, टाइप करने के लिए संकलित किया जाता है, देखने के लिए कंपाइलर और प्रोग्रामर दोनों के लिए।

मैं एक IRC बातचीत का दस्तावेज बनाना चाहता था, जो भविष्य में पैदा होने वाले काल्पनिक मुद्दे के बारे में @sfackler के साथ हो।

मुख्य प्रश्न यह है कि क्या mem::zeroed के लिए वर्तमान कार्यान्वयन प्रस्ताव के लिए MaybeUninit<NonZeroU8> mem::zeroed एक मान्य इन-मेमोरी प्रतिनिधित्व है। मेरी सोच में, "यूनिनिट" राज्य में मूल्य केवल पैडिंग है, जिसे कंपाइलर किसी भी उद्देश्य के लिए उपयोग कर सकता है, और "मूल्य" राज्य में, mem::zeroed को छोड़कर सभी संभावित मूल्य मान्य हैं ( NonZero )।

अधिक उन्नत एनम डिस्क्रिमिनेन्ट पैकिंग (अब हमारे पास) के साथ एक भविष्य के प्रकार की लेआउट प्रणाली "अनइनिट" स्थिति / "मेमोरी" स्थिति में शून्य मेमोरी की पैडिंग में एक भेदभाव स्टोर कर सकती है। उस काल्पनिक प्रणाली में, Option<MaybeUninit<NonZeroU8>> का आकार 1 है, जबकि वर्तमान में यह 2. है। इसके अलावा, उस काल्पनिक प्रणाली में, Some(MaybeUninit::uninitialized()) None से अप्रभेद्य होगा। मुझे लगता है कि हम इस तरह के सिस्टम में जाने से पहले MaybeUninit (लेकिन इसका सार्वजनिक एपीआई नहीं) के कार्यान्वयन को बदलकर इसे ठीक कर सकते हैं।

मैं इस संबंध में NonZeroU8 और &'static i32 बीच कोई अंतर नहीं देखता हूं। ये दोनों ऐसे प्रकार हैं जहाँ "0" मान्य नहीं MaybeUninit<T>::zeroed().into_inner() insta-UB है।

क्या Option<Union> लेआउट कर सकते हैं अनुकूलन एक संघ के लिए वैधता पर निर्भर करता है। यह अभी तक सभी मामलों के लिए तय नहीं किया गया है, लेकिन सामान्य समझौता है कि यूनियनों के लिए प्रकार () का एक प्रकार है, कोई भी बिट-पैटर्न मान्य है और इसलिए कोई लेआउट अनुकूलन संभव नहीं है। इसमें MaybeUninit । तो Option<MaybeUninit<NonZeroU8>> का आकार कभी भी 1 नहीं होगा।

सामान्य समझौता है कि यूनियनों के लिए प्रकार का एक प्रकार () है, कोई भी बिट-पैटर्न वैध है और इसलिए कोई लेआउट अनुकूलन संभव नहीं है।

क्या यह "यूनियनों के लिए एक विशेष प्रकार का मामला है (प्रकार)"? क्या इस फीचर के स्थिरीकरण से Rust ABI के उस हिस्से को स्थिर किया जा सकता है? union युक्त struct UnitType; या struct NewType(()); क्या? struct Padded (नीचे) क्या है? एक union struct Padded युक्त के बारे में क्या?

#[repr(C, align(4))]
struct Padded {
    a: NonZeroU8,
    b: (),
    c: NonZeroU16
}

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

वर्तमान सहमति पर विचार करने के लिए हमारे पास एक उचित चर्चा होगी और हो सकता है कि UCG रेपो में अगले डिस्कशन में से किसी एक में अधिक चीजों पर सहमति हो, और ऐसा होने पर आपका इसमें शामिल होने का स्वागत है।

क्या इस फीचर के स्थिरीकरण से Rust ABI के उस हिस्से को स्थिर किया जा सकता है?

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

ये संबंधित लेकिन विशिष्ट हैं, और वास्तव में यूनियनों के एबीआई पर वर्तमान में चर्चा चल रही है।

AFAICT कि चर्चा केवल यूनियनों के मेमोरी प्रतिनिधित्व के बारे में है, और इसमें शामिल नहीं है कि कैसे फंक्शन सीमाओं और अन्य चीजों के माध्यम से यूनियनों को पारित किया जाता है जो एक एबीआई के लिए प्रासंगिक हो सकते हैं। मुझे नहीं लगता कि UCG रेपो का उद्देश्य Rust के लिए ABI बनाना है।

खैर, उद्देश्य सी के साथ इंटरोप के लिए पर्याप्त चीजों को परिभाषित करना है। "रस्ट bool और C bool ABI- संगत हैं"।

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

मुझे यह जानने की उत्सुकता है कि क्या लेआउट-ऑप्टिमाइज़िंग Option<Foo> खिलाफ कुछ तर्क है जहाँ Foo को इस प्रकार परिभाषित किया गया है:

union Foo {
   bar: NonZeroUsize,
   baz: &'static str,
}

@Kixunil क्या आप https://github.com/rust-rfcs/unsafe-code-guidelines/issues/13 पर उठा सकते हैं MaybeUninit से संबंधित नहीं है।

मैं जानना चाहता हूं कि किस खंड में आरंभीकरण के बिना स्थिर चर होंगे?
"C" में मैं उच्च स्तर की फ़ाइल में uint8_t a[100]; लिख सकता हूं, और मुझे पता है कि एक प्रतीक tobss अनुभाग में रखा जाएगा। अगर मैं uint8_t a[100] = {}; लिखता हूँ तो एक प्रतीक .data सेक्शन में डाला जाएगा (जो कि मुख्य से पहले FLASH से RAM में कॉपी किया जाएगा)।

यह Rust में छोटा सा उदाहरण है जो शायद यूफिनिट का उपयोग करता है:

struct A {
    data: MaybeUninit<[u8; 100]>,
    len: usize,
}

impl A {
    pub const fn new() -> Self {
        Self {
            data: MaybeUninit::uninitialized(),
            len: 0,
        }
    }
}

static mut a: MaybeUninit<[u8; 100]> = MaybeUninit::uninitialized();
static mut b: A = A::new();

किस खंड में a और b चिन्ह होंगे?

पीएस मुझे प्रतीक मैन्बलिंग के बारे में पता है लेकिन यह इस सवाल के लिए कोई बात नहीं है।

@ qwerty19106 आपके उदाहरण में a और b .bss में जगह होगी। एलएलवीएम undef मानों को मानता है, जैसे MaybeUninit::uninitialized() , शून्य के रूप में जब एक सेक्शन में किस वेरिएबल में जाना होगा।

यदि A::new() len से 1 तक तो b .data में समाप्त हो जाते। यदि static में कोई भी गैर-शून्य मान है तो चर .data । पैडिंग को शून्य मान के रूप में माना जाता है।

एलएलवीएम यही करता है। जंग कोई ~ गारंटी नहीं देता है ~ वादे (*) जिसके बारे में लिंकर खंड static चर में जाएगा। यह सिर्फ एलएलवीएम के व्यवहार को विरासत में मिला है।

(*) जब तक आप #[link_section]

मज़ेदार तथ्य: कुछ बिंदु माना जाता LLVM पर undef एक गैर शून्य मान के रूप में तो चर a अपने उदाहरण में समाप्त हो गया में .data । # 41315 देखें।

आपके उत्तर के लिए @japaric धन्यवाद। यह मेरे लिए बहुत ही मददगार रहा।

मेरे पास नया विचार है।
एक कॉल मुख्य से पहले स्थिर mut चर प्रारंभ करने में .init_array अनुभाग का उपयोग कर सकते हैं।

यह अवधारणा का प्रमाण है:

#[macro_export]
macro_rules! static_singleton {
    ($name_var: ident, $ty:ty, $name_init_fn: ident, $name_init_var: ident, $init_block: block) => {
        static mut $name_var: MaybeUninit<$ty> = unsafe {MaybeUninit::uninitialized()};

        extern "C" fn $name_init_fn() {
            unsafe {
                $init_block
            }
        }

        #[link_section = ".init_array"]
        #[used]
        static $name_init_var: [extern "C" fn(); 1] = [$name_init_fn];
    };
}

परीक्षण कोड :

static_singleton!(A, u8, a_init_fn, A_INIT_VAR, {
    let ptr = A.get_mut();
    *ptr = 5;
});

fn main() {
    println!("A inited to {}", unsafe {&A.get_ref()});
}

परिणाम : 5 के लिए एक inित

पूर्ण उदाहरण : खेल का मैदान

अनारक्षित प्रश्न :
मैं concat_idents उपयोग नहीं कर सका a_init_fn पैदा करते हैं और A_INIT_VAR करने के लिए। ऐसा लगता है कि # 1628 अभी तक उपयोग के लिए तैयार नहीं है।

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

क्यों जंग का उपयोग नहीं करते .init_array अनुभाग? यह एलएलएफ प्रारूप ( लिंक ) का बड़ा खंड है।

@ qwerty19106 क्योंकि मुख्य () से पहले का जीवन एक मिसफिट माना जाता है और रुस्त के शब्दार्थ से स्पष्ट रूप से विघटित हो गया था।

ठीक है, यह अच्छा लंग डिज़ाइन है।

लेकिन # [no_std] में अब हमारे पास अच्छा विकल्प नहीं है (शायद मैं बुरा खोज रहा था)।

हम स्पिन का उपयोग कर सकते हैं ऑर्डरिंग :: प्रत्येक संदर्भ प्राप्त करने पर

मैं एम्बेडेड पर एक संकलन-समय की जांच करना चाहूंगा।

यह बहुत महंगा है (हर संदर्भ में Ordering::SeqCst )।

यह मेरे लिए सही नहीं लगता है। सभी "एक बार" सार तक पहुँचने पर आराम नहीं होना चाहिए, और आरंभीकरण पर सिंक्रनाइज़ करें? या मैं कुछ और सोच रहा हूं?
cc @Amanieu @alexcrichton

@ qwerty19106 :

जब आप "एम्बेडेड" कहते हैं, तो क्या आप नंगे-धातु का उल्लेख कर रहे हैं? यह ध्यान देने योग्य है कि .init_array वास्तव में, ELF प्रारूप का हिस्सा नहीं है part - यह सिस्टम V ABI का हिस्सा भी नहीं है जो इसे विस्तारित करता है; केवल .init है। आपको सिस्टम V ABI ड्राफ्ट अपडेट मिलने तक .init_array नहीं मिलते हैं, जो Linux ABI को विरासत में मिलता है।

नतीजतन, यदि आप नंगे धातु पर चल रहे हैं, तो .init_array भी आपके उपयोग के मामले के लिए मज़बूती से काम नहीं कर सकते हैं - आखिरकार, यह डायनेमिक लोडर और / या libc में कोड द्वारा गैर-नंगे-धातु पर लागू किया जाता है। जब तक आपका बूटलोडर .init_array में संदर्भित कोड चलाने की जिम्मेदारी नहीं लेता, तब तक वह कुछ भी नहीं करेगा।

1: पृष्ठ 28 देखें, आंकड़ा 1-13 "विशेष अनुभाग"
२: पृष्ठ ६३ देखें, ४-१३ का आंकड़ा "विशेष खंड (जारी)"

@eddyb आप एक की जरूरत है Acquire बहुत कम जब पढ़ने पर लोड Once । यह x86 पर एक सामान्य भार और ARM पर लोड + बाड़ है।

वर्तमान कार्यान्वयन load(SeqCst) का उपयोग करता है, लेकिन व्यवहार में यह सभी आर्किटेक्चर पर load(Acquire) के समान ही उत्पन्न करता है।

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

Am 13. सितंबर 2018 00:59:20 MESZ schrieb Amanieu सूचनाएं @github.com:

@ हेड्डी आपको पढ़ने के दौरान बहुत कम से कम Acquire लोड की आवश्यकता होती है
Once । यह x86 पर एक सामान्य भार और ARM पर लोड + बाड़ है।

वर्तमान कार्यान्वयन load(SeqCst) का उपयोग करता है, लेकिन व्यवहार में यह
सभी आर्किटेक्चर पर load(Acquire) रूप में समान एश उत्पन्न करता है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें:
https://github.com/rust-lang/rust/issues/53491#issuecomment -420825802

MaybeUninit मास्टर में उतरा है और अगले रात में होगा। :)

https://github.com/rust-lang/rust/issues/54470 Box<[MaybeUninit<T>]> RawVec<T> का उपयोग करने का प्रस्ताव करता है। कम संप्रेषण वाले बक्से और स्लाइस के साथ इसे और संभवतः अन्य दिलचस्प संयोजनों को सक्षम करने के लिए, शायद हम मानक पुस्तकालय में कुछ और एपीआई जोड़ सकते हैं?

आरंभिक के बिना आवंटित करने के लिए विशेष रूप से (मुझे लगता है कि Box::new(MaybeUninit::uninitialized()) अभी भी size_of::<T>() बाइट्स की नकल करेगा?):?

impl<T> Box<MaybeUninit<T>> {
    pub fn new_uninit() -> Self {…}
    pub unsafe fn assert_init(s: Self) -> Box<T> { transmute(s) }
}

impl<T> Box<[MaybeUninit<T>]> {
    pub fn new_uninit_slice(len: usize) -> Self {…}
    pub unsafe fn assert_init(s: Self) -> Box<[T]> { transmute(s) }
}

core::slice / std::slice , उप-स्लाइस लेने के बाद उपयोग किया जा सकता है:

pub unsafe fn assert_init<T>(s: &[MaybeUninit<T>]) -> &[T] { transmute(s) }
pub unsafe fn assert_init_mut<T>(s: &mut [MaybeUninit<T>]) -> &mut [T] { transmute(s) }

मुझे लगता है कि बॉक्स :: नया (शायद यूनीटाइन :: अनइंस्टाल्यूटेड ()) अभी भी size_of कॉपी करेगा ::() पैडिंग बाइट्स

यह नहीं होना चाहिए, और वहाँ एक codegen परीक्षण है कि परीक्षण करने का इरादा है।

पैडिंग बाइट्स को कॉपी करने की ज़रूरत नहीं है क्योंकि उनका बिट प्रतिनिधित्व मायने नहीं रखता है (कुछ भी जो बिट प्रतिनिधित्व को दर्शाएगा यूबी वैसे भी है)।

ठीक है, तो शायद Box::new_uninit अनावश्यक है? स्लाइस संस्करण अलग है, हालांकि, Box::new लिए T: Sized आवश्यकता होती है।

मैं MaybeUninit::zeroed लिए वकालत करना चाहूँगा const fn । कुछ एफएफआई-संबंधित उपयोग हैं जो मैं इसके लिए होगा (उदाहरण के लिए एक स्थिर जिसे शून्य से आरंभ किया जाना चाहिए) और मेरा मानना ​​है कि अन्य लोग इसे उपयोगी पा सकते हैं। मैं zeroed फ़ंक्शन को कॉन्स्टेबल करने के लिए अपना समय स्वेच्छा से खुश करूंगा।

@mjbshaw को आपके लिए #[rustc_const_unstable(feature = "const_maybe_uninit_zeroed")] का उपयोग करने की आवश्यकता होगी क्योंकि zeroed ऐसी चीज़ें करता है जो min_const_fn चेक पास नहीं करती (https://github.com/rust-lang/ जंग / मुद्दों / 53555) जिसका अर्थ है कि MaybeUninit::zeroed 'की गति स्थिर है, भले ही फ़ंक्शन स्थिर हो।

क्या इसे लागू करने / स्थिरीकरण को कुछ चरणों में विभाजित किया जा सकता है, ताकि व्यापक इकोसिस्टम को जल्द से जल्द IFUninit प्रकार उपलब्ध कराया जा सके? कदम हो सकते हैं:

1) IFUninit जोड़ें
2) मेम के सभी उपयोगों को रूपांतरित करें :: असिंचित / शून्य और पदावनत

@scottjmaddox

IFUninit जोड़ें

https://doc.rust-lang.org/nightly/core/mem/union.MaybeUninit.html :)

अच्छा! तो क्या हो सकता है योजना को स्थिर करना ASUninit ASAP?

अगला कदम यह पता लगाना है कि https://github.com/rust-lang/rust/pull/54668 इतनी अच्छी तरह से (कुछ बेंचमार्क में) रिग्रेस करता है। मेरे पास इस सप्ताह देखने के लिए अधिक समय नहीं होगा, हालांकि अगर कोई और देख सकता है तो वह खुश होगा। : डी

इसके अलावा, मुझे नहीं लगता कि हमें इसमें जल्दबाज़ी करनी चाहिए। हमें अनलिमिटेड डेटा को गलत तरीके से हैंडल करने के लिए अंतिम एपीआई मिला है, चलो जल्दी नहीं है और फिर से पेंच करें। ;)

उस ने कहा, मैं किसी भी अनावश्यक देरी को नहीं जोड़ना चाहूंगा, ताकि हम अंत में पुराने फुटगन को हटा सकें। :)

ओह, और कुछ और ही मेरे साथ हुआ ... https://github.com/rust-lang/rust/pull/54667 के साथ, पुराने एपीआई वास्तव में कुछ सबसे खराब फुटगनों के खिलाफ की रक्षा करते हैं। मुझे आश्चर्य है कि अगर हम MaybeUninit लिए भी कुछ प्राप्त कर सकते हैं? यह स्थिरीकरण को अवरुद्ध नहीं कर रहा है, लेकिन हम एक निर्जन प्रकार पर कॉल करने पर MaybeUninit::into_inner घबराहट करने का तरीका खोजने की कोशिश कर सकते हैं। डिबग बिल्ड में, मैं *x घबराने की कल्पना भी कर सकता हूं जब x: &[mut] T T निर्जन के साथ।

स्थिति अद्यतन: https://github.com/rust-lang/rust/pull/54668 के साथ प्रगति करने के लिए, हमें संभावना है कि किसी को यूनियनों के लिए लेआउट कम्प्यूटेशन को ट्वीक करने की आवश्यकता होगी। @ हेडब संरक्षक के लिए तैयार है, लेकिन हमें कार्यान्वयन करने के लिए किसी की आवश्यकता है। :)

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

pub unsafe fn take(&mut self) -> T

क्या मैं इसे प्रस्तुत करूंगा?

@shepmaster यह मौजूदा into_inner पद्धति के समान लगता है। शायद हम यहां नकल से बचने की कोशिश कर सकते हैं?

इसके अलावा "के साथ प्रतिस्थापित" होने की संभावना है गलत चित्र यहां, यह self की सामग्री को बिल्कुल भी नहीं बदलना चाहिए। बस स्वामित्व को स्थानांतरित कर दिया जाता है, इसलिए यह अब प्रभावी रूप से उसी स्थिति में है जब अनैतिक रूप से निर्माण किया गया हो।

self को बिल्कुल बदलें

निश्चित रूप से, इसलिए कार्यान्वयन मूल रूप से ptr::read , लेकिन उपयोग के दृष्टिकोण से मैं इसे एक असमान मूल्य वाले वैध मूल्य के प्रतिस्थापन के रूप में तैयार करने के लिए प्रोत्साहित करूंगा।

नकल से बचें

मुझे कोई सख्त आपत्ति नहीं है, जैसा कि मुझे उम्मीद है कि एक के कार्यान्वयन से दूसरे को फोन आएगा। मुझे अभी पता नहीं है कि अंतिम स्थिति क्या होगी।

मुझे लगता है कि into_inner एक तरह से बहुत ही निर्दोष फ़ंक्शन नाम है। लोग, शायद डॉक्स को भी ध्यान से पढ़े बिना, अभी भी MaybeUninit::uninitialized().into_inner() । क्या हम was_initialized_unchecked जैसी किसी चीज़ का नाम बदल सकते हैं या यह इंगित करता है कि डेटा आरंभ होने के बाद आपको केवल इसे कॉल करना चाहिए?

मुझे लगता है कि शायद take पर लागू होता है।

जबकि थोड़ा अजीब है, unchecked_into_initialized जैसे कुछ काम हो सकता है?

या उन तरीकों को पूरी तरह से हटा दिया जाना चाहिए और डॉक्स x.as_ptr().read() साथ उदाहरण देते हैं?

@SimonSapin into_inner self उपभोग करता है, जो अच्छा है।

लेकिन @shepmaster के take , as_mut_ptr().read() भी ऐसा ही होगा ... हालाँकि निश्चित रूप से फिर आप एक उत्परिवर्ती सूचक के साथ भी क्यों परेशान होंगे?

कैसे take_unchecked और into_inner_unchecked ?

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

दोनों जोर देकर कहा कि इसे शुरू करना होगा और यह बताता है कि यह क्या करता है (पूर्ववत / in_inner / etc।) एक नाम में बल्कि अस्पष्ट हो जाता है, इसलिए कैसे बस assert_initialized साथ पूर्व कर रहा है और बाद को छोड़ रहा है। हस्ताक्षर से निहित है? unchecked_assert_initialized तरह रनटाइम चेक लगाने से बचने के लिए assert!() है।

संभव है अनियंत्रित_आसानी_अनुशासित करने के लिए एक रनटाइम जाँच जैसे मुखर लगाने से बचने के लिए! () है।

हम पहले से ही intrinsics::assume(foo) बनाम assert!(foo) माध्यम से मान्यताओं और कथनों में अंतर करते हैं, इसलिए शायद assume_initialized ?

assume अस्थिर एपीआई है, धारणा के एक स्थिर उदाहरण बनाम जोर unreachable_unchecked unreachable और get_unchecked बनाम get । इसलिए मुझे लगता है कि unchecked सही अवधि है।

मैं कहता हूँ कि foo_unchecked केवल तभी समझ में आता है जब वहाँ एक समान foo , अन्यथा फ़ंक्शन का सरासर स्वभाव unsafe होना मुझे इंगित करता है कि कुछ "अलग" चल रहा है पर।

_{यह बिकेशेड स्पष्ट रूप से गलत रंग है}

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

@RalfJung

मुझे लगता है कि into_inner एक तरह से बहुत ही निर्दोष फ़ंक्शन नाम है। लोग, शायद डॉक्स को भी ध्यान से पढ़े बिना, अभी भी MaybeUninit::uninitialized().into_inner() । क्या हम was_initialized_unchecked जैसी किसी चीज़ का नाम बदल सकते हैं या यह इंगित करता है कि डेटा आरंभ होने के बाद आपको केवल इसे कॉल करना चाहिए?

I _ वास्तव में _ इस विचार की तरह; मुझे दृढ़ता से लगता है कि यह दोनों शब्दार्थों के बारे में सही बात कहता है और यह संभावित रूप से खतरनाक है।

@rkruppe

दोनों जोर देकर कहा कि इसे शुरू करना होगा और यह बताता है कि यह क्या करता है (पूर्ववत / in_inner / etc।) एक नाम में बल्कि अस्पष्ट हो जाता है, इसलिए कैसे बस assert_initialized साथ पूर्व कर रहा है और बाद को छोड़ रहा है। हस्ताक्षर से निहित है? unchecked_assert_initialized जैसे रनटाइम चेक लगाने से बचने के लिए assert!() है।

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

याद रखें कि अधिकांश लोग संभवतः किसी न किसी रूप में स्वत: पूर्ण के साथ IDE का उपयोग कर रहे हैं, इसलिए एक लंबा नाम एक मामूली रोडमैप है।

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

@ शेरेमास्टर श्योर; मैं आईडीई का उपयोग ऑटो पूरा करने के साथ ही करता हूं; लेकिन मुझे लगता है कि unchecked साथ एक लंबा नाम unsafe ब्लॉक के अंदर शामिल है जो कि खुद को कुछ अतिरिक्त ठहराव देगा।

@rkruppe

एक चैट सिस्टम में उन्हें मेमोरी से टाइप करना ... कम अच्छा है (मैं इस बिंदु के बारे में आधा मजाक कर रहा हूं, लेकिन केवल आधा)।

मैं उस व्यापार को बंद कर दूंगा। अगर कोई नाम कुछ खास है जो इसे और भी यादगार बना सकता है। ;)

कोई भी (या समान नाम जिसमें एक ही शब्दार्थ अर्थ शामिल हैं):

• was_initialized_unchecked
• was_initialized_into_inner_unchecked
• is_initialized_unchecked
• is_initialized_into_inner_unchecked
• was_init_unchecked
• was_init_into_inner_unchecked
• is_init_unchecked
• is_init_into_inner_unchecked
• assume_initialized_unchecked
• assume_init_unchecked

मेरे द्वारा ठीक हैं

initialized_into_inner बारे में क्या? या initialized_into_inner_unchecked , अगर आपको लगता है कि unchecked वास्तव में आवश्यक है, हालांकि मैं @shepmaster से सहमत unchecked केवल कुछ अन्य के _checked और वैरिएंट से अलग करने के लिए आवश्यक है कार्यक्षमता, जहां रनटाइम चेक नहीं हो रहे हैं।

जब स्व-उधार जनरेटर को मैन्युअल रूप से लागू करते हुए मैंने ptr::drop_in_place(maybe_uninit.as_mut_ptr()) कई बार उपयोग किया, तो ऐसा लगता है कि यह एक अंतर्निहित विधि unsafe fn drop_in_place(&mut self) MaybeUninit पर अच्छी तरह से काम करेगा।

ManuallyDrop::drop साथ मिसाल है।

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

मुझे नहीं लगता कि असुरक्षित संस्करण से चेतावनी के संकेत को हटाने के लिए एक सुरक्षित संस्करण नहीं है।

असुरक्षित संस्करण से चेतावनी साइन हटा दें

एक बालक होने के नाते, जब unsafe फ़ंक्शन _unchecked नहीं होना चाहिए, तब अंत में अटक गया? एक ही बात कहने वाले दो चेतावनियों का क्या मतलब है?

यह एक उचित सवाल है। :) लेकिन मुझे लगता है कि उत्तर "लगभग कभी नहीं" है, और मुझे वास्तव में पछतावा है कि हमारे पास offset संकेत पर असुरक्षित फ़ंक्शन के रूप में है जो किसी भी तरह से व्यक्त नहीं करता है कि यह असुरक्षित है। इसका शाब्दिक होने के लिए नहीं है unchecked , लेकिन IMO वहाँ कुछ किया जाना चाहिए। जब मैं वैसे भी एक असुरक्षित ब्लॉक में हूँ और गलती से लिख .offset के बजाय .wrapping_offset , मैं संकलक है कि मैं बनाने का इरादा नहीं था करने के लिए एक वादा कर दिया।

बिंदुओं पर असुरक्षित कार्य के रूप में जो किसी भी तरह से व्यक्त नहीं करता है कि यह असुरक्षित है

यह इस स्तर पर मेरी धूर्तता को दर्शाता है।

@shepmaster तो आपको नहीं लगता कि यह वास्तविक है कि कोई मौजूदा unsafe ब्लॉक (शायद एक बड़ा, शायद एक बड़े unsafe fn के अंदर कोड को संपादित करेगा जिसका निहितार्थ unsafe ब्लॉक), और पता नहीं है कि वे जो कॉल जोड़ रहे हैं वह unsafe ?

कोई मौजूदा unsafe ब्लॉक [...] के अंदर कोड संपादित करेगा और इस बात से अवगत नहीं होगा कि वे जो कॉल जोड़ रहे हैं वह unsafe

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

हो सकता है कि यह एक विफलता है कि हम पीछे की ओर संगत तरीके से तय नहीं कर सकते हैं और शब्दों को नामों में जोड़ना एकमात्र संभव समाधान है, लेकिन मुझे उम्मीद है कि ऐसा नहीं होगा।

शायद एक बड़ा एक, शायद एक बड़े unsafe fn जिसका निहितार्थ unsafe ब्लॉक है

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

अब, अगर रुस के कुछ पहलू असुरक्षित ब्लॉकों को "जरूरत" से बड़ा होने के लिए मजबूर करते हैं, तो शायद यह भी एक अधिक मौलिक मुद्दे को इंगित करता है।

एक तरफ के रूप में, मुझे आश्चर्य है कि आईडीई + आरएलएस असुरक्षित के रूप में चिह्नित किसी भी फ़ंक्शन की पहचान कर सकते हैं और विशेष रूप से उन पर प्रकाश डाल सकते हैं। मेरे संपादक ने पहले से ही unsafe कीवर्ड पर प्रकाश डाला है।

अब, अगर रुस के कुछ पहलू असुरक्षित ब्लॉकों को "जरूरत" से बड़ा होने के लिए मजबूर करते हैं, तो शायद यह भी एक अधिक मौलिक मुद्दे को इंगित करता है।

वैसे वहाँ https://github.com/rust-lang/rfcs/pull/2585;) है

एक तरफ के रूप में, मुझे आश्चर्य है कि आईडीई + आरएलएस असुरक्षित के रूप में चिह्नित किसी भी फ़ंक्शन की पहचान कर सकते हैं और विशेष रूप से उन पर प्रकाश डाल सकते हैं।

वह महान होगा! सभी लोग केवल IDEs में कोड नहीं पढ़ते हैं - हालाँकि, समीक्षाएँ आमतौर पर IDEs में नहीं की जाती हैं।

अब, अगर रुस के कुछ पहलू असुरक्षित ब्लॉकों को "जरूरत" से बड़ा होने के लिए मजबूर करते हैं, तो शायद यह भी एक अधिक मौलिक मुद्दे को इंगित करता है।

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

काफी 'ताकतों' नहीं, लेकिन निश्चित रूप से 'प्रेरित'।

l जंग-लंग / rfcs # 2585 ;) है

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

हालांकि हर कोई आईडीई में केवल कोड नहीं पढ़ता है

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

मुझे लगता है कि मेरी समस्या यह है कि, प्रभावी रूप से , आप इसके लिए वकालत कर रहे हैं:

unsafe fn unsafe_real_name_of_function() { ... }
          ^~~~~~ for humans
^~~~~~           for the compiler

यह आपको कोड पढ़ते समय हर असुरक्षित फ़ंक्शन को स्पष्ट रूप से देखने की अनुमति देता है। पुनरावृत्ति मुझे बहुत परेशान करती है और इंगित करती है कि कुछ उप-विषयी है।

यह आपको कोड पढ़ते समय हर असुरक्षित फ़ंक्शन को स्पष्ट रूप से देखने की अनुमति देता है। पुनरावृत्ति मुझे बहुत परेशान करती है और इंगित करती है कि कुछ उप-विषयी है।

मै समझता हुँ। आप इस पुनरावृत्ति को 4-आंखों के सिद्धांत को लागू करने के रूप में भी देख सकते हैं, जहां कंपाइलर दो आंखों की आपूर्ति करता है। ;)

@shepmaster मुझे लगता है कि यह थोड़ा बंद हो रहा है, लेकिन IMO मूल बिंदु यह है कि यह स्पष्ट नहीं है कि इस पद्धति के अपरिवर्तनीय क्या हैं - यानी unsafe कोड वास्तव में UB नहीं है , सरल नाम के साथ।

मैं मानता हूं कि "अनियंत्रित" सबसे अच्छा विकल्प नहीं है, लेकिन यह "आसानी से उल्लंघन करने वालों" के रूप में मिसाल है।

इससे मुझे लगता है कि हमारे पास initialized_or_ub की तर्ज पर एक नामकरण सम्मेलन था।

मुझे लगता है कि यह थोड़ा बंद हो रहा है

मैं खुद ऐसा कहने वाला था। मैंने कहा है कि मेरा टुकड़ा (और जाहिर है कोई मुझसे सहमत नहीं है), इसलिए मैं इसे झूठ बोलने दूंगा; आप जो भी चाहते हैं, उसे चुनें।

हमारे पास initialized_or_ub की तर्ज पर एक नामकरण सम्मेलन था

आप maybe_uninit(ialized) तरह मतलब है? कुछ है कि मोटे तौर पर किसी भी तरह से संबंधित तरीकों का एक सेट के लिए लागू किया जा सकता है? 😇

नहीं, मेरा मतलब है unwrap_or_else - पद्धति के नाम में "दुखी मामले" में क्या होता है।

@ हेड्डी अरे यह इतना बुरा नहीं है ... .initialized_or_unsound शायद?

सामान्य तौर पर, पहचानकर्ता नामों में टाइप जानकारी जोड़ने को एक एंटी-पैटर्न माना जाता है (जैसे foo_i32 , bar_mutex , baz_iterator ) क्योंकि यही प्रकार हैं।

फिर भी जब यह कार्यों की बात आती है, भले ही unsafe fn प्रकार का हिस्सा हो, _unchecked , _unsafe , _you_better_know_what_you_are_doing दिखाई देता है। बहुत आम हो।

मुझे आश्चर्य है, यह मामला क्यों है?

इसके अलावा, FYI करें, एक मुद्दा है (https://github.com/rust-analyzer/rust-analyzer/issues/190) rust-analyzer यह उजागर करने के लिए कि क्या कार्य unsafe या नहीं। संपादकों और IDE को उन ऑपरेशनों पर जोर देने में सक्षम होना चाहिए जिनके लिए unsafe unsafe ब्लॉक के लिए unsafe आवश्यकता होती है, जिसमें न केवल unsafe फ़ंक्शंस शामिल हैं (स्वतंत्र रूप से चाहे वे एक पहचानकर्ता के साथ प्रत्यय हों, जैसे,) उदाहरण के लिए, _unchecked या नहीं), लेकिन कच्चे पॉइंटर्स, इत्यादि को भी संदर्भित कर रहे हैं।

यकीनन, rust-analyzer अभी तक ऐसा नहीं कर सकते हैं (EDIT: intellij-Rust तरह का: https://github.com/intellij-rust/intellij-rust/issues/3013#issuecomod-440442306), लेकिन यदि आशय यह स्पष्ट करना है कि unsafe ब्लॉक के अंदर इसे कॉल करने के लिए unsafe आवश्यकता होती है, सिंटैक्स हाइलाइटिंग किसी भी चीज़ के साथ यह प्रत्यय करने का एक संभावित विकल्प है। मेरा मतलब है, यदि आप वास्तव में अभी यह चाहते हैं, तो आप शायद इस फ़ंक्शन का नाम "सिंटैक्स" के रूप में अपने वाक्यविन्यास हाइलाइटर में कुछ मिनटों में जोड़ सकते हैं और इसे एक दिन कह सकते हैं।

@gnzlbg

सामान्य तौर पर, पहचानकर्ता नामों में टाइप जानकारी जोड़ने को एक एंटी-पैटर्न माना जाता है (जैसे foo_i32 , bar_mutex , baz_iterator ) क्योंकि यही प्रकार हैं।

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

फिर भी जब यह कार्यों की बात आती है, भले ही unsafe fn प्रकार का हिस्सा हो, _unchecked , _unsafe , _you_better_know_what_you_are_doing दिखाई देता है। बहुत आम हो।

मुझे आश्चर्य है, यह मामला क्यों है?

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

इसके अलावा, FYI करें, rust-analyzer में एक मुद्दा ( जंग-विश्लेषक / जंग-विश्लेषक # 190 ) है, यह उजागर करने के लिए कि क्या कार्य unsafe या नहीं। संपादकों और IDE को उन ऑपरेशनों पर जोर देने में सक्षम होना चाहिए जिनके लिए unsafe unsafe ब्लॉक के लिए unsafe आवश्यकता होती है, जिसमें न केवल unsafe फ़ंक्शंस शामिल हैं (स्वतंत्र रूप से चाहे वे एक पहचानकर्ता के साथ प्रत्यय हों, जैसे,) उदाहरण के लिए, _unchecked या नहीं), लेकिन कच्चे पॉइंटर्स, इत्यादि को भी संदर्भित कर रहे हैं।

यकीनन, rust-analyzer अभी तक ऐसा नहीं कर सकते हैं, लेकिन यदि इरादा यह स्पष्ट करना है कि unsafe ब्लॉक के अंदर इसे कॉल करने के लिए unsafe आवश्यकता होती है, तो सिंटैक्स हाइलाइटिंग प्रत्यय के लिए एक संभावित विकल्प है किसी भी चीज़ के साथ।

यह सब बहुत बढ़िया है। हालाँकि, जैसा @RalfJung ने उल्लेख किया है: "हर कोई केवल IDEs में कोड नहीं पढ़ता है - हालांकि, समीक्षाएँ आमतौर पर IDEs में नहीं की जाती हैं।" यह मुझे संभावना नहीं है कि GitHub अपने UI में जंग-विश्लेषक को एम्बेड करेगा ताकि यह दिखाया जा सके कि एक तथाकथित फ़ंक्शन / ऑपरेशन असुरक्षित है या नहीं।

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

उदाहरण के लिए, यदि आप मुंडन में असुरक्षित क्रिप्टोग्राफिक ऑपरेशन का उपयोग करना चाहते हैं, तो आपको निम्न करना होगा:

• इसे insecure मॉड्यूल से आयात करें
• जब भी आप उस ऑपरेशन का उपयोग करते हैं, तब allow(deprecated) लिखें या बस संकलित चेतावनी के साथ रहें
• कोड लिखें जो let mut hash = InsecureSha1::default(); hash.insecure_write(bytes); ... जैसा दिखता है

यह सब यहाँ और अधिक विस्तार से प्रलेखित

पूरी तरह से गंभीर सुझाव

चूँकि हम 95% इस प्रकार के लोगों के दुरुपयोग के बारे में चिंतित हैं, और केवल 5% लंबे नामों के बारे में चिंतित हैं, आइए MaybeUninitialized प्रकार का नाम बदलकर शुरू करें। अतिरिक्त 7 वर्ण इसके लायक हैं।

ज्यादातर गंभीर सुझाव

1. उपयोगकर्ताओं को समाप्त करने के लिए घर पर वास्तव में हथौड़ा करने के लिए इसे MaybeUninitializedOrUndefinedBehavior का नाम दें।

2. इस प्रकार के विकल्प के लिए कोई विधि

   MaybeUninitializedOrUndefinedBehavior::into_inner(value)
   

मूर्खतापूर्ण सुझाव

MaybeUninitializedOrUndefinedBehaviorReadTheDocsAllOfThemYesThisMeansYou

खैर ... सच में, MaybeUninitializedOrUndefinedBehavior प्रकार में एक लंबा नाम होने से मुझे गलत लगता है। यह ऑपरेशन .into_inner() है जिसे अच्छे नाम की आवश्यकता है क्योंकि यह संभावित समस्याग्रस्त बिट है जिसे अतिरिक्त ध्यान देने की आवश्यकता है। कोई विधियाँ होने से अच्छा विचार नहीं हो सकता। MaybeUninit::initialized_or_undefined(foo) बहुत स्पष्ट लगता है।

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

याद रखें कि अधिकांश लोग संभवतः किसी न किसी रूप में स्वत: पूर्ण के साथ IDE का उपयोग कर रहे हैं, इसलिए एक लंबा नाम एक मामूली रोडमैप है।

जब तक आरएलएस अधिक कार्यात्मक है, यह मेरे लिए कम से कम नहीं है।

मुझे लगता है कि हम में से अधिकांश सहमत हैं

• अधिक वर्णनात्मक नाम अच्छे हैं

• कम एर्गोनोमिक नाम खराब हैं

और सवाल यह है कि तनाव में होने पर चीजों को कैसे हल किया जाए।

यहां तक ​​कि मुझे लगता है कि into_inner विशेष रूप से इस पद्धति का एक बुरा नाम है (फैंसी शब्द का उपयोग करने के लिए, यह पारेतो सीमा पर नहीं है)। सामान्य सम्मेलन यह है कि हमारे पास into_inner जब Foo<T> में ठीक एक T , और आप इसे बाहर निकालना चाहते हैं। लेकिन यह MaybeUninit<T> का सच नहीं है। इसमें शून्य या एक T s शामिल हैं।

तो एक कम बुरा विकल्प, कम से कम, इसे unwrap , या शायद unwrap_unchecked कहना होगा।

मुझे भी लगता है कि from_initialized या from_initialized_unchecked ध्वनि ठीक है, हालांकि "से" आमतौर पर स्थिर तरीकों के नामों में प्रकट होता है।

शायद unwrap_initialized_unchecked ठीक होगा?

इसे take_initialized कॉल करें और इसे &mut self बजाय self । नाम यह स्पष्ट करता है कि यह आंतरिक मूल्य को आरंभिक होने की उम्मीद करता है। MaybeUninit , unsafe और इस तथ्य के संदर्भ में कि यह Option / Result करता है, यह भी स्पष्ट करता है कि यह ऑपरेशन अनियंत्रित है।

एक &mut self होने से यह एक फुटगन की तरह प्रतीत होता है, जिससे यह ट्रैक करना आसान हो जाता है कि क्या आप शब्दार्थ MaybeUninit बाहर चले गए हैं।

वैकल्पिक नाम: चूंकि यह वास्तव में into imply, शायद into_initialized_unchecked नाम के तरीकों की तरह ही चलती है?

यह होने में एक & mut स्वयं लगता है कि एक फुटगन की तरह यह ट्रैक को खोना आसान बनाता है चाहे आप शब्दार्थ से बाहर चले गए हों।

यह एक ऐसा तरीका है, जिसका अनुरोध किया गया है , और जब तक आप ट्रैक करते हैं अन्यथा यह दो बार नहीं होता है, यह ठीक है।

और यह उधार लेने और लेने वाले दोनों प्रकारों के लायक नहीं लगता है।

मुझे take_initialized , या अधिक स्पष्ट संस्करण take_initialized_unchecked ।

आइए शायद प्रकार को नाम देकर शुरू करें

पीआर तैयार करने के लिए कोई भी?

पीआर तैयार करने के लिए

जब से मैंने इसे सुझाया है, मैं अपने भयानक sed कौशल का उपयोग कर सकता हूं ;-)

मुझे लगता है कि यह into_inner पद्धति को कॉल करने के लिए एक सुधार होगा, जो इस बात पर जोर देता है कि यह मानता है कि इसे आरंभीकृत किया गया है, लेकिन मुझे लगता है कि unchecked का जोड़ बहुत ही अच्छा और अप्रभावी है। हमारे पास उपयोगकर्ताओं को सूचित करने का एक तरीका है कि असुरक्षित कार्य असुरक्षित हैं: यदि हम उन्हें असुरक्षित ब्लॉक में नहीं लपेटते हैं तो हम एक संकलक त्रुटि उत्पन्न करते हैं।

संपादित करें: take_initialized अच्छा लगता है

assume_initialized बारे में क्या? यह:

• 'प्रमाण दायित्व' मॉडल से जुड़ता है
• 'धारणाएँ जोखिम भरी हैं' से काफी हद तक जुड़ता है
• केवल दो शब्दों की जरूरत है
• ऑपरेशन के शब्दार्थ अर्थ का वर्णन करता है
• बहुत स्वाभाविक रूप से पढ़ता है
• एलएलवीएम assume आंतरिक की तरह, गलत मान लिया जाए तो UB है

पीआर तैयार करने के लिए कोई भी?

कोई बात नहीं। एफबीआई की टीम ने फैसला किया कि यह इसके लायक नहीं है।

क्या कोई कारण है कि MaybeUninit<T> Copy जब T: Copy ?

@tommit क्योंकि वह MaybeUninit<T> ManuallyDrop<T> पर निर्भर करता है, हमें प्रोग्रामर को गारंटी देनी चाहिए कि जब हमारी संरचना दायरे से बाहर हो जाती है तो आंतरिक मूल्य गिरा दिया जाता है। यदि यह Copy , तो मुझे लगता है कि रुस्ट नए-कॉमर्स के लिए आंतरिक मूल्य T हर समय, याद रखना मुश्किल हो सकता है, या तो संरचना या इसकी प्रतियाँ। इस तरह से यह अधिक बेहूदा मेमोरी लीक पैदा कर सकता है जिसकी हम उम्मीद नहीं कर रहे हैं।

@ luojia65 यह निश्चित नहीं है कि तर्क की लाइन तब लागू होती है जब T स्वयं Copy , भले ही ManuallyDrop और MaybeUninit भी हो।

मुझे नहीं लगता कि इसका कोई कारण है। बस किसी ने #[derive(Copy)] जोड़ने के बारे में नहीं सोचा;)

इसका एक अवलोकन शायद कुछ सूक्ष्म पहलू है:
मेरा मानना ​​है कि भले ही MaybeUninit<T> Copy MaybeUninit<T> होना चाहिए, जब T: Copy , MaybeUninit<T> Clone नहीं होना चाहिए जब T: Clone T Copy ।

अरे हाँ, हम निश्चित रूप से clone कॉल नहीं कर सकते।

मैं ये भूलता रहता हूँ कि Copy: Clone ...

के ठीक यही कारण है, हम लागू कर सकते हैं Clone for MaybeUninit<T> where T: Copy लौटने के आधार पर *self ।

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

ManuallyDrop::drop लिए प्रलेखन कहता है

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

उस शब्द को कैसे बेहतर बनाया जाए, इसके लिए कोई सुझाव, ताकि संभवत: इसे "अनइंस्टॉलिजेनाइजेशन" के साथ भ्रमित न किया जा सके, जो MaybeUninit हैंडल हो?

मेरे शब्दों में, एक गिरा ManuallyDrop<T> नहीं रह गया है एक सुरक्षित T , लेकिन यह एक वैध है T जहाँ तक लेआउट अनुकूलन परवाह ... कम से कम।

"बासी" / "अमान्य", शायद? इसे इनिशियलाइज़ किया गया है ।

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

क्या हम असंवैधानिक रूप से पदावनत करने से पहले शायदUninit को स्थिर कर सकते हैं?

@ राल्फजंग मैं कहूंगा कि वह जगह "से स्थानांतरित" है। FWIW को हमें std::ptr::read में एक ही तरह की शब्दावली का उपयोग करना चाहिए, लेकिन यह बहुत स्पष्ट नहीं है।

@bluss हम कभी भी एक "बेहतर" के बिना व्यापक रूप से इस्तेमाल किए गए कुछ भी नहीं
समाधान "/" प्रवासन पथ "वर्तमान उपयोगकर्ताओं के लिए।

पदावनति चेतावनियाँ यह होनी चाहिए: "X पदावनत है, इसके बजाय Y का उपयोग करें"। हम अगर
एक Y और X का व्यापक रूप से उपयोग नहीं किया जाता है ... तो हमें पकड़ पर विचार करना चाहिए
जब तक हम एक वाई।

अन्यथा, हम वास्तव में एक अजीब संदेश भेज रहे होंगे।

@cramertj "अमान्य" एक अच्छा विकल्प नहीं है, क्योंकि यह अभी भी (चाहिए!) वैधता अपरिवर्तनीय को संतुष्ट करता है।

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

हमें एक बार कुछ करना चाहिए: डी

@RalfJung मुझे नहीं लगता कि "वैधता अपरिवर्तनीय" सबसे (लगभग किसी भी समय?) उपयोगकर्ताओं के शब्दकोश में है - मुझे लगता है कि "अमान्य डेटा" का उल्लेख करना बोलचाल की भाषा में स्वीकार्य है ( ManuallyDrop<T> अब उतना उपयोगी नहीं है एक T )। यह कहते हुए कि इसे कुछ निरूपण अभिप्रायों को बनाए रखना है जो कि अनुकूलन के लिए संकलक का उपयोग करता है, इससे कोई कम अमान्य डेटा नहीं बनता है।

मुझे नहीं लगता कि "वैधता अपरिवर्तनीय" अधिकांश (लगभग किसी भी?) जंग उपयोगकर्ताओं के लेक्सिकॉन में है

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

@shepmaster ने कुछ समय पहले लिखा था

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

pub unsafe fn take(&mut self) -> T

मुझे लगता है कि इसके साथ मेरी सबसे बड़ी चिंता यह है कि इस तरह के फ़ंक्शन के साथ, गैर-प्रतिलिपि डेटा को गलती से कॉपी करना बहुत आसान है। यदि आपको इसकी आवश्यकता है, तो क्या maybe_uninit.as_ptr().read() करना वास्तव में इतना बुरा है?

मुझे लगता है कि मैंने कहीं न कहीं ऐसा सुझाव दिया होगा कि take जगह into_inner । मुझे नहीं लगता है कि यह एक अच्छा विचार है किसी भी अधिक: अधिकांश समय, अतिरिक्त प्रतिबंध कि into_inner self वास्तव में मददगार है।

@RalfJung अंत में, MaybeUninit सभी तरीके असुरक्षित हैं और केवल as_ptr आसपास सुविधा आवरण हैं। हालाँकि, मैं take सबसे आम कार्यों में से एक होने की उम्मीद करता हूं, क्योंकि MaybeUninit प्रभावी रूप से सिर्फ Option जहां टैग बाहरी रूप से प्रबंधित किया जाता है। यह कई मामलों में उपयोगी है, उदाहरण के लिए एक सरणी जहां सभी तत्व आरंभीकृत नहीं होते हैं (जैसे हैश तालिका)।

Https://github.com/rust-lang/rust/pull/57045 में , मैं MaybeUninit दो नए ऑपरेशन जोड़ने का प्रस्ताव कर रहा हूं:

    /// Get a pointer to the first contained values.
    pub fn first_ptr(this: &[MaybeUninit<T>]) -> *const T {
        this as *const [MaybeUninit<T>] as *const T
    }

    /// Get a mutable pointer to the first contained values.
    pub fn first_mut_ptr(this: &mut [MaybeUninit<T>]) -> *mut T {
        this as *mut [MaybeUninit<T>] as *mut T
    }

प्रेरणा और चर्चा के लिए वह पीआर देखें।

zeroed निकालने पर ऐसा लगता है कि इसे केवल MaybeUninit::zeroed().into_inner() द्वारा प्रतिस्थापित किया गया है जो समान चीज़ लिखने के लिए एक समान तरीका बन जाता है। कोई व्यावहारिक परिवर्तन नहीं है। एकात्मक मूल्यों के साथ हमारे बजाय सभी MaybeUninit या समकक्ष यूनियन के मूल्यों में संग्रहीत किए जा रहे सभी अनैतिक डेटा का व्यावहारिक परिवर्तन होता है।

इस कारण से, मैं std::mem::zeroed को रखने पर विचार करूंगा क्योंकि यह एफएफआई में व्यापक रूप से उपयोग किया जाने वाला कार्य है। पदावनति से यह जोरदार चेतावनी होगी, जो इसे हटाए जाने के लगभग समान है, और कम से कम बहुत कष्टप्रद है - इससे #[allow(deprecated)] की बढ़ती संख्या हो सकती है जो अन्य महत्वपूर्ण मुद्दों को छिपा सकती है।

unsafe -मार्क कोड के लिए रस्ट के मॉडल और दिशानिर्देशों को स्पष्ट करने की यह कवायद सुपर उपयोगी है, लेकिन चलो zeroed जैसे बदलावों से बचें, जहां यह कहने के लिए एक नए तरीके का उपयोग करके केवल उसी व्यावहारिक प्रभाव को पुन: उपयोग कर रहा है। ।

@bluss मेरी समझ (जो गलत हो सकती है) यह है कि std::mem:zeroed उतना ही खतरनाक है जितना std::mem::uninitialized , और UB में परिणाम होने की संभावना है। शायद इसका उपयोग बाइट सरणियों को शुरू करने के लिए किया जा रहा है, जो vec![0; N] या [0; N] साथ बेहतर होगा, जिस स्थिति में शायद rustfix नियम को परिवर्तन को स्वचालित करने के लिए जोड़ा जा सकता है? बाइट या पूर्णांक सरणियों को प्रारंभ करने के बाहर, हालांकि, मेरी समझ यह है कि std::mem::zeroed का उपयोग करने का एक अच्छा मौका है जो यूबी को जन्म दे सकता है।

@scottjmaddox std::mem:zeroed साथ UB को आमंत्रित करना बहुत आसान है, लेकिन std::mem::uninitialized विपरीत, कुछ ऐसे प्रकार हैं जिनके लिए std::mem:zeroed पूरी तरह से मान्य है (जैसे, देशी प्रकार, कई FFI से संबंधित) struct s, आदि)। कई unsafe कार्यों की तरह, zeroed() को हल्के से उपयोग नहीं किया जाना है, लेकिन यह लगभग uninitialized() रूप में समस्याग्रस्त नहीं है। मैं एक के लिए MaybeUninit::zeroed().into_inner() बजाय std::mem:zeroed() का उपयोग करने के लिए दुखी होऊंगा, क्योंकि सुरक्षा के मामले में दोनों के बीच कोई अंतर नहीं है और MaybeUninit संस्करण अधिक बेमानी है और थोड़ा कम सुपाठ्य (और जब मुझे असुरक्षित कोड का उपयोग करना चाहिए, तो मैं अत्यधिक मूल्य की देयता)।

@mjbshaw

std :: mem :: uninitialized के विपरीत, कुछ ऐसे प्रकार हैं जिनके लिए std :: mem: zeroed पूरी तरह से मान्य है (उदाहरण के लिए, देशी)

कुछ प्रकार हैं जिनके लिए mem::uninitialized पूरी तरह से सुरक्षित है ( जैसे unit ), जबकि कुछ "देशी" प्रकार हैं (जैसे bool , &T , आदि) ।) जिसके लिए mem::zeroed अपरिभाषित व्यवहार करता है।

यहाँ एक ग़लतफ़हमी प्रतीत होती है कि MaybeUninit किसी भी तरह से अनइंस्टाल्यूटेड मेमोरी के बारे में है (और मैं देख सकता हूँ कि क्यों: "Uninitialized" इसके नाम पर है)।

जिस खतरे को हम रोकने की कोशिश कर रहे हैं, वह एक _invalid_ मूल्य के निर्माण के कारण होता है, क्या _invalid_ मान में सभी शून्य, या असमानकृत बिट्स, या कुछ और होता है (उदाहरण के लिए बिट पैटर्न से bool true या false ) नहीं है, वास्तव में कोई फर्क नहीं पड़ता - mem::zeroed और mem::uninitialized दोनों का उपयोग _invalid_ मान बनाने के लिए किया जा सकता है, और इसलिए मेरे दृष्टिकोण से बहुत अधिक समान रूप से खतरनाक है।

OTOH MaybeUninit::zeroed() और MaybeUninit::uninitialized() _safe_ विधियाँ हैं क्योंकि वे union । MaybeUninit::into_inner unsafe , और इसे कॉल करना केवल _safe_ है अगर पूर्व शर्त कि MaybeUninit<T> में वर्तमान बिट्स T संतुष्ट है। यदि बिट-पैटर्न _invalid_ है, तो व्यवहार अपरिभाषित है। बिट-पैटर्न अमान्य है या नहीं, क्योंकि इसमें सभी शून्य, अनइंस्टाल्यूटेड बिट्स या कुछ और हैं, वास्तव में कोई फर्क नहीं पड़ता।

@ राल्फजंग मैं यह महसूस करना शुरू कर रहा हूं कि MaybeUninit नाम थोड़ा भ्रामक हो सकता है। हो सकता है कि हम इसका नाम बदलकर MaybeInvalid या कुछ इस तरह रखें कि समस्या को हल करने के लिए बेहतर तरीके से हल किया जा सके और खतरों से बचा जा सके। संपादित करें: निम्नलिखित @Centril के सुझाव मैं bikeshed मुद्दे पर पोस्ट किया है।

संपादित करें: एफडब्ल्यूआईडब्ल्यू, मुझे लगता है कि एर्गोनोमिक तरीके (जैसे कि MaybeUninit का उपयोग किए बिना) सुरक्षित रूप से शून्य मेमोरी बनाने के लिए उपयोगी होगा, लेकिन mem::zeroed यह नहीं है। हम Zeroed विशेषता Default समान जोड़ सकते हैं जो केवल उन प्रकारों के लिए कार्यान्वित किया जाता है जिनके लिए सभी शून्य बिट-पैटर्न मान्य हैं या ऐसा कुछ है, जो समान प्रभाव को प्राप्त करने के तरीके के रूप में है mem::zeroed अब करता है, लेकिन इसके नुकसान के बिना।

सामान्य तौर पर, मुझे लगता है कि हमें कार्यक्षमता को तब तक नहीं रोकना चाहिए जब तक कि वर्तमान उपयोगकर्ताओं के लिए एक बेहतर समाधान के लिए एक माइग्रेशन पथ न हो। MaybeUninit mem::zeroed मेरी नज़र में, भले ही यह सही नहीं हो सकता (यह सुरक्षित है, लेकिन यह एर्गोनोमिक के रूप में नहीं है), इसलिए मैं mem::zeroed साथ ठीक हो जाएगा MaybeUninit भूमि, भले ही ऐसा होने से हमारे पास जगह में अधिक एर्गोनोमिक प्रतिस्थापन न हो।

हो सकता है कि हमें इसका नाम बदलकर शायद इनवैलिड या ऐसा कुछ कर देना चाहिए जिससे समस्या को हल किया जा सके और इससे होने वाले खतरों से बचा जा सके।

Https://github.com/rust-lang/rust/pull/56138 में बिकेश किया गया ।

@gnzlbg

कुछ "देशी" प्रकार हैं (जैसे bool

जब तक bool FFI- सुरक्षित है (जिसे आम तौर पर माना जाता है, RFC 954 खारिज होने और फिर अनौपचारिक रूप से आधिकारिक तौर पर स्वीकार किए जाने के बावजूद), इसके लिए mem::zeroed का उपयोग करना सुरक्षित होना चाहिए।

, &T , आदि) जिसके लिए mem::zeroed अपरिभाषित व्यवहार करता है।

हां, लेकिन mem::zeroed लिए UB वाले इन प्रकारों में भी MaybeUninit::zeroed().into_inner() लिए UB है (मैं जानबूझकर .into_inner() को अपनी मूल टिप्पणी में शामिल करता था)। MaybeUninit कुछ भी नहीं जोड़ता है अगर उपयोगकर्ता तुरंत .into_inner() कॉल करता है (जो कि ठीक है कि मैं और कई अन्य लोग क्या करेंगे यदि mem::zeroed पदावनत नहीं किया गया था, क्योंकि मैं केवल mem::zeroed का उपयोग कर रहा हूं

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

मैं इस की बारीकियों में नहीं जाना चाहता था, लेकिन bool FFI- इस अर्थ में सुरक्षित है कि इसे C के _Bool बराबर माना जाता है। हालाँकि, C true के false मान _Bool C मानक में परिभाषित नहीं हैं (हालाँकि वे कुछ दिन हो सकते हैं, शायद C20 में), इसलिए mem::zeroed एक मान्य bool mem::zeroed बनाता है या नहीं तकनीकी रूप से कार्यान्वयन-परिभाषित है।

हां, लेकिन ये प्रकार जो मेम के लिए यूबी हैं :: शून्य भी हो सकते हैं यूबी के लिए शायद यूनुइनिट :: शून्य () ।__नेर () (मैं जानबूझकर शामिल था। मेरी मूल टिप्पणी में .into_inner () शामिल हैं)। हो सकता है अगर उपयोगकर्ता सिर्फ तुरंत कॉल .into_inner () (जो ठीक है कि मैं और कई अन्य क्या करेंगे अगर मेम :: शून्य हटा दिया गया था, तो शायद कुछ भी नहीं जोड़ता है, क्योंकि मैं केवल मेम का उपयोग कर रहा हूँ :: शून्य के लिए प्रकार जो सुरक्षित है) ।

मुझे वास्तव में समझ नहीं आ रहा है कि आप यहां कौन सा मुद्दा बनाने की कोशिश कर रहे हैं। MaybeUninit कॉलिंग या कॉल न करने का विकल्प into_inner , जो mem::zeroed नहीं है, और इसमें मूल्य है क्योंकि वह ऑपरेशन है जो अपरिभाषित व्यवहार का परिचय दे सकता है ( संघ का निर्माण असिंचित या शून्य सुरक्षित है)।

कोई क्यों आँख बंद करके mem::zeroed से MayeUninit + into_inner ? mem::zeroed के डिप्रेशन चेतावनी को "ठीक" करने का यह उपयुक्त तरीका नहीं है, और डिप्रेशन की चेतावनी को शांत करने का एक ही प्रभाव और बहुत कम लागत है।

mem::zeroed से MaybeUninit स्थानांतरित करने का उचित तरीका यह मूल्यांकन करना है कि क्या into_inner कॉल करना सुरक्षित है, जिस स्थिति में कोई भी ऐसा कर सकता है और एक टिप्पणी लिख सकता है, जिसमें बताया गया है कि सुरक्षित है, या बस MaybeUninit union साथ काम करना जारी रखें जब तक into_inner सुरक्षित नहीं हो जाता (एक बहुत कोड बदलने की आवश्यकता हो सकती है जब तक कि मामला नहीं हो, एपीआई ब्रेकिंग करें T s, आदि के बजाय MaybeUninit वापस करने के लिए परिवर्तन)।

मैं इस की बारीकियों में नहीं जाना चाहता था, लेकिन bool FFI- इस अर्थ में सुरक्षित है कि इसे C के _Bool बराबर माना जाता है। हालाँकि, true और false C's _Bool are not defined in the C standard (although they might be some day, maybe in C20), so whether मेम :: शून्य creates a valid bool` या नहीं तकनीकी रूप से कार्यान्वयन-परिभाषित है ।

स्पर्शरेखा जारी रखने के लिए क्षमायाचना, लेकिन C11 के लिए आवश्यक है कि ऑल-बिट्स-सेट-टू-शून्य पूर्णांक प्रकारों के लिए मान 0 का प्रतिनिधित्व करता है (अनुभाग 6.2.6.2 "पूर्णांक प्रकार", पैराग्राफ 5 देखें) (जिसमें _Bool ) । इसके अतिरिक्त, true और false मूल्यों को स्पष्ट रूप से परिभाषित किया गया है (अनुभाग 7.18 "बूलियन प्रकार और मान <stdbool.h> " देखें)।

मुझे वास्तव में समझ नहीं आ रहा है कि आप यहां कौन सा मुद्दा बनाने की कोशिश कर रहे हैं। MaybeUninit कॉलिंग या कॉल न करने का विकल्प into_inner , जो mem::zeroed नहीं है, और इसमें मूल्य है क्योंकि वह ऑपरेशन है जो अपरिभाषित व्यवहार का परिचय दे सकता है ( संघ का निर्माण असिंचित या शून्य सुरक्षित है)।

MaybeUninit और MaybeUninit::zeroed । हम दोनों उस पर सहमत हैं। मैं MaybeUninit::zeroed निकालने के लिए बहस नहीं कर रहा हूँ। मेरा कहना है कि std::mem::zeroed में भी मूल्य है।

कुछ ऐसे प्रकार हैं जिनके लिए मेम :: अनइंस्टॉलिज्ड पूरी तरह से सुरक्षित है (जैसे यूनिट), जबकि कुछ "देशी" प्रकार (जैसे बूल, और टी, आदि) हैं, जिसके लिए मेम :: शून्य इन्वेड अपरिभाषित व्यवहार करता है।

यह एक लाल हेरिंग है। सिर्फ इसलिए कि दोनों zeroed और uninitialized कुछ उप-प्रकारों के लिए मान्य हैं जो उन्हें वास्तविक उपयोग में तुलनीय नहीं बनाते हैं। आपको उन सबसेट के आकार को देखना होगा। उन प्रकारों की संख्या जिनके लिए mem::uninitialized बहुत बहुत कम है (वास्तव में, क्या यह केवल शून्य-आकार के प्रकार हैं?), और कोई भी वास्तव में ऐसा कोड नहीं लिखेगा जो ऐसा करता है (जैसे ZSTs के लिए आप बस उपयोग करेंगे? प्रकार)। दूसरी ओर, कई प्रकार हैं जिनके लिए mem::zeroed मान्य है। mem::zeroed कम से कम निम्नलिखित प्रकारों के लिए मान्य है (आशा है कि मुझे यह अधिकार मिला है):

• सभी पूर्णांक प्रकार ( bool , जैसा कि ऊपर बताया गया है)
• सभी कच्चे सूचक प्रकार
• Option<T> जहां टी ट्रिम एनम लेआउट अनुकूलन को ट्रिगर करता है। T शामिल हैं:
  
  
  
  • NonZeroXXX (सभी पूर्णांक प्रकार)
  
  
  • NonNull<U>
  
  
  • &U
  
  
  • &mut U
  
  
  • fn -पोइंटर्स
  
  
  • इस सूची में किसी भी प्रकार की कोई भी सरणी
  
  
  • कोई भी struct जहां कोई भी फ़ील्ड इस सूची में एक प्रकार है।
  
  
• कोई भी सरणी, struct , या union इस सूची में केवल प्रकारों से मिलकर।

हां, दोनों uninitialized और zeroed संभावित-अवैध मूल्यों के साथ सौदा करते हैं। हालांकि, प्रोग्रामर इन प्राइमिटिव्स को बहुत अलग तरीकों से उपयोग करते हैं।

mem::uninitialized लिए सामान्य पैटर्न है:

let val = MaybeUninit::uninitialized();
initialize_value(val.as_mut_ptr()); // or val.set
val.into_inner()

यदि आप इस तरह से अनधिकृत मूल्यों के अपने उपयोग को नहीं लिख रहे हैं, तो आप सबसे बड़ी गलती कर रहे हैं।

mem::zeroed का सबसे आम उपयोग आज ऊपर वर्णित प्रकारों के लिए है, और यह पूरी तरह से वैध है। मैं पूरी तरह से @bluss से सहमत है कि मैं बदल कर किसी भी footgun की रोकथाम लाभ नहीं दिख रहा है mem::zeroed() हर जगह से MaybeUninit::zeroed().into_inner() ।

संक्षेप में, uninitialized का सामान्य उपयोग उन प्रकारों के लिए है जिनके लिए अमान्य मान हो सकते हैं। zeroed का सामान्य उपयोग उन प्रकारों के लिए है जो शून्य होने पर मान्य हैं।

एक Zeroed विशेषता या समान (जैसे Pod , लेकिन ध्यान दें कि T: Zeroed अर्थ T: Pod ) जैसा कि सुझाव दिया गया है कि इसमें जोड़ना ठीक बात है भविष्य, लेकिन हम fn zeroed<T>() -> T नहीं घटाते जब तक कि हमारे पास वास्तव में fn zeroed2<T: Zeroed>() -> T स्थिर न हों।

@mjbshaw

स्पर्शरेखा जारी रखने के लिए क्षमा याचना, लेकिन C11 के लिए आवश्यक है कि

वास्तव में! यह केवल C ++ का bool जो मान्य मूल्यों को अनिर्दिष्ट छोड़ देता है! मुझे सुधारने के लिए धन्यवाद, इस गारंटी के साथ UC को एक PR भेजें।

@jethrogb

आपको उन सबसेट के आकार को देखना होगा। प्रकारों की संख्या जिसके लिए mem::uninitialized वैध है वह बहुत छोटा है (वास्तव में, क्या यह केवल शून्य-आकार के प्रकार हैं?), और कोई भी वास्तव में ऐसा कोड नहीं लिखता है जो ऐसा करता है (जैसे ZSTs के लिए आप सिर्फ उपयोग करेंगे? प्रकार कंस्ट्रक्टर)।

यह सभी ZSTs के लिए भी सही नहीं है यदि आप गोपनीयता में कारक हैं जिसके साथ ZSTs "कार्य का प्रमाण" या "संसाधन के लिए टोकन" या सामान्य रूप से सिर्फ "प्रमाण गवाह" के रूप में होना संभव है। एक तुच्छ उदाहरण :

mod refl {
    use core::marker::PhantomData;
    use core::mem;

    /// Having an object of type `Id<A, B>` is a proof witness that `A` and `B`
    /// are nominally equal type according to Rust's type system.
    pub struct Id<A, B> {
        witness: PhantomData<(
            // Make sure `A` is Id is invariant wrt. `A`.
            fn(A) -> A,
            // Make sure `B` is Id is invariant wrt. `B`.
            fn(B) -> B,
        )>
    }

    impl<A> Id<A, A> {
        /// The type `A` is always equal to itself.
        /// `REFL` provides a proof of this trivial fact.
        pub const REFL: Self = Id { witness: PhantomData };
    }

    impl<A, B> Id<A, B> {
        /// Casts a value of type `A` to `B`.
        ///
        /// This is safe because the `Id` type is always guaranteed to
        /// only be inhabited by `Id<A, B>` types by construction.
        pub fn cast(self, value: A) -> B {
            unsafe {
                // Transmute the value;
                // This is safe since we know by construction that
                // A == B (including lifetime invariance) always holds.
                let cast_value = mem::transmute_copy(&value);

                // Forget the value;
                // otherwise the destructor of A would be run.
                mem::forget(value);

                cast_value
            }
        }
    }
}

fn main() {
    use core::mem::uninitialized;

    // `Id<?A, ?B>` is a ZST; let's make one out of thin air:
    let prf: refl::Id<u8, String> = unsafe { uninitialized() };

    // Segfault:
    let _ = prf.cast(42u8);
}

@ केंद्र यह एक स्पर्शरेखा की तरह है, लेकिन मुझे यकीन नहीं है कि अगर आपका कोड वास्तव में एक प्रकार का उदाहरण है जिसके लिए uninitialized कॉल करना एक अमान्य मूल्य बनाता है। आप आंतरिक आक्रमणकारियों का उल्लंघन करने के लिए असुरक्षित कोड का उपयोग कर रहे हैं कि Id को बनाए रखना है। ऐसा करने के कई तरीके हैं, उदाहरण के लिए transmute(()) , या टाइप-कास्टिंग रॉ पॉइंटर्स।

@jethrogb मेरी एकमात्र बात यह है कि क) कृपया शब्दों के साथ और अधिक सावधान रहें, ख) गोपनीयता वैधता के बारे में चर्चा करने में पर्याप्त रूप से उचित नहीं लगती है। मुझे ऐसा लगता है कि "आंतरिक आक्रमणकारियों का उल्लंघन" और "अमान्य मूल्य" एक ही बात है; यहाँ एक साइड-कंडीशन है "अगर A != B तो Id<A, B> निर्जन है।"

मुझे ऐसा लगता है कि "आंतरिक आक्रमणकारियों का उल्लंघन" और "अमान्य मूल्य" एक ही बात है; यहाँ एक साइड-कंडीशन है "अगर A != B तो Id<A, B> निर्जन है।"

अपरिवर्तनशीलताओं "पुस्तकालय कोड द्वारा लगाए गए" अपरिवर्तनशीलताओं कई मायनों में "संकलक द्वारा लगाए गए" से अलग कर रहे हैं, को देखने के @RalfJung के ब्लॉग विषय के बारे में पोस्ट । उस शब्दावली में, आपके Id उदाहरण में एक सुरक्षा अपरिवर्तनीय और mem::zeroed या अन्य तरीके हैं जो Id<A, B> संश्लेषित करने के लिए सुरक्षित नहीं हो सकते हैं, लेकिन यह सिर्फ तत्काल बीबी के लिए नहीं है। mem::zeroed या mem::uninitialized साथ एक गलत Id मूल्य का निर्माण करें क्योंकि Id की कोई वैधता नहीं है। हालांकि असुरक्षित कोड लेखकों को निश्चित रूप से दोनों प्रकार के आक्रमणकारियों को ध्यान में रखने की आवश्यकता है, ऐसे कुछ कारण हैं जिनकी वजह से यह चर्चा ज्यादातर वैधता पर केंद्रित है:

• सुरक्षा आक्रमणकारी उपयोगकर्ता-परिभाषित हैं, शायद ही कभी औपचारिक रूप से, और मनमाने ढंग से जटिल हो सकते हैं, इसलिए उनके बारे में उदारतापूर्वक तर्क करने की कोई उम्मीद नहीं है या किसी विशेष सुरक्षा अपरिवर्तनीय को बनाए रखने में मदद करने वाले कंपाइलर / भाषा।
• सुरक्षा आक्रमणकारी को तोड़ना कभी-कभी आवश्यक हो सकता है (आंतरिक रूप से एक ध्वनि पुस्तकालय के भीतर), इसलिए भले ही हम यंत्रवत् रूप से mem::zeroed::<T>() T के सुरक्षा आक्रमणकारी के आधार पर शासन कर सकें , हम नहीं चाहते हैं।
• संबंधित रूप से, टूटी वैधता के परिणामों के परिणाम किसी तरह से टूटे हुए सुरक्षा आक्रमणकारी से भी बदतर हैं (इसे डीबग करने का कम मौका क्योंकि सभी नरक तुरंत ढीले हो जाते हैं, और अक्सर यूबी से उत्पन्न वास्तविक व्यवहार कम समझदार होता है क्योंकि सभी संकलक और अनुकूलक कारकों में यह, जबकि सुरक्षा अपरिवर्तनीय केवल एक ही मॉड्यूल / टोकरा में कोड द्वारा सीधे शोषण किया जाता है)।

@Jethrogb की टिप्पणी पढ़ने के बाद, मैं सहमत हूं कि mem::zeroed को MaybeUninit की शुरूआत के साथ नहीं निकाला जाना चाहिए।

@ जैथ्रोज स्माल

इस सूची में किसी भी प्रकार की कोई भी सरणी
कोई भी संरचना जहाँ कोई भी क्षेत्र इस सूची में एक प्रकार है।

यकीन नहीं होता कि यह एक सरल टाइपो या शब्दार्थ अंतर है, लेकिन मुझे लगता है कि आपको इन दो गोलियों को बाहर करने की आवश्यकता है - मुझे विश्वास नहीं है कि यह जरूरी नहीं है कि None जैसे Option<[&u8; 2]> का एक वैध प्रतिनिधित्व के रूप में बिटवाइज़-ज़ीरो है (यह [0, 24601] का उपयोग None केस के प्रतिनिधित्व के रूप में कर सकता है - केवल एक आंतरिक मूल्यों को एक आला प्रतिनिधित्व पर लेना चाहिए - cc @ eddyb मुझे इस पर जाँच करने के लिए)। मुझे संदेह है कि हम आज ऐसा करते हैं, लेकिन यह पूरी तरह से असंभव नहीं लगता कि भविष्य में ऐसा कुछ दिखाई दे।

@jethrogb

मेम का सबसे आम उपयोग :: शून्य आज ऊपर वर्णित प्रकारों के लिए है, और यह पूरी तरह से वैध है।

क्या इसके लिए कोई स्रोत है?

दूसरी ओर, कई प्रकार हैं जिनके लिए मेम :: शून्यित मान्य है।

ऐसे कई मामले हैं जिनके लिए इसका गलत तरीके से इस्तेमाल किया जा सकता है।

मैं समझता हूं कि mem::zeroed भारी और सही तरीके से उपयोग करने वालों के लिए, डिप्रेशन को कम करने में तब तक देरी होती है जब तक कि अधिक एर्गोनोमिक समाधान उपलब्ध न हो।

मैं mem::zeroed के गलत उपयोगों की संख्या को कम करने या समाप्त करने के व्यापार-बंद को पसंद करता हूं, भले ही वह एक अस्थायी एर्गोनोमिक लागत हो। एक अवमूल्यन उपयोगकर्ताओं को चेतावनी देता है कि वे जो कर रहे हैं वह संभावित रूप से अपरिभाषित व्यवहार (विशेष रूप से नए उपयोगकर्ता जो पहली बार इसका उपयोग करते हैं) को आह्वान करते हैं, और हमारे पास इसके बजाय क्या करना है, इसके लिए एक ध्वनि समाधान है, जो चेतावनी को कार्रवाई योग्य बनाता है।

मैं MaybeUninit अक्सर उपयोग करता हूं और mem::zeroed और mem::uninitialized तुलना में इसका उपयोग करना कम एर्गोनोमिक है, लेकिन यह मेरे लिए दर्दनाक रूप से नहीं है। यदि MaybeUninit इस चर्चा के दावे में कुछ टिप्पणियों के रूप में दर्दनाक है, तो एक सुरक्षित mem::zeroed विकल्प के लिए एक पुस्तकालय और / या RFC कुछ ही समय में पॉप जाएगा (कुछ भी यहां AFAICT को अवरुद्ध नहीं कर रहा है)।

वैकल्पिक रूप से, उपयोगकर्ता चेतावनी को अनदेखा कर सकते हैं और mem::zeroed का उपयोग कर सकते हैं, जो उनके ऊपर है, हम कभी भी mem::zeroed को libcore वैसे भी नहीं निकाल सकते।

लेकिन mem::zeroed का उपयोग करने वाले लोगों को सक्रिय रूप से निरीक्षण करना चाहिए कि क्या उनके सभी उपयोग सही हैं। विशेष रूप से mem::zeroed भारी उपयोग करने वाले, सामान्य कोड में इसका उपयोग करने वालों, mem::uninitialized विकल्प के रूप में" कम डरावने "विकल्प के रूप में इसका उपयोग करने वाले, इत्यादि की देरी से उपयोगकर्ताओं को चेतावनी दे रहे हैं कि वे क्या कर रहे हैं।" अपरिभाषित व्यवहार हो सकता है।

@bluss

शून्य हटाते समय ऐसा लगता है कि इसे केवल IFUnit द्वारा प्रतिस्थापित किया गया है :: zeroed ()। In_inner () जो एक ही चीज़ लिखने के लिए एक समान तरीका बन जाता है। कोई व्यावहारिक परिवर्तन नहीं है। यूनिनिट वैल्यूज के साथ हमारे बजाय सभी यूनीलिनेटेड डेटा का व्यावहारिक परिवर्तन हो सकता है, जो कि टाइप यू यूनीटिट या समतुल्य यूनियन के मानों में संग्रहीत किया जा सकता है।

यह सच है जब हम पूर्णांक के बारे में बात कर रहे हैं, लेकिन एक बार जब हम उदाहरण के प्रकारों को देखते हैं, तो mem::zeroed() एक समस्या बन जाती है।

हालांकि, मैं मानता हूं कि यह अधिक संभावना है कि लोग वास्तव में महसूस करेंगे कि mem::zeroed::<&T>() एक समस्या है, लोगों को यह महसूस करने से कि mem::uninitialized::<bool>() एक समस्या है। तो शायद यह mem::zeroed() रखने के लिए समझ में आता है।

ध्यान दें, हालांकि, हम अभी भी तय कर सकते हैं कि mem::uninitialized::<u32>() ठीक है - अगर हम पूर्णांक प्रकारों में अनधिकृत बिट्स की अनुमति देते हैं, तो mem::uninitialized() लगभग सभी "POD प्रकारों" के लिए मान्य हो जाता है। मुझे नहीं लगता कि हमें इसकी अनुमति देनी चाहिए, लेकिन हमें अभी भी इस पर चर्चा करनी है।

किस प्रकार के मेम के लिए :: अनइंस्टॉलिज्ड वैध है यह बहुत छोटा है (वास्तव में, क्या यह केवल शून्य-आकार के प्रकार हैं?), और कोई भी वास्तव में कोड नहीं लिखता है जो ऐसा करता है (जैसे ZSTs के लिए आप सिर्फ टाइप का उपयोग करेंगे निर्माता)।

एफडब्ल्यूआईडब्ल्यू, कुछ स्लाइस इटरेटर कोड वास्तव में जेनेरिक कोड में एक प्रकार का कंस्ट्रक्टर लिखने में सक्षम होने के बिना एक ZST बनाना है। यह उस के लिए mem::zeroed() / MaybeUninit::zeroed().into_inner() का उपयोग करता है।

mem::zeroed() कुछ एफएफआई मामलों के लिए उपयोगी है जहां आपको C फ़ंक्शन को कॉल करने से पहले memset(&x, 0, sizeof(x)) साथ एक मूल्य शून्य करने की उम्मीद है। मुझे लगता है कि इसे कम रखने के लिए यह पर्याप्त कारण है।

@Amanieu जो अनावश्यक लगता है। Rust का निर्माण memset मेल write_bytes ।

मेम :: शून्य () कुछ एफएफआई मामलों के लिए उपयोगी है

इसके अलावा, पिछली बार जब मैंने जाँच की थी, mem::zeroed निजी या प्लेटफ़ॉर्म-निर्भर क्षेत्रों के साथ libc संरचनाओं को आरंभ करने का मुहावरेदार तरीका था।

@RalfJung प्रश्न में पूर्ण कोड आमतौर पर Type x; memset(&x, 0, sizeof(x)); और पहले भाग में एक महान जंग बराबर नहीं है। इस पैटर्न के लिए MaybeUninit का उपयोग करना बहुत अधिक शोर है (और अनुकूलन के बिना बहुत बुरा कोडीन) जब memset बाद मेमोरी वास्तव में कभी भी अमान्य नहीं होती है।

मैं के डिजाइन के बारे में कोई प्रश्न है MaybeUninit : वहाँ की एक एकल क्षेत्र के लिए लिखने के लिए कोई तरीका है T के अंदर एक निहित MaybeUninit<T> ऐसी है कि आप के लिए खत्म हो समय लिख सकता है सभी क्षेत्र और एक मान्य / आरंभिक प्रकार के साथ समाप्त होते हैं?

मान लें कि हमारे पास निम्नलिखित की तरह एक संरचना है:

// Let us suppose that Foo can in principle be any struct containing arbitrary types
struct Foo {bar: bool, baz: String}

क्या एक & उत्परिवर्ती Foo संदर्भ उत्पन्न करता है, और फिर इसे लिखने के लिए UB ट्रिगर होता है?

main () {
    let uninit_foo = MaybeUninitilized::<Foo>::uninitialized();
    unsafe { *uninit_foo.get_mut().bar = true; }
    unsafe { *uninit_foo.get_mut().baz = "hello world".to_owned(); }
}

क्या एक संदर्भ के बजाय कच्चे सूचक का उपयोग करने से इस समस्या से बचा जाता है?

main () {
    let uninit_foo = MaybeUninitilized::<Foo>::uninitialized();
    unsafe { *uninit_foo.as_mut_pointer().bar = true; }
    unsafe { *uninit_foo.as_mut_pointer().baz = "hello world".to_owned(); }
}

या कोई अन्य तरीका है जिसमें इस पैटर्न को यूबी को ट्रिगर किए बिना लागू किया जा सकता है? सहज रूप से, यह मुझे लगता है कि जब तक मैं एकतरफा / अमान्य स्मृति नहीं पढ़ रहा हूं, तब तक सब कुछ ठीक होना चाहिए, लेकिन इस थ्रेड में कई टिप्पणियां मुझे संदेह की ओर ले जाती हैं।

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

क्या टी के किसी एकल क्षेत्र को लिखने का कोई तरीका है, जो कि शायद यूफिनिट के अंदर हैआप समय के साथ सभी क्षेत्रों को लिख सकते हैं और एक वैध / आरंभिक प्रकार के साथ समाप्त हो सकते हैं?

हाँ। उपयोग

ptr::write(&mut *(uninit.as_mut_ptr()).bar, val1);
ptr::write(&mut *(uninit.as_mut_ptr()).baz, val2);
...

आपको इसके लिए get_mut() उपयोग नहीं करना चाहिए, यही कारण है कि get_mut लिए डॉक्स का कहना है कि इस पद्धति को कॉल करने से पहले मूल्य को आरंभीकृत किया जाना चाहिए। हम भविष्य में उस नियम को शिथिल कर सकते हैं, जिसकी चर्चा https://github.com/rust-rfcs/unsafe-code-guidelines/ पर की जा रही है

@RalfJung *(uninit.as_mut_ptr()).bar = val1; जोखिम bar में पहले से गिराने वाला नहीं होगा, जो कि अनैतिक हो सकता है? मुझे लगता है कि ऐसा करना जरूरी है

ptr::write(&mut (*uninit.as_mut_ptr()).bar, val1);

@scottjmaddox आह, ठीक है। मैं Drop भूल गया। मैं पोस्ट अपडेट कर दूंगा।

किस तरह से असिंचित क्षेत्रों में लेखन का यह संस्करण get_mut() से कम अपरिभाषित व्यवहार प्रदर्शित करता है? कोड बिंदु पर जहां ptr::write के पहले तर्क का मूल्यांकन किया जाता है, कोड ने आंतरिक क्षेत्र में &mut _ का निर्माण किया है जो पूरी संरचना के संदर्भ के रूप में केवल अपरिभाषित होना चाहिए जो अन्यथा होगा बनाया था। क्या कंपाइलर को यह मानने की अनुमति नहीं दी जानी चाहिए कि वह पहले से ही आरंभिक अवस्था में है?

क्या ऐसे नए पॉइंटर-प्रोजेक्शन मेथड की आवश्यकता नहीं होगी, जिसमें &mut _ मध्यवर्ती की आवश्यकता न हो?

थोड़ा दिलचस्प उदाहरण:

pub struct A { inner: bool }

pub fn init(mut uninit: MaybeUninit<A>) -> A {
    unsafe {
        let mut previous: [u8; std::mem::size_of::<bool>()] = [0];

        {
            // Doesn't the temorary reference assert inner was in valid state before?
            let inner_ptr: *mut _ = &mut (*uninit.as_mut_ptr()).inner;
            ptr::copy(inner_ptr as *const [u8; 1], (&mut previous) as *mut _, 1);

            // With the assert below, couldn't the compiler drop this?
            std::ptr::write(inner_ptr, true);
        }

        // Assert Inner wasn't false before, so it must have been true already!
        assert!(previous[0] != 0);

        // initialized all fields, good to proceed.
        uninit.into_inner()
    }
}

लेकिन यदि कंपाइलर वैध प्रतिनिधित्व होने के लिए &mut _ मान सकता है, तो यह केवल ptr::write एकमुश्त फेंक सकता है? यदि हम मुखर हो जाते हैं, तो सामग्री 0 नहीं थी, लेकिन केवल अन्य मान्य बूल true/1 । इसलिए अगर हम मुखर हो जाएं तो इसे एक नो-ऑप माना जा सकता है। चूंकि मान पहले एक्सेस नहीं किया गया है, पुन: व्यवस्थित करने के बाद हम इसे समाप्त कर सकते हैं? ऐसा लगता नहीं है कि llvm अभी इसका फायदा उठाता है, लेकिन मैं बहुत अनिश्चित हूं अगर इसकी गारंटी दी जाएगी।

यदि हम इसके बजाय फ़ंक्शन के भीतर अपना MaybeUninit बनाते हैं, तो हमें थोड़ी अलग वास्तविकता मिलती है। खेल के मैदान पर हम बजाय पता लगाना यह मानता है कि ज़ोर कर सकते हैं कभी नहीं ट्रिगर, शायद के रूप में यह मान लिया गया है str::ptr::write के लिए एक ही लिखना है inner इस प्रकार यह हुआ होगा पहले से ही इससे पहले कि हम से पढ़ा previous ? यह थोड़ा गड़बड़ लगता है। इस सिद्धांत का समर्थन करने के लिए, देखें कि क्या होता है जब आप सूचक लिखने के बदले false लिखते हैं।

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

@RalfJung @scottjmaddox आपके उत्तर के लिए धन्यवाद। ये बारीकियाँ बिलकुल मैंने क्यों पूछी।
@HeroicKatora हाँ, मैं इस बारे में सोच रहा था।

शायद सही झुकाव यह है?

struct Foo {bar: bool, baz: String}

fn main () {
    let mut uninit_foo = MaybeUninit::<Foo>::uninitialized();
    unsafe { ptr::write_unaligned(&mut ((*uninit_foo.as_mut_ptr()).bar) as *mut bool, true); }
    unsafe { ptr::write_unaligned(&mut ((*uninit_foo.as_mut_ptr()).baz) as *mut String, "".to_string()); }
}

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

मैंने Reddit पर एक टिप्पणी पढ़ी (जो दुर्भाग्य से मुझे अब नहीं मिल सकती है) जिसने सुझाव दिया कि तुरंत एक पॉइंटर ( &mut foo as *mut T ) के संदर्भ में कास्टिंग करना वास्तव में सिर्फ एक पॉइंटर बनाने के लिए संकलित करता है। हालाँकि, *uninit_foo.as_mut_ptr() बिट मुझे चिंतित करता है। क्या सूचक को इस तरह की स्मृति में रखा जाना ठीक है? हम वास्तव में कुछ भी नहीं पढ़ रहे हैं, लेकिन यह मेरे लिए अस्पष्ट है कि क्या संकलक को पता है।

मुझे लगा कि unaligned ptr::write MaybeUninit<T> से अधिक जेनेरिक कोड के लिए आवश्यक हो सकता है क्योंकि सभी प्रकारों में संरेखित फ़ील्ड नहीं होंगे?

write_unaligned आवश्यकता नहीं है। कंपाइलर आपके लिए फील्ड अलाइनमेंट संभालता है। और as *mut bool या तो आवश्यक नहीं होना चाहिए, क्योंकि कंपाइलर यह अनुमान लगा सकता है कि इसे &mut को *mut समेटने की आवश्यकता है। मुझे लगता है कि यह अनुमान जबरन है कि यह सुरक्षित / वैध क्यों है। यदि आप स्पष्ट होना चाहते हैं और as *mut _ , तो यह भी ठीक होना चाहिए। यदि आप पॉइंटर को एक वैरिएबल में सेव करना चाहते हैं, तो उसे पॉइंटर में करने के लिए आवश्यक है।

@scottjmaddox क्या ptr::write अभी भी सुरक्षित है, भले ही #[repr(packed)] ? ptr::write कहना है कि सूचक को सही ढंग से संरेखित किया जाना चाहिए, इसलिए मुझे लगता है कि ptr::write_unaligned उन मामलों में आवश्यक है जहां आप कुछ सामान्य कोड लिख रहे हैं जिन्हें पैक्ड अभ्यावेदन को संभालने की आवश्यकता है (हालांकि ईमानदार होने के लिए मुझे यकीन नहीं है मैं " MaybeUninit<T> " पर सामान्य कोड के एक उदाहरण के बारे में सोच सकता हूं जो यह नहीं जानता होगा कि क्षेत्र ठीक से संरेखित था या नहीं)।

@nicoburns

जो सुझाव दिया कि तुरंत एक पॉइंटर (और म्यूट फू के रूप में * म्यूट टी) का संदर्भ देते हुए वास्तव में सिर्फ एक पॉइंटर को creting करने के लिए संकलित करता है।

यह जो संकलन करता है वह शब्दार्थ से अलग है इस संकलन को करने के लिए संकलक का उपयोग करने की अनुमति है। यहां तक ​​कि अगर यह आईआर में एक नो-ऑप है, तो भी यह एक अर्थ प्रभाव डाल सकता है जैसे कि कंपाइलर के लिए अतिरिक्त मान्यताओं को सम्मिलित करना। @scottjmaddox सही है जिसमें ऑपरेशन यहां खेले जा रहे हैं, लेकिन प्रश्न का महत्वपूर्ण हिस्सा उत्परिवर्तनीय संदर्भ का निर्माण है जो रेफ-टू- @mjbshaw तकनीकी रूप से सामान्य सुरक्षा के बारे में ptr::write_unaligned आवश्यकता के बारे में सही है जब तर्क एक अज्ञात सामान्य तर्क है।

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

किस तरह से असिंचित क्षेत्रों के लिए लेखन का यह संस्करण get_mut () की तुलना में कम अपरिभाषित व्यवहार प्रदर्शित करता है? कोड बिंदु पर जहां ptr :: write का पहला तर्क दिया गया है, कोड ने आंतरिक क्षेत्र में एक & mut _ बनाया है जो पूरे ढांचे के संदर्भ के रूप में केवल अपरिभाषित होना चाहिए जो अन्यथा बनाया जाएगा। क्या कंपाइलर को यह मानने की अनुमति नहीं दी जानी चाहिए कि वह पहले से ही आरंभिक अवस्था में है?

बहुत अच्छा सवाल! इन चिंताओं का एक कारण है कि मैंने https://github.com/rust-lang/rfcs/pull/2582 को खोला &mut नहीं बनाता है, यह *mut बनाता है।

@ मज्जबशो टचे । हां, मुझे लगता है कि आप संरचना के पैक होने की संभावना के बारे में सही हैं, और इसके लिए ptr::write_unaligned आवश्यकता होगी। मैंने पहले इस पर विचार नहीं किया था, मुख्यतः क्योंकि मैं अभी तक जंग में पैक संरचनाओं का उपयोग करना चाहता हूं। यह शायद एक क्लीपी लिंट होना चाहिए, अगर यह पहले से ही नहीं है।

संपादित करें: मुझे एक प्रासंगिक क्लिपी लिंट दिखाई नहीं दिया, इसलिए मैंने एक मुद्दा प्रस्तुत किया: https://github.com/rust-lang/rust-clippy/issues/3659

मैंने एक PR को un-deprecate mem::zeroed खोला: https://github.com/rust-lang/rust/pull/57825

मैंने सुरक्षित मेमोरी शून्यकरण के बारे में चर्चा को कांटा करने के लिए RFC रेपो में एक मुद्दा खोला है, ताकि हम उस समस्या का बेहतर समाधान करने के बाद किसी समय mem::zeroed घटा सकें: https://github.com / जंग-लैंग / RFCs / मुद्दों / 2626

क्या const uninitialized , as_ptr और स्थिर करना संभव होगा
बाकी एपीआई की तुलना में as_mut_ptr ? यह मेरे लिए बहुत संभावना है कि ये
स्थिर हो जाएगा क्योंकि वे अभी हैं। साथ ही, बाकी एपीआई पर बनाया जा सकता है
as_ptr और as_mut_ptr , इसलिए एक बार स्थिर होने पर यह संभव होगा
crates.io पर MaybeUninitExt गुण है जो स्थिर, एपीआई पर प्रदान करता है
वर्तमान में अधिक लोगों (जैसे स्थिर-केवल उपयोगकर्ता) पर चर्चा की जा रही है
इस पर प्रतिक्रिया दें।

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

आपको यह समझने के लिए कि एम्बेडेड समुदाय के लिए यह कितना महत्वपूर्ण है, हमने किया
[एक सर्वेक्षण] समुदाय से उनके दर्द बिंदुओं और जरूरतों के बारे में पूछ रहा है। स्थिर
MaybeUninit दूसरी सबसे अधिक अनुरोधित चीज़ के रूप में स्थिर हुई (पीछे)
const fn सीमा सीमाओं के साथ) और, कुल मिलाकर, दर्जनों में से 7 वें स्थान पर समाप्त हुआ
जंग-लंग / * संबंधित अनुरोध। डब्ल्यूजी के भीतर आगे के विचार-विमर्श के बाद हम टकराए
पारिस्थितिकी तंत्र पर अपेक्षित प्रभाव के कारण इसकी प्राथमिकता, कुल मिलाकर, तीसरे स्थान पर है।

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

@ जापरिक जो निश्चित रूप से into_inner और दोस्तों के नामकरण चर्चा से बचेंगे । हालाँकि, मैं अभी भी शब्दार्थ चर्चा के बारे में चिंतित हूं, उदाहरण के लिए, let r = &mut *foo.as_mut_ptr(); करने वाले लोगों के बारे में और इसलिए यह दावा करते हुए कि उनके पास एक वैध संदर्भ है, जबकि हम अभी तक निश्चित नहीं हैं कि संदर्भों की वैधता आवश्यकताएं क्या हैं - अर्थात, हम हैं अभी तक यह सुनिश्चित नहीं है कि अमान्य डेटा के लिए रेफरी इंस्टा-यूबी है। एक ठोस उदाहरण के लिए:

let x: MaybeUninit<!> = MaybeUninit::uninitialized();
let r: &! = &*x.as_ptr() // is this UB?

यह चर्चा अभी हाल ही में UCG WG में

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

लेकिन इस तरह से मुझे लगता है कि हमें https://github.com/rust-lang/rfcs/pull/2582 स्वीकार करने से पहले हमें कुछ भी स्थिर नहीं करना चाहिए, ताकि हम कम से कम लोगों को निश्चितता के साथ बता सकें कि निम्नलिखित यूबी नहीं है :

let x: MaybeUninit<(!, u32)> = MaybeUninit::uninitialized();
let r1: *const ! = &(*x.as_ptr()).1; // immediately coerced to raw ptr, no UB
let r2 = &(*x.as_ptr()).1 as *const !; // immediately cast to raw ptr, no UB

(ध्यान दें कि हमेशा की तरह ! यहां एक लाल हेरिंग है, और इस पोस्ट के सभी उदाहरणों में हम एक ही हैं, यूबी-वार, अगर हमने bool इस्तेमाल किया।)

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

मुझे यह तर्क बहुत सम्मोहक लगता है।

मुझे लगता है कि यूबी के बिना असंबद्ध स्मृति को संभालने के लिए सबसे स्पष्ट आवश्यकता कुछ स्पष्ट संदेश है। यदि वह वर्तमान में "कच्चे पॉइंटर्स और ptr::read_unaligned और ptr::write_unaligned " का उपयोग करता है, तो यह ठीक है, लेकिन हमें निश्चित रूप से अनैतिक रूप से स्टैक मानों और संरचना / कछुआ क्षेत्रों के लिए कच्चे पॉइंटर्स प्राप्त करने के लिए कुछ अच्छी तरह से परिभाषित तरीके की आवश्यकता है। । जंग-लंग / rfcs # 2582 (प्लस कुछ प्रलेखन) तत्काल जरूरतों को पूरा करने के लिए लगता है, जबकि MaybeUninit नहीं है।

@scottjmaddox कैसे है कि RFC लेकिन MaybeUninit किसी भी तरह की अनइंस्टालिनेटेड (स्टैक) मेमोरी?

@ राल्फजंग मुझे लगता है कि निम्न यूबी पर निर्भर करता है या नहीं:

let x: bool = mem::uninitialized();
ptr::write(&x as *mut bool, false);
assert_eq!(x, false);

मेरी निहित धारणा यह थी कि जंग-लंग / rfcs # 2582 उपरोक्त उदाहरण को मान्य और अच्छी तरह से परिभाषित करेगा। क्या यह मामला नहीं है?

@scottjmaddox

let x: bool = mem::uninitialized();

यह यूबी है। इसका संदर्भों से कोई लेना-देना नहीं है।

मेरी निहित धारणा यह थी कि जंग-लंग / rfcs # 2582 उपरोक्त उदाहरण को मान्य और अच्छी तरह से परिभाषित करेगा।

मैं इससे पूरी तरह से हैरान हूं। वह RFC केवल संदर्भों के बारे में है। आप यह क्यों मानते हैं कि यह बूलियन के बारे में कुछ बदलता है?

@RalfJung

यह यूबी है। इसका संदर्भों से कोई लेना-देना नहीं है।

दस्तावेज़ को मेम करने के लिए

कुछ भी नहीं करते हुए टाइप टी के मूल्य का उत्पादन करने के बहाने रस्ट की सामान्य मेमोरी-इनिशियलाइज़ेशन जांचों को दरकिनार कर देता है।

प्रलेखन T* बारे में कुछ नहीं कहता है।

@kpp आप क्या कहना चाह रहे हैं? उस कोड की एक पंक्ति में कोई * और & :

let x: bool = mem::uninitialized();

आप इस लाइन को UB होने का दावा क्यों करते हैं?

क्योंकि एक bool हमेशा true या false , और यह एक नहीं है। इसके अलावा https://github.com/rust-rfcs/unsafe-code-guidelines/blob/master/reference/src/glossary.md#validity -and-safety-invariant देखें।

उस कथन के लिए @kpp ने व्यवहार को परिभाषित किया है mem::uninitialized को एक _valid_ bool ।

सभी वर्तमान में समर्थित प्लेटफॉर्मों पर bool के केवल दो _वलिध_ मान हैं, true (बिट-पैटर्न: 0x1 ) और false (बिट-पैटर्न: 0x0 )।

mem::uninitialized , हालांकि, एक बिट-पैटर्न पैदा करता है जहां सभी बिट्स का मूल्य uninitialized । यह बिट-पैटर्न न तो 0x0 और न ही 0x1 , इसलिए, परिणामस्वरूप bool _invalid_ है, और व्यवहार अपरिभाषित है।

व्यवहार को परिभाषित करने के लिए हमें तीन मान्य मूल्यों का समर्थन करने के लिए bool की परिभाषा को बदलना होगा: true , false , या uninitialized । हालाँकि, हम ऐसा नहीं कर सकते, क्योंकि टी-लैंग और टी-कंपाइलर पहले से ही RFC'ed है कि bool C के _Bool समान है और हम उस गारंटी को नहीं तोड़ सकते (यह अनुमति देता है) C FFI में bool का आंशिक रूप से उपयोग किया जाना है)।

तर्क, सी की वैधता की वही परिभाषा नहीं है जो रुस्त करता है, लेकिन सी "ट्रैप प्रतिनिधित्व" बहुत करीब आते हैं। संक्षेप में, बहुत कुछ ऐसा नहीं है जो C में _Bool साथ कर सकता है, जिसका मूल्य अपरिभाषित व्यवहार किए बिना true या false प्रतिनिधित्व नहीं करता है।

यदि आप सही हैं तो निम्न सुरक्षित कोड भी UB होना चाहिए:

let x: bool;
x = true;

जो स्पष्ट रूप से नहीं है।

यदि आप सही हैं तो निम्नलिखित सुरक्षित कोड भी यूबी होना चाहिए:

let x: bool; x को uninitialized बिट-पैटर्न से प्रारंभ नहीं करता है, यह x बिल्कुल भी प्रारंभ नहीं करता है। x = true; x (नोट करता है: यदि आप x का उपयोग करने से पहले इसे संकलित करने में त्रुटि नहीं करते हैं)।

यह C के व्यवहार से अलग है, जहां, संदर्भ के आधार पर, _Bool x; x _

नहींं, वहां कंपाइलर जानता है कि x का इनिशियलाइज़ नहीं हुआ है।

mem::uninitialized साथ मुद्दा यह है कि यह एक वैरिएबल

let x: bool; अपने आप पर भी x लिए किसी भी स्थान को आरक्षित नहीं करता है, यह सिर्फ एक नाम रखता है। let x = foo; कुछ स्थान आरक्षित करता है और foo का उपयोग करके इसे आरंभ करता है। let x: bool = mem::uninitialized(); 1 x लिए अंतरिक्ष का 1 बाइट आरक्षित करता है, लेकिन इसे असिंचित छोड़ देता है, और यह एक समस्या है।

यह आपके पैर के डिज़ाइन किए गए एपीआई को शूट करने का इतना आसान तरीका है कि इसे डॉक्यूमेंट में दोनों होना चाहिए :: uninitialized और intrinsics :: uninit for a specialis with mem :: uninitializedसंकलन के दौरान आतंकित होना।

क्या इसका यह भी अर्थ है कि मेम के साथ इसमें किसी भी संरचना को आरंभीकृत करना :: असंबद्ध यूबी भी है?

@kpp

क्या इसका यह भी अर्थ है कि मेम के साथ इसमें किसी भी संरचना को आरंभीकृत करना :: असंबद्ध यूबी भी है?

हाँ - जैसा कि आप शायद खोज रहे हैं, mem::uninitialized यह अपने आप को पैर में गोली मारने के लिए तुच्छ बनाता है, मैं यह कहकर आगे बढ़ूंगा कि सही तरीके से उपयोग करना लगभग असंभव है। इसलिए हम इसे MaybeUninit पक्ष में चित्रित करने की कोशिश कर रहे हैं, जो कि उपयोग करने के लिए थोड़ा अधिक क्रिया है, लेकिन इसका लाभ यह है कि, क्योंकि यह एक संघ है, आप मूल्यों को "भागों द्वारा" वास्तव में समाप्त किए बिना आरंभ कर सकते हैं। एक _invalid_ स्थिति में स्वयं का मान। मूल्य केवल पूरी तरह से _valid_ होना चाहिए जब तक कोई into_inner() कॉल करता है।

आपको चेक और अनचेक किए गए (संयुक्त राष्ट्र) आरंभीकरण के बारे में नामांकित के वर्गों को पढ़ने में रुचि हो सकती है: https://doc.rust-lang.org/nomicon/checked-uninit.html वे कवर करते हैं कि कैसे let x: bool; आरंभीकरण। सुरक्षित जंग में काम करता है। यदि स्पष्टीकरण स्पष्ट नहीं है तो कृपया मुद्दों को भरें या ऐसा कुछ भी हो जो आपको समझ में न आए। यह भी ध्यान रखें कि अधिकांश स्पष्टीकरण "गैर-मानक" हैं क्योंकि वे अभी तक आरएफसी प्रक्रिया से नहीं गुजरे हैं। असुरक्षित कोड दिशानिर्देश WG इस वर्ष किसी समय RFC दस्तावेज़ प्रस्तुत करने और वर्तमान व्यवहार की गारंटी देने का प्रयास करेगा।

यह आपके पैर के डिज़ाइन किए गए एपीआई को शूट करने का इतना आसान तरीका है कि इसे मेम दोनों में डॉक्यूमेंट किया जाना चाहिए :: uninitialized और intrinsics :: uninit

मुद्दा यह है कि वर्तमान में ऐसा करने का कोई सही तरीका नहीं है - यही कारण है कि हम MaybeUninit स्थिर करने के लिए काम में कठिन हैं, ताकि इन कार्यों को उनके दस्तावेज़ को वसा "डू नॉट यूएसई" द्वारा प्रतिस्थापित किया जा सके।

इस तरह चर्चाएं और जैसे मुद्दों इस मुझे अधिक से अधिक के साथ @japaric कि हम दरवाजा यथाशीघ्र बाहर कुछ मिलना चाहिए सहमत हैं। असल में हम की जरूरत है इस और इस चेक बॉक्स की सूची टिक पाने के लिए, मैं कहता हूँ चाहते हैं। फिर हमारे पास कुछ बुनियादी पैटर्न प्रदान करने के लिए पर्याप्त है।

क्या यह असमान रूप से, असंगत, as_ptr और को स्थिर करना संभव होगा
बाकी एपीआई से आगे as_mut_ptr? यह मेरे लिए बहुत संभावना है कि ये
स्थिर हो जाएगा क्योंकि वे अभी हैं।

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

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

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

Https://github.com/rust-lang/rfcs/pull/2582 की मानें, तो क्या हम पूरी तरह से सुनिश्चित हैं कि (1) भले ही UB नहीं है (2) है, और (1) में एक सूचक की derefencing भी होती है एकतरफा स्मृति को इंगित करता है?

(1) unsafe { ptr::write_unaligned(&mut ((*uninit_foo.as_mut_ptr()).bar) as *mut bool, true); }
(२) let x: bool = mem::uninitialized();

और यदि ऐसा है, तो इसके पीछे क्या तर्क है (उम्मीद है कि हम इस मुद्दे पर कुछ चर्चा शायद डॉक्यूमेंट्री के लिए कर सकते हैं)? मैं ऐसा कुछ अनुमान लगा रहा हूं क्योंकि (1) में डीरिफ़र्ड वैल्यू हमेशा "रिवेल्यू" रहती है और कभी नहीं बनती और "लेवेल्यू" बन जाती है, जबकि (2) में अमान्य बूल "लैवल्यू" बन जाता है और इस तरह वास्तव में मेमोरी में कैटेगराइज़ होना पड़ता है (मुझे यकीन नहीं है कि इसके लिए सही शब्द Rust में क्या है, लेकिन मैंने इन शब्दों को C ++ के लिए इस्तेमाल किया है)।

और क्या दूसरों को लगता है कि यह कच्चे पॉइंटर्स पर फ़ील्ड एक्सेस सिंटैक्स के लिए एक RFC बनाने के लायक होगा जो सीधे क्षेत्र में कच्चे पॉइंटर का मूल्यांकन करता है ताकि पहली जगह में इस भ्रम से बचा जा सके?

यदि नियम "अनइंस्टाल्ड मेमोरी के संदर्भ में कभी नहीं बना है"

मुझे नहीं लगता कि यह नियम होना चाहिए, लेकिन यह हो सकता है। इसकी चर्चा अभी यूसीजी में हो रही है।

क्या हम पूरी तरह से सुनिश्चित हैं कि (1) भी UB नहीं है (भले ही 2) है, और (1) में एक सूचक की एक derefencing भी होती है जो कि एकतरफा स्मृति को इंगित करता है?

अच्छा प्रश्न! लेकिन हां, हम हैं - कतरनी आवश्यकता से, मूल रूप से। के बारे में सोचो &mut foo as *mut bool के रूप में &raw mut foo , प्रकार का एक परमाणु अभिव्यक्ति *mut bool । यहाँ कोई संदर्भ नहीं है, बस एक कच्ची पीटीआर से लेकर असंबद्ध स्मृति तक - और यह निश्चित रूप से ठीक है।

let x: bool = mem::uninitialized();

यह यूबी है। इसका संदर्भों से कोई लेना-देना नहीं है।

मेरी निहित धारणा यह थी कि जंग-लंग / rfcs # 2582 उपरोक्त उदाहरण को मान्य और अच्छी तरह से परिभाषित करेगा।

मैं इससे पूरी तरह से हैरान हूं। वह RFC केवल संदर्भों के बारे में है। आप यह क्यों मानते हैं कि यह बूलियन के बारे में कुछ बदलता है?

@ राल्फजंग मुझे लगता है कि मुझे लगा कि यह यूबी नहीं है क्योंकि अपरिभाषित मूल्य

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

मुझे लगता है कि मुझे लगा कि यह यूबी नहीं था क्योंकि अपरिभाषित मूल्य अप्राप्य था क्योंकि इसे तुरंत एक मान्य बूल मूल्य के साथ ओवरराइट किया गया था। लेकिन मुझे लगता है कि ऐसा नहीं है?

शब्दार्थ कथन (MIR को देखते हुए) कथन को आगे बढ़ाता है। हर एक कथन का अर्थ होना चाहिए। let x: bool = mem::uninitialized(); एक बुरे बूलियन को भौतिक बनाता है, और इससे कोई फर्क नहीं पड़ता कि बाद में क्या होता है - आपको एक बुरा बूलियन नहीं बनाना चाहिए।

मैं समझता हूं कि x का मान अमान्य है, लेकिन क्या इसके लिए अपरिभाषित व्यवहार की आवश्यकता

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

हो सकता है कि आप कुछ और फॉर्म की उम्मीद कर रहे हों "मान का निरीक्षण करने के लिए वैधता अपरिवर्तनीय रखने की आवश्यकता है"। यहाँ, "निरीक्षण" एक bool एक में इसका उपयोग करने की जाएगी if । यह एक उचित विनिर्देश है, लेकिन एक कम उपयोगी है: अब संकलक को यह साबित करना होगा कि मूल्य वास्तव में "निरीक्षण" है इससे पहले कि यह अपरिवर्तनीय मान सकता है।

क्या अपरिभाषित व्यवहार की आवश्यकता है?

हम उठाते हैं कि क्या है और अपरिभाषित व्यवहार नहीं है। यह एक भाषा को डिजाइन करने का हिस्सा है। अपरिभाषित व्यवहार शायद ही कभी "आवश्यक" दर असल है - लेकिन यह अधिक अनुकूलन सक्षम करने के लिए आवश्यक है। तो यहां कला अपरिभाषित व्यवहार की परिभाषा ढूंढना है (जैसा कि ध्वनि के विपरीत हो सकता है ^ ^) जो दोनों वांछित अनुकूलन को सक्षम करता है, और (असुरक्षित) प्रोग्रामर की अपेक्षाओं के अनुरूप होता है।

मैं "अपरिभाषित व्यवहार" का अर्थ पूरी तरह से नहीं समझता।

मैंने इसके बारे में एक ब्लॉग पोस्ट लिखा था , लेकिन संक्षिप्त जवाब यह है कि अपरिभाषित व्यवहार आपके और संकलक के बीच एक अनुबंध है - और अनुबंध कहता है कि यह सुनिश्चित करना आपका दायित्व है कि कोई अपरिभाषित व्यवहार नहीं होता है। यह एक प्रमाण दायित्व है। "एक NULL पॉइंटर को dereferencing UB है" यह कहने के बराबर है कि "हर बार जब कोई पॉइंटर डीफ़र किया जाता है, तो प्रोग्रामर को यह साबित करने की उम्मीद की जाती है कि यह पॉइंटर संभवतः NULL नहीं हो सकता"। यह कंपाइलर को कोड को समझने में मदद करता है, क्योंकि हर बार जब एक पॉइंटर को डिफाइन किया जाता है, तो कंपाइलर अब "aha" कर सकता है! यहां प्रोग्रामर ने साबित कर दिया कि पॉइंटर NULL नहीं है, और इसलिए मैं ऑप्टिमाइज़ेशन और कोड जनरेशन के लिए उस जानकारी का उपयोग कर सकता हूं। धन्यवाद , प्रोग्रामर! "

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

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

अपना उदाहरण लेते हुए:

let x: bool = mem::uninitialized();

यह कोड आज जंग में यूबी है। यदि आप mem::uninitialized::<bool>() लिए (Unoptimized) LLVM IR को देखते हैं, तो आपको यही मिलता है:

; core::mem::uninitialized
; Function Attrs: inlinehint nonlazybind uwtable
define zeroext i1 @_ZN4core3mem13uninitialized17h6c99c480737239c2E() unnamed_addr #0 !dbg !5 {
start:
  %tmp_ret = alloca i8, align 1
  %0 = load i8, i8* %tmp_ret, align 1, !dbg !14, !range !15
  %1 = trunc i8 %0 to i1, !dbg !14
  br label %bb1, !dbg !14

bb1:                                              ; preds = %start
  ret i1 %1, !dbg !16
}
; snip
!15 = !{i8 0, i8 2}

अनिवार्य रूप से, यह फ़ंक्शन स्टैक पर 1 बाइट आवंटित करता है और फिर उस बाइट को लोड करता है। हालाँकि लोड !range के साथ चिह्नित है, जो LLVM को बताता है कि बाइट 0 <= x <2 के बीच होनी चाहिए, अर्थात यह केवल 0 या 1. हो सकती है। LLVM यह मान लेगा कि यह सत्य है, और व्यवहार अपरिभाषित है यदि इस बाधा का उल्लंघन किया जाता है।

सारांश में, यह समस्या इतनी अधिक गैर-व्यवस्थित चर नहीं है, यह तथ्य है कि आप प्रतिलिपि बना रहे हैं और मूल्यों को बढ़ा रहे हैं जो उनके प्रकार की बाधाओं का उल्लंघन करते हैं।

प्रदर्शनी के लिए दोनों को धन्यवाद! यह अब बहुत स्पष्ट है!

मुझे लगता है कि मेरा मूल हैंगअप यह है कि मैं "अपरिभाषित व्यवहार" का अर्थ पूरी तरह से नहीं समझता हूं।

ब्लॉग पोस्टों की यह श्रृंखला (जिसमें दूसरी पोस्ट में दिलचस्प / डरावने उदाहरण हैं) काफी मददगार हैं, मुझे लगता है: http://blog.llvm.org/2011/05/what-every-c-programmer-should-know .html

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

(ऐसा नहीं है कि मैं इस तरह के दस्तावेज लिखने के लिए स्वेच्छा से हूं। मैं नामांकित करता हूं ... जो कोई भी मेरे बारे में इससे अधिक जानता है।)

Https://github.com/rust-lang/rust/issues/55422#issuecomment -433943803 से एक दिलचस्प विचार: हम into_inner जैसे कार्यों को तरीकों में बदल सकते हैं, ताकि आपको MaybeUninit::into_inner(foo) लिखना पड़े। foo.into_inner() - कि बहुत स्पष्ट रूप से क्या हो रहा है दस्तावेज़।

में https://github.com/rust-lang/rust/pull/58129 मैं कुछ डॉक्स द्वारा जोड़ा जा रहा, वापसी एक &mut T से set और का नाम बदलने into_inner करने के लिए into_initialized ।

मुझे लगता है कि इसके बाद, और एक बार https://github.com/rust-lang/rust/pull/56138 को हल कर दिया गया है, हम एपीआई के हिस्सों (निर्माणकर्ताओं, as_ptr , as_mut_ptr को स्थिर करने के साथ आगे बढ़ सकते हैं। set , into_initialized )।

MaybeUninit::zeroed() a const fn क्यों नहीं है? ( MaybeUninit::uninitialized() एक const fn )

संपादित करें: क्या यह वास्तव में रात में जंग का उपयोग करके const fn बनाया जा सकता है?

MaybeUninit::zeroed() a const fn क्यों नहीं है? ( MaybeUninit::uninitialized() एक const fn )

@gnzlbg मैंने कोशिश की , लेकिन इसके लिए निम्न में से एक की आवश्यकता है:

• init आंतरिक को const fn बनाओ। यह उल्लेखनीय है, लेकिन राल्फ आर-कि करने के लिए कोई भी प्रयास करेगा ; या
• std::ptr::write_bytes a const fn बनाएं। इसके लिए &mut const लेने की आवश्यकता होती है, जो वर्तमान में अनुमति नहीं है ।

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

@ रस्ट-लैंग / लिबास वह सामान्य स्थितियां हैं जिनके तहत आप एक विधि के बजाय एक फ़ंक्शन का उपयोग करेंगे? मैं सोच रहा हूं कि क्या यहां कुछ संचालन कार्य होने चाहिए ताकि लोगों को लिखना पड़े, जैसे, MaybeUninit::as_ptr(...) । मुझे चिंता है कि यह कोड को अपठनीय बनने के लिए उड़ा देगा - लेकिन ओटीओएच, ManuallyDrop पर कुछ कार्यों ने ठीक यही किया।

@RalfJung मेरी समझ यह है कि उपयोगकर्ता के प्रकार से छिपने के तरीकों से बचने के लिए, जिन तरीकों से जेनेरिक मापदंडों तक सीमित हैं, उन तरीकों से बचा जाता है - इसलिए ManuallyDrop::take ।

चूँकि MaybeUninit<T> कभी भी Deref<Target = T> , मुझे लगता है कि विधियाँ यहाँ उपयुक्त हैं।

प्रतिक्रिया के लिए पूछें और आपको प्राप्त होगा। मैंने हाल ही में std में नई कार्यक्षमता को लागू करने के लिए MaybeUninit उपयोग किया।

1. Sys / sgx / ext / arch.rs में मैं इनलाइन असेंबली के साथ संयोजन में इसका उपयोग करता हूं। मैं वास्तव में get_mut गलत तरीके से उपयोग करता था, सोच संदर्भ और कच्चे संकेत बराबर होंगे (928efca1 में तय किए गए)। मैं पहले से ही एक असुरक्षित ब्लॉक में था इसलिए मुझे वास्तव में पहले अंतर पर ध्यान नहीं था।
2. Sys / sgx / rwlock.rs में , मैं यह सुनिश्चित करने के लिए उपयोग कर रहा हूं कि const fn new() का बिट पैटर्न C हेडर फ़ाइल में एक सरणी इनिलाइज़र के समान है। मैं zeroed का उपयोग कर रहा हूँ set सुनिश्चित करने के लिए "परवाह मत करो" बिट्स हैं 0. मुझे नहीं पता कि यह सही उपयोग है, लेकिन यह ठीक काम करने लगता है ।

1. अगर out.get_mut() as *mut _ ! = out.as_mut_ptr() हो तो मैं बहुत भ्रमित हो जाऊंगा। वास्तव में सी ++ ish लगता है। मुझे उम्मीद है कि इसे किसी तरह ठीक कर लिया जाएगा।

get_mut() का क्या मतलब है?

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

struct Foo {
    x: i32,
}

let mut partial: Box<MaybeUninit<Foo>> = Box::new(MaybeUninit::uninitialized());
let complete: Box<Foo> = unsafe {
    ptr::write(&mut (*partial.as_mut_ptr()).x, 5);
    mem::transmute(partial)
};

मिरी के अनुसार यह उदाहरण काम करता है (हालांकि, मुझे अब पता चला है कि मुझे नहीं पता है कि समान लेआउट वाले प्रकार के बक्से को स्थानांतरित करना खुद ही ध्वनि है)।

@ निमो 157 आपको into_inner होने पर उसी मेमोरी लेआउट की आवश्यकता क्यों है?

@Pixix प्रारंभ के बाद मान की प्रतिलिपि बनाने से बचने के लिए, कल्पना करें कि इसमें 100 एमबी बफर होता है जो स्टैक पर आवंटित होने पर स्टैक ओवरफ्लो का कारण होगा। हालांकि, एक टेस्टकेस लिखते हुए ऐसा लगता है कि स्टैक को छूने के बिना एक अनइंस्टॉल किए गए बॉक्स को आवंटित करने की अनुमति देने के लिए अतिरिक्त एपीआई fn uninit_boxed<T>() -> Box<MaybeUninit<T>> आवश्यकता होती है।

box सिंटैक्स का उपयोग करते हुए, असिंचित हीप स्थान को आवंटित करने की अनुमति देने के लिए आप देख सकते हैं कि इस तरह से काम करता है, जबकि into_initialized का उपयोग करने का प्रयास एक ढेर अतिप्रवाह का कारण बनता है: खेल का मैदान

@ निमो 157 शायद नकल को दूर करने के लिए कंपाइलर लागू करना बेहतर है? मुझे लगता है कि इसे वैसे भी करना चाहिए, लेकिन यह सुनिश्चित करने के लिए एक विशेषता हो सकती है कि यह संकलन करता है।

@ Nemo157

एक बात जो मैं हाल ही में सोच रहा था कि क्या MaybeUninit<T> को T के समान लेआउट की गारंटी थी या नहीं, और क्या ऐसा कुछ है जो ढेर पर मूल्यों को आंशिक रूप से आरंभ करने के लिए इस्तेमाल किया जा सकता है, फिर इसे पूरी तरह से बदल दें। आरंभिक मूल्य,

मेरा मानना ​​है कि इसकी गारंटी है, और यह कि आप मान्य हैं, कुछ दोहों के साथ:

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

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

@Pzixel यदि आपके पास समान मेमोरी लेआउट है तो एक बार निर्माण करने के बाद आप संपूर्ण डेटा संरचना की प्रतिलिपि बनाने से बच सकते हैं। बेशक संकलक कॉपी को खत्म

@nicoburns हाँ, मैं इसे अब देख रहा हूँ। मैं सिर्फ यह कह रहा हूं कि कुछ विशेषता हो सकती है, जैसे #[same_layout] या #[elide_copying] , या वे दोनों, या कुछ और, यह सुनिश्चित करने के लिए कि यह उसी तरह से काम करता है जैसे transmute । या हो सकता है अतिरिक्त नकल से बचने के लिए into_constructed कार्यान्वयन को बदल दें। मुझे उम्मीद है कि यह एक डिफ़ॉल्ट व्यवहार होगा, न कि केवल उन स्मार्ट लोगों के लिए जो लेआउट के बारे में डॉक्स पढ़ते हैं। मेरा मतलब है कि मेरे पास मेरा कोड है जो into_constructed कॉल करता है और मुझे एक अतिरिक्त कॉपी मिलती है, लेकिन @ Nemo157 सिर्फ transmute कॉल करता है और वह ठीक है। कोई कारण नहीं है कि into_constructed एक ही काम न कर सके।

अगर out.get_mut() as *mut _ ! = out.as_mut_ptr() हो तो मैं बहुत भ्रमित हो जाऊंगा। वास्तव में सी ++ ish लगता है। मुझे उम्मीद है कि इसे किसी तरह ठीक कर लिया जाएगा।

get_mut() का क्या मतलब है?

मैंने ऊपर एक समान बिंदु बनाया है कि get_mut() और get_ref() संभावित रूप से भ्रमित कर रहे हैं / गलती से अपरिभाषित व्यवहार करना आसान बना देते हैं (क्योंकि वे as_ptr() लिए सुरक्षित विकल्प होने का भ्रम देते हैं) as_mut_ptr() , लेकिन वास्तव में उन तरीकों से कम सुरक्षित हैं)।

मेरा मानना ​​है कि वे API के सबसेट में नहीं हैं जो @RalfJung ने स्थिर करने का प्रस्ताव दिया (देखें: https://www.ralfj.de/blog/2019/02/12/all-hands-recap.html)

@RalfJung ptr::freeze() पद्धति के लिए आपके प्रस्ताव के बारे में (https://www.ralfj.de/blog/2019/02/12/all-hands-recap.html):

क्या MaybeUninit ? ( MaybeUninit::frozen() , MaybeUninit::abitrary() या समान) के निर्माण के लिए इसी तरह की विधि का अर्थ होगा? सहज रूप से, ऐसा लगता है कि इस तरह की स्मृति zeroed तरह मेमोरी में लिखने की लागत के बिना, कई उपयोग के मामलों के लिए सही मायने में अनैतिक रूप से स्मृति के रूप में होगी। शायद यह uninitialized कंस्ट्रक्टर से अधिक की सिफारिश की जा सकती है जब तक कि लोग वास्तव में सुनिश्चित न हों कि उन्हें एकतरफा स्मृति की आवश्यकता है?

उस नोट पर, ऐसे उपयोग के मामले क्या हैं जहाँ आपको "फ्रोजन" मेमोरी के बजाय "अनइंस्टाल्यूटेड" मेमोरी की आवश्यकता है?

@Pzixel

1. I'd be very confused if `out.get_mut() as *mut _` != `out.as_mut_ptr()`. Looks really C++ish. I hope it would be fixed somehow.

का उल्लेख किया। इसका कारण कुछ लोग यह प्रस्तावित करते हैं कि &mut ! निर्जन घोषित करना उपयोगी हो सकता है (जैसे कि, ऐसा मान होना UB है)। हालांकि, MaybeUninit::<!>::uninitiailized().get_mut() , हमने ऐसा मूल्य बनाया है। इसीलिए as_mut_ptr कम खतरनाक है - यह एक संदर्भ बनाने से बचता है।

@nicoburns (ध्यान दें कि freeze मेरा विचार नहीं है, मैं सिर्फ चर्चा का हिस्सा था और मुझे प्रस्ताव बहुत पसंद है।)

मेरा मानना ​​है कि वे एपीआई के सबसेट में _not_ हैं जो @RalfJung को स्थिर करने का प्रस्ताव है

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

क्या MaybeUninit बनाने के लिए इसी तरह की विधि का अर्थ होगा? ( MaybeUninit::frozen() , MaybeUninit::abitrary() या समान)।

हाँ! मैं इसे एक बार जोड़ने का प्रस्ताव रखने जा रहा था जब एक मूल MaybeUninit स्थिर है और ptr::freeze उतरा है।

उस नोट पर, ऐसे उपयोग के मामले क्या हैं जहाँ आपको "फ्रोजन" मेमोरी के बजाय "अनइंस्टाल्यूटेड" मेमोरी की आवश्यकता है?

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

(समय मिलने पर मैं अन्य टिप्पणियों पर भी आऊंगा।)

@Pixix पूर्व-आवंटित मेमोरी में सीधे वस्तुओं का निर्माण करने में सक्षम होने के कारण गैर-तुच्छ है, रस्ट ने दो RFC को ऐसी चीज़ को लागू करने के लिए स्वीकार किया था (4 साल पहले!), लेकिन वे तब से अन-स्वीकृत हैं और अधिकांश कार्यान्वयन हटा दिए गए हैं! (सिवाय box सिंटैक्स मैंने ऊपर प्रयोग किया है)। यदि आप अधिक विवरण चाहते हैं तो हटाने के बारे में i.rl.o धागा शुरू करने के लिए सबसे अच्छी जगह होगी।

जैसा कि @nicoburns में MaybeUninit का उल्लेख है, संभवतः उसी समस्या के लिए एक कम-एर्गोनोमिक लाइब्रेरी-आधारित समाधान के लिए बिल्डिंग ब्लॉक के रूप में इस्तेमाल किया जा सकता है, यह अवधारणा के साथ प्रयोग करना शुरू करने और एपीआई की किस तरह देखने के लिए एक तरह से बहुत उपयोगी है। निर्माण की अनुमति देता है। यह सिर्फ इस बात पर निर्भर करता है कि क्या MaybeUninit इस तरह के समाधान के निर्माण के लिए आवश्यक गारंटी प्रदान कर सकते हैं।

@ निमो 157 मैं केवल एक ही स्थान पर इसका उपयोग करने का सुझाव

@jethrogb बहुत बहुत धन्यवाद! तो ऐसा लगता है कि एपीआई अभी आपके लिए ठीक काम करता है?

2. sys / sgx / rwlock.rs में , मैं इसे const fn new() के बिट पैटर्न को सुनिश्चित करने के लिए उपयोग कर रहा हूं, जो कि C हेडर फ़ाइल में एक सरणी इनिलाइज़र के समान है।

वाह, यह पागल है। ^ ^ लेकिन मुझे लगता है कि यह काम करना चाहिए, यह एक const fn जिसमें कोई तर्क नहीं है, इसलिए इसे हमेशा एक ही चीज़ वापस करना चाहिए ...

एक बात जो मैं हाल ही में सोच रहा था कि क्या MaybeUninit<T> T के समान लेआउट की गारंटी थी या नहीं, और क्या ऐसा कुछ है जो कि ढेर पर मूल्यों को आंशिक रूप से आरंभ करने के लिए इस्तेमाल किया जा सकता है तो इसे पूरी तरह से बदल दें। आरंभिक मूल्य

चीजों की सूची में हमें अंततः जोड़ना चाहिए कुछ ऐसा है

fn into_initialized_box(Box<MaybeUninit<T>>) -> Box<T>

यह Box प्रसारित करता है।

लेकिन हां, मुझे लगता है कि हमें इस तरह के प्रसारण की अनुमति देनी चाहिए। क्या डॉक्स में यह कहने के लिए कोई मिसाल है कि "आप इसे निम्न तरीके से प्रसारित कर सकते हैं"? मुझे लगता है कि आमतौर पर हम अपने स्वयं के प्रसारण करने के बजाय सहायक तरीकों को जोड़ना पसंद करते हैं।

• आपके द्वारा उपयोग किए जा रहे प्रकार (और सामान्य कोड में) के आधार पर, आपको ptr::write_unaligned आवश्यकता हो सकती है।

सामान्य कोड में आप फ़ील्ड्स तक नहीं पहुँच सकते। मुझे लगता है कि यदि आप खेतों को एक्सेस कर सकते हैं, तो आप आमतौर पर जानते हैं कि क्या संरचना पैक की गई है, और यदि यह नहीं है तो ptr::write काफी अच्छा है। (हालांकि असाइनमेंट का उपयोग न करें क्योंकि वह गिर सकता है! मैं भूल जाता हूं कि ...)

हालांकि, एक टेस्टकेस लिखते हुए ऐसा लगता है कि स्टैक को छूने के बिना एक अनइंस्टॉल किए गए बॉक्स को आवंटित करने की अनुमति देने के लिए अतिरिक्त एपीआई fn uninit_boxed<T>() -> Box<MaybeUninit<T>> आवश्यकता होती है।

यह एक बग है , लेकिन चूंकि उस बग को ठीक करना मुश्किल हो सकता है, इसलिए इसके लिए एक अलग कंस्ट्रक्टर की पेशकश करना भी एक अच्छा विचार हो सकता है। हालांकि इसे लागू करने का तरीका सुनिश्चित नहीं है। और फिर हम शायद zeroed_box जैसा कुछ भी चाहते हैं जो एक स्टैक स्लॉट को ज़ीरोइंग से बचाते हैं और फिर याद करते हैं, और इसी तरह ... मुझे यह सब दोहराव पसंद नहीं है। : /

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

मेरी खुद की बिट प्रतिक्रिया: मैं आमतौर पर MaybeUninit<T> खुश हूं। मुझे कोई बड़ी शिकायत नहीं है। यह mem::uninitialized तुलना में फुटगन से कम है, जो अच्छा है। const new और uninitialized विधियाँ अच्छी हैं। मैं चाहता हूं कि अधिक विधियाँ कांस्टेबल थीं, लेकिन जैसा कि मैंने समझा कि उनमें से कई को const fn सामान्य रूप से बनाने से पहले const होने पर अधिक प्रगति की आवश्यकता होती है।

मैं T और MaybeUninit<T> लिए "समान लेआउट" से अधिक मजबूत गारंटी चाहता हूं। मैं उन्हें ABI- संगत होना चाहता हूं (प्रभावी रूप से, #[repr(transparent)] , हालांकि मुझे पता है कि विशेषता यूनियनों पर लागू नहीं की जा सकती) और FFI- सुरक्षित (यानी, यदि T FFI- सुरक्षित है , तो MaybeUninit<T> FFI- सुरक्षित भी होना चाहिए)। (तात्कालिक रूप से, मैं चाहता हूं कि हम यूनियनों पर #[repr(transparent)] उपयोग कर सकते हैं, जिनके पास केवल एक सकारात्मक आकार का क्षेत्र है (जैसे हम संरचना के लिए कर सकते हैं)

मैं वास्तव में अनुकूलन के साथ सहायता करने के लिए अपनी परियोजना में MaybeUninit<T> का भरोसा करता हूं (लेकिन असुरक्षित तरीके से नहीं, इसलिए घबराएं नहीं)। अगर किसी को दिलचस्पी है, तो मैं विवरण में खुश हूं, लेकिन मैं इस टिप्पणी को संक्षिप्त रखूंगा और अभी के विवरणों को छोड़ दूंगा।

@mjbshaw धन्यवाद!

मेरी इच्छा है कि हम यूनियनों पर #[repr(transparent)] उपयोग कर सकते हैं जिनके पास केवल एक सकारात्मक आकार का क्षेत्र है (जैसे हम संरचनाओं के लिए कर सकते हैं)।

एक बार जब यह विशेषता मौजूद हो जाती है, तो इसे MaybeUninit जोड़ना एक बिना दिमाग वाला होगा। और वास्तव में इस के लिए तर्क पहले से ही rustc में लागू किया गया ( MaybeUninit<T> जिस वास्तविक साथ ABI-संगत है T , लेकिन हम इस बात की गारंटी नहीं है।)

सभी को लगता है कि किसी को RFC लिखना है और इसके माध्यम से देखना है, और कुछ चेक जोड़े हैं, जो सुनिश्चित करते हैं कि repr(transparent) यूनियनों के पास केवल एक गैर-ZST क्षेत्र हो। क्या आप इसे आजमाना चाहेंगे? : डी

सभी को लगता है कि किसी को RFC लिखना और उसके माध्यम से देखना है, और कुछ चेक जोड़ना है जो repr(transparent) यूनियनों के लिए केवल एक गैर-ZST क्षेत्र है। क्या आप इसे आजमाना चाहेंगे? : डी

@ राल्फजंग पूछो और तु प्राप्त होगा!

Cc https://github.com/rust-lang/rust/pull/58468

यह केवल एपीआई मुझे लगता है कि हम यथोचित रूप से maybe_uninit में स्थिर कर सकते हैं, और बाकी को अलग-अलग फ़ीचर गेट्स में स्थानांतरित कर सकते हैं।

ठीक है, प्रारंभिक पीआर सभी उतरे, और into_inner भी चला गया।

हालाँकि, मैं वास्तव में https://github.com/rust-lang/rfcs/pull/2582 को स्थिर करने से पहले स्वीकार करना चाहूंगा, अन्यथा हमारे पास एक संरचनात्मक क्षेत्र-दर-क्षेत्र को आरम्भ करने का कोई तरीका नहीं है - और यह MaybeUninit लिए एक प्रमुख उपयोग-मामला जैसा लगता है। हम बहुत आवश्यक सभी बक्से होने बंद कर रहे हैं FCP शुरू करने के लिए।

मैंने MaybeUninit का उपयोग करने के लिए अपना कोड परिवर्तित किया है। काफी कुछ स्थानों पर जहां मैं एक प्रयोग किया जा सकता था रहे हैं take विधि है जो पर काम करता है &mut self बजाय self । मैं वर्तमान में x.as_ptr().read() का उपयोग कर रहा हूं, लेकिन मुझे लगता है कि x.take() या x.take_initialized() अधिक स्पष्ट होगा।

@Amanieu यह मौजूदा into_inner पद्धति के समान लगता है। शायद हम यहां नकल से बचने की कोशिश कर सकते हैं?

😉

विधि take Option का अन्य अर्थ है। x.as_ptr().read() x का आंतरिक मूल्य नहीं बदलते हैं, लेकिन Option::take मूल्य को बदलने का प्रयास करते हैं। यह मेरे लिए भ्रामक हो सकता है।

@ qwerty19106 x.as_ptr().read() एक MaybeUninit _semantically_ पर मूल्य निकालता है और आवरण को फिर से निर्विवादित छोड़ देता है, बस इतना होता है कि पीछे छोड़ दिया गया असमान मूल्य उसी बिट-पैटर्न के रूप में होता है जो बाहर निकाला गया मान है। ।

मैं वर्तमान में x.as_ptr().read() का उपयोग कर रहा हूं, लेकिन मुझे लगता है कि x.take() या x.take_initialized() अधिक स्पष्ट होगा।

मुझे लगता है कि उत्सुक, आप समझा सकते हैं क्यों?

मेरे विचार में, एक take -समान पद्धति कुछ भ्रामक है क्योंकि दोनों take और into_initialized विपरीत, यह दो बार टेक-इन के विरुद्ध सुरक्षा नहीं करता है। दरअसल, Copy प्रकार (और वास्तव में Copy मान जैसे None as Option<Box<T>> ) के लिए, दो बार लेना पूरी तरह से ठीक है! तो, take साथ सादृश्य वास्तव में मेरे दृष्टिकोण से, पकड़ नहीं है।

हम इसे read_initialized() कह सकते हैं, लेकिन उस समय मैं गंभीरता से सोच रहा हूं कि क्या वास्तव में as_ptr().read() तुलना में कोई स्पष्ट है।

x.as_ptr().read() MaybeUninit _semantically_ के माध्यम से बाहर निकालता है और आवरण को फिर से असंवैधानिक रूप से छोड़ देता है, यह सिर्फ इतना होता है कि पीछे छोड़ दिया गया असमान मूल्य उसी बिट-पैटर्न के रूप में होता है जिसे बाहर निकाल दिया गया था।

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

@ राल्फजंग हम्म, शायद "शब्दार्थ" यहाँ गलत शब्द है। किसी उपयोगकर्ता को उस प्रकार का उपयोग कैसे करना चाहिए, जिसके बारे में आपको यह मान लेना चाहिए कि आपके द्वारा इसे पढ़े जाने के बाद मूल्य फिर से अनधिकृत है (जब तक कि आप समझ नहीं लेते कि प्रकार Copy )।

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

@RalfJung मेरे सभी मामलों में, इसमें एक static mut है, जिसमें एक मूल्य रखा गया है, और बाद में इसे समाप्त कर दिया गया है। चूंकि मैं एक स्थैतिक का उपभोग नहीं कर सकता, इसलिए मैं into_uninitialized उपयोग नहीं कर सकता।

@Amanieu मैं क्या पूछ रहा था, आपको क्यों लगता है कि x.take_initialized() x.as_ptr().read() से अधिक स्पष्ट है?

@ Nemo157

मैं उम्मीद कर रहा था कि मिरी अभी भी असमान स्मृति की 0 लंबाई रीड्स को ट्रैक करेगा, लेकिन ऐसा प्रतीत नहीं होता है

एकतरफा मेमोरी की एक 0-लंबाई पढ़ी गई यूबी कभी नहीं होती है, इसलिए मिरी उनकी परवाह क्यों करेगा?

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

निश्चित रूप से, आप बिना किसी अनधिकृत मेमोरी को पढ़े, सुरक्षा आक्रमणकारियों का उल्लंघन कर सकते हैं। आप इसके लिए MaybeUninit::zeroed().into_initialized() का भी उपयोग कर सकते हैं। मुझे समस्या नहीं दिख रही है।
यहां "अजीब इंटरैक्शन" यह है कि आपने एक प्रकार के दो मान बनाए हैं जिन्हें बनाने का आपको कोई अधिकार नहीं था। यह सब Spartacus के सुरक्षा आक्रमणकारी के बारे में है, और वैधता के साथ कुछ नहीं करना है।

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

@RalfJung मैं अनिवार्य रूप से MaybeUninit को Option रूप में मान रहा हूं, लेकिन टैग के बिना। वास्तव में, मैं पहले इस उद्देश्य के लिए अछूता-विकल्प टोकरा का उपयोग कर रहा था, और इसमें यूनियन से मूल्य निकालने के लिए take विधि है।

@Amanieu @shepmaster मैंने https://github.com/rust-lang/rust/pull/58660 में read_initialized जोड़ा । मुझे अभी भी लगता है कि take_initialized से बेहतर नाम है। क्या यह आपकी जरूरतों को पूरा करता है?

पीआर कुछ अन्य तरीकों के उदाहरण भी जोड़ता है, प्रतिक्रिया का स्वागत करता है!

मैं read_initialized खुश हूं।

जब मैं उस पर था, मैंने भी MaybeUninit<T>: Copy अगर T: Copy । ऐसा नहीं करने के लिए कोई अच्छा कारण लगता है।

हम्म, शायद get_initialized एक बेहतर नाम होगा? यह सभी के बाद set का पूरक है।

या शायद set का नाम बदलकर write होना चाहिए? वह भी निरंतरता हासिल करेगा।

मैं MaybeUninit का उपयोग करने के लिए अपने कोड को परिवर्तित कर रहा हूं और पाया है कि असिंचित स्लाइस के साथ काम करना बहुत ही गैर-आर्थिक है। मुझे लगता है कि अगर हम निम्नलिखित के लिए कार्य करते हैं तो इसमें सुधार किया जा सकता है:

• &mut [T] से &mut [MaybeUninit<T>] सुरक्षित रूपांतरण। यह प्रभावी रूप से &out मापदंडों को &mut [MaybeUninit<T>] का उपयोग करके अनुकरण करने की अनुमति देता है, जो read लिए उपयोगी है।
• &mut [MaybeUninit<T>] से &mut [T] (और &[T] लिए समान) का असुरक्षित रूपांतरण, एक बार उपयोग करने के लिए, हमने स्लाइस के प्रत्येक तत्व पर .set का उपयोग किया है।

मेरे पास कुछ इस तरह दिखने वाले API हैं:

// The returned slice is truncated to the number of elements actually read.
fn read<T>(out: &mut [MaybeUninit<T>]) -> Result<&mut [T]>;

मैं इस बात से सहमत हूं कि वर्तमान में स्लाइस के साथ काम करना गैर-आर्थिक है और इसीलिए मैंने first_ptr और first_ptr_mut जोड़ा। लेकिन यह शायद सबसे अच्छा एपीआई से दूर है।

हालाँकि, अगर हम पहले "कोर एपीआई" प्राप्त करने पर ध्यान केंद्रित कर सकते हैं, तो मैं पसंद करूंगा और फिर स्लाइस के साथ (और Box ) बातचीत करूंगा।

मुझे set से write का नाम बदलने का विचार पसंद है, ptr::write साथ स्थिरता प्रदान करता है।

एक ही नस में, read_initialized वास्तव में सिर्फ read से बेहतर है? यदि चिंता आकस्मिक उपयोग से अधिक है जो छिपी हो जाती है, तो शायद यह एक विधि के बजाय एक फ़ंक्शन बनाता है, अर्थात MaybeUninit::read(&mut v) ? एक ही write , यानी MaybeUninit::write(&mut v) निरंतरता के लिए किया जा सकता है। दोनों मामलों में व्यापार की स्थिति प्रयोज्य और खोजकर्ता के बीच है, और यदि एक मामले में खोजकर्ता को बेहतर माना जाता है, तो मैं यह नहीं देखता कि यह दूसरे में अलग क्यों होगा।

इसके बावजूद, जब तक कि इन एपीआई को बाहर नहीं निकाला जाता है, मैं दृढ़ता से एक नंगे न्यूनतम एपीआई के साथ स्थिर समर्थन करता हूं, अर्थात new , uninitialized , zeroed , as_ptr , as_mut_ptr , और शायद get_ref और get_mut ।

और शायद get_ref और get_mut ।

एक बार जब हम https://github.com/rust-rfcs/unsafe-code-guidelines/issues/77 को हल कर लेते हैं, तो इन्हें स्थिर किया जाना चाहिए और ऐसा लगता है कि इसमें कुछ समय लग सकता है ...

एक न्यूनतम न्यूनतम एपीआई के साथ स्थिर, यानी new , uninitialized , zeroed , as_ptr , as_mut_ptr

मेरी योजना into_initialized , set / write , और read_initialized उस न्यूनतम सेट का हिस्सा बनने के लिए थी। लेकिन शायद यह नहीं होना चाहिए? set / write और read_initialized बाकी के साथ आसानी से लागू किए जा सकते हैं, इसलिए मैं अब पहले बैच में उन्हें स्थिर नहीं करने की ओर भी झुकाव कर रहा हूं। लेकिन शुरू से into_initialized जैसा कुछ होना वांछनीय है, आईएमओ।

शायद यह एक विधि के बजाय एक समारोह है, MaybeUninit::read(&mut v) ? वही write लिए किया जा सकता है, यानी MaybeUninit::write(&mut v) निरंतरता के लिए।

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

क्या read_initialized वास्तव में सिर्फ read से बेहतर है?

अच्छा प्रश्न! मुझे नहीं पता। यह into_initialized समरूपता के लिए था। लेकिन into_inner एक सामान्य तरीका है, जहाँ कोई व्यक्ति यह अवलोकन खो सकता है कि उसे किस प्रकार का कहा जाता है, read बहुत कम आम है। और शायद यह सिर्फ होना चाहिए initialized के बजाय into_initialized ? इतने सारे विकल्प ...

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

ptr::read और ptr::write फ़ंक्शंस हैं, विधियाँ नहीं। तो पहले से ही MaybeUninit::read और MaybeUninit::write MaybeUninit::read पक्ष में पहले से ही सेट है।

संपादित करें : ठीक है, जाहिरा तौर पर वहाँ read और write संकेत पर भी तरीके हैं ... पहले कभी उन पर ध्यान नहीं दिया ... लेकिन वे सूचक का उपभोग करते हैं, जो वास्तव में MaybeUninit लिए कोई मतलब नहीं है।

इतने सारे विकल्प ...

माना। जब तक अन्य तरीकों पर बहुत अधिक बाइक-शेडिंग नहीं होती है, मुझे लगता है कि केवल new , uninitialized , zeroed , as_ptr , as_mut_ptr स्थिरीकरण के लिए वास्तव में तैयार हैं।

सिवाय ptr::read और ptr::write फ़ंक्शंस हैं, विधियाँ नहीं। तो पहले से ही सेट है

वे डेटा संरचना का हिस्सा नहीं हैं, निश्चित रूप से वे मुक्त-कार्य हैं। और जैसा कि आप टिप्पणी करते हैं, वे आजकल विधियों के रूप में भी मौजूद हैं।

लेकिन वे सूचक का उपभोग करते हैं

कच्चे संकेत Copy , इसलिए वास्तव में कुछ भी नहीं खाया जाता है।

कच्चे संकेत Copy , इसलिए वास्तव में कुछ भी नहीं खाया जाता है।

अच्छी बात...

खैर, v.as_ptr().read() पहले से ही काफी स्पष्ट और स्पष्ट है। as_ptr बाद read को ध्यान से सोचने के लिए कुछ ऐसा करना चाहिए जिससे into_initialized अधिक हो। निजी तौर पर, मैं कम से कम अभी के लिए as_ptr और as_mut_ptr खुलासा करने के पक्ष में हूं। और, new , uninitialized , और zeroed , बिल्कुल।

@Amanieu क्या Cell की तरह कुछ के बारे में है, जहां &mut MaybeUninit<[T]> लिए और &mut [MaybeUninit<T>] लिए सुरक्षित रूपांतरण हैं?

यह निम्नलिखित की अनुमति देगा, जो मुझे बहुत स्वाभाविक लगता है:

fn read<T>(out: &mut MaybeUninit<[T]>) -> Result<&mut [T]> {
    let split = out.as_mut_slice_of_uninit();
    // ... operate on split ...
    return Some(unsafe { split[0..n].as_uninit_mut_slice().get_mut() })
}

यह भी लगता है कि यह अधिक सटीक रूप से कॉलर को शब्दार्थ का प्रतिनिधित्व करता है। &mut [MaybeUninit<T>] लेने वाला कार्य मुझे महसूस होगा, जैसे कि इसमें कुछ अलग तर्क हो सकते हैं जिनके लिए ठीक हैं और जो नहीं हैं। दूसरी ओर &mut MaybeUninit<[T]> , यह व्यक्त करता है कि यह उन कोशिकाओं के बीच भेद करने वाला नहीं है जब यह आता है कि उनमें क्या डेटा पहले से है।

(तरीकों के नाम, निश्चित रूप से, बिकेशिंग के अधीन हैं - मैंने सिर्फ Cell जो किया है, वह नकल करता है।)

@eternaleye MaybeUninit<[T]> एक वैध प्रकार नहीं है क्योंकि यूनियन DST नहीं हो सकते।

मम, सही है

जब तक अन्य तरीकों पर बहुत अधिक बाइक-शेडिंग नहीं होती, मुझे लगता है कि केवल new , uninitialized , zeroed , as_ptr , as_mut_ptr स्थिरीकरण के लिए वास्तव में तैयार हैं।

ठीक है, मुझे लगता है कि हमें कुछ भी स्थिर करने से पहले इस RFC को

इसलिए जब हम प्रयोगों के लिए प्रतीक्षा set , read_initialized और into_initialized कहे जाने वाले नामों के बारे में थोड़ा बहुत विचार कर सकते हैं। निम्नलिखित नाम सुझाए गए हैं:

1. set -> write । .as_ptr().read() लिए सबसे अच्छा रूपक "पढ़ा" लगता है, "नहीं" मिलता है, लेकिन फिर पूरक ( .as_ptr_mut().write() ) "लिखना" होना चाहिए, "सेट" नहीं।
2. read_initialized -> read । नीली write मेल खाता है, लेकिन असुरक्षित है। क्या यह (प्लस प्रलेखन) एक चेतावनी के पर्याप्त है जिसे आपको मैन्युअल रूप से सुनिश्चित करना चाहिए कि डेटा पहले से ही आरंभिक है? बहुत सारे समझौते हुए कि एक असुरक्षित into_inner पर्याप्त नहीं है, यही वजह है कि मैंने इसका नाम बदलकर into_initialized ।
3. into_initialized -> initialized । यदि हमारे पास read_initialized और into_initialized , तो इसके लिए एक अच्छी स्थिरता IMO है - लेकिन अगर यह read , तो into_initialized थोड़ा बाहर चिपक जाता है। विधि का नाम काफी लंबा है। फिर भी, अधिकांश खपत ऑपरेशनों को into_* कहा जाता है, जो मुझे पता है।

(1) के लिए कोई आपत्ति? और मैं ज्यादातर (3) के खिलाफ झुक रहा हूं। के लिए (2) मैं अनिर्दिष्ट हूं: read टाइप करना आसान है, लेकिन read_initialized IMO इस तरह के कोड को पढ़ते समय बेहतर काम करता है - और कोड को लिखित रूप से अधिक बार पढ़ा और समीक्षा किया जाता है। उस जगह को कॉल करना अच्छा लगता है जहां हम वास्तव में चीजों को इनिशियलाइज़ करते हैं।

विचार, राय?

ठीक है, मुझे लगता है कि हमें कुछ भी स्थिर करने से पहले इस RFC को

यह वह जगह है जहाँ मैंने offset_of! लिए प्लग लगाया है? :)

ध्यान दें कि read_initialized की एक सख्त superset है into_initialized (लेता है &self के बजाय self )। क्या यह दोनों का समर्थन करने के लिए बहुत मायने रखता है?

यह वह जगह है जहाँ मैंने offset_of! लिए प्लग लगाया है? :)

यदि आप मेरे RFC द्वारा स्वीकार किए जाने से पहले स्थिर हो सकते हैं, तो निश्चित रूप से। ;)

क्या यह दोनों का समर्थन करने के लिए बहुत मायने रखता है?

IMO हाँ। into_initialized सुरक्षित है क्योंकि यह दो बार समान मूल्य का उपयोग करने से रोकता है, और इसलिए जब भी संभव हो, इसे read_initialized से अधिक पसंद किया जाना चाहिए।

इसलिए @nikomatsakis तरह के इस बिंदु को पहले बनाया लेकिन इसे एक कठिन अवरोधक नहीं बनाया।

मैंने MaybeUninit<T> और into_initialized का उपयोग करने के लिए बहुत सारे कोड को पोर्ट किया और मुझे यह अनावश्यक रूप से क्रिया लगता है। कोड पहले से ही बहुत अधिक क्रियात्मक है क्योंकि यह पहले mem::uninitialized का उपयोग करके "गलत तरीके से" था।

मुझे लगता है कि MaybeUninit<T> को केवल Uninit<T> कहा जाना चाहिए, क्योंकि सभी व्यावहारिक उद्देश्यों के लिए, यदि आपको कोई अज्ञात MaybeUninit<T> मिलता है, तो आपको यह मान लेना होगा कि यह अनैतिक है, इसलिए Uninit<T> कि संक्षेप में सही होगा। इसके अलावा, into_uninitialized केवल into_init() या समान कारणों से होना चाहिए।

हम टाइप Uninitialized<T> और मेथड into_initialized भी कह सकते हैं, लेकिन टाइप के लिए एक संक्षिप्त नाम और विधि या इसके विपरीत के लिए लंबे समय का उपयोग करना एक दर्दनाक असंगति है। आदर्श रूप में मुझे बस यह याद रखना चाहिए कि "जंग एपीआई संक्षिप्त / लंबे रूपों का उपयोग करते हैं" और यही है।

क्योंकि संक्षिप्तीकरण विभिन्न लोगों के लिए अस्पष्ट हो सकता है, मैं हर जगह लंबे रूपों का उपयोग करना पसंद करता हूं और इसे एक दिन कहता हूं। लेकिन एक मिश्रण का उपयोग करना IMO दोनों दुनिया में सबसे खराब है। जंग लंबे समय तक रूपों से अधिक बार संक्षिप्त रूप का उपयोग करती है, इसलिए मेरे पास Uninit<T> एक संक्षिप्त नाम के रूप में और .into_init() विधि के लिए एक अन्य संक्षिप्त नाम के रूप में होगा।

मुझे into_initialized() पसंद नहीं है, क्योंकि ऐसा लगता है कि मूल्य को शुरू करने के लिए एक परिवर्तन हो रहा है। मैं take_initialized() बहुत पसंद करता हूं। मुझे लगता है कि टाइप सिग्नेचर अन्य take विधियों से छूटता है, लेकिन मुझे लगता है कि यह बहुत स्पष्ट, शब्दार्थ है, और मेरा मानना ​​है कि शब्दार्थ स्पष्टता को उधार / चाल स्थिरता को छोड़ देना चाहिए। अन्य विकल्प जिनके पास पहले से उत्परिवर्तित उधार होने की कोई पूर्वता नहीं है, वे move_initialized या consume_initialized ।

set() write() , मैं दृढ़ता से write() का पक्ष लेता हूं ताकि as_ptr().write() को समानता प्रदान की जा सके, जिसके लिए यह एक उपनाम होगा।

और अंत में, अगर कोई take_initialized() या समान होने जा रहा है, तो मैं read_initialized() read() पक्ष पूर्व के गवाह के कारण देता हूं।

संपादित करें : लेकिन स्पष्ट करने के लिए, मुझे लगता है कि as_ptr().write() और as_ptr().read() साथ चिपके रहना और भी स्पष्ट है और DANGER DANGER मानसिक सर्किट को ट्रिगर करने की अधिक संभावना है।

@gnzlbg हमारे पास एक था FCP प्रकार के नाम के लिए, मुझे यकीन नहीं है कि हमें उस चर्चा को फिर से खोलना चाहिए।

हालांकि, मैं लगातार "init" का उपयोग करने के प्रस्ताव को पसंद करता हूं, जैसा कि MaybeUninit::uninit() और x.into_init() ।

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

into विधियाँ वास्तव में किसी विशेष प्रकार पर समान (स्वामित्व) डेटा देखने के अलावा कोई भी परिवर्तन नहीं करती हैं - उदाहरण के लिए विभिन्न into_vec विधियाँ देखें।

मैं take_initialized(&mut self) (in_init के अतिरिक्त) के साथ ठीक हूं, लेकिन मुझे लगता है कि इसे आंतरिक अवस्था में undef वापस कर देना चाहिए।

आंतरिक स्थिति को वापस लाएं

https://github.com/rust-lang/rust/issues/53491#issuecomment -437811282

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

इनमें से कई बातें पहले से ही 200+ छिपी टिप्पणियों में चर्चा की गई हैं।

इनमें से कई बातें पहले से ही 200+ छिपी टिप्पणियों में चर्चा की गई हैं।

मैं थोड़ी देर के लिए चर्चा का पालन कर रहा हूं, और मुझसे गलती हो सकती है, लेकिन मुझे नहीं लगता कि इस बिंदु को पहले लाया गया है। विशेष रूप से, आपके द्वारा उद्धृत टिप्पणी "आंतरिक राज्य को undef " में वापस करने का सुझाव नहीं देती है, लेकिन यह ptr::read बराबर है (जो आंतरिक स्थिति को अपरिवर्तित छोड़ना है)। मैं जो सुझाव दे रहा हूं वह mem::replace(self, MaybeUninit::uninitialized()) के वैचारिक समतुल्य है।

mem::replace(self, MaybeUninit::uninitialized()) के वैचारिक समतुल्य।

क्योंकि के अर्थ का undef , कि के बराबर है read : https://rust.godbolt.org/z/e0-Gyu

@scottmcm नहीं यह नहीं है। read , निम्नलिखित कानूनी है:

let mut x = MaybeUninit::<u32>::uninitialized();
x.set(13);
let x1 = unsafe { x.read_initialized() };
// `u32` is `Copy`, so we may read multiple times.
let x2 = unsafe { x.read_initialized() };
assert_eq!(x1, x2);

प्रस्तावित take , यह अवैध होगा क्योंकि x2 undef ।

सिर्फ इसलिए कि दो कार्य एक ही विधानसभा उत्पन्न करते हैं इसका मतलब यह नहीं है कि वे समान हैं।

हालाँकि, मैं undef साथ सामग्री को अधिलेखित करने से कोई लाभ नहीं देखता। यह सिर्फ लोगों को खुद को पैर में गोली मारने के लिए और अधिक तरीके पेश करता है। @jethrogb आपने कोई प्रेरणा नहीं दी है, क्या आप बता सकते हैं कि आपको क्यों लगता है कि यह एक अच्छा विचार है?

मैं take_initialized(&mut self) (in_init के अतिरिक्त) के साथ ठीक हूं, लेकिन मुझे लगता है कि इसे आंतरिक अवस्था में undef वापस कर देना चाहिए।

मैं प्रस्ताव कर रहा था take_initialized(self) के बजाय into_initialized(self) , क्योंकि मेरा मानना है कि पूर्व नाम और अधिक सही संचालन का वर्णन है। फिर से, मैं समझता हूं कि take आमतौर पर &mut self और into आम तौर पर self लगते हैं, लेकिन मेरा मानना ​​है कि शब्दार्थ रूप से सटीक नामकरण, लगातार लिखे जाने से अधिक महत्वपूर्ण है नामकरण। शायद एक अलग नाम का उपयोग किया जाना चाहिए, हालांकि, जैसे move_initialized या transmute_initialized ।

और, फिर से, v.write() और v.read_initialized() , मुझे v.as_ptr().write() और v.as_ptr().read() से अधिक कोई सकारात्मक मूल्य नहीं दिखता है। बाद के दो का दुरुपयोग होने की संभावना कम लगती है।

और, फिर से, v.write() और v.read_initialized() , मुझे v.as_ptr().write() और v.as_ptr().read() से अधिक कोई सकारात्मक मूल्य दिखाई नहीं देता है। बाद के दो का दुरुपयोग होने की संभावना कम लगती है।

v.write() (या v.set() या जो भी हम इसे इन दिनों कह रहे हैं) सुरक्षित है। v.as_ptr().write() को unsafe ब्लॉक की आवश्यकता होती है, जो कि कष्टप्रद है। हालाँकि मैं v.read_init() vs v.as_ptr().read() सहमत हूँ। v.read_init() सतही लगता है।

मैं in_initialized (स्व) के बजाय take_initialized (self) का प्रस्ताव कर रहा था, क्योंकि मेरा मानना ​​है कि पूर्व नाम अधिक सटीक रूप से ऑपरेशन का वर्णन करता है। फिर से, मैं समझता हूं कि आम तौर पर टेक एक और म्यूट सेल्फ लेता है और आमतौर पर सेल्फी लेता है, लेकिन मेरा मानना ​​है कि शब्दबद्ध रूप से सटीक नामकरण लगातार टाइप किए गए नामकरण से अधिक महत्वपूर्ण है।

मुझे दृढ़ता से लगता है कि into_init(ialized) भी शब्दार्थ से अधिक सटीक है - यह सब के बाद MaybeUninit उपभोग करता है।

@mjbshaw आह, हाँ, तो यह है। मैंने यह नहीं देखा कि ... ठीक है, ठीक है, उस मामले में मैंने अपनी पिछली सभी टिप्पणियों को set / write बारे में रद्द कर दिया। शायद set अधिक समझ में आता है; Cell और Pin पहले से ही set विधियों को परिभाषित करते हैं। प्राथमिक अंतर यह होगा कि MaybeUninit::set पहले संग्रहीत किसी भी मूल्य को नहीं गिराएगा; शायद यह अब भी write ... मुझे नहीं पता। किसी भी तरह से, प्रलेखन बहुत स्पष्ट है।

@RalfJung ठीक है, take... भूल जाओ। एक नए नाम के बारे में क्या है, जैसे move... , consume... , या transmute... या कुछ और? मुझे लगता है कि into_init(ialized) बहुत भ्रामक है; मुझे भी, इसका मतलब है कि मूल्य को इनिशियलाइज़ किया जा रहा है, जब हम वास्तव में यह अनुमान लगा रहे हैं कि यह पहले से ही इनिशियलाइज़ हो गया था।

जब हम वास्तव में स्पष्ट रूप से कहते हैं कि यह पहले से ही आरंभिक था।

मुझे लगता है कि यह फिर से कॉल करने के लिए लायक है कि into_init जोर देने वाली एकमात्र बात यह है कि मूल्य T के _validity invariant_ को संतुष्ट करता है, जिसे T साथ भ्रमित नहीं होना है

उदाहरण के लिए:

pub mod foo {
    pub struct AlwaysTrue(bool);
    impl AlwaysTrue { 
        pub fn new() -> Self { Self(true) }
        /// It is impossible to initialize `AlwaysTrue` to false
        /// and unsafe code can rely on `is_true` working properly:
        pub fn is_true(x: bool) -> bool { x == self.0 }
    }
}

pub unsafe fn improperly_initialized() -> foo::AlwaysTrue {
    let mut v: MaybeUninit<foo::AlwaysTrue> = MaybeUninit::uninitialized();
    // let v = v.into_init(); // UB: v is invalid
    *(v.as_mut_ptr() as *mut u8) = 3; // OK
    // let v = v.inti_init(); // UB v is invalid
    *(v.as_mut_ptr() as *mut bool) = false; // OK
    let v = v.into_init(); // OK: v is valid, even though AlwaysTrue is false
    v
}

यहाँ improperly_initialized का वापसी मूल्य इस अर्थ में "इनिशियलाइज़्ड" है कि यह T की _validity invariant_ को संतुष्ट करता है, लेकिन इस अर्थ में नहीं कि यह T के _safety के Invantant_ को संतुष्ट करता है , और भेद सूक्ष्म लेकिन महत्वपूर्ण है, क्योंकि इस मामले में इस अंतर को improperly_initialized unsafe fn रूप में घोषित करने की आवश्यकता है।

जब अधिकांश उपयोगकर्ता "आरंभिक" होने के बारे में बात करते हैं, तो उनके पास आमतौर पर MaybeUninit::into_init का "वैध लेकिन शायद होउंसफेफ़" शब्दार्थ नहीं होता है।

अगर हम इनके बारे में विशेष रूप से जानना चाहते हैं, तो हमारे पास Invalid<T> और Unsafe<T> , Invalid<T>::into_valid() -> Unsafe<T> , और उपयोगकर्ताओं को uninit.into_valid().into_safe() लिखने की आवश्यकता होती है। तब improperly_initialized Unsafe<T> वापस आएगा, और उपयोगकर्ता द्वारा AlwaysTrue true का मान ठीक से सेट करने के बाद ही वे वास्तव में सुरक्षित T प्राप्त कर सकते हैं:

// note: this is now a safe fn
fn improperly_uninitialized() -> Unsafe<foo::AlwaysTrue>;
fn initialized() -> foo::AlwaysTrue {
    let mut v: Unsafe<foo::AlwaysTrue> = improperly_uninitialized();
    unsafe { v.as_mut_ptr() as *mut bool } = true;
    unsafe { v.into_safe() }
}

ध्यान दें कि यह improperly_uninitialized सुरक्षित fn बनने की अनुमति देता है, क्योंकि अब यह कि AlwaysTrue सुरक्षित नहीं है फ़ंक्शन के आसपास "टिप्पणियों" में एन्कोडेड नहीं है, लेकिन प्रकार के।

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

एक बात Invalid<T> और Unsafe<T> दो लक्षणों के साथ भी हो सकती है, ValidityCheckeable और UnsafeCheckeable , दो विधियों के साथ, ValidityCheckeable::is_valid(Invalid<Self>) UnsafeCheckeable::is_safe(Unsafe<Self>) , और उन पर Invalid::into_valid और Unsafe::into_safe विधियाँ assert_validity! और assert_safety! ।

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

मुझे लगता है कि यह फिर से कॉल करने के लिए लायक है कि केवल in_init का दावा है कि मान T की वैधता अपरिवर्तनीय को संतुष्ट करता है, जो कि टी को शब्द के किसी भी सामान्य अर्थ में "आरंभीकृत" होने के साथ भ्रमित नहीं होना है।

यह सही है। OTOH, मुझे लगता है कि "इनिशियलाइज़्ड" पहली व्याख्या में इसके लिए एक उचित प्रॉक्सी है।

अन्यथा लोग fn को अनुचित रूप से लिख सकते हैं_अनियंत्रित () -> AlwaysTrue को एक सुरक्षित fn के रूप में, और बस एक असुरक्षित OneTrue को वापस लौटा दें क्योंकि ठीक है, उन्होंने इसे "इनिशियलाइज़" किया है।

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

एक बात अमान्य के साथ भी हो सकती हैऔर असुरक्षितहै) और असुरक्षित है :: is_safe (असुरक्षित)), और अमान्य :: in_valid और असुरक्षित :: in_safe विधियाँ assert_validity! और assert_safety! उन पर।

अधिकांश मामलों में, सुरक्षा अपरिवर्तनीय जाँच योग्य नहीं होगी। यहां तक ​​कि वैधता अपरिवर्तनीय भी संदर्भों के लिए जाँच योग्य नहीं है। (खैर, यह इस बात पर थोड़ा निर्भर करता है कि हम चीजों को कैसे करते हैं।)

@scottjmaddox

एक नए नाम के बारे में क्या है, जैसे कि चाल ..., उपभोग ..., या प्रसारण ... या कुछ और? मुझे लगता है कि in_init (ialized) बहुत भ्रामक है; मुझे भी, इसका मतलब है कि मूल्य को इनिशियलाइज़ किया जा रहा है, जब हम वास्तव में यह अनुमान लगा रहे हैं कि यह पहले से ही इनिशियलाइज़ हो गया था।

move_init एक "दावे" को into_init से अधिक कैसे दर्शाता है?

assert_init(italized) पहले सुझाया गया है।

हालाँकि, ध्यान दें कि read या read_initialized या as_ptr().read भी वास्तव में कुछ भी करने के बारे में कुछ भी नहीं कहते हैं।

अगर हम इनके बारे में विशेष रूप से जानना चाहते हैं, तो हमारे पास Invalid<T> और Unsafe<T> , Invalid<T>::into_valid() -> Unsafe<T> , और उपयोगकर्ताओं को uninit.into_valid().into_safe() लिखने की आवश्यकता होती है। तब improperly_initialized Unsafe<T> वापस आएगा, और उपयोगकर्ता द्वारा AlwaysTrue true का मान ठीक से सेट करने के बाद ही वे वास्तव में सुरक्षित T प्राप्त कर सकते हैं:

@gnzlbg अरे, यह बहुत अच्छा है। मुझे यह पसंद है कि यह एक अपरिहार्य तरीके से उपयोगकर्ता के चेहरे में अंतर को फेंकता है। यह शायद एक अच्छा शिक्षण क्षण है। "वैधता" और "सुरक्षा" जो लोगों को दो बार सोचेंगी? uninit.into_valid().into_safe() uninit.assume_initialized() या whatnot की तुलना में वैसे भी क्रिया नहीं है। बेशक इस अंतर को बनाने के लिए हमें पहले स्थान पर मॉडल के आसपास समझौते की आवश्यकता होगी। Should मुझे लगता है कि हमें इस मॉडल की कुछ और जांच करनी चाहिए।

assert_init(italized) पहले सुझाया गया है।

@ राल्फजंग हमारे पास @eternaleye (मुझे लगता है) के कारण assume_initialized भी है। Https://github.com/rust-lang/rust/issues/53491#issuecomment -440730699 औचित्य की सूची के साथ देखें जो बहुत सम्मोहक हैं।

टीबीएच मुझे लगता है कि दो तरह से होने की संभावना बहुत अधिक है।

@ राल्फजंग क्या हम

हम्म ... यदि हम अधिक क्रिया एपीआई पर विचार कर रहे हैं, तो

uninit.into_inner(uninit.assert_initialized());

बहुत अच्छी तरह से शब्दार्थ काम कर सकता है। पहला तरीका एक टोकन देता है जो आपके दावे को दर्ज करता है। दूसरी विधि आंतरिक प्रकार लौटाती है, लेकिन आपको यह मानने की आवश्यकता है कि यह मान्य है।

मैं पूरी तरह से आश्वस्त नहीं हूं कि यह अतिरिक्त प्रयास के लायक है, क्योंकि अमूर्तता सिर्फ लोगों को अधिक भ्रमित कर सकती है और इस तरह गलतियां होने की संभावना है।

हमने @eternaleye (मुझे लगता है) के कारण

मेला। assume_initialized मुझे अच्छा लगता है।

या शायद यह assume_init ? यह संभव है कि कंस्ट्रक्टर के साथ संगत होना चाहिए, MaybeUninit::uninit() बनाम MaybeUninit::uninitialized() - और वह पहले बैच के साथ स्थिर होने के लिए स्लेटेड है, इसलिए हमें जल्द ही उस कॉल को करना चाहिए।

@nicoburns मुझे यहां एक टोकन के माध्यम से एक अप्रत्यक्ष जोड़ने से लाभ नहीं मिलेगा।

क्या हम उसमें गहरी खुदाई कर सकते हैं? संभवत: उदाहरणों की कुछ तुलनाओं के साथ जो आपको लगता है कि उच्च स्तर की क्रियाशीलता है?

ठीक है, यह स्पष्ट है कि यह "सिर्फ" MaybeUninit से अधिक वर्बोज़ है, है ना? बहुत अधिक मानसिक बोझ है (दो प्रकारों को समझने के लिए), वहाँ डबल-अलिखित है, और इसका मतलब है कि मुझे यह चुनना है कि किस प्रकार का उपयोग करना है। तो यहाँ कुछ अतिरिक्त लागत है जो मुझे लगता है कि आपको उचित ठहराने की आवश्यकता है।

मुझे वास्तव में Unsafe की उपयोगिता पर संदेह है। संकलक दृष्टिकोण से, यह पूरी तरह से एक एनओपी होगा; संकलक कभी नहीं मानता है कि आपका डेटा सुरक्षा आक्रमणकारी को संतुष्ट करता है। पुस्तकालय कार्यान्वयन के दृष्टिकोण से, मुझे अत्यधिक संदेह है कि Vec कार्यान्वयन में, कोड की पठनीयता में सुधार होगा, जब भी हम अस्थायी रूप से सुरक्षा आक्रमणकारी का उल्लंघन करते हैं, हम चीजों को Unsafe<Vec<T>> प्रसारित करते हैं। और एक शिक्षण के नजरिए से, मुझे संदेह है कि जब Vec<T> मिलेंगे तो किसी को आश्चर्य नहीं होगा।
इसके विपरीत MaybeUninit जो एक संकलक दृष्टिकोण से आवश्यक है, और जहां तथ्य यह है कि आपको "ख़राब" bool अपने स्वयं के निजी कोड में सावधान रहने की आवश्यकता है, कुछ के लिए एक आश्चर्य के रूप में आ सकता है ।

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

मैं MaybeUninit से MaybeInvalid नाम बदलने के तर्क देख सकता हूं। हालांकि, "अमान्य" बेहद अस्पष्ट है ( किस लिए अमान्य है?), मैंने "वैध" और "सुरक्षित" के बीच के अंतर को देखकर लोगों को भ्रमित किया है - कोई यह मान सकता है कि "मान्य Vec " के लिए मान्य है। किसी भी तरह का उपयोग। कम से कम मूल रूप से "uninitialized" ज्यादातर लोगों के लिए सही संघ हैं। हो सकता है कि हमें "वैद्यता अक्रियाशील" का नाम बदलकर "इनिशियलाइज़ेशन इनवेरियंट" कर दिया जाए?

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

तो IMO जो कोई भी यह देखना चाहता है कि सम्मेलन में MaybeUninit API को काटने की तुलना में बड़ी मछली है, और मैं सुझाव दूंगा कि इसके स्थिरीकरण में और देरी न करें और उस प्रक्रिया के समाधान पर प्रतीक्षा करें। यदि हम MaybeUninit<T> -> T रूपांतरणों को स्थिर करते हैं, तो भविष्य की रस्ट पीढ़ियों को डेटा को इंगित करने के लिए अभी भी MaybeUninit<Unsafe<T>> लिखा जा सकता है, जो कि पहले गैर-पंजीकृत है, और फिर संभवतः आरंभीकृत होने के बाद भी सुरक्षित नहीं है।

@RalfJung

या शायद यह assume_init ? यह संभव है कि कंस्ट्रक्टर के साथ संगत होना चाहिए, MaybeUninit::uninit() बनाम MaybeUninit::uninitialized() - और _that_ को पहले बैच के साथ स्थिर किया जाना है, इसलिए हमें जल्द ही उस कॉल को करना चाहिए।

यदि हमारे पास टाइप, कंस्ट्रक्टर और -> T फ़ंक्शन के साथ 3-तरिके संगति हो सकती है जो और भी बेहतर होगी। जैसा कि -ialized प्रत्यय नहीं है, मुझे लगता है कि ::uninit() और .assume_init() शायद जाने का रास्ता है।

ठीक है, यह स्पष्ट है कि यह "सिर्फ" MaybeUninit , सही से अधिक क्रिया है?

निर्भर करता है ... मुझे लगता है कि foo.assume_init().assume_safe() (या foo.init().safe() अगर एक संक्षिप्त होने की इच्छुक है) सब लंबे समय तक कि नहीं है। यदि आवश्यक हो तो हम संयोजन को foo.assume_init_safe() रूप में भी पेश कर सकते हैं। संयोजन में अभी भी लाभ है कि यह दो मान्यताओं को मंत्र देता है।

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

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

मुझे वास्तव में Unsafe की उपयोगिता पर संदेह है। संकलक दृष्टिकोण से, यह पूरी तरह से एक एनओपी होगा; संकलक कभी नहीं मानता है कि आपका डेटा सुरक्षा आक्रमणकारी को संतुष्ट करता है।

ज़रूर; मैं सहमत हूँ कि एक संकलक POV से यह बेकार है। भेद से कोई भी उपयोगिता "सत्र प्रकार" इंटरफ़ेस के रूप में है।

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

जिस पहलू ने मेरी आंख को पकड़ा, वह एक व्यक्ति था। मुझे लगता है कि गलतियाँ तब होती हैं जब लोग सोचते हैं कि .assume_init() मतलब है कि "ठीक है; मैंने वैधता की जाँच की है और अब मेरे पास एक अच्छा T "। MaybeUninit<T> की वर्तमान योजना इस तरह से अप्राप्य है। मैं हालांकि Unsafe<T> और Invalid<T> के नाम के रूप में शादी नहीं कर रहा हूँ। मैं केवल यह सोचता हूं कि दो प्रकारों में अलगाव, उनके नाम, जो शैक्षिक रूप से सहायक हो सकते हैं। शायद ऐसे और भी तरीके हैं जैसे कि दस्तावेज़ में गोमांस डालना जो मौजूदा ढांचे के भीतर इसकी भरपाई कर सकते हैं?

I _can_ MaybeUninit से MaybeInvalid नाम बदलने के तर्कों को देखें। हालांकि, "अमान्य" बेहद अस्पष्ट है (_what_? के लिए अमान्य), मैंने "वैध" और "सुरक्षित" के बीच के अंतर को देखकर लोगों को भ्रमित किया है - कोई यह मान सकता है कि "मान्य Vec " के लिए मान्य है किसी भी तरह का उपयोग। कम से कम मूल रूप से "uninitialized" ज्यादातर लोगों के लिए सही संघ हैं। हो सकता है कि हमें "वैद्यता अक्रियाशील" का नाम बदलकर "इनिशियलाइज़ेशन इनवेरियंट" कर दिया जाए?

मैं निश्चित रूप से "वैधता" और "सुरक्षा" के साथ सहमत हूं जिस तरह से "वैध" ध्वनियों के कारण भ्रमित हो रहा है। मैं "सुरक्षा" के लिए "वैधता" और "प्रकार प्रणाली अपरिवर्तनीय" के प्रतिस्थापन के रूप में "मशीन इनवेरिएंट" के लिए आंशिक रहा हूं।

@rkruppe

तो IMO जो कोई भी यह देखना चाहता है कि सम्मेलन में MaybeUninit API को काटने की तुलना में बड़ी मछली है, और मैं सुझाव दूंगा कि इसके स्थिरीकरण में और देरी न करें और उस प्रक्रिया के समाधान पर प्रतीक्षा करें। यदि हम MaybeUninit<T> -> T रूपांतरणों को स्थिर करते हैं, तो भविष्य की रस्ट पीढ़ी अभी भी MaybeUninit<Unsafe<T>> डेटा को इंगित करने के लिए लिख सकती है, जो पहले अनधिकृत है, और फिर संभवतः आरंभीकृत होने के बाद भी सुरक्षित नहीं है।

अच्छे अंक, विशेष रूप से फिर से। MaybeUninit<Unsafe<T>> ; आप संभवतः टाइप नाम को कम क्रिया बनाने के लिए कुछ प्रकार के उपनाम भी जोड़ सकते हैं।

यदि हम टाइप, कंस्ट्रक्टर, और -> T फ़ंक्शन के साथ 3-तरिके संगति रख सकते हैं, जो और भी बेहतर होगा। जैसा कि टाइप में -ialized प्रत्यय नहीं है मुझे लगता है :: uninit () और .assume_init () शायद जाने का रास्ता है।

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

तो फिर read / read_init क्या? क्या ptr::read साथ समानता को ट्रिगर करने के लिए पर्याप्त है "आप बेहतर सुनिश्चित करते हैं कि यह वास्तव में आरंभीकृत है"? क्या read_init पास into_init समान मुद्दा है, जहां ऐसा लगता है कि यह एक धारणा के रूप में होने के बजाय इसे आरंभीकृत करता है? शायद assume_init read तरह होना चाहिए?

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

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

मुझे लगता है कि इस तरह के प्रकार को जोड़ना अंतर्निहित अवधारणा को व्यक्त करने का गलत तरीका है।

मुझे लगता है कि गलतियाँ तब होती हैं जब लोग सोचते हैं कि .assume_init () का अर्थ है कि "ठीक है; मैंने वैधता की जांच की है और अब मेरे पास एक अच्छा टी है"।

मैं इसे अत्यधिक संभावना नहीं किसी तरह "मैं प्रारंभ है यह हो जाएगा कि लगता है Vec<i32> इसे लिखने से भरा द्वारा 0xFF , अब यह आरंभ नहीं हो जाता, कि साधन मैं इसे करने के लिए धक्का कर सकते हैं"। मैं कम से कम एक संकेत, बेहतर ठोस डेटा देखना चाहूंगा कि यह वास्तव में एक गलती है जो लोग करते हैं।
मेरे अनुभव में, लोगों को एक बहुत ही ठोस अंतर्ज्ञान है कि जब वे अज्ञात कोड को डेटा सौंपते हैं, या कुछ डेटा पर पुस्तकालय संचालन कहते हैं, तो पुस्तकालय के आक्रमणकारियों को बरकरार रखने की आवश्यकता होती है।

यहां चीजें थोड़ी शांत हो गई हैं। तो निम्नलिखित योजना के बारे में क्या:

• मैं MaybeUninit::uninitialized निकालने के लिए PR तैयार करता हूं और इसे MaybeUninit::uninit नाम देता हूं।
• एक बार जो उतरा है (स्टडसिम को अपडेट करने की आवश्यकता है, इसलिए यहां कुछ समय है अगर लोगों को लगता है कि यह रास्ता नहीं है), मैं MaybeUninit::{new, uninit, zeroed, as_ptr, as_mut_ptr} को स्थिर करने के लिए एक पीआर तैयार करता हूं।

यह पत्ते set / write , into_init[ialized] / assume_init[ialized] और read[_init[italized]] के आसपास प्रश्न खोलते हैं। वर्तमान में, मैं assume_init , write और read ओर झुकता हूं, लेकिन मैंने पहले इस बारे में अपना विचार बदल दिया है। दुर्भाग्य से मुझे इस बारे में अच्छा विचार नहीं है कि यहां निर्णय कैसे लिया जाए।

• एक बार जो उतरा है

क्या इसका मतलब यह है कि ऐसी अवधि होगी जहां अस्थिर विशेषताओं का उपयोग करके या तो (ए) एक डिप्रेसेशन चेतावनी या (बी) के बिना एक असमान मूल्य बनाने के लिए कोई आय

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

क्या इसका मतलब यह है कि ऐसी अवधि होगी जहां अस्थिर विशेषताओं का उपयोग करके या तो (ए) एक डिप्रेसेशन चेतावनी या (बी) के बिना एक असमान मूल्य बनाने के लिए कोई आय नहीं है?

मैं उलझन में हूं। मैं एक अस्थिर विधि को अपदस्थ करने का प्रस्ताव कर रहा हूं और इसके बजाय एक और अस्थिर विधि का परिचय दे रहा हूं।

ध्यान दें कि मैं MaybeUninit::uninitialized बारे में बात कर रहा था, mem::uninitialized ।

दुर्भाग्य से मुझे इस बारे में अच्छा विचार नहीं है कि यहां निर्णय कैसे लिया जाए।

@RalfJung बस इसे (और आर? मुझे पसंद है तो आप) जैसा कि आपने पहले अन्य नाम बदलने वाले पीआर के साथ किया था और अगर कोई भी वस्तु जो हम उस में सौदा कर सकते हैं FCP। :)

बस यह करो (और आर? मुझे अगर तुम पसंद हो) जैसा कि आपने पहले अन्य नाम बदलने वाले पीआर के साथ किया था और अगर कोई वस्तु जो हम उस के साथ सौदा कर सकते हैं FCP। :)

खैर, मैं थोड़ा इंतजार करने जा रहा हूं क्योंकि इन्हें शुरुआती स्थिरीकरण का हिस्सा नहीं बनना है।

एक अस्थिर विधि को चित्रित करें और इसके बजाय एक और अस्थिर विधि का परिचय दें

आह, गच्चा। तब तक ले जाना।

सभी अधिकार, https://github.com/rust-lang/rust/pull/59284 में नाम बदलकर कर रहे हैं:

uninitialized -> एकतरफा
in_initialized -> मान_अनुकूल
read_initialized -> पढ़ा
सेट -> लिखना

मुझे नए प्रस्तावित नाम पसंद हैं। मैं read दुरुपयोग के बारे में थोड़ा चिंतित हूं, लेकिन ऐसा लगता है कि into_initialized का दुरुपयोग होने की संभावना बहुत कम है, मुख्य रूप से ptr::read साथ सहयोग के कारण। कुल मिलाकर, मुझे लगता है कि नया नामकरण पूरी तरह से स्थिरीकरण के लिए स्वीकार्य है।

मैं IFUninit को स्थिर करने के लिए एक PR तैयार करता हूं :: {नया, uninit, zeroed, as_ptr, as_mut_ptr}।

कोई भी मौका इसे 1.35-बीटा (~ 2 सप्ताह में) के कारण बना सकता है?

मैं इसे देखते हुए थोड़ा विवादित हूं कि यह पूरी तरह से हवा में कैसे है https://github.com/rust-lang/rfcs/pull/2582 अभी भी है। : / RFC के बिना, किसी संरचना का क्रमिक आरंभ अभी भी संभव नहीं है, लेकिन लोग इसे वैसे भी करेंगे।
OTOH, MaybeUninit ने काफी पहले इंतजार किया है। और यह क्रमिक आरंभीकरण के लिए कोड की तरह नहीं है जो लोग वर्तमान में लिखते हैं कि वे MaybeUninit साथ जो लिखेंगे उससे बेहतर है।

उस ने कहा, https://github.com/rust-lang/rust/pull/59284 अभी भी नहीं उतरा है, इसलिए हमें इसे 1.35 में लाने के लिए जल्दी करना होगा। टीबीएच मैं एक और चक्र की प्रतीक्षा करना पसंद करूंगा ताकि लोगों को कम से कम कुछ समय नई पद्धति के नामों के साथ खेलने के लिए मिले और देखें कि वे कैसा महसूस करते हैं।

वहाँ किसी भी मौका पर निर्माण कार्यों कि है MaybeInit हो सकता है const ?

init और new const । zeroed नहीं है, हमें कुछ एक्सटेंशन की आवश्यकता है कि इससे पहले कि यह const हो जाए, कांस्ट फ़ंक्शन क्या कर सकता है।

मैं MaybeUninit पर कुछ प्रतिक्रिया देना चाहता था, वास्तविक कोड परिवर्तन यहां देखे जा सकते हैं https://github.com/Thomasdezeeuw/mio-st/pull/71। एपीआई के साथ कुल मिलाकर मेरा (सीमित) अनुभव सकारात्मक था।

केवल एक छोटा सा मुद्दा जो मुझे मिला वह यह था कि &mut T MaybeUninit::set रिटर्न let _ = ... (https://github.com/Thomasdezeeuw/mio-st-pull/) का उपयोग करने के लिए होता है। 71 / फ़ाइलें # diff-1b9651542d08c6eca04e6025b1c6fd53R116), जो थोड़ा अजीब है, लेकिन बहुत बड़ी समस्या नहीं है।

मुझे एपीआई को भी जोड़ना होगा, जब मैं सी के साथ संयोजन में अक्सर इकाईबद्ध सरणियों के साथ काम करना चाहूंगा।

1. &mut [MaybeUninit<T>] से &mut [T] जाने की विधि अच्छी होगी, उपयोगकर्ता को यह सुनिश्चित करना होगा कि स्लाइस में सभी मान एक ठीक से आरंभीकृत हों
2. एक सार्वजनिक सरणी इनिशियलाइज़र फ़ंक्शन या मैक्रो, uninitialized_array , वास्तव में अच्छा भी होगा।

मैं शायद यूफिनिट पर कुछ प्रतिक्रिया देना चाहता था

आपका बहुत बहुत धन्यवाद!

हो सकता है लौटने और mutUninit में म्यूट टी :: सेट का उपयोग करने की ओर जाता है _ = ...

यह क्यों? आप केवल रिटर्न मानों को "फेंक" सकते हैं, वास्तव में डॉक्स में उदाहरण let _ = ... नहीं करते हैं। ( write / set का उदाहरण अभी तक नहीं है ... लेकिन वास्तव में यह read के समान ही है, शायद यह सिर्फ लिंक होना चाहिए।)

foo.write(bar); let बिना ठीक काम करता है।

इकाईबद्ध सरणियों के साथ काम करना

हाँ, यह निश्चित रूप से भविष्य के हित का एक क्षेत्र है।

@RalfJung

हो सकता है लौटने और mutUninit में म्यूट टी :: सेट का उपयोग करने की ओर जाता है _ = ...

यह क्यों? आप केवल रिटर्न मानों को "फेंक" सकते हैं, वास्तव में डॉक्स में उदाहरण let _ = ... नहीं करते हैं। ( write / set का उदाहरण अभी तक नहीं है ... लेकिन वास्तव में यह read के समान ही है, शायद यह सिर्फ लिंक होना चाहिए।)

मैंने unused_results लिए चेतावनी को सक्षम किया है, इसलिए let _ = ... बिना यह एक चेतावनी उत्पन्न करेगा। मैं भूल गया कि डिफ़ॉल्ट नहीं है।

आह, मैं उस चेतावनी के बारे में नहीं जानता था। दिलचस्प।

यह एक write एक संदर्भ वापस नहीं करने के लिए एक तर्क हो सकता है, और यदि अधिक मांग है तो इसके लिए एक अलग विधि प्रदान करें।

एक सार्वजनिक सरणी आरंभीकरण समारोह या मैक्रो, uninitialized_array , वास्तव में अच्छा इसके अलावा होगा।

यह सिर्फ [MaybeUninit::uninit(); EVENTS_CAP] । Https://github.com/rust-lang/rust/issues/49147 देखें

मैं भूल गया कि डिफ़ॉल्ट नहीं है।

यह एक write एक संदर्भ नहीं लौटाने के लिए एक तर्क हो सकता है, और यदि अधिक मांग है तो इसके लिए एक अलग विधि प्रदान करें।

आला लगता है? यदि भविष्य में अधिक मांग है तो हम एक ऐसी विधि जोड़ सकते हैं जो एक संदर्भ वापस नहीं करती है ।

आला लगता है?

हाँ, वहाँ कई तरीके हैं जो एक मूल्य निर्धारित करते हैं और फिर एक परस्पर संदर्भ देते हैं।

@ सेंट्रील हेह, मुझे नहीं लगता कि मैंने आपकी टिप्पणी यहां देखी थी जब मैंने इसे कहीं और लिखा था: https://github.com/rust-lang/rust/issues/54542#issuecomment -478261027

Https://github.com/rust-lang/rust/pull/59912 में पुराने निकाले गए पुराने कार्यों को हटाना

उसके बाद, मुझे लगता है कि अगले काम करना स्थिरीकरण का प्रस्ताव है ...: टाडा:

मैं इस बात को लेकर थोड़ा विवादित हूं कि यह कैसे पूरी तरह से हवा में जंग-लंग / rfcs # 2582 अभी भी है। : / RFC के बिना, किसी संरचना का क्रमिक आरंभ अभी भी संभव नहीं है, लेकिन लोग इसे वैसे भी करेंगे।
OTOH, MaybeUninit ने काफी पहले इंतजार किया है। और यह क्रमिक आरंभीकरण के लिए कोड की तरह नहीं है जो लोग वर्तमान में लिखते हैं कि वे MaybeUninit साथ जो लिखेंगे उससे बेहतर है।

उसके बाद, मुझे लगता है कि अगले काम करना स्थिरीकरण का प्रस्ताव है ... the

@RalfJung यहाँ प्रलेखन की स्थिति कैसी है? यदि हम कुछ स्पष्ट डॉक्स के साथ "लोगों को इसे वैसे भी" कम कर सकते हैं जो मुझे बेहतर नींद में मदद करेंगे ... :)

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

यहाँ प्रलेखन की स्थिति कैसी है? यदि हम कुछ स्पष्ट डॉक्स के साथ "लोगों को इसे वैसे भी" कम कर सकते हैं जो मुझे बेहतर नींद में मदद करेंगे ... :)

मैं शायद यह कहते हुए कि यह वर्तमान में समर्थित नहीं है, यह कहते हुए कि यह क्रमिक रूप से शुरू होने वाली संरचना पर एक खंड जोड़ देगा। इसे पढ़ने वाले लोग "डब्ल्यूटीएफ, वास्तव में?" जैसे होंगे।

टीबीएच मुझे यह निराशा होती है। :( मुझे लगता है कि हमारे लिए अब तक कुछ सलाह के साथ आना बहुत संभव था और मुझे दुख है कि हम ऐसा नहीं कर पाए।

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

आप मूल रूप से इसे डॉक्स में टाइप करने का सुझाव दे रहे हैं, जिसमें डेटा-प्रकार के इनवेरिएंट्स के पूरे विचार को समझाया गया है और यह जंग में कैसे निकलता है। मुझे लगता है कि MaybeUninit उसके लिए गलत जगह है; यह इस तरह लग रहा है कि यह चिंता MaybeUninit लिए विशिष्ट है जब वास्तव में ऐसा नहीं है। जो चीजें आप पूछ रहे हैं, उन्हें कुछ और उच्च-स्तरीय जगह में नामिक की तरह समझाया जाना चाहिए। मेरी योजना इस प्रकार के मूल मुद्दे पर MaybeUninit के डॉक्स को केंद्रित करने की है। अगर आपको लगता है कि यह उपयोगी है, तो उन्हें विस्तारित करने के लिए स्वतंत्र महसूस करें। :)

आप मूल रूप से इसे डॉक्स में टाइप करने का सुझाव दे रहे हैं, जिसमें डेटा-प्रकार के इनवेरिएंट्स के पूरे विचार को समझाया गया है और यह जंग में कैसे निकलता है।

यह थोड़ा मजबूत है ... मैं केवल MaybeUninit<T> के दस्तावेज़ीकरण में कुछ रणनीतिक जगह में "ओह, __by way__, सुरक्षा अपरिवर्तनीय मामलों को भी MaybeUninit<T> करेंगे, जो ज्यादातर मानक पुस्तकालय प्रलेखन के साथ इंटरफ़ेस करेंगे।

सब ठीक है, मैंने स्थिरीकरण में सभी को शामिल करने की कोशिश की पीआर: https://github.com/rust-lang/rust/pull/60445

मैं सिर्फ मानकों पुस्तकालय के प्रलेखन में mem::uninitialized उपयोग पर ठोकर खाई, वास्तव में पता नहीं कहाँ और कहाँ core::ptr::drop_in_place के अंतिम उदाहरण को अद्यतन करने की आवश्यकता है (यह भी विडंबना की तरह) यह यूबी के दूसरे रूप को प्रदर्शित करता है जो केवल https://github.com/rust-lang/rfcs/pull/2582 द्वारा अनुमोदित किया जाएगा, इसलिए व्यक्तिगत रूप से मैं इसे हटा दूंगा)।

@HeroicKatora धन्यवाद! मैंने उसके लिए फिक्स को https://github.com/rust-lang/rust/pull/60445 में शामिल किया

हम वर्तमान में रेफ-टू-अनलग्ड-फील्ड के बारे में वास्तव में कुछ नहीं कर सकते हैं, यह सुनिश्चित नहीं है कि डॉक्टर को हटाना एक अच्छा विचार है।

हो सकता है कि इसमें PartialUninit (या PartialInit ) शामिल हों, जो मेटाडेटा के आधार पर आंशिक रूप से डेटा को इनिशियलाइज़ करेगा।

उदाहरण: MODULEENTRY32W ।
पहला क्षेत्र ( dwSize ) संरचना के आकार ( size_of::<MODULEENTRY32W>() ) द्वारा आरंभ किया जाना चाहिए।

pub trait PartialUninit: Sized {
    fn uninit() -> MaybeUninit<Self>;
}

impl<T> PartialUninit for T {
    default fn uninit() -> MaybeUninit<Self> {
        MaybeUninit::uninit()
    }
}

impl PartialUninit for MODULEENTRY32W {
    unsafe fn uninit() -> MaybeUninit<MODULEENTRY32W> {
        let uninit = MaybeUninit { uninit: () };
        uninit.get_mut().dwSize = size_of::<MODULEENTRY32W>();
        uninit
    }
}

तुम कैसे सोचते हो?

@kgv मुझे डर है कि मैं आपके सुझाव को नहीं समझता। शायद कुछ अतिरिक्त संदर्भ बता रहे हैं कि आप किस समस्या को हल करने की कोशिश कर रहे हैं? और शायद आपके सुझाए गए समाधान का एक और पूर्ण उदाहरण?

@scottjmaddox तय किया । क्या यह स्पष्ट है?

@kgv यह किस समस्या को हल कर रहा है (किसी के विरोध में सिर्फ इसके लिए एक सहायक कार्य लिख रहा है)? मैं यह नहीं देखता कि लिब्स्टड को यहाँ कुछ भी क्यों करना है।

ध्यान दें कि असाइनमेंट-आधारित आंशिक आरंभिक संरचना केवल उन प्रकारों के लिए काम करती है जिन्हें छोड़ने की आवश्यकता नहीं है। uninit.get_mut().foo = bar अन्यथा foo गिरा देगा, जो कि UB है।

@ राल्फजंग मैं जिस समस्या को हल करने की कोशिश कर रहा हूं - एफएफआई संरचनाओं के साथ एकीकृत काम, जिनमें से कुछ क्षेत्र self (केवल Self पर निर्भर नहीं होते हैं या किसी भी चीज़ पर निर्भर नहीं होते हैं (निरंतर), उदाहरण के लिए - फ़ील्ड में से एक का आकार Self ।

@kgv मुझे यहाँ @RalfJung से सहमत

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

बेशक, हम काम से बहुत दूर हैं। हल करने के लिए https://github.com/rust-lang/rfcs/pull/2582 है। libstd में अभी भी mem::uninitialized (अधिकतर प्लेटफ़ॉर्म-विशिष्ट कोड) का कुछ उपयोग होता है, जिन्हें पोर्टिंग की आवश्यकता होती है। अब हमारे पास जो स्थिर एपीआई है वह बहुत कम है: हमें यह पता लगाने की जरूरत है कि read और write साथ क्या करना चाहिए, और हमें API के साथ आना चाहिए जो MaybeUninit सरणियों और बक्से के साथ काम करने में मदद करता है। mem::uninitialized से पूरे पारिस्थितिकी तंत्र को धीरे-धीरे स्थानांतरित करने के लिए बहुत कुछ करने के लिए समझाने की है।

लेकिन हम वहां पहुंचेंगे, ans यह पहला कदम शायद सबसे महत्वपूर्ण था। :)

और हमें एपीआई के साथ आना चाहिए जो MaybeUninit सरणियों और बक्से के साथ काम करने में मदद करता है।

@RalfJung उस अंत तक; शायद अब https://github.com/rust-lang/rust/issues/49147 पर काम शुरू करने का समय है

इसके अलावा, हमें संभवतः इस ट्रैकिंग मुद्दे को शेष बिट्स के लिए छोटे वाले के पक्ष में विभाजित और बंद करना चाहिए।

उस अंत तक; शायद अब # 49147 पर काम शुरू करने का समय है? = P

क्या आप सिर्फ स्वयंसेवक थे? ;) (मुझे डर है कि मेरे पास इसके लिए समय नहीं होगा।)

हमें संभवतः शेष बिट्स के लिए इस ट्रैकिंग समस्या को छोटे लोगों के पक्ष में विभाजित और बंद करना चाहिए।

मैं इस प्रक्रिया के विशेषज्ञों को छोड़ दूँगा। लेकिन मैं सहमत हूं।

क्या आप सिर्फ स्वयंसेवक थे? ;) (मुझे डर है कि मेरे पास इसके लिए समय नहीं होगा।)

मैंने क्या किया है ... = डी - मेरे पास पहले से ही एक परियोजना है जिस पर मैं काम कर रहा हूं इसलिए शायद कुछ समय लगेगा। शायद किसी और को दिलचस्पी है? (यदि ऐसा है, तो ट्रैकिंग मुद्दे में आशा रखें)

मैं इस प्रक्रिया के विशेषज्ञों को छोड़ दूँगा। लेकिन मैं सहमत हूं।

यह मैं होगा ...;) मैं इसे जल्द ही ईश को विभाजित करने और बंद करने की कोशिश करूंगा।

@RalfJung आपके कथन के बारे में है कि let x: bool = mem::uninitialized(); UB है, सवाल यह है कि अमान्य आदिमता को ऐसा

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

क्या संकलक में कोई वास्तविक मामले हैं जब यह इन मान्यताओं पर निर्भर करता है?

उदाहरण के लिए, हम foo(x: bool) LLVM को बताने वाले कार्यों की व्याख्या करते हैं कि x एक मान्य बूलियन है। यह UB को bool पास करने के लिए बनाता है, जो कि true या false भले ही फ़ंक्शन मूल रूप से x न दिखता हो। यह उपयोगी है क्योंकि कभी-कभी कंपाइलर पहले अप्रयुक्त चर के उपयोग को प्रस्तुत करना चाहता है (विशेष रूप से, यह तब होता है जब लूप से बाहर की ओर बयान यह साबित किए बिना कि लूप कम से कम एक बार लिया जाता है)।

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

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

उदाहरण के लिए, हम foo (x: bool) जैसे कार्यों को LLVM को बताते हैं कि x एक मान्य बूलियन है। यह UB को एक बूल पास करने के लिए बनाता है जो सही नहीं है या गलत नहीं है भले ही फ़ंक्शन मूल रूप से x को नहीं देखता हो। यह उपयोगी है क्योंकि कभी-कभी कंपाइलर पहले अप्रयुक्त चर के उपयोग को प्रस्तुत करना चाहता है (विशेष रूप से, यह तब होता है जब लूप से बाहर की ओर बयान यह साबित किए बिना कि लूप कम से कम एक बार लिया जाता है)।

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

संक्षेप में, मेरा प्रश्न यह है कि क्या यह कोड यूबी (डॉक्स के अनुसार - यह है), और यदि ऐसा है, तो यदि मैं ऐसा लिखता हूं तो वास्तव में क्या टूट सकता है?

let _: bool = unsafe { mem::unitialized };

विषय के बारे में एक और सवाल: हम जानते हैं कि हमारे पास box सिंटैक्स है जो आपको सीधे हीप पर मेमोरी आवंटित करने की अनुमति देता है, और यह हमेशा Box::new() विपरीत काम करता है जो कभी-कभी स्टैकलॉक मेमोरी। तो अगर मैं box MaybeUninit::new() हूं और फिर इसे भरता हूं तो मैं Box<MaybeUninit<T>> को Box<T> कैसे बदल सकता हूं? क्या मुझे कोई प्रसारण या क्या लिखना चाहिए? हो सकता है कि मैं प्रलेखन में केवल इस बिंदु से चूक गया।

@Pixix हमने वास्तव में इस धागे पर Box और MaybeUninit के बीच बातचीत पर चर्चा की है : मुस्कान:

@ केंद्र की चर्चा करने के लिए एक उप-मुद्दा है जो तब अच्छा हो सकता है जब आप इसे विभाजित करते हैं।

हां, मुझे वह चर्चा याद है, लेकिन मुझे कोई विशेष एपी याद नहीं है।

संक्षेप में, मैं कुछ ऐसा करना चाहता हूं

fn into_inner<A,T>(value: A<MaybeUninit<T>>) -> A<T> { unsafe { std::mem::transmute() } }

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

मैंने इसके बारे में थोड़ा और सोचा और ऐसा लगता है कि इसे किसी भी स्तर के घोंसले पर काम करना चाहिए। तो Vec<Result<Option<MaybeUninit<u8>>>> होना चाहिए into_inner विधि है जो रिटर्न Vec<Result<Option<u8>>>

मुझे लग रहा था कि get_ref और get_mut एक ही समय में स्थिर होने जा रहे हैं (इस मुद्दे पर सभी सुविधाएँ इंगित करती हैं)। क्या कोई कारण नहीं है? वे अच्छे हैं और केवल संकेत हैं कि वे जो प्रदर्शन कर रहे हैं उसे करने की अनुमति है (जो इमो स्पष्ट रूप से सच होना चाहिए)।

इसे उपयोग माना जा सकता है।

तो let x: bool = mem::uninitialized() bool का उपयोग नहीं कर रहा है (भले ही यह x को सौंपा गया हो!), लेकिन!

fn id(x: bool) -> bool { x }
let x: bool = id(mem::uninitialized());

इसका उपयोग करता है? व्हाट अबाउट

fn uninit() -> bool { mem::uninitialized() }
let x: bool = uninit();

क्या यहां वापसी एक उपयोग है?

यह बहुत जल्दी अति सूक्ष्म हो जाता है। तो मुझे लगता है कि हमें जो उत्तर देना चाहिए वह यह है कि प्रत्येक असाइनमेंट (वास्तव में हर कॉपी, जैसा कि, एमआईआर को कम करने के बाद हर असाइनमेंट) एक उपयोग है, और इसमें let x: bool = mem::uninitialized() असाइनमेंट शामिल है।

मुझे लग रहा था कि get_ref और get_mut एक ही समय में स्थिर होने जा रहे हैं (इस मुद्दे पर सभी सुविधाएँ इंगित करती हैं)। क्या कोई कारण नहीं है? वे अच्छे हैं और केवल संकेत हैं कि वे जो प्रदर्शन कर रहे हैं उसे करने की अनुमति है (जो imo स्पष्ट रूप से सच होना चाहिए)।

यह https://github.com/rust-lang/unsafe-code-guidelines/issues/77 को हल करने पर ब्लॉक किया गया है: क्या &mut bool जो एकतरफा स्मृति को इंगित करता है? मुझे लगता है कि उत्तर "हां" होना चाहिए, लेकिन लोग असहमत हैं।

यह जंग-लंग / असुरक्षित-कोड-दिशानिर्देश # 77 को हल करने पर अवरुद्ध है

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

और फिर बाद में आवश्यकता को नरम करें

जिसका अर्थ है कि अगर मैं भविष्य के संस्करण के प्रलेखन के खिलाफ कोड करता हूं, लेकिन कोई मेरे कोड को संकलक के पुराने संस्करण (एपीआई संगत!) का उपयोग करके संकलित करता है, तो अब यूबी है?

@Gankro

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

यह मेरे लिए बहुत फुटगन-वाई लगता है। सिर्फ &mut *foo.as_mut_ptr() क्यों नहीं लिखते? एक बार जब आप सब कुछ शुरू कर देते हैं, तो वह काम क्यों नहीं करेगा? IOW, मैं अब आपके बारे में सोच रहा हूं

एकमात्र संकेत है कि वे जो कार्य करते हैं, उसे करने की अनुमति है

क्योंकि यह क्यों नहीं होगा? यदि हम एक बार मूल्य को इनिशियलाइज़ करने के बाद आप वह सब कुछ सूचीबद्ध कर सकते हैं, जो एक लंबी सूची होगी। ^ ^

@shepmaster

जिसका अर्थ है कि अगर मैं भविष्य के संस्करण के प्रलेखन के खिलाफ कोड करता हूं, लेकिन कोई मेरे कोड को संकलक के पुराने संस्करण (एपीआई संगत!) का उपयोग करके संकलित करता है, तो अब यूबी है?

यह आज सच है अगर लोग &mut *foo.as_mut_ptr() । मुझे इससे बचने का कोई रास्ता नहीं दिख रहा है।

इसके अलावा, वहाँ केवल यूबी है अगर हमें वास्तव में उस दस्तावेज को करते समय कुछ भी बदलना है। अन्यथा, हम अजीब स्थिति है जहाँ यूबी वहाँ हो गया होता अगर है कि एक ही कोड एक ही संकलक के साथ मार डाला गया था इससे पहले कि हम एक गारंटी बनाया में हैं, लेकिन अब है कि हम गारंटी कर कोई यूबी किसी भी अधिक है। यूबी एक ऐसी संपत्ति है जो न केवल संकलक की है, बल्कि कल्पना की भी है, और युक्ति रेट्रो रूप से बदल सकती है। ;)

ठीक है, मैं मान रहा था कि प्रक्रिया थी

• इसे सख्त लेकिन कार्यान्वयन-निरर्थक आवश्यकता के साथ स्थिर करें
• मेमोरी मॉडल पर काम करने के लिए आगे बढ़ें और आपके पास क्या है
• एक बार मॉडल किया जाता है
  
  
  
  • अगर यह यूबी होना चाहिए, तो शांत रहें, डॉक्स को छोड़ दें, यदि यह उपयोगी है तो अनुकूलन जोड़ें
  
  
  • अगर उसे UB होने की जरूरत नहीं है, तो उसे कूल करें, डॉक्स से हटाएं और उसे एक दिन कॉल करें
  
  

@RalfJung

क्या यहां वापसी एक उपयोग है?

हां, एक मूल्य वापस करना या इसे कहीं भी पारित करना एक उपयोग है।

यह बहुत जल्दी अति सूक्ष्म हो जाता है। तो मुझे लगता है कि हमें जो जवाब देना चाहिए वह यह है कि हर असाइनमेंट (वास्तव में हर कॉपी, जैसा कि, एमआईआर को कम करने के बाद हर असाइनमेंट) एक उपयोग है, और जिसमें असाइनमेंट को let x: bool = mem :: uninitialized () शामिल है।

मान्य दिखता है।

वैसे भी, हो सकता है कि मध्यस्थता के बारे में हो सकता है NUUnit घोंसले के शिकार? क्या प्रत्येक रैपर प्रकार के लिए ट्रांसमीटर लिखने वाले उपयोगकर्ता की आवश्यकता के बिना इसे सुरक्षित रूप से प्रसारित किया जा सकता है?

@Pixixel मुझे यकीन नहीं है कि अगर मैं आपके प्रश्न को समझता हूं, लेकिन मुझे लगता है कि इसकी चर्चा https://github.com/rust-lang/rust/issues/61011 पर हो रही है

मैंने देखा कि अभी भी अस्थिर MaybeUninit::write() विधि unsafe हालांकि यह पहले से मौजूद T पर कॉलिंग को छोड़ सकता है, जिसे मैंने असुरक्षित माना है। क्या इसे सुरक्षित मानने की मिसाल है?

https://doc.rust-lang.org/nomicon/leaking.html#leaking
https://doc.rust-lang.org/nightly/std/mem/fn.forget.html

forget को unsafe के रूप में चिह्नित नहीं किया जाता है, क्योंकि रस्ट की सुरक्षा गारंटी में एक गारंटी शामिल नहीं है कि विनाशकारी हमेशा चलेगा।

हालाँकि, https://github.com/rust-lang-nursery/nomicon/issues/135 भी देखें

हम एक जोड़े जा सके MaybeUninit<T> -> NonNull<T> करने के लिए विधि MaybeUninit ? AFAICT सूचक MaybeUninit::as_mut_ptr() -> *mut T द्वारा लौटाया गया है कभी अशक्त नहीं है। यह एपीआई के साथ इंटरफेस करने के मंथन को कम करेगा जो NonNull<T> , इससे:

let mut x = MaybeUninit<T>::uninit();
foo(unsafe { NonNull::new_unchecked(x.as_mut_ptr() });

सेवा:

let mut x = MaybeUninit<T>::uninit();
foo(x.ptr());

पॉइंटर शायद यूनीनिट :: as_mut_ptr () -> * म्यूट टी से शून्य नहीं है।

यह सही है।

आम तौर पर और मुझे लगता है कि मैंने @Gankro को यह कहते हुए देखा है), NonNull काफी अच्छी तरह से "आराम से" काम करता है, लेकिन जब वास्तव में पॉइंटर्स का उपयोग करते हुए एक कच्चे पॉइंटर ASAP को प्राप्त करना चाहता है। यह सिर्फ बहुत अधिक पठनीय है।

हालाँकि, ऐसा तरीका जोड़ना जो NonNull ठीक लगे। हालांकि इसे क्या कहा जाना चाहिए? क्या पूर्वता है?

Cc https://github.com/rust-lang/rust/pull/62451

Https://github.com/rust-lang/rust/issues/47336 के साथ मिसाल है, लेकिन नाम अच्छा नहीं है और मुझे यकीन नहीं है कि हम इस विधि को स्थिर करने जा रहे हैं।

क्या https://github.com/rust-lang/rust/pull/60445#issuecomment -488818677 में गड्ढा चलाने का उल्लेख किया गया है?

3 महीने के उपलब्ध समय का विचार है कि @centril में उन लोगों के लिए कोई सामग्री नहीं है जो बीटा, स्थिर और रात के सभी पर चेतावनी-मुक्त होना चाहते हैं। 1.36.0 एक हफ्ते से भी कम समय पहले जारी किया गया है और रात को पहले से ही चेतावनी जारी कर रहा है।

हो सकता है कि पदावनति को 1.40.0 पर स्थगित कर दिया जाए?

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

Glium मास्टर पर cargo +nightly test चलने से मुझे आउटपुट की 1400 से अधिक लाइनें मिलती हैं, जिनमें ज्यादातर uninitialized फंक्शन की डेप्रिसिएशन चेतावनियाँ शामिल हैं (मैं 200 बार चेतावनी गिनता हूं, लेकिन यह संभवतः उस संख्या के रूप में कैप किया जाता है कि rg "uninitialized" | wc -l आउटपुट 561 है)।

शेष विधियों के स्थिरीकरण को रोकने वाली शेष चिंताएँ क्या हैं? *foo.as_mut_ptr() माध्यम से सब कुछ करना बहुत थकाऊ हो जाता है, और कभी-कभी ( write ) आवश्यकता से अधिक unsafe ब्लॉक शामिल होता है।

@SimonSapin write का अनुकरण करने के लिए, आप पूरे MaybeUninit को बिना किसी असुरक्षित उपयोग करके *val = MaybeUninit::new(new_val) जहाँ val: &mut MaybeUninit<T> और new_val: T या का उपयोग कर सकते हैं या आप उपयोग कर सकते हैं std::mem::replace यदि आप पुराना मूल्य चाहते हैं।

@ est31 ये अच्छे अंक हैं। मैं एक रिलीज या दो से वापस deprecation धक्का ठीक हो जाएगा।

कोई एतराज?

हमने पहले ही 1.36.0 रिलीज ब्लॉग पोस्ट में कहा है:

के रूप में शायदसुरक्षित विकल्प है, जंग 1.38 के साथ शुरू, समारोह मेम :: uninitialized को पदावनत किया जाएगा।

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

शायद uninitialized के मूल्यह्रास पर वापस जाने के लिए देर हो सकती है। लेकिन हो सकता है कि हम कुछ समय के लिए स्टेबल चैनल पर रिप्लेसमेंट के बाद नाइटली में केवल डेप्रिसिएशन की चेतावनी देने की नीति पर फैसला कर सकें?

उदाहरण के लिए, फ़ायरफ़ॉक्स ने रिलीज़ होने के दो हफ्ते बाद एक नया रस्ट संस्करण की आवश्यकता पर समझौता किया।

हमने पहले ही 1.36.0 रिलीज ब्लॉग पोस्ट में कहा है:

मैं असहमत हूं कि एक ब्लॉग पोस्ट में एक तारीख का उल्लेख इस तरह के एक लोहे की डिग्री है। यह एक रेपो में है और हम एक एडिट सबमिट कर सकते हैं।

जैसे, मुझे लगता है कि हमें इस पर फ्लिप-फ्लॉपी से बचना चाहिए क्योंकि इससे अच्छा संदेश नहीं जाता है और यह भ्रामक है।

"फ्लिप-फ्लॉपी" एक बुरी बात है, लेकिन डेटा और प्रतिक्रिया के आधार पर हमारे दिमाग को बदलना ऐसा नहीं है।

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

"फ्लिप-फ्लॉपी" एक बुरी बात है, लेकिन डेटा और प्रतिक्रिया के आधार पर हमारे दिमाग को बदलना ऐसा नहीं है।

पूरी तरह से सहमत। मुझे यह कहते हुए बुरा संदेश नहीं दिखाई दे रहा है कि "अरे, हमारा पदावनति शेड्यूल कुछ ज्यादा ही आक्रामक था, हमने चीजों को एक रिलीज के द्वारा वापस ले लिया"। वास्तव में इसके विपरीत है।
वास्तव में IIRC मैंने स्थिरीकरण पीआर लैंडिंग के दौरान उल्लेख किया है कि मिसाल भविष्य में 3 रिलीज को हटाने के लिए है और 2 नहीं है, लेकिन किसी कारण से हम 2 के साथ गए। तीन रिलीज का मतलब है, स्थिर-जारी-के-साथ-साथ 1 पूरी रिलीज। -डिप्रेसन-घोषणा और पदावनत-रात्रिकालीन, जो रात्रि में ट्रैकिंग करने वाले लोगों के लिए उचित समय लगता है। 6 सप्ताह एक ईओन है, है ना? ;)

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

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

मैं १.३ ९ के लिए सहमत हो जाऊंगा लेकिन बाद में नहीं। आपको ब्लॉग-पोस्ट के अलावा रिलीज़ नोट्स को भी अपडेट करना होगा।

बदले हुए अपग्रेड शेड्यूल के लिए प्रस्तुत पीआर: https://github.com/rust-lang/rust/pull/62599।

@SimonSapin

शेष विधियों के स्थिरीकरण को रोकने वाली शेष चिंताएँ क्या हैं? * Foo.as_mut_ptr () के माध्यम से सब कुछ करना बहुत थकाऊ हो जाता है, और कभी-कभी (लिखने के लिए) में आवश्यकता से अधिक असुरक्षित ब्लॉक शामिल होते हैं।

as_ref / as_mut , मैं ईमानदारी से इंतजार करना चाहता था जब तक कि हम यह नहीं जानते कि संदर्भों को आरंभिक डेटा को इंगित करना है या नहीं। अन्यथा उन विधियों के लिए प्रलेखन सिर्फ इतना प्रारंभिक है।

read / write , अगर सभी के नाम और हस्ताक्षर समझ में आते हैं, तो मैं उन्हें स्थिर कर रहा हूं। मुझे लगता है कि इसे ManuallyDrop::take/read साथ समन्वित किया जाना चाहिए, और शायद ManuallyDrop::write भी होना चाहिए?

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

इस विषय पर निर्णय लेने के लिए Unsafe Code Guidelines WG और Language Team को क्या करना चाहिए? क्या आपको लगता है कि यह कुछ हफ्तों, कुछ महीनों या कुछ वर्षों में होने की संभावना है?

इस बीच, as_mut अस्थिर होना उपयोगकर्ताओं को &mut *manually_drop.as_mut_ptr() लिखने से नहीं रोकता है जब उन्हें कुछ करने की आवश्यकता होती है।

इस विषय पर निर्णय लेने के लिए Unsafe Code Guidelines WG और Language Team को क्या करना चाहिए? क्या आपको लगता है कि यह कुछ हफ्तों, कुछ महीनों या कुछ वर्षों में होने की संभावना है?

महीने, शायद साल।

इस बीच, as_mut अस्थिर होना उपयोगकर्ताओं को लिखने और म्यूट * मैन्युअल रूप से बंद करने से रोकता है। “__mut_ptr () तब होता है जब उन्हें कुछ करने की आवश्यकता होती है।

हाँ मैं जानता हूँ। आशा है कि लोगों को &mut भाग में देरी करने की दिशा में, और कच्चे संकेत के साथ काम करने की ओर प्रेरित किया जा सके। बेशक बिना https://github.com/rust-lang/rfcs/pull/2582 जो अक्सर कठिन होता है।

शायद यूनुइनिट पर प्रलेखन कम से कम चर्चा करने के लिए एक प्रमुख स्थान की तरह लगता है कि यह भाषा के शब्दार्थ में एक अस्पष्टता है और उपयोगकर्ताओं को यह मान लेना चाहिए कि यह ठीक नहीं है।

सच है, यह दूसरा विकल्प होगा।

एक रूढ़िवादी धारणा के साथ भी, मूल्य पूरी तरह से शुरू होने के बाद as_mut वैध है।

सरणियों के साथ रूढ़िवादी होने का एक तरीका MaybeUninit<[MaybeUninit<Foo>; N]> । बाहरी रैपर एकल uninit() कॉल के साथ सरणी बनाने की अनुमति देता है। (मुझे लगता है कि [expr; N] शाब्दिक के लिए Copy आवश्यकता होती है?) आंतरिक आवरण इस सरणी को पीछे हटाने के लिए slice::IterMut की सुविधा का उपयोग करने के लिए रूढ़िवादी धारणा में भी सुरक्षित बनाते हैं। फिर एक-एक करके Foo मूल्यों को इनिशियलाइज़ करें।

@SimonSapin ने अस्थिर uninitialized_array! मैक्रो को libcore में देखा ।

@ राल्फजंग शायद uninit_array! एक बेहतर नाम होगा।

@ स्टार्गेटर बिल्कुल, यह निश्चित रूप से अपने वर्तमान नाम के साथ स्थिर होने वाला नहीं है। यह उम्मीद है कि https://github.com/rust-lang/rust/issues/49147 सून (टीएम) होने पर यह कभी स्थिर नहीं होगा।

@ राल्फजंग उघ , यह मेरी गलती है, मैं बिना किसी कारण के पीआर को रोक रहा था: https://github.com/rust-lang/rust/pull/61749#issuecomment -512867703

@eddyb इस काम के लिए libcore, yay! लेकिन किसी तरह जब मैं liballoc में सुविधा का उपयोग करने की कोशिश करता हूं, तो यह ध्वज को सेट करने के बावजूद संकलित नहीं करता है। Https://github.com/rust-lang/rust/commit/4c2c7e0cc9b2b2b589fe2bab44173acc2170b20c09 देखें

Building stage1 std artifacts (x86_64-unknown-linux-gnu -> x86_64-unknown-linux-gnu)
   Compiling alloc v0.0.0 (/home/r/src/rust/rustc.2/src/liballoc)
error[E0277]: the trait bound `core::mem::MaybeUninit<K>: core::marker::Copy` is not satisfied
   --> <::core::macros::uninit_array macros>:1:32
    |
1   |   ($ t : ty ; $ size : expr) => ([MaybeUninit :: < $ t > :: uninit () ; $ size])
    |   -                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `core::marker::Copy` is not implemented for `core::mem::MaybeUninit<K>`
    |  _|
    | |
2   | | ;
    | |_- in this expansion of `uninit_array!`
    | 
   ::: src/liballoc/collections/btree/node.rs:109:19
    |
109 |               keys: uninit_array![_; CAPACITY],
    |                     -------------------------- in this macro invocation
    |
    = help: consider adding a `where core::mem::MaybeUninit<K>: core::marker::Copy` bound
    = note: the `Copy` trait is required because the repeated element will be copied

error[E0277]: the trait bound `core::mem::MaybeUninit<V>: core::marker::Copy` is not satisfied
   --> <::core::macros::uninit_array macros>:1:32
    |
1   |   ($ t : ty ; $ size : expr) => ([MaybeUninit :: < $ t > :: uninit () ; $ size])
    |   -                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `core::marker::Copy` is not implemented for `core::mem::MaybeUninit<V>`
    |  _|
    | |
2   | | ;
    | |_- in this expansion of `uninit_array!`
    | 
   ::: src/liballoc/collections/btree/node.rs:110:19
    |
110 |               vals: uninit_array![_; CAPACITY],
    |                     -------------------------- in this macro invocation
    |
    = help: consider adding a `where core::mem::MaybeUninit<V>: core::marker::Copy` bound
    = note: the `Copy` trait is required because the repeated element will be copied

error[E0277]: the trait bound `core::mem::MaybeUninit<collections::btree::node::BoxedNode<K, V>>: core::marker::Copy` is not satisfied
   --> <::core::macros::uninit_array macros>:1:32
    |
1   |   ($ t : ty ; $ size : expr) => ([MaybeUninit :: < $ t > :: uninit () ; $ size])
    |   -                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `core::marker::Copy` is not implemented for `core::mem::MaybeUninit<collections::btree::node::BoxedNode<K, V>>`
    |  _|
    | |
2   | | ;
    | |_- in this expansion of `uninit_array!`
    | 
   ::: src/liballoc/collections/btree/node.rs:162:20
    |
162 |               edges: uninit_array![_; 2*B],
    |                      --------------------- in this macro invocation
    |
    = help: the following implementations were found:
              <core::mem::MaybeUninit<T> as core::marker::Copy>
    = note: the `Copy` trait is required because the repeated element will be copied

error: aborting due to 3 previous errors

रहस्य सुलझ: libcore में दोहराने की अभिव्यक्ति का उपयोग करता है वास्तव में प्रकार है कि नकल कर रहे हैं के लिए थे।

और कारण यह liballoc में काम नहीं करता है कि MaybeUninit::uninit प्रचार योग्य नहीं है।

@ राल्फजंग शायद एक पीआर को हटाता है जो मैक्रो के उपयोग को हटाता है जहां यह पूरी तरह से अनावश्यक है?

@eddyb मैंने https://github.com/rust-lang/rust/pull/62799 का वह हिस्सा बनाया

maybe_uninit_ref

As_ref / as_mut के लिए, मैं ईमानदारी से प्रतीक्षा करना चाहता था जब तक कि हम यह न जान लें कि संदर्भों को आरंभिक डेटा को इंगित करना है या नहीं। अन्यथा उन विधियों के लिए प्रलेखन सिर्फ इतना प्रारंभिक है।

अस्थिर get_ref / get_mut निश्चित रूप से इसकी वजह से उचित हैं; हालांकि, ऐसे मामले हैं जहां get_ref / get_mut का उपयोग तब किया जा सकता है जब MaybeUninit init हो गया हो: किसी भी परहेज करते हुए (अब ज्ञात प्रारंभिक) डेटा को सुरक्षित हैंडल प्राप्त करने के लिए memcpy ( assume_init बजाय, जो memcpy ट्रिगर हो सकता है )।

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

इस वजह से, मुझे लगता है कि assume_init_by_ref / assume_init_by_mut का होना अच्छा हो सकता है (क्योंकि into_inner को assume_init कहा जाता है, मुझे यह अच्छा लगता है कि ref / ref mut गेटर्स को भी यह प्रतिबिंबित करने के लिए एक विशेष नाम मिलता है)।

इसके लिए दो / तीन विकल्प हैं, Drop इंटरैक्शन से संबंधित:

1. get_ref API get_mut रूप में एक ही API प्राप्त करें, जो ड्रॉप ड्रॉप होने पर मेमोरी लीक हो सकता है;

   • (वेरिएंट): समान एपीआई get_ref / get_mut , लेकिन Copy बाउंड के साथ;

2. ड्रॉप की गारंटी करने के लिए बंद शैली एपीआई,

impl<T> MaybeUninit<T> {
    /// # Safety
    ///
    ///   - the contents must have been initialised
    unsafe
    fn assume_init_with_mut<R, F> (mut self: MaybeUninit<T>, f: F) -> R
    where
        F : FnOnce(&mut T) -> R,
    {
        if mem::needs_drop::<T>().not() {
            return f(unsafe { self.get_mut() });
        }
        let mut this = ::scopeguard::guard(self, |mut this| {
            ptr::drop_in_place(this.as_mut_ptr());
        });
        f(unsafe { MaybeUninit::<T>::get_mut(&mut *this) })
    }
}

(जहां scopeguard के तर्क को आसानी से लागू किया जा सकता है, इसलिए इस पर निर्भर रहने की कोई आवश्यकता नहीं है)

इन्हें get_ref / get_mut से अधिक तेज़ी से स्थिर किया जा सकता है, यह स्पष्ट assume_init आवश्यकता को देखते हुए।

कमियां

यदि विकल्प का एक संस्करण .1 चुना गया था, और get_ref / get_mut assume_init स्थिति के बिना उपयोग करने योग्य बन गए थे, तो यह एपीआई लगभग सख्ती से हीन हो जाएगा (मैं कहता हूं कि प्रस्तावित एपीआई के साथ, संदर्भ से पढ़ने के कारण लगभग ठीक होगा, जो कि get_ref और get_mut के मामले में कभी नहीं हो सकता)

@Danielhenrymantilla ने get_{ref,mut} बारे में जो लिखा है, उसके समान, मुझे लगता है कि read नाम शायद read_init या read_assume_init या तो रखा जाना चाहिए, ऐसा कुछ इंगित करता है यह केवल आरंभीकरण पूरा होने के बाद किया जा सकता है।

@ राल्फजंग मेरे पास इस बारे में एक प्रश्न है:

fn foo<T>() -> T {
    let newt = unsafe { MaybeUninit::<T>::zeroed().assume_init() };
    newt
}

उदाहरण के लिए, हम foo<NonZeroU32> । क्या यह UB को ट्रिगर करता है जब हम foo फ़ंक्शन की घोषणा करते हैं (क्योंकि इसे सभी T s के लिए मान्य होना चाहिए या जब हम इसे UB को ट्रिगर करने वाले एक प्रकार के साथ त्वरित करते हैं? तो क्षमा करें यदि यह एक गलत जगह है? प्रश्न पूछें।

@Pixixel कोड केवल यूबी का कारण बन सकता है जब यह चलता है।

तो, foo::<i32>() ठीक है। लेकिन foo::<NonZeroU32>() UB है।

कॉल करने के सभी संभावित तरीकों के लिए वैध होने की संपत्ति को "ध्वनि" कहा जाता है, संदर्भ भी देखें। जंग में सामान्य अनुबंध यह है कि एक पुस्तकालय की सुरक्षित एपीआई सतह ध्वनि होनी चाहिए। ऐसा इसलिए ताकि लाइब्रेरी के उपयोगकर्ताओं को यूबी के बारे में चिंता न करनी पड़े। रस्ट की पूरी सुरक्षा कहानी ध्वनि एपीआई के साथ पुस्तकालयों पर टिकी हुई है।

@ राल्फजंग धन्यवाद

इसलिए यदि मैं आपको सही ढंग से प्राप्त करता हूं तो यह फ़ंक्शन अनसुना है (और इस प्रकार, अमान्य है), लेकिन अगर हम इसे unsafe रूप में चिह्नित करते हैं, तो यह शरीर मान्य और ध्वनि बन जाता है

@Pzixel यदि आप इसे असुरक्षित चिह्नित करते हैं, तो

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

हां, निश्चित रूप से, मैं समझता हूं कि। मैं केवल यह निष्कर्ष निकालना चाहता था कि आंशिक फंक्शनल को unsafe के रूप में चिह्नित किया जाना चाहिए। मेरे लिए समझ में आता है, लेकिन आपने जवाब देने से पहले इसके बारे में नहीं सोचा।

चूँकि इस ट्रैकिंग मुद्दे पर चर्चा इतनी लंबी है, क्या हम इसे MaybeUninit के प्रत्येक फीचर के लिए कुछ अन्य ट्रैकिंग मुद्दों में तोड़ सकते हैं जो अभी भी अस्थिर है?

• maybe_uninit_extra
• maybe_uninit_ref
• maybe_uninit_slice

उचित लगता है। इसमें भी https://github.com/rust-lang/rust/issues/63291 है।

इसे एक मेटा-इश्यू के पक्ष में बंद करना जो MaybeUninit<T> अधिक सामान्यतः ट्रैक करता है: # 63566