Rust: एलाटेटर लक्षण और एसटी :: ढेर

मैं दुर्भाग्य से आरएफसी चर्चा में इसका उल्लेख करने के लिए पर्याप्त ध्यान नहीं दे रहा था, लेकिन मुझे लगता है कि realloc_in_place को दो कार्यों से बदला जाना चाहिए, grow_in_place और shrink_in_place , दो के लिए कारण हैं:

• मैं एक भी उपयोग के मामले के बारे में नहीं सोच सकता हूं (जहां realloc या realloc_in_place लागू करने की कमी है) यह अज्ञात है कि आवंटन का आकार बढ़ रहा है या घट रहा है। अधिक विशिष्ट विधियों का उपयोग करने से यह थोड़ा और स्पष्ट हो जाता है कि क्या चल रहा है।
• बढ़ते और सिकुड़ते आवंटन के लिए कोड पथ मौलिक रूप से भिन्न होते हैं - बढ़ते में यह परीक्षण शामिल होता है कि क्या मेमोरी के आस-पास के ब्लॉक मुक्त हैं और उन पर दावा कर रहे हैं, जबकि सिकुड़ने में ठीक से सबब्लॉक को आकार देना और उन्हें मुक्त करना शामिल है। जबकि realloc_in_place अंदर एक शाखा की लागत grow और shrink का उपयोग करते हुए काफी बेहतर होती है, जो एक आवंटनकर्ता को प्रदर्शन करने के लिए आवश्यक विभिन्न कार्यों को पकड़ती है।

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

स्थिरता के लिए, realloc शायद grow और split में विभाजित होना चाहते हैं, लेकिन एक अधिभार realloc फ़ंक्शन होने का एकमात्र लाभ जो मुझे पता है mmap के रीमैप विकल्प का उपयोग करने में सक्षम होना चाहिए, जिसमें ऐसा कोई अंतर नहीं है।

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

इससे realloc उच्च-प्रदर्शन कार्यान्वयन का उत्पादन करना आसान हो जाता है: जो भी आवश्यक है वह realloc_in_place सुधार कर रहा है। हालांकि, realloc का डिफ़ॉल्ट प्रदर्शन नहीं भुगतना पड़ता है, क्योंकि usable_size खिलाफ चेक अभी भी प्रदर्शन किया जाता है।

एक और मुद्दा: fn realloc_in_place लिए डॉक्टर का कहना है कि अगर यह ठीक है, तो किसी को आश्वासन दिया जाता है कि ptr अब " new_layout फिट बैठता है।

मेरे लिए इसका तात्पर्य यह है कि यह जाँचना चाहिए कि दिए गए पते के संरेखण में new_layout द्वारा निहित किसी भी बाधा से मेल खाता है।

हालाँकि, मुझे नहीं लगता कि अंतर्निहित fn reallocate_inplace फ़ंक्शन के लिए कल्पना का अर्थ है कि _it_ इस तरह के किसी भी चेक का प्रदर्शन करेगा।

• इसके अलावा, यह उचित प्रतीत होता है कि fn realloc_in_place का उपयोग करने वाले किसी भी ग्राहक को यह सुनिश्चित करना होगा कि संरेखण कार्य (व्यवहार में मुझे संदेह है कि इसका मतलब है कि दिए गए उपयोग के मामले में हर जगह समान संरेखण आवश्यक है ...)

तो, के कार्यान्वयन चाहिए fn realloc_in_place वास्तव में जांच करते हुए कि दिया के संरेखण साथ बोझ से दबा ptr के उस के साथ संगत है new_layout ? यह शायद बेहतर है _ इस मामले में (इस एक विधि का) कॉल करने वाले को उस आवश्यकता को वापस लाने के लिए ...

@gereeter आप अच्छे अंक बनाते हैं; मैं उन्हें सूची सूची में जोड़ दूंगा जो मैं मुद्दे के विवरण में जमा कर रहा हूं।

(इस बिंदु पर मैं #[may_dangle] समर्थन का इंतजार कर रहा हूं ताकि beta चैनल में ट्रेन की सवारी कर सकूं ताकि बाद में मैं इसका उपयोग आवंटन संग्रह के हिस्से के रूप में संग्रह के लिए कर सकूं)

मैं जंग के लिए नया हूँ, इसलिए मुझे माफ कर दो अगर यह कहीं और चर्चा की गई है।

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

वर्तमान में, इस प्रस्ताव में ObjectAllocator<T> की तर्ज पर कुछ भी शामिल नहीं है, लेकिन यह बहुत उपयोगी होगा। विशेष रूप से, मैं एक पत्रिका आवंटनकर्ता ऑब्जेक्ट-कैशिंग परत (ऊपर लिंक) के कार्यान्वयन पर काम कर रहा हूं, और जब मेरे पास यह केवल एक Allocator और कैशिंग में ऑब्जेक्ट बनाने और छोड़ने का कार्य कर सकता है परत ही, यह बहुत अच्छा होगा अगर मैं भी इस लपेट को अन्य ऑब्जेक्ट एलोकेटर (एक स्लैब आवंटनकर्ता की तरह) हो सकता है और वास्तव में एक सामान्य कैशिंग परत हो सकता है।

इस प्रस्ताव में एक वस्तु आबंटक प्रकार या विशेषता कहाँ फिट होगी? क्या इसे भविष्य के RFC के लिए छोड़ा जाएगा? कुछ और?

मुझे नहीं लगता कि इस पर अभी चर्चा हुई है।

आप अपने स्वयं के ObjectAllocator<T> लिख सकते हैं, और फिर impl<T: Allocator, U> ObjectAllocator<U> for T { .. } कर सकते हैं, ताकि हर नियमित आवंटनकर्ता सभी वस्तुओं के लिए एक वस्तु-विशिष्ट आवंटनकर्ता के रूप में सेवा कर सके।

भविष्य के काम सीधे सादे ओले '(जेनेरिक) के बजाय अपने नोड्स के लिए अपनी विशेषता का उपयोग करने के लिए संग्रह को संशोधित करना होगा।

@pnkfelix

(इस बिंदु पर मैं बीटा चैनल में ट्रेन की सवारी करने के लिए # [may_dangle] समर्थन की प्रतीक्षा कर रहा हूं, ताकि मैं फिर से आवंटन एकीकरण के भाग के रूप में std संग्रहों के लिए इसका उपयोग कर सकूं)

मुझे लगता है कि यह हुआ है?

@Emon2314 हाँ, अपने स्वयं के लेखन निश्चित रूप से प्रायोगिक उद्देश्यों के लिए एक विकल्प है, लेकिन मुझे लगता है कि इंटरऑपरेबिलिटी के संदर्भ में इसे मानकीकृत किए जाने से बहुत अधिक लाभ होगा (उदाहरण के लिए, मैं एक स्लैब आवंटन लागू करने की योजना भी बना रहा हूं, लेकिन यह होगा यदि मेरे कोड का कोई तृतीय-पक्ष उपयोगकर्ता किसी और का उपयोग कर सकता है, तो मेरी पत्रिका कैशिंग परत के साथ _else's_ slab आवंटनकर्ता)। मेरा सवाल बस यह है कि क्या एक ObjectAllocator<T> विशेषता या ऐसा कुछ जो चर्चा करने लायक है। हालांकि ऐसा लगता है कि यह एक अलग RFC के लिए सबसे अच्छा हो सकता है? मैं एक RFC में कितना है और कब अलग RFC में चीजें हैं, इसके दिशानिर्देशों से मैं बहुत परिचित नहीं हूं ...

@joshlf

इस प्रस्ताव में एक वस्तु आबंटक प्रकार या विशेषता कहाँ फिट होगी? क्या इसे भविष्य के RFC के लिए छोड़ा जाएगा? कुछ और?

हां, यह एक और RFC होगा।

मैं एक RFC में कितना है और कब अलग RFC में चीजें हैं, इसके दिशानिर्देशों से मैं बहुत परिचित नहीं हूं ...

वह स्वयं RFC के दायरे पर निर्भर करता है, जो उस व्यक्ति द्वारा तय किया जाता है जो इसे लिखता है, और फिर सभी द्वारा प्रतिक्रिया दी जाती है।

लेकिन वास्तव में, जैसा कि इस पहले से स्वीकृत आरएफसी के लिए एक ट्रैकिंग मुद्दा है, एक्सटेंशन और डिजाइन में बदलाव के बारे में सोचना वास्तव में इस धागे के लिए नहीं है; आपको RFCs रेपो पर एक नया ओवर खोलना चाहिए।

@ जोशफेल आह, मुझे लगा कि ObjectAllocator<T> का गुण होना चाहिए था। मैं विशेषता न कि किसी विशिष्ट संभाजक प्रोटोटाइप का मतलब है। हां, यह गुण अपने RFC को मेरिट के रूप में मेरिटेकल्बनिक कहते हैं।

@steveklabnik हाँ अब चर्चा कहीं और बेहतर होगी। लेकिन @ जोशफेल भी इस मुद्दे को उठा रहा था कि यह स्वीकार किए जाते हैं लेकिन एपीआई डिजाइन को स्वीकार नहीं करता है। इस अर्थ में यह इस सूत्र में पहले के पदों से मेल खाता है।

@Emon2314 हाँ, मैंने सोचा था कि आपका क्या मतलब था। मुझे लगता है कि हम एक ही पृष्ठ पर हैं :)

@steveklabnik अच्छा लगता है; मैं अपने स्वयं के कार्यान्वयन के साथ चारों ओर प्रहार करूंगा और अगर यह एक अच्छा विचार की तरह प्रतीत होता है, तो एक आरएफसी प्रस्तुत करेगा।

@joshlf कोई कारण नहीं है कि कस्टम

@alexreg यह एक विशेष कस्टम Allocator ) को परिभाषित करता है, जो कि किसी भी निम्न-स्तर के आवंटनकर्ता का प्रकार है, मैं एक विशेषता ( ObjectAllocator<T> ) के बारे में पूछ रहा हूं जो कि किसी भी आवंटनकर्ता का प्रकार है T वस्तुओं को आवंटित / घटाएँ और निर्माण / गिरा सकते हैं।

@alexreg कस्टम ऑब्जेक्ट-विशिष्ट एलोकेटर के साथ मानक लाइब्रेरी संग्रह का उपयोग करने के बारे में मेरा प्रारंभिक बिंदु देखें।

ज़रूर, लेकिन मुझे यकीन नहीं है कि मानक पुस्तकालय में होगा। कार्यक्षमता या प्रयोज्य के कोई नुकसान के साथ आसानी से दूसरे टोकरे में जा सकता है।

4 जनवरी 2017 को, 21:59 पर, यहोशू लेबो-फ़ेसर नोटिफिकेशन @github.com ने लिखा:

@alexreg https://github.com/alexreg यह एक विशेष कस्टम आवंटनकर्ता के बारे में नहीं है, बल्कि एक विशेषता है जो सभी आवंटनकर्ताओं के प्रकार को निर्दिष्ट करता है जो एक विशेष प्रकार पर पैरामीट्रिक हैं। तो जैसे RFC 1398 एक विशेषता (एलोकेटर) को परिभाषित करता है जो कि किसी भी निम्न स्तर के आवंटनकर्ता का प्रकार है, मैं एक विशेषता (ObjectAllocator) के बारे में पूछ रहा हूँ) कि किसी भी आवंटनकर्ता का प्रकार जो आवंटित कर सकता है / टाइप कर सकता है और टाइप / टी की वस्तुओं को गिरा सकता है।

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

मुझे लगता है कि आप एक मनमाना कस्टम आवंटनकर्ता के साथ मानक-पुस्तकालय संग्रह (कोई ढेर-आवंटित मूल्य) का उपयोग करना चाहते हैं; अर्थात वस्तु-विशेष तक सीमित नहीं।

4 जनवरी 2017 को, 22:01 पर, जॉनीन सूचनाएँ @ithub.com ने लिखा:

@alexreg https://github.com/alexreg कस्टम ऑब्जेक्ट-विशिष्ट आवंटनकर्ताओं के साथ मानक लाइब्रेरी संग्रह का उपयोग करने के बारे में मेरा प्रारंभिक बिंदु देखें।

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

ज़रूर, लेकिन मुझे यकीन नहीं है कि मानक पुस्तकालय में होगा। कार्यक्षमता या प्रयोज्य के कोई नुकसान के साथ आसानी से दूसरे टोकरे में जा सकता है।

हां, लेकिन आप शायद इस पर भरोसा करने के लिए कुछ मानक पुस्तकालय कार्यक्षमता चाहते हैं (जैसे @SON2314 ने क्या सुझाव दिया है)।

मुझे लगता है कि आप एक मनमाना कस्टम आवंटनकर्ता के साथ मानक-पुस्तकालय संग्रह (कोई ढेर-आवंटित मूल्य) का उपयोग करना चाहते हैं; अर्थात वस्तु-विशेष तक सीमित नहीं।

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

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

4 जनवरी 2017 को, 22:13 पर, यहोशू लेबो-फ़ेसर नोटिफिकेशन @github.com ने लिखा:

ज़रूर, लेकिन मुझे यकीन नहीं है कि मानक पुस्तकालय में होगा। कार्यक्षमता या प्रयोज्य के कोई नुकसान के साथ आसानी से दूसरे टोकरे में जा सकता है।

हां, लेकिन आप शायद इस पर भरोसा करने के लिए कुछ मानक पुस्तकालय कार्यक्षमता चाहते हैं (जैसे कि @SON2314 https://github.com/Ericson233 ने सुझाव दिया है)।

मुझे लगता है कि आप एक मनमाना कस्टम आवंटनकर्ता के साथ मानक-पुस्तकालय संग्रह (कोई ढेर-आवंटित मूल्य) का उपयोग करना चाहते हैं; अर्थात वस्तु-विशेष तक सीमित नहीं।

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

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

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

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

trait ObjectAllocator<T> {
    fn alloc() -> T;
    fn free(t T);
}

यह Allocator के साथ संगत नहीं है, जिनके तरीके कच्चे संकेत से निपटते हैं और प्रकार की कोई धारणा नहीं है। इसके अतिरिक्त, Allocator s के साथ, यह कॉलर की जिम्मेदारी है कि drop ऑब्जेक्ट को पहले मुक्त किया जाए। यह वास्तव में महत्वपूर्ण है - T ObjectAllocator<T> T drop पद्धति जैसी चीजों को करने की अनुमति देता है, और free(t) बाद से t free , कॉलर _cannot_ t पहले गिरता है - यह ObjectAllocator<T> की जिम्मेदारी है। मौलिक रूप से, ये दो लक्षण एक दूसरे के साथ असंगत हैं।

आह ठीक है, मैं देख रहा हूँ मुझे लगा कि इस प्रस्ताव में पहले से ही कुछ शामिल है, यानी बाइट स्तर पर "उच्च-स्तरीय" आवंटनकर्ता। उस मामले में, एक पूरी तरह से उचित प्रस्ताव!

4 जनवरी 2017 को, 22:29 पर, यहोशू लेबो-फ़ेसर नोटिफिकेशन @github.com ने लिखा:

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

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

विशेषता वस्तु{
एफएन आवंटन () -> टी;
fn मुक्त (टी टी);
}
यह एलोकेटर के साथ संगत नहीं है, जिनके तरीके कच्चे पॉइंटर्स से निपटते हैं और उनकी कोई धारणा नहीं है। इसके अतिरिक्त, Allocators के साथ, यह कॉलर की जिम्मेदारी है कि पहले ऑब्जेक्ट को मुक्त किया जाए। यह वास्तव में महत्वपूर्ण है - टी के प्रकार के बारे में जानने से ऑब्जेक्ट एंकोलेटर की अनुमति मिलती हैकॉल टी की ड्रॉप विधि जैसी चीजों को करने के लिए, और चूंकि फ्री (टी) टी में मुक्त हो जाता है, कॉल करने वाला पहले टी ड्रॉप नहीं कर सकता है - यह इसके बजाय हैजिम्मेदारी है। मौलिक रूप से, ये दो लक्षण एक दूसरे के साथ असंगत हैं।

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

@alexreg आह हाँ, मैं भी यही उम्मीद कर रहा था :) ओह ठीक है - इसे दूसरे RFC की प्रतीक्षा करनी होगी।

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

5 जनवरी 2017 को, 00:53 पर, यहोशू लेबो-फ़ेसर नोटिफिकेशन @github.com ने लिखा:

@alexreg https://github.com/alexreg आह हाँ, मैं भी यही उम्मीद कर रहा था :) ओह ठीक है - इसे किसी अन्य IFC के लिए इंतजार करना होगा।

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

कस्टम आवंटनकर्ताओं के परीक्षण के लिए एक टोकरा उपयोगी होगा।

मुझे माफ कर दो अगर मैं कुछ स्पष्ट याद कर रहा हूं, लेकिन इस RFC में Layout विशेषता का वर्णन करने का एक कारण है कि Copy साथ-साथ Clone , क्योंकि यह सिर्फ है पॉड?

मैं किसी के बारे में सोच भी नहीं सकता।

खेद है कि इस प्रक्रिया में इतनी देर हो रही है, लेकिन ...

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

यह कस्टम संरचनाओं का उपयोग करने वाली डेटा संरचनाओं के लिए एक बड़ी जीत हो सकती है। यह उन्हें आवंटनकर्ता को स्वयं एक संदर्भ नहीं रखने की अनुमति देगा, बल्कि केवल आवंटनकर्ता के _type_ पर पैरामीट्रिक होने की आवश्यकता है, जो कि dealloc फ़ंक्शन को कॉल करने में सक्षम हो। उदाहरण के लिए, यदि Box को अंततः कस्टम एलोकेटर्स का समर्थन करने के लिए संशोधित किया गया है, तो यह एक संदर्भ को संग्रहीत करने के लिए दो शब्दों तक विस्तारित किए जाने के विपरीत केवल एक शब्द (सिर्फ सूचक) रखने में सक्षम होगा। आवंटनकर्ता को भी।

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

@joshlf वर्तमान डिज़ाइन आपको यह प्राप्त करने की अनुमति देता है कि आपके आवंटनकर्ता को एक (शून्य-आकार) इकाई प्रकार होना चाहिए - यानी struct MyAlloc; जिस पर आप Allocator विशेषता लागू करते हैं।
हमेशा के लिए संदर्भों को संचय करना या कुछ भी नहीं, कम सामान्य है।

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

struct Foo()

struct Blah{
    foo: &Foo,
}

क्या Blah का आकार शून्य है?

वास्तव में, यह भी संभव है, आप अपने आवंटनकर्ता को शून्य आकार नहीं दे सकते। उदाहरण के लिए, आपके पास एक गैर-शून्य आकार के साथ एक आबंटक हो सकता है जिसे आप _from_ आवंटित करते हैं, लेकिन इसमें मूल आबंटक के बारे में जानने के लिए वस्तुओं को मुक्त करने की क्षमता है। यह अभी भी Box केवल एक शब्द लेने के लिए उपयोगी होगा। आपके पास Box::new_from_allocator जैसा कुछ होगा जो एक आबंटक को एक तर्क के रूप में लेना होगा - और यह एक गैर-आकार के आवंटनकर्ता हो सकता है - लेकिन यदि आवंटनकर्ता मूल आवंटन संदर्भ के बिना मुक्त करने का समर्थन करता है, तो Box<T> मूल Box::new_from_allocator कॉल में पारित किए गए आवंटनकर्ता के संदर्भ को संग्रहीत करने से बच सकता है।

उदाहरण के लिए, आपके पास एक गैर-शून्य आकार के साथ एक आबंटक हो सकता है जिसे आप से आबंटित करते हैं, लेकिन इसमें मूल आबंटक के बारे में जानने की क्षमता w / o को मुक्त करने की क्षमता है।

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

क्या संकलक को इन आवंटनकर्ताओं के साथ आवंटन का अनुकूलन करने की अनुमति दी जानी चाहिए?

क्या संकलक को इन आवंटनकर्ताओं के साथ आवंटन का अनुकूलन करने की अनुमति दी जानी चाहिए?

@Zoxc तुम्हारा क्या मतलब है?

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

पोस्टरिटी के लिए, मैं इस कथन को स्पष्ट कर दूं (मैंने @2323 से बात की): विचार यह है कि Box एक डीलॉकर पर पैरामीट्रिक हो सकता है। तो आप निम्नलिखित कार्यान्वयन हो सकता है:

trait Allocator {
    type D: Deallocator;

    fn get_deallocator(&self) -> Self::D;
}

trait Deallocator {}

struct Box<T, D: Deallocator> {
    ptr: *mut T,
    d: D,
}

impl<T, D: Deallocator> Box<T, D> {
    fn new_from_allocator<A: Allocator>(x: T, a: A) -> Box<T, A::D> {
        ...
        Box {
            ptr: ptr,
            d: a.get_deallocator()
        }
    }
}

इस तरह, जब new_from_allocator कॉल किया जाता है, यदि A::D एक शून्य-आकार का प्रकार है, तो d फ़ील्ड का Box<T, A::D> शून्य आकार लेता है, और इसलिए परिणामी Box<T, A::D> का आकार एक शब्द है।

वहाँ के लिए एक समय है जब यह उतर जाएगा? मैं कुछ एलोकेटर सामान पर काम कर रहा हूं, और यह अच्छा होगा अगर यह सामान मेरे लिए बंद हो।

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

ठीक है, हम हाल ही में आवंटनकर्ताओं की स्थिति का मूल्यांकन करने के लिए मिले हैं और मुझे लगता है कि इसके लिए कुछ अच्छी खबरें भी हैं! ऐसा लगता है कि समर्थन अभी तक इन APIs के लिए libstd में नहीं उतरा है, लेकिन हर कोई अभी भी उनके साथ उतरने से खुश है!

एक बात जिस पर हमने चर्चा की है वह यह है कि संभावित इंट्रेंस मुद्दों के कारण सभी लीबस्टैड प्रकारों में बदलाव थोड़ा समय से पहले हो सकता है, लेकिन इस बात की परवाह किए बिना कि यह Allocator विशेषता और Layout पारिस्थितिकी तंत्र में कहीं और प्रयोग के लिए प्रस्तावित std::heap मॉड्यूल में Layout प्रकार!

@joshlf अगर आप यहाँ मदद करना चाहते हैं तो मुझे लगता है कि आपका स्वागत से अधिक होगा! पहला टुकड़ा संभवतः इस RFC से बुनियादी प्रकार / गुण को मानक पुस्तकालय में उतारने का होगा, और फिर वहाँ से हम libstd में संग्रह के साथ प्रयोग करना और खेलना शुरू कर सकते हैं।

@alexcrichton मुझे लगता है कि आपका लिंक टूट गया है? यह यहाँ वापस इंगित करता है।

एक बात जिस पर हमने चर्चा की, वह यह है कि संभावित बचाव मुद्दों के कारण सभी लीबस्टैड प्रकारों में बदलाव करना थोड़ा समय से पहले हो सकता है

विशेषता जोड़ना एक अच्छा पहला कदम है, लेकिन मौजूदा APIs का उपयोग किए बिना इसे उपयोग करने के बिना वे बहुत उपयोग नहीं देखेंगे। Https://github.com/rust-lang/rust/issues/27336#issuecomment -30072151558 में हम प्रस्ताव रखते हैं कि हम मोहरे के पीछे के टुकड़ों को तुरंत ठीक कर सकते हैं, लेकिन std में newtype रैपर जोड़ें। करने के लिए कष्टप्रद, लेकिन हमें प्रगति करने की अनुमति देता है।

@alexcrichton ऑब्जेक्ट यहां चर्चा ने मुझे विश्वास दिलाया है कि आवंटन गुण और वस्तु के बीच एक पूर्ण-समरूपता होने जा रही है। आवंटनकर्ता लक्षण जैसे, आपके पास कुछ होगा (मैंने Address *mut u8 समरूपता के साथ *mut T ObjectAllocator<T> ; हम शायद Address<T> साथ समाप्त करेंगे

unsafe trait Allocator {
    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr>;
    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout);
}

unsafe trait ObjectAllocator<T> {
    unsafe fn alloc(&mut self) -> Result<*mut T, AllocErr>;
    unsafe fn dealloc(&mut self, ptr: *mut T);
}

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

ओह, मेरा मतलब यहां लिंक करना @ जोशफोल यह है कि आप क्या सोच रहे हैं?

ऐसा लगता है कि @alexcrichton एक ऐसा पीआर चाहता है जो Allocator विशेषता और Layout प्रकार प्रदान करे, भले ही वह libstd में किसी भी संग्रह में एकीकृत न हो।

अगर मुझे वह सही तरीके से समझ में आता है, तो मैं उसके लिए एक पीआर रख सकता हूं। मैंने ऐसा नहीं किया था क्योंकि मैं RawVec और Vec साथ कम से कम एकीकरण प्राप्त करने की कोशिश कर रहा हूँ। (इस बिंदु पर मेरे पास RawVec किया गया है, लेकिन Vec कई अन्य संरचनाओं के कारण अधिक चुनौतीपूर्ण है, जो इसके निर्माण के लिए हैं, जैसे Drain और IntoIter आदि ...)

वास्तव में, मेरी वर्तमान शाखा ऐसा लगता है कि यह वास्तव में निर्माण कर सकती है (और RawVec साथ एकीकरण के लिए एक परीक्षण), इसलिए मैंने आगे बढ़कर इसे पोस्ट किया: # 42313

@hawkw ने पूछा:

मुझे माफ कर दो अगर मुझे कुछ स्पष्ट याद आ रहा है, लेकिन क्या इस आरएफसी में वर्णित लेआउट विशेषता के लिए एक कारण है कि कॉपी के साथ-साथ क्लोन को भी लागू नहीं करना है, क्योंकि यह सिर्फ पीओडी है?

जिस कारण से मैंने Layout केवल Clone और Copy यह नहीं है कि मैं Layout प्रकार में अधिक संरचना जोड़ने की संभावना को छोड़ना चाहता था। विशेष रूप से, मैं अभी भी इसे बनाने के लिए उपयोग किए गए किसी भी प्रकार के ढांचे को ट्रैक करने के लिए Layout प्रयास करने में रुचि रखता हूं (उदाहरण के लिए, struct { x: u8, y: [char; 215] } 16-

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

लेकिन फिर भी, इस तरह की विशेषताएं मुख्य कारण थे कि मैंने Layout Copy लागू करने का विकल्प नहीं चुना; मैं मूल रूप से सोचा है कि के एक कार्यान्वयन Copy पर समय से पहले बाधा होगा Layout ही।

@alexcrichton @pnkfelix

ऐसा लगता है कि @pnkfelix में यह कवर है, और पीआर में कर्षण हो रहा है, तो चलो बस उसी के साथ चलते हैं। मैं इसे देख रहा हूं और अभी टिप्पणी कर रहा हूं, और यह बहुत अच्छा लग रहा है!

वर्तमान में Allocator::oom लिए हस्ताक्षर है:

    fn oom(&mut self, _: AllocErr) -> ! {
        unsafe { ::core::intrinsics::abort() }
    }

हालांकि, यह मेरे ध्यान में क्यों हो रहा है, इसके लिए Option<Layout> जैसे संदर्भ जोड़ना संभव हो सकता है।

@alexcrichton
यह कई oom_xxx वेरिएंट या विभिन्न तर्क प्रकारों का एक एनाम होने के लायक हो सकता है? ऐसे तरीकों के लिए कुछ अलग-अलग हस्ताक्षर हैं जो विफल हो सकते हैं (जैसे, alloc एक लेआउट लेता है, realloc एक पॉइंटर, एक मूल लेआउट और एक नया लेआउट, आदि) लेता है, और हो सकता है ऐसे मामले हों जिनमें oom -समान विधि उन सभी के बारे में जानना चाहें।

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

यहां स्थिरीकरण के लिए एक बिंदु " fn dealloc " के लिए प्रदान की जाने वाली संरेखण पर क्या आवश्यकताएँ हैं, यह भी निर्धारित करें, और विंडोज पर dealloc का वर्तमान कार्यान्वयन align का उपयोग कैसे निर्धारित करने के लिए करता है। सही ढंग से मुफ्त। @ruuda आपको इस तथ्य में दिलचस्पी हो सकती है।

यहां स्थिरीकरण के लिए एक बिंदु " fn dealloc " के लिए प्रदान की जाने वाली संरेखण पर क्या आवश्यकताएँ हैं, यह भी निर्धारित करें, और विंडोज पर dealloc का वर्तमान कार्यान्वयन align का उपयोग कैसे निर्धारित करने के लिए करता है। सही ढंग से मुफ्त।

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

@ruuda

के रूप में HeapAlloc कोई संरेखण गारंटी देता है

यह 32 बिट के लिए 8 बाइट्स की न्यूनतम संरेखण गारंटी प्रदान करता है या 64 बिट के लिए 16 बाइट्स, यह सिर्फ संरेखण की गारंटी देने के लिए कोई भी तरीका प्रदान नहीं करता है।

विंडोज पर CRT द्वारा दिया गया _aligned_malloc उच्च संरेखण का आवंटन प्रदान कर सकता है, लेकिन विशेष रूप से इसे _aligned_free के साथ जोड़ा जाना चाहिए, free का उपयोग करना अवैध है। इसलिए यदि आप नहीं जानते कि malloc या _aligned_malloc माध्यम से एक आवंटन किया गया था या नहीं, तो आप एक ही नतीजे में फंस गए हैं कि alloc_system Windows पर है यदि आप डॉन ' t deallocate लिए संरेखण पता है। CRT मानक aligned_alloc फ़ंक्शन प्रदान नहीं करता है जिसे free के साथ जोड़ा जा सकता है, इसलिए Microsoft भी इस समस्या को हल करने में सक्षम नहीं है। (हालांकि यह एक C11 समारोह है और माइक्रोसॉफ्ट सी 11 का समर्थन नहीं करता तो यह है कि एक कमजोर तर्क है।)

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

@alexcrichton ने लिखा :

वर्तमान में Allocator::oom लिए हस्ताक्षर है:

    fn oom(&mut self, _: AllocErr) -> ! {
        unsafe { ::core::intrinsics::abort() }
    }

हालांकि, यह मेरे ध्यान में क्यों हो रहा है, इसके लिए Option<Layout> जैसे संदर्भ जोड़ना संभव हो सकता है।

AllocErr पहले से ही Layout AllocErr::Exhausted वेरिएंट में होता है। हम सिर्फ Layout को AllocErr::Unsupported वैरिएंट के रूप में अच्छी तरह से जोड़ सकते हैं, जो मुझे लगता है कि ग्राहक अपेक्षाओं के संदर्भ में सबसे सरल होगा। (इसमें AllocErr एनुम की ओर से चुपचाप बढ़ने का दोष है, लेकिन शायद हमें उस बारे में चिंता नहीं करनी चाहिए ...)

ओह मुझे संदेह है कि यह सब आवश्यक है, सुधार @pnkfelix के लिए धन्यवाद!

मैं सामान्य रूप से std::heap लिए ट्रैकिंग समस्या के लिए इस मुद्दे को फिर से शुरू करने जा रहा हूं क्योंकि यह https://github.com/rust-lang/rust/pull/42727 भूमि के बाद होगा। मैं इसके पक्ष में कुछ अन्य संबंधित मुद्दों को बंद करूंगा।

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

• संबंधित त्रुटि प्रकार पर चर्चा करें
• किसी भी स्थानीय आवंटनकर्ता (विशेषकर संबंधित त्रुटि प्रकार का लाभ उठाने) का उपयोग करने के लिए संग्रह परिवर्तित करने पर चर्चा करें

मैंने https://github.com/rust-lang/rust/issues/42774 को स्टैड कलेक्शन में Alloc एकीकरण को ट्रैक करने के लिए खोला है। Libs टीम में ऐतिहासिक चर्चा के साथ std::heap मॉड्यूल के प्रारंभिक पास की तुलना में स्थिरीकरण के एक अलग ट्रैक पर होने की संभावना है।

आवंटन-संबंधी मुद्दों की समीक्षा करते समय मैं भी https://github.com/rust-lang/rust/issues/30170 पर आया था, जो @pnkfelix थोड़ी देर पहले वापस आ गया था। ऐसा लगता है कि OSX सिस्टम आबंटक उच्च संरेखण के साथ छोटी गाड़ी है और जब उस प्रोग्राम को jemalloc के साथ चलाया जा रहा है, तो यह कम से कम लिनक्स पर सौदे के दौरान segfaulting है। स्थिरीकरण के दौरान विचार करने लायक!

मैंने # 42794 को विशिष्ट प्रश्न पर चर्चा करने के लिए एक जगह के रूप में खोला है कि क्या शून्य-आकार के आवंटन को उनके अनुरोधित संरेखण से मेल खाने की आवश्यकता है।

(ओह रुको, शून्य आकार के आवंटन उपयोगकर्ता आवंटनकर्ताओं में अवैध हैं!)

चूंकि alloc::heap::allocate फ़ंक्शन और मित्र अब रात में चले गए हैं, इसलिए मैंने इस नए API का उपयोग करने के लिए सर्वो को अपडेट किया है। यह अंतर का हिस्सा है:

-use alloc::heap;
+use alloc::allocator::{Alloc, Layout};
+use alloc::heap::Heap;

-        let ptr = heap::allocate(req_size as usize, FT_ALIGNMENT) as *mut c_void;
+        let layout = Layout::from_size_align(req_size as usize, FT_ALIGNMENT).unwrap();
+        let ptr = Heap.alloc(layout).unwrap() as *mut c_void;

मुझे लगता है कि एर्गोनॉमिक्स महान नहीं हैं। हम एक आइटम को आयात करने से दो अलग-अलग मॉड्यूल से तीन आयात करने गए।

• क्या allocator.alloc(Layout::from_size_align(…)) लिए एक सुविधा विधि रखना समझदारी होगी?
• क्या यह <Heap as Alloc>::_ बनाने के लिए स्वतंत्र कार्यों या निहित विधियों के रूप में समझ में आएगा? (आयात करने के लिए एक कम आइटम के लिए, Alloc विशेषता।)

वैकल्पिक रूप से, Alloc गुण प्रस्ताव में हो सकते हैं या क्या यह उपयोग के मामले में बहुत अधिक है?

@SimonSapin IMO में इस तरह के निम्न-स्तरीय एपीआई के एर्गोनॉमिक्स के अनुकूलन के लिए बहुत कुछ नहीं है।

@SimonSapin

मुझे लगता है कि एर्गोनॉमिक्स महान नहीं हैं। हम एक आइटम को आयात करने से दो अलग-अलग मॉड्यूल से तीन आयात करने गए।

मुझे अपने कोडबेस के साथ ठीक वैसा ही अहसास था - अब यह बहुत अच्छा है।

क्या यह allocator.alloc(Layout::from_size_align(…))? लिए एक सुविधा विधि का अर्थ होगा

क्या आपका मतलब Alloc विशेषता में है, या केवल Heap ? यहाँ एक बात पर गौर करें कि अब एक तीसरी त्रुटि की स्थिति है: Layout::from_size_align Option , इसलिए वह None वापस कर सकता है, जबकि सामान्य त्रुटियां आपको आवंटित करते समय मिल सकती हैं ।

वैकल्पिक रूप से, Alloc गुण प्रस्ताव में हो सकते हैं या क्या यह उपयोग के मामले में बहुत अधिक है?

IMO इस तरह के निम्न-स्तरीय API के एर्गोनॉमिक्स के अनुकूलन के लिए बहुत अधिक नहीं है।

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

@SimonSapin क्या आपने पहले OOM को हैंडल नहीं किया था? इसके अलावा std सभी तीन प्रकार std::heap मॉड्यूल में उपलब्ध हैं (वे एक मॉड्यूल में होना चाहिए)। क्या आपने इससे पहले आकार के अतिप्रवाह के मामले को नहीं संभाला? या शून्य आकार के प्रकार?

क्या आपने पहले OOM को हैंडल नहीं किया था?

जब यह अस्तित्व में alloc::heap::allocate समारोह के बिना एक एक सूचक लौटे Result और OOM से निपटने में एक विकल्प नहीं छोड़ा था। मुझे लगता है कि इसने इस प्रक्रिया को निरस्त कर दिया। अब मैंने धागे को घबराने के लिए .unwrap() जोड़ा है।

वे एक मॉड्यूल में होना चाहिए

मैं अब देखता हूं कि heap.rs में pub use allocator::*; । लेकिन जब मैं क्लिक किया Alloc के लिए rustdoc पृष्ठ पर सूचीबद्ध impl में Heap मैं करने के लिए भेजा गया था alloc::allocator::Alloc ।

बाकी के रूप में, मैंने इसमें नहीं देखा। मैं एक नए संकलक के लिए कोडिंग का एक बड़ा ढेर लगा रहा हूं जो वर्षों पहले लिखा गया था। मुझे लगता है कि ये FreeType, एक C लाइब्रेरी के लिए कॉलबैक हैं।

जब यह आबंटित होता है :: heap :: आबंटित फ़ंक्शन बिना परिणाम के एक पॉइंटर लौटाता है और OOM हैंडलिंग में कोई विकल्प नहीं छोड़ता है।

इसने आपको एक विकल्प दिया। पॉइंटर जो लौटाया गया था, वह एक शून्य पॉइंटर हो सकता था जो इंगित करेगा कि ढेर आवंटनकर्ता आवंटित करने में विफल रहा। यही कारण है कि मुझे बहुत खुशी है कि यह Result बदल गया है ताकि लोग उस मामले को संभालना न भूलें।

ओह ठीक है, शायद फ्री टाइप एक शून्य जांच कर रहा था, मुझे नहीं पता। वैसे भी, हां, रिजल्ट लौटाना अच्छा है।

# 30170 और # 43097 को देखते हुए, मैं ओएस एक्स मुद्दे को हास्यास्पद रूप से बड़े संरेखण के साथ हल करने के लिए प्रलोभित हूं, यह निर्दिष्ट करके कि उपयोगकर्ता संरेखण का अनुरोध नहीं कर सकते हैं = = 1 << 32 ।

इस लागू करने के लिए एक बहुत ही आसान तरीके: बदलें Layout इंटरफ़ेस ताकि align एक से दर्शाया जाता है u32 एक के बजाय usize ।

@alexcrichton क्या आपके पास इस पर विचार हैं? क्या मुझे सिर्फ एक पीआर बनाना चाहिए जो ऐसा करता है?

@pnkfelix Layout::from_size_align अभी भी usize लगेगा और u32 ओवरफ़्लो पर एक त्रुटि लौटाएगा, है ना?

@SimonSapin यह usize संरेखित करने के लिए जारी रखने के लिए क्या कारण है, अगर एक स्थैतिक पूर्व शर्त यह है कि किसी मूल्य> = 1 << 32 पास करना असुरक्षित है?

और अगर जवाब "अच्छी तरह से कुछ आबंटक एक संरेखण> = 1 << 32 " का समर्थन कर सकते हैं, तो हम यथास्थिति में वापस आ जाते हैं और आप मेरे सुझाव की अवहेलना कर सकते हैं। मेरे सुझाव की बात मूल रूप से इस तरह की टिप्पणियों के लिए एक "+1" है

क्योंकि std::mem::align_of usize लौटते हैं

@SimonSapin आह, अच्छे पुराने स्थिर एपीआई की ... आह।

@pnkfelix 1 << 32 सीमित होना मुझे उचित लगता है!

@rfcbot fcp मर्ज

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

pub struct Layout { /* ... */ }

extern {
    pub type void;
}

impl Layout {
    pub fn from_size_align(size: usize, align: usize) -> Option<Layout>;
    pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Layout;

    pub fn size(&self) -> usize;
    pub fn align(&self) -> usize;
}

pub unsafe trait Alloc {
    unsafe fn alloc(&mut self, layout: Layout) -> *mut void;
    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> *mut void;
    unsafe fn dealloc(&mut self, ptr: *mut void, layout: Layout);

    // all other methods are default and unstable
}

/// The global default allocator
pub struct Heap;

impl Alloc for Heap {
    // ...
}

impl<'a> Alloc for &'a Heap {
    // ...
}

/// The "system" allocator
pub struct System;

impl Alloc for System {
    // ...
}

impl<'a> Alloc for &'a System {
    // ...
}

pub struct Layout { /* ... */ }

impl Layout {
    pub fn from_size_align(size: usize, align: usize) -> Option<Layout>;
    pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Layout;

    pub fn size(&self) -> usize;
    pub fn align(&self) -> usize;
}

// renamed from AllocErr today
pub struct Error {
    // ...
}

impl Error {
    pub fn oom() -> Self;
}

pub unsafe trait Alloc {
    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, Error>;
    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout);

    // all other methods are default and unstable
}

/// The global default allocator
pub struct Heap;

impl Alloc for Heap {
    // ...
}

impl<'a> Alloc for &'a Heap {
    // ...
}

/// The "system" allocator
pub struct System;

impl Alloc for System {
    // ...
}

impl<'a> Alloc for &'a System {
    // ...
}

विशेष रूप से:

• केवल alloc , alloc_zeroed , और dealloc विधियों को Alloc विशेषता पर स्थिर करना अभी के लिए। मुझे लगता है कि यह हमारे पास आज के सबसे अधिक दबाव वाले मुद्दे को हल करता है, एक कस्टम वैश्विक आवंटनकर्ता को परिभाषित करता है।
• कच्चे पॉइंटर्स का उपयोग करने के पक्ष में Error प्रकार निकालें।
• इंटरफ़ेस में u8 प्रकार को void बदलें
• Layout प्रकार का एक छीन लिया गया संस्करण।

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

+1 कुछ स्थिर होने के लिए!

AllocErr से Error का नाम बदलें और इंटरफ़ेस को थोड़ा अधिक रूढ़िवादी बनाता है।

क्या यह Unsupported निर्दिष्ट करने के लिए आवंटनकर्ताओं के लिए विकल्प को समाप्त करता है? किसी चीज़ पर अधिक चोट पहुँचाने के जोखिम पर मैं बहुत कुछ कर रहा हूँ, मुझे लगता है कि # 44557 अभी भी एक मुद्दा है।

Layout

ऐसा लगता है कि आपने Layout से कुछ विधियों को हटा दिया है। क्या आप वास्तव में हटाए गए, या अस्थिर के रूप में छोड़ दिए गए लोगों का मतलब है?

impl Error {
    pub fn oom() -> Self;
}

क्या यह आज AllocErr::Exhausted लिए एक निर्माता है? यदि हां, तो क्या इसके लिए Layout पैरामीटर नहीं होना चाहिए?

टीम के सदस्य @alexcrichton ने इसे मर्ज करने का प्रस्ताव दिया है। अगले चरण की समीक्षा बाकी टैग टीमों द्वारा की गई है:

• [x] @ बर्टसुशी
• [x] @ किमुंडी
• [x] @alexcrichton
• [x] @ न्यूटन
• [x] @cramertj
• [x] @dtolnay
• [x] @ हेड्डी
• [x] @ मुनोमकोत्सकिस
• [x] @nrc
• [x] @pnkfelix
• [x] @sfackler
• [x] @withoutboats

चिंताओं:

• * mut u8 https://github.com/rust-lang/rust/issues/32838#issuecomment -342622672 द्वारा हल किया गया

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

टीम के सदस्य मुझे क्या टैग दे सकते हैं, इसके बारे में जानकारी के लिए यह दस्तावेज़ देखें।

मैं वास्तव में इस काम को स्थिर करने के बारे में उत्साहित हूं!

एक प्रश्न: उपरोक्त सूत्र में, @joshlf और @emon2314 ने Alloc और Dealloc लक्षणों को अलग करने की संभावना के बारे में एक दिलचस्प बात उठाई , जिसमें alloc कुछ डेटा की आवश्यकता होती है, लेकिन dealloc को अतिरिक्त जानकारी की आवश्यकता नहीं होती है, इसलिए Dealloc प्रकार शून्य-आकार हो सकते हैं।

क्या यह प्रश्न कभी हल किया गया था? दो लक्षणों को अलग करने के क्या नुकसान हैं?

@joshlf

क्या यह असमर्थित निर्दिष्ट करने के लिए आवंटनकर्ताओं के लिए विकल्प को समाप्त करता है?

हां और नहीं, इसका मतलब यह होगा कि इस तरह के ऑपरेशन को तुरंत स्थिर जंग में समर्थित नहीं किया गया

क्या आप वास्तव में हटाए गए, या अस्थिर के रूप में छोड़ दिए गए लोगों का मतलब है?

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

@SimonSapin

क्या यह आज के AllocErr :: के लिए एक निर्माता है? यदि ऐसा है, तो यह एक लेआउट पैरामीटर नहीं होना चाहिए?

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

@cramertj

मैंने अभी तक व्यक्तिगत रूप से इस तरह के प्रश्न / चिंता को नहीं देखा था (मुझे लगता है कि मैं इससे चूक गया था!), लेकिन मैं व्यक्तिगत रूप से इसके लायक होने के रूप में नहीं देखूंगा। दो लक्षण सामान्य रूप से बॉयलरप्लेट से दोगुना है, क्योंकि अब हर किसी को उदाहरण के लिए Alloc + Dealloc संग्रह में टाइप करना होगा। मुझे उम्मीद है कि इस तरह के एक विशेष उपयोग इंटरफ़ेस को अन्य सभी उपयोगकर्ताओं को व्यक्तिगत रूप से उपयोग करने की सूचना नहीं देना चाहते हैं।

@cramertj @alexcrichton

मैंने अभी तक व्यक्तिगत रूप से इस तरह के प्रश्न / चिंता को नहीं देखा था (मुझे लगता है कि मैं इससे चूक गया था!), लेकिन मैं व्यक्तिगत रूप से इसके लायक होने के रूप में नहीं देखूंगा।

सामान्य तौर पर मैं मानता हूं कि यह एक झलक के साथ इसके लायक नहीं है: Box । Box<T, A: Alloc> , Alloc की मौजूदा परिभाषा को देखते हुए, कम से कम दो शब्द बड़े (सूचक जो पहले से ही है और Alloc बहुत कम से कम होना चाहिए) ) वैश्विक सिंगलेट्स के मामले को छोड़कर (जिसे ZST के रूप में लागू किया जा सकता है)। इस तरह के एक सामान्य और मौलिक प्रकार को संग्रहीत करने के लिए आवश्यक स्थान में एक 2x (या अधिक) ब्लूप मेरे लिए संबंधित है।

@alexcrichton

उदाहरण के लिए अब सभी को संग्रह में Alloc + Dealloc टाइप करना होगा

हम कुछ इस तरह से जोड़ सकते हैं:

trait Allocator: Alloc + Dealloc {}
impl<T> Allocator for T where T: Alloc + Dealloc {}

इस तरह के एक आम और मौलिक प्रकार को संग्रहीत करने के लिए आवश्यक स्थान में एक 2x (या अधिक) ब्लूपअप

केवल जब आप एक कस्टम आवंटनक का उपयोग करते हैं जो प्रक्रिया-वैश्विक नहीं है। std::heap::Heap (डिफ़ॉल्ट) शून्य-आकार है।

या क्या आपको लगता है कि लेआउट-प्रोटेक्शन एरर को पहले पास में स्थिर किया जाना चाहिए?

@alexcrichton मैं वास्तव में यह नहीं समझता कि यह प्रस्तावित प्रथम पास आखिर क्यों है। Vec दुरुपयोग करके मुश्किल से अधिक किया जा सकता है, और उदाहरण के लिए https://crates.io/crates/jemallocator का उपयोग करने के लिए पर्याप्त नहीं है

पूरी चीज़ को स्थिर करने के लिए अभी भी क्या हल करने की आवश्यकता है?

केवल जब आप एक कस्टम आवंटनक का उपयोग करते हैं जो प्रक्रिया-वैश्विक नहीं है। std :: heap :: ढेर (डिफ़ॉल्ट) शून्य-आकार है।

ऐसा लगता है कि पैरामीट्रिक एलोकेटर होने के प्राथमिक उपयोग के मामले में, नहीं? एक पेड़ की निम्नलिखित सरल परिभाषा की कल्पना करें:

struct Node<T, A: Alloc> {
    t: T,
    left: Option<Box<Node<T, A>>>,
    right: Option<Box<Node<T, A>>>,
}

1-शब्द Alloc लोगों से निर्मित एक पेड़ में ZST Alloc की तुलना में संपूर्ण डेटा संरचना के लिए आकार में ~ 1.7x ब्लूपअप होगा। यह मेरे लिए बहुत बुरा लगता है, और इस प्रकार के एप्लिकेशन Alloc होने का संपूर्ण बिंदु हैं।

@cramertj

हम कुछ इस तरह से जोड़ सकते हैं:

हम भी वास्तविक विशेषता उपनाम रखने जा रहे हैं :) https://github.com/rust-lang/rust/issues/41517

@glaebhoerl हाँ, लेकिन स्थिरीकरण अभी भी एक रास्ता है क्योंकि अभी तक कोई कार्यान्वयन नहीं है। अगर हमें लगता है कि हम Allocator मैन्युअल इम्प्लॉईज़ को निष्क्रिय कर देते हैं, तो हमें लगता है कि हम आने-जाने पर पीछे-पीछे आने वाले एलियटेस पर स्विच कर सकते हैं;)

@joshlf

इस तरह के एक सामान्य और मौलिक प्रकार को संग्रहीत करने के लिए आवश्यक स्थान में एक 2x (या अधिक) ब्लूप मेरे लिए संबंधित है।

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

@cramertj

हम कुछ इस तरह से जोड़ सकते हैं:

वास्तव में! हमने फिर एक विशेषता को तीन तक ले लिया है। अतीत में हमें इस तरह के लक्षणों के साथ एक महान अनुभव नहीं था। उदाहरण के लिए Box<Both> Box<OnlyOneTrait> को कास्ट नहीं करता है। मुझे यकीन है कि हम इस सभी सुविधाओं को सुचारू करने के लिए भाषा की विशेषताओं का इंतजार कर सकते हैं, लेकिन ऐसा लगता है कि यह सबसे अच्छा तरीका है।

@SimonSapin

पूरी चीज़ को स्थिर करने के लिए अभी भी क्या हल करने की आवश्यकता है?

मुझे नहीं पता। मैं पूरी छोटी से छोटी बात से शुरुआत करना चाहता था ताकि कम बहस हो।

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

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

डीलक्लोकेट पर संरेखण में वापस आने के लिए, मुझे आगे दो तरीके दिखाई देते हैं:

• प्रस्तावित के रूप में स्थिर (डीललॉकेट पर संरेखण के साथ)। जब तक Layout शामिल न हो, मैन्युअल रूप से आवंटित मेमोरी का स्वामित्व देना असंभव होगा। विशेष रूप से, आवश्यकता से अधिक कठोर संरेखण के साथ Vec या Box या String या अन्य std कंटेनर बनाना असंभव है (उदाहरण के लिए क्योंकि डॉन) 'बॉक्सिंग एलीमेंट को कैशे लाइन को स्ट्रैडल करना चाहते हैं), बिना डिकॉन्स्ट्रक्ट किए और इसे बाद में मैन्युअल रूप से डील किया (जो हमेशा एक विकल्प नहीं होता)। कुछ और जो असंभव होगा, का एक और उदाहरण एक Vec simd संचालन का उपयोग करके भरना है, और फिर इसे दूर करना है।

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

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

मुझे लगता है कि हम वास्तव में जस्ट फाइन (टीएम) हो सकते हैं। Alloc डॉक्स का हवाला देते हुए:

कुछ तरीकों की आवश्यकता है कि एक लेआउट एक मेमोरी ब्लॉक फिट बैठता है।
एक मेमोरी ब्लॉक को "फिट" करने के लिए लेआउट के लिए इसका क्या मतलब है (या
समान रूप से, एक मेमोरी ब्लॉक को एक लेआउट "फिट" करने के लिए यह है कि
निम्नलिखित दो शर्तों का पालन करना चाहिए:

1. ब्लॉक का शुरुआती पता layout.align() लिए संरेखित होना चाहिए।

2. ब्लॉक का आकार [use_min, use_max] की सीमा में होना चाहिए, जहां:

   • use_min self.usable_size(layout).0 , और

   • use_max वह क्षमता है जो थी (या रही होगी)
     जब (अगर) ब्लॉक को कॉल के माध्यम से आवंटित किया गया था
     alloc_excess या realloc_excess ।

ध्यान दें कि:

• लेआउट का आकार हाल ही में ब्लॉक को आवंटित करने के लिए उपयोग किया गया था
  [use_min, use_max] की सीमा में होने की गारंटी है, और

• use_max पर कम-बाउंड को कॉल द्वारा सुरक्षित रूप से अनुमानित किया जा सकता है
  usable_size ।

• अगर एक लेआउट k एक मेमोरी ब्लॉक फिट बैठता है ( ptr द्वारा चिह्नित)
  वर्तमान में एक आवंटनकर्ता a माध्यम से आवंटित किया गया है, तो यह कानूनी है
  उस लेआउट का उपयोग करने के लिए इसे हटा दें, अर्थात a.dealloc(ptr, k); ।

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

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

क्या संभव अनुकूलन नहीं है कि कुछ पॉइंटर-आकार-प्रकार शून्य आकार हो सकते हैं? (या कुछ इस तरह का?)

हाल ही में इसके लिए एक RFC था और ऐसा लगता है कि संगतता की चिंताओं के कारण ऐसा नहीं किया जा सकता है: https://github.com/rust-lang/rfcs/pull/2040

उदाहरण के लिए Box<Both> Box<OnlyOneTrait> को कास्ट नहीं करता है। मुझे यकीन है कि हम इस सभी सुविधाओं को सुचारू करने के लिए भाषा की विशेषताओं का इंतजार कर सकते हैं, लेकिन ऐसा लगता है कि यह सबसे अच्छा तरीका है।

दूसरी ओर उपहास की वस्तु वस्तु अनियंत्रित रूप से वांछनीय प्रतीत होती है, और इसे लागू करने के लिए अधिकतर प्रयास / बैंडविड्थ / इच्छाशक्ति का प्रश्न होता है। हाल ही में एक धागा था: https://internals.rust-lang.org/t/trait-upcasting/5970

@ इरुडा मैं वह था जिसने मूल रूप से alloc_system कार्यान्वयन लिखा था। alexcrichton ने केवल <time period> के महान आवंटनकर्ता रिफैक्टर्स के दौरान इसे चारों ओर घुमाया।

वर्तमान कार्यान्वयन के लिए आवश्यक है कि आप उसी संरेखण के साथ डील करें जो आपने दिए गए मेमोरी ब्लॉक के साथ आवंटित किया हो। भले ही दस्तावेज़ीकरण का दावा किया जा सकता है, यह वर्तमान वास्तविकता है जिसे हर किसी को तब तक पालन करना चाहिए जब तक कि विंडोज पर alloc_system बदल न जाए।

विंडोज पर आवंटन हमेशा MEMORY_ALLOCATION_ALIGNMENT एक से अधिक का उपयोग करते हैं (हालांकि वे उस आकार को याद करते हैं जो आपने उन्हें बाइट के साथ आवंटित किया था)। MEMORY_ALLOCATION_ALIGNMENT 32 पर 8 है और 16 पर 64 बिट है। Overaligned प्रकारों के लिए, क्योंकि संरेखण से अधिक है MEMORY_ALLOCATION_ALIGNMENT , भूमि के ऊपर की वजह से alloc_system लगातार निर्दिष्ट संरेखण की राशि है, तो एक 64byte गठबंधन आवंटन भूमि के ऊपर के 64 बाइट्स होगा।

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

@ruuda

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

@joshlf

मुझे लगता है कि टिप्पणी गलत है, जैसा कि बताया गया है कि alloc_system विंडोज पर निर्भर करता है एक ही संरेखण पर निर्भर करता है जो आवंटन पर पारित किया गया था।

99.99% आवंटन को ध्यान में रखते हुए ओवरलैग नहीं किया जाएगा, क्या आप वास्तव में सभी आवंटन पर उस तरह का ओवरराइड करना चाहते हैं?

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

@alexcrichton

मुझे लगता है कि टिप्पणी गलत है, जैसा कि बताया गया है कि alloc_system विंडोज पर उसी संरेखण पर निर्भर है जो आवंटन पर पारित किया गया था।

क्या इसका मतलब यह नहीं है कि विंडोज पर alloc_system वास्तव में Alloc विशेषता को लागू नहीं करता है (और इस प्रकार शायद हमें Alloc विशेषता की आवश्यकताओं को बदलना चाहिए)?

@ retep998

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

@joshlf वर्तमान में alloc_system कारण होने वाला ओवरहेड बड़े-से-सामान्य संरेखण का अनुरोध करने के कारण है। यदि आपका संरेखण MEMORY_ALLOCATION_ALIGNMENT से कम या बराबर है, तो alloc_system वजह से कोई ओवरहेड नहीं है।

हालांकि, अगर हमने अलग-अलग संरेखण के साथ डील करने की अनुमति देने के लिए कार्यान्वयन को बदल दिया, तो ओवरहेड संरेखण की परवाह किए बिना लगभग सभी आवंटन पर लागू होगा।

ओह समझा; समझ में आता है।

हीप और हीप दोनों के लिए एलोक को लागू करने का क्या अर्थ है? किन मामलों में उपयोगकर्ता उन बनामों में से किसी एक का उपयोग करेगा बनाम दूसरे का?

क्या यह पहला मानक पुस्तकालय एपीआई है जिसमें *mut u8 का अर्थ "जो कुछ भी सूचक" होगा? स्ट्रिंग है :: from_raw_parts लेकिन वह वास्तव में बाइट्स को इंगित करता है। मैं *mut u8 अर्थ नहीं हूं, "जो कुछ भी" का सूचक है - यहां तक ​​कि सी भी बेहतर करता है। कुछ अन्य विकल्प क्या हैं? शायद अपारदर्शी प्रकार के लिए एक सूचक अधिक सार्थक होगा।

@rfcbot की चिंता * mut u8

@dtolnay Alloc for Heap "मानक" की तरह है और Alloc for &Heap Write for &T जहाँ गुण के लिए &mut self आवश्यकता होती है लेकिन कार्यान्वयन नहीं होता है। विशेष रूप से इसका मतलब है कि Heap और System जैसे प्रकार थ्रेडसेफ़ हैं और आवंटित करते समय इसे सिंक्रनाइज़ करने की आवश्यकता नहीं है।

इससे भी महत्वपूर्ण बात यह है कि, #[global_allocator] आवश्यक है कि वह जिस स्टैटिक से जुड़ी हो, जिसमें T , Alloc for &T । (उर्फ सभी वैश्विक आवंटनकर्ता थ्रेडसेफ़ होने चाहिए)

*mut u8 मुझे लगता है कि *mut () दिलचस्प हो सकता है, लेकिन मैं व्यक्तिगत रूप से प्रति सेकंड यहाँ "यह अधिकार" प्राप्त करने के लिए मजबूर महसूस नहीं करता हूं।

*mut u8 का मुख्य लाभ यह है कि बाइट ऑफ़सेट के साथ .offset का उपयोग करना बहुत सुविधाजनक है।

*mut u8 मुझे लगता है कि *mut () दिलचस्प हो सकता है, लेकिन मैं व्यक्तिगत रूप से प्रति सेकंड "यह अधिकार" प्राप्त करने के लिए मजबूर महसूस नहीं करता हूं।

यदि हम एक स्थिर इंटरफ़ेस में *mut u8 साथ जाते हैं, तो क्या हम अपने आप को लॉक नहीं कर रहे हैं? दूसरे शब्दों में, एक बार जब हम इसे स्थिर कर देते हैं, तो हमें भविष्य में "यह अधिकार प्राप्त करने" का मौका नहीं मिलेगा।

इसके अलावा, *mut () मुझे उस स्थिति में थोड़ा खतरनाक लगता है जब हम भविष्य में RFC 2040 जैसा अनुकूलन करते हैं।

*mut u8 का मुख्य लाभ यह है कि इसका उपयोग करना बहुत सुविधाजनक है। बाइट ऑफ़सेट के साथ .offset।

सच है, लेकिन आप आसानी से let ptr = (foo as *mut u8) और फिर अपने मीरा के रास्ते के बारे में जान सकते हैं। ऐसा लगता नहीं है कि एपीआई में *mut u8 साथ चिपके रहने के लिए एक प्रेरणा पर्याप्त है यदि कोई सम्मोहक विकल्प हैं (जो कि, निष्पक्ष होने के लिए, मुझे यकीन नहीं है कि वहाँ हैं)।

इसके अलावा, यदि हम भविष्य में कभी भी RFC 2040 जैसा अनुकूलन करते हैं, तो * mut () मुझे थोड़ा खतरनाक लगता है।

अनुकूलन पहले से ही शायद कभी नहीं होगा - यह बहुत अधिक मौजूदा कोड को तोड़ देगा। यदि ऐसा हुआ भी, तो यह &() और &mut () , न कि *mut () ।

यदि RFC 1861 लागू / स्थिर होने के करीब था, तो मैं इसका उपयोग करने का सुझाव दूंगा:

extern { pub type void; }

pub unsafe trait Alloc {
    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut void, Error>;
    unsafe fn dealloc(&mut self, ptr: *mut void, layout: Layout);
    // ...
}

यह शायद बहुत दूर है हालांकि, है ना?

@ जोशफेल मुझे लगा कि मैंने उनके बारे में एक पीआर देखा है, शेष अज्ञात DynSized ।

क्या यह वस्तुओं की तरह स्ट्रक्चर हैक के लिए काम करेगा? कहो मेरे पास एक Node<T> जो ऐसा दिखता है:

struct Node<T> {
   size: u32,
   data: T,
   // followed by `size` bytes
}

और एक मूल्य प्रकार:

struct V {
  a: u32,
  b: bool,
}

अब मैं एकल आबंटन में a आकार के तार के साथ Node<V> आवंटित करना चाहता हूं। आदर्श रूप से मैं आकार का एक संरेखण करना चाहता हूं 16 संरेखित 4 और इसमें सब कुछ फिट है: 4 u32 , V , और स्ट्रिंग बाइट्स के लिए 7। यह काम करता है क्योंकि V के अंतिम सदस्य में संरेखण 1 होता है और स्ट्रिंग बाइट्स में संरेखण 1 भी होता है।

ध्यान दें कि यह C / C ++ में अनुमति नहीं है यदि उपरोक्त प्रकार की रचना की जाती है, जैसा कि पैक्ड स्टोरेज के लिए लिखना अपरिभाषित व्यवहार है। मुझे लगता है कि यह सी / सी ++ मानक में एक छेद है जो दुर्भाग्य से तय नहीं किया जा सकता है। मैं इस बात पर विस्तार कर सकता हूं कि यह क्यों टूटा है, लेकिन इसके बजाय रस्ट पर ध्यान दें। क्या यह काम कर सकता है? :-)

Node<V> संरचना के आकार और संरेखण के संबंध में, आप बहुत अधिक राइनर कंपाइलर हैं। यह यूबी (अपरिभाषित व्यवहार) है, जिसे किसी भी आकार या संरेखण के साथ आवंटित किया जा सकता है, जो कि जंग की आवश्यकता के मुकाबले छोटी होती है, क्योंकि रुस्ट इस धारणा के आधार पर अनुकूलन कर सकता है कि कोई Node<V> ऑब्जेक्ट - ढेर पर, एक संदर्भ के पीछे, आदि। - एक आकार और संरेखण मिलान है जो संकलन समय पर अपेक्षित है।

व्यवहार में, ऐसा लगता है कि उत्तर दुर्भाग्य से नहीं है: मैंने इस कार्यक्रम को चलाया और पाया कि, कम से कम रस्ट प्लेग्राउंड पर, Node<V> को 12 का आकार दिया गया है और 4 का संरेखण है, जिसका अर्थ है कि किसी भी वस्तु के बाद Node<V> को कम से कम 12 बाइट द्वारा ऑफसेट किया जाना चाहिए। यह data.b फ़ील्ड की Node<V> 8 बाइट्स के भीतर ऑफसेट की तरह दिखता है, जिसका अर्थ है कि बाइट्स 9-11 पैडिंग पीछे हैं। दुर्भाग्य से, भले ही उन पैडिंग बाइट्स का "कुछ अर्थों में" उपयोग नहीं किया जाता है, फिर भी कंपाइलर उन्हें Node<V> हिस्से के रूप में मानते हैं, और उनके साथ पसंद आने वाले कुछ भी करने का अधिकार सुरक्षित रखते हैं (सबसे महत्वपूर्ण बात, लेखन सहित जब आप Node<V> लिए असाइन करते हैं, तो इसका मतलब है कि यदि आप वहाँ अतिरिक्त डेटा को दूर करने की कोशिश करते हैं, तो यह ओवरराइट हो सकता है)।

(ध्यान दें, btw: आप एक प्रकार का व्यवहार नहीं कर सकते हैं जिसे पैक किया जाता है जिसे रस्ट कंपाइलर पैक नहीं लगता है। हालांकि, आप _can_ रस्ट कंपाइलर को बताते हैं कि कुछ पैक किया गया है, जो टाइप के लेआउट को बदल देगा (पैडिंग हटाकर) repr(packed) )

हालाँकि, एक वस्तु को एक के बाद एक रखने के संबंध में, उन दोनों को समान जंग प्रकार का हिस्सा होने के बावजूद, मुझे लगभग 100% यकीन है कि यह वैध है - आखिरकार, यह Vec है। आप कुल आवंटन के लिए कितनी जगह की जरूरत है, इसकी गणना करने के लिए Layout प्रकार के तरीकों का उपयोग कर सकते हैं:

let node_layout = Layout::new::<Node<V>>();
// NOTE: This is only valid if the node_layout.align() is at least as large as mem::align_of_val("a")!
// NOTE: I'm assuming that the alignment of all strings is the same (since str is unsized, you can't do mem::align_of::<str>())
let padding = node_layout.padding_needed_for(mem::align_of_val("a"));
let total_size = node_layout.size() + padding + 7;
let total_layout = Layout::from_size_align(total_size, node_layout.align()).unwrap();

क्या यह काम पसंद आएगा?

#[repr(C)]
struct Node<T> {
   size: u32,
   data: T,
   bytes: [u8; 0],
}

... तो एक बड़े आकार के साथ आवंटित करें, और slice::from_raw_parts_mut(node.bytes.as_mut_ptr(), size) ?

विस्तृत उत्तर के लिए @joshlf धन्यवाद! मेरे usecase के लिए TLDR यह है कि मैं Node<V> 16 repr(packed) । अन्यथा सबसे अच्छा मैं कर सकता है आकार 19 (12 + 7)।

@SimonSapin निश्चित नहीं; मै कोशिश करूँगा।

वास्तव में इस धागे के साथ नहीं पकड़ा गया है, लेकिन मैं अभी तक कुछ भी स्थिर करने के खिलाफ

1. अलोकेटर-बहुरूपी संग्रह
   
   
   
   • नॉन-ब्लॉटेड बॉक्स भी नहीं!
   
   
2. पतनशील संग्रह

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

पुन: @SON2314 की टिप्पणी

मुझे लगता है कि उस परिप्रेक्ष्य और @alexcrichton के बीच संघर्ष से संबंधित एक प्रासंगिक सवाल कुछ स्थिर करने की इच्छा है: न्यूनतम इंटरफ़ेस को स्थिर करने से हमें कितना लाभ होता है? विशेष रूप से, बहुत कम उपभोक्ता Alloc विधियों को सीधे कॉल करेंगे (यहां तक ​​कि अधिकांश संग्रह शायद Box या कुछ इसी तरह के कंटेनर का उपयोग करेंगे), इसलिए असली सवाल यह बन जाता है: उपयोगकर्ताओं के लिए स्थिर खरीद क्या करती है Alloc विधियों को सीधे कॉल नहीं किया जा सकता है? ईमानदारी से एकमात्र गंभीर उपयोग का मामला जो मैं सोच सकता हूं, वह यह है कि यह आवंटन-पॉलीमॉर्फिक संग्रह (जो संभवतः उपयोगकर्ताओं के एक बहुत व्यापक सेट द्वारा उपयोग किया जाएगा) के लिए एक मार्ग प्रशस्त करता है, लेकिन ऐसा लगता है कि यह # 27336 पर अवरुद्ध है, जो इससे दूर है हल किया जा रहा है। शायद अन्य बड़े उपयोग के मामले हैं जो मुझे याद आ रहे हैं, लेकिन उस त्वरित विश्लेषण के आधार पर, हम स्थिरीकरण से दूर रहने के इच्छुक हैं क्योंकि हमें केवल एक डिजाइन में लॉक करने की कीमत पर सीमांत लाभ हैं जो हमें बाद में उप-रूप में मिल सकते हैं ।

@ जोशफाइल यह लोगों को अपने स्वयं के वैश्विक आवंटन को परिभाषित करने और उपयोग करने की अनुमति देता है।

हम्मम अच्छी बात है। क्या Alloc को स्थिर किए बिना वैश्विक आवंटनकर्ता को निर्दिष्ट करना संभव होगा? यानी, Alloc लागू करने वाले कोड को अस्थिर होना होगा, लेकिन वह संभवतः अपने स्वयं के टोकरे में समझाया जाएगा, और उस आवंटनकर्ता को वैश्विक आवंटनकर्ता के रूप में चिह्नित करने के लिए तंत्र स्वयं स्थिर होगा। या मैं गलत समझ रहा हूं कि स्थिर / अस्थिर और स्थिर संकलक / रात्रिकालीन संकलक बातचीत कैसे करते हैं?

अह @ जशफूल याद रखें कि # 27336 एक व्याकुलता है, https://github.com/rust-lang/rust/issues/42774#issuecomment -317279035 के अनुसार। मुझे पूरा यकीन है कि हम अन्य समस्याओं में भाग लेंगे --- लक्षणों के साथ समस्याएँ जैसे वे मौजूद हैं, यही वजह है कि मैं अब उस पर काम शुरू करना चाहता हूं। एक बार उन सभी समस्याओं पर चर्चा करना बहुत आसान हो जाता है जब वे बहस की भविष्यवाणी की गई वायदा पोस्ट की तुलना में सभी के लिए देखते हैं- # 27336।

@ जोशफेल लेकिन आप एक स्थिर संकलक के साथ वैश्विक

@sfackler आह हाँ, वहाँ गलतफहमी है कि मुझे डर था: पी

मुझे नाम Excess(ptr, usize) थोड़ा भ्रामक लगता है क्योंकि usize अनुरोधित आवंटन के आकार में excess है (जैसा कि अतिरिक्त आकार में आवंटित किया गया है), लेकिन total आवंटन का

IMO Total , Real , Usable , या कोई भी नाम जो बताता है कि आकार कुल आकार या आवंटन का वास्तविक आकार "अतिरिक्त" से बेहतर है, जो मुझे लगता है भ्रामक। वही _excess विधियों के लिए लागू होता है।

मैं ऊपर @gnzlbg से सहमत हूं, मुझे लगता है कि एक सादा (ptr, usize) ट्यूपल सिर्फ ठीक होगा।

ध्यान दें कि Excess को पहले पास में स्थिर रखने का प्रस्ताव नहीं है

Reddit पर चर्चा के लिए इस धागे को पोस्ट करें, जिसमें कुछ लोग हैं जिनकी चिंताएँ हैं: https://www.reddit.com/r/rust/comments/78dabn/custom_allocators_are_on_the_verge_of_being/

आज @ जंग-लेंग / परिवादों के साथ आगे की चर्चा के बाद, मैं स्थिरीकरण प्रस्ताव को कुछ मोड़ देना चाहूंगा जिसे संक्षेप में प्रस्तुत किया जा सकता है:

• स्थिर तरीकों के सेट में alloc_zeroed जोड़ें, अन्यथा alloc के समान हस्ताक्षर होने चाहिए।
• बदले *mut u8 करने के लिए *mut void का उपयोग कर एपीआई में extern { type void; } समर्थन, @dtolnay की चिंता को सुलझाने और एकीकृत के लिए आगे एक तरीका प्रदान c_void इकोसिस्टम में।
• alloc *mut void का रिटर्न प्रकार बदलें, Result और Error को हटा दें

शायद सबसे विवादास्पद अंतिम बिंदु है, इसलिए मैं उस पर भी विस्तार करना चाहता हूं। यह आज के लिबास टीम के साथ चर्चा से बाहर आया और विशेष रूप से चारों ओर घूमने लगा कि कैसे (a) Result -बेड इंटरफ़ेस में एक संकेतक की तुलना में कम कुशल ABI है और एक (b) लगभग कोई "उत्पादन" आवंटनकर्ता आज नहीं है "यह सिर्फ OOM'd" से अधिक कुछ भी सीखने की क्षमता प्रदान करें। प्रदर्शन के लिए हम अधिकतर इनलाइनिंग के साथ इस पर पेपर कर सकते हैं और यह ऐसा रहता है कि Error एक अतिरिक्त पेलोड है जो सबसे कम परतों पर निकालना मुश्किल है।

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

*mut u8 का मुख्य लाभ यह है कि बाइट ऑफ़सेट के साथ .offset का उपयोग करना बहुत सुविधाजनक है।

परिवाद बैठक में हमने impl *mut void { fn offset } सुझाव दिया है जो मौजूदा offset T: Sized लिए परिभाषित नहीं है। byte_offset भी हो सकता है।

+1 *mut void और byte_offset । क्या बाहरी प्रकार की सुविधा के स्थिरीकरण के साथ कोई समस्या है, या क्या हम उस मुद्दे को दरकिनार कर सकते हैं क्योंकि केवल परिभाषा अस्थिर है (और liballoc अस्थिर चीजों को आंतरिक रूप से कर सकती है) और उपयोग नहीं (जैसे, let a: *mut void = ... isn 'टी अस्थिर)?

हां, हमें बाहरी प्रकार के स्थिरीकरण पर रोक लगाने की जरूरत नहीं है। यहां तक ​​कि अगर बाहरी प्रकार का समर्थन हटा दिया जाता है, तो इसके लिए परिभाषित void हमेशा एक जादुई प्रकार का सबसे खराब मामला हो सकता है।

क्या कोई और अधिक चर्चा होनी चाहिए कि क्या Alloc और Dealloc अलग-अलग लक्षण होने चाहिए?

हम उस पर विशेष रूप से स्पर्श नहीं करते थे, लेकिन हम आम तौर पर महसूस करते थे कि हमें पूर्व कला से विचलन नहीं करना चाहिए जब तक कि हमारे पास ऐसा करने के लिए विशेष रूप से सम्मोहक कारण न हो। विशेष रूप से, C ++ के एलोकैटर अवधारणा में समान विभाजन नहीं है।

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

std::unique_ptr एक "Deleter" पर सामान्य है ।

@ जोशफेल unique_ptr Box , vector Vec के बराबर है, unordered_map HashMap के बराबर है

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

कंबल प्रत्यारोपण दृष्टिकोण क्लीनर हो सकता है, वास्तव में:

pub trait Dealloc {
    fn dealloc(&self, ptr: *mut void, layout: Layout);
}

impl<T> Dealloc for T
where
    T: Alloc
{
    fn dealloc(&self, ptr: *mut void, layout: Layout) {
        <T as Alloc>::dealloc(self, ptr, layout)
    }
}

उपयोग के मामलों के बहुमत के बारे में चिंता करने के लिए एक कम विशेषता।

• आबंटन और त्रुटि को हटाते हुए, रिटर्न ऑफ़ * म्यूट शून्य में बदलें

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

मुझे चिंता है कि यह अशक्त के लिए जाँच किए बिना पॉइंटर का उपयोग करना बहुत आसान बना देगा। ऐसा लगता है कि Result<NonZeroPtr<void>, AllocErr> करके और AllocErr शून्य-आकार बनाकर इस जोखिम को जोड़े बिना ओवरहेड को भी हटाया जा सकता है?

( NonZeroPtr एक विलय ptr::Shared और ptr::Unique जैसा कि https://github.com/rust-lang/rust/issues/27730#issuecomment-31666397 में प्रस्तावित है।)

@SimonSapin Result<NonZeroPtr<void>, AllocErr> जैसी कुछ चीज़ों को स्थिर करने के लिए तीन प्रकारों की आवश्यकता होती है, जिनमें से सभी बिल्कुल नए हैं और जिनमें से कुछ ऐतिहासिक रूप से स्थिरीकरण के लिए काफी कम हैं। void तरह कुछ भी आवश्यक नहीं है और एक अच्छा करने के लिए (मेरी राय में) है।

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

लोग निम्न स्तर alloc शीर्ष पर alloc_one जैसे उच्च स्तर के सार का निर्माण भी कर सकते हैं जो Result<NonZeroPtr<void>, AllocErr> जैसे अधिक जटिल रिटर्न प्रकार हो सकते हैं।

मैं मानता हूं कि AllocErr व्यवहार में उपयोगी नहीं होगा, लेकिन सिर्फ Option<NonZeroPtr<void>> बारे में कैसे? एपीआई जो कि गलती से, बिना ओवरहेड के दुरुपयोग के लिए असंभव है, उन चीजों में से एक है जो सी के अलावा जंग को सेट करते हैं, और सी-शैली के अशक्त बिंदुओं पर लौटने से मेरे लिए एक कदम पीछे की तरह महसूस होता है। यह कहना "एक बहुत ही निम्न-स्तरीय एपीआई है जिसका भारी उपयोग करने का इरादा नहीं है" यह कहने जैसा है कि हमें असामान्य माइक्रोकंट्रोलर आर्किटेक्चर पर स्मृति सुरक्षा के बारे में ध्यान नहीं देना चाहिए क्योंकि वे बहुत कम-स्तर के हैं और भारी उपयोग नहीं किए जाते हैं।

आवंटनकर्ता के साथ प्रत्येक इंटरैक्शन में इस फ़ंक्शन के वापसी प्रकार की परवाह किए बिना असुरक्षित कोड शामिल है। निम्न स्तर के आवंटन API का दुरुपयोग संभव है कि क्या वापसी प्रकार Option<NonZeroPtr<void>> या *mut void ।

Alloc::alloc विशेष रूप से एपीआई है जो निम्न स्तर का है और इसका भारी उपयोग करने का इरादा नहीं है। Alloc::alloc_one<T> या Alloc::alloc_array<T> जैसी विधियाँ ऐसे विकल्प हैं जो अधिक भारी उपयोग किए जाएंगे और एक "अच्छे" रिटर्न प्रकार होंगे।

एक स्टेटफुल AllocError इसके लायक नहीं है, लेकिन एक शून्य आकार प्रकार है कि औजार त्रुटि है और एक है Display के allocation failure के लिए अच्छा है। यदि हम NonZeroPtr<void> मार्ग पर जाते हैं, तो मैं Result<NonZeroPtr<void>, AllocError> को Option<NonZeroPtr<void>> Result<NonZeroPtr<void>, AllocError> रूप में बेहतर देखता हूं।

क्यों स्थिर करने के लिए भीड़ :( !! Result<NonZeroPtr<void>, AllocErr> का उपयोग करने के लिए ग्राहकों के लिए निर्विवाद रूप से अच्छा है। यह कहते हुए कि यह "बहुत ही निम्न स्तर का एपीआई" है, जो अच्छा नहीं है बस निराशाजनक रूप से अनुचित नहीं है। सभी स्तरों पर कोड होना चाहिए। संभव के रूप में सुरक्षित और बनाए रखने; अस्पष्ट कोड है कि लगातार संपादित नहीं किया गया है (और इस तरह लोगों की अल्पकालिक यादों में) सभी अधिक!

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

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

@sfackler मुझे लगता है कि हमें कुछ संबद्ध प्रकारों की आवश्यकता है जो कि

@Emon2314 स्थिर करने के लिए "भीड़" है क्योंकि लोग वास्तविक दुनिया में वास्तविक चीजों के लिए आवंटन का उपयोग करना चाहते हैं। यह एक विज्ञान परियोजना नहीं है।

उस संबद्ध प्रकार का उपयोग किस लिए किया जाएगा?

@sfackler लोग अभी भी रात्रि / दिन पिन कर सकते हैं और इस प्रकार की अग्रिम सुविधा की परवाह करने वाले लोगों को ऐसा करने में सहज होना चाहिए। [अगर समस्या अस्थिर जंग बनाम अस्थिर जंग है, तो यह एक अलग समस्या है, जिसे नीति निर्धारण की आवश्यकता है।] लूसी एपीआई में बेकिंग, इसके विपरीत, हमें हमेशा के लिए बाधित कर देता

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

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

क्या आप कुछ कोड लिख सकते हैं जो दिखाता है कि एक डीलर को अपने संबंधित आवंटनकर्ता के प्रकार को जानने की आवश्यकता क्यों है? C ++ के आवंटनकर्ता API को एक समान मैपिंग की आवश्यकता क्यों नहीं है?

अगर लोग सिर्फ एक रात में पिन कर सकते हैं, तो हमारे पास स्थिर बिल्ड क्यों हैं?

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

जो लोग सीधे तौर पर एलोकेटर एपीआई के साथ बातचीत कर रहे हैं, उनका सेट उन लोगों की तुलना में बहुत छोटा है, जो वैश्विक आवंटनकर्ता की जगह उन एपीआई का लाभ लेना चाहते हैं।

अहा! यह जमालॉक को पेड़ से बाहर ले जाने के लिए होगा, आदि? किसी ने भी भयानक आवंटन को स्थिर करने का प्रस्ताव नहीं किया है जो वैश्विक आवंटनकर्ता को चुनने की अनुमति देता है, बस ढेर स्थिर है? या मैंने प्रस्ताव को गलत पढ़ा है?

वैश्विक आवंटनकर्ता को चुनने की अनुमति देने वाली भयानक हैक को स्थिर करने का प्रस्ताव है, जो कि हमें पेड़ से जमालॉक को स्थानांतरित करने की अनुमति देता है, जो कि आधा है। यह मुद्दा अन्य आधा है।

#[global_allocator] विशेषता स्थिरीकरण: https://github.com/rust-lang/rust/issues/27389#issuecomment -336955367

ओह

@Emon2314 आपको क्या लगता है कि वैश्विक

(Https://github.com/rust-lang/rust/issues/27389#issuecomment-342285805 पर जवाब दिया गया)

प्रस्ताव का उपयोग करने के लिए संशोधित किया गया है * उत्परिवर्ती शून्य।

@rfcbot ने * mut u8 को हल किया

@rfcbot ने समीक्षा की

IRC पर कुछ चर्चा के बाद, मैं इसे इस समझ के साथ स्वीकार कर रहा हूं कि हम _do not_ Box पर Alloc Box जेनेरिक को स्थिर करने का इरादा रखते हैं, लेकिन इसके बजाय कुछ Dealloc साथ ट्रैफ़िक के साथ यहाँ @sfackler द्वारा सुझाया गया उपयुक्त कंबल है । कृपया मुझे बताएं कि क्या मैंने इस इरादे को गलत समझा है।

@cramertj स्पष्ट करने के लिए, इस तथ्य के बाद उस कंबल को जोड़ना संभव है और Alloc परिभाषा को तोड़ना नहीं है जिसे हम यहां स्थिर कर रहे हैं?

@ जोशफेल हां, यह इस तरह दिखेगा: https://github.com/rust-lang/rust/issues/32838#issuecomment -340959804

हम किसी दिए गए Alloc लिए Dealloc कैसे निर्दिष्ट करेंगे? मैं कुछ इस तरह की कल्पना करेंगे?

pub unsafe trait Alloc {
    type Dealloc: Dealloc = Self;
    ...
}

मुझे लगता है कि हमें कांटेदार क्षेत्र WRT https://github.com/rust-lang/rust/issues/29661 पर रखता है

हाँ, मुझे नहीं लगता है कि Dealloc के जोड़ का कोई तरीका है, डिफ़ॉल्ट रूप से बिना Alloc (जो कि संबंधित प्रकार का नहीं है) की मौजूदा परिभाषाओं के साथ पीछे-संगत हो।

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

लेकिन, इसे भविष्य में उस सामान के साथ Alloc एक अलग उप-सीमा के साथ जोड़ा जा सकता है, जो मुझे लगता है।

@sfackler मुझे यकीन नहीं है कि मैं समझता हूं। क्या आप अपने डिजाइन के तहत Box::new का हस्ताक्षर लिख सकते हैं?

यह प्लेसमेंट सिंटैक्स और उस सभी को अनदेखा कर रहा है, लेकिन एक तरीका यह हो सकता है

pub struct Box<T, D>(NonZeroPtr<T>, D);

impl<T, D> Box<T, D>
where
    D: Dealloc
{
    fn new<A>(alloc: A, value: T) -> Box<T, D>
    where
        A: Alloc<Dealloc = D>
    {
        let ptr = alloc.alloc_one().unwrap_or_else(|_| alloc.oom());
        ptr::write(&value, ptr);
        let deallocator = alloc.deallocator();
        Box(ptr, deallocator)
    }
}

विशेष रूप से, हमें वास्तव में डीलक्लॉकर का एक उदाहरण प्रस्तुत करने में सक्षम होना चाहिए, न कि इसके प्रकार को जानना। तुम भी parameterize सकता है Box से अधिक Alloc और स्टोर A::Dealloc बजाय, प्रकार निष्कर्ष के साथ जो आ सकता है। इस स्थिरीकरण के बाद हम Dealloc और deallocator एक अलग निशान में ले जाकर यह काम कर सकते हैं:

pub trait SplitAlloc: Alloc {
    type Dealloc;

    fn deallocator(&self) -> Self::Dealloc;
}

लेकिन Drop का निहितार्थ कैसा दिखेगा?

impl<T, D> Drop for Box<T, D>
where
    D: Dealloc
{
    fn drop(&mut self) {
        unsafe {
            ptr::drop_in_place(self.0);
            self.1.dealloc_one(self.0);
        }
    }
}

लेकिन यह मानते हुए कि हम Alloc पहले स्थिर करते हैं, तब सभी Alloc s Dealloc लागू नहीं करेंगे, है ना? और मैंने सोचा था कि विशेषज्ञता विशेषज्ञता अभी भी एक रास्ता था? दूसरे शब्दों में, सिद्धांत रूप में, आप निम्नलिखित में से कुछ करना चाहेंगे, लेकिन मुझे नहीं लगता कि यह अभी तक काम करता है?

impl<T, D> Drop for Box<T, D> where D: Dealloc { ... }
impl<T, A> Drop for Box<T, A> where A: Alloc { ... }

अगर कुछ भी, हम एक होगा

default impl<T> SplitAlloc for T
where
    T: Alloc { ... }

लेकिन मुझे नहीं लगता कि यह वास्तव में आवश्यक होगा। कस्टम आवंटनकर्ताओं और वैश्विक आवंटनकर्ताओं के लिए उपयोग के मामले पर्याप्त हैं कि मैं नहीं मानता कि उनके बीच ओवरलैप का एक टन होगा।

मुझे लगता है कि काम कर सकता है। यह मुझे बहुत साफ लगता है, हालांकि, बल्ले से Dealloc सही है, इसलिए हमारे पास सरल इंटरफ़ेस हो सकता है। मुझे लगता है कि हमारे पास एक बहुत ही सरल, बिना विवादास्पद इंटरफ़ेस हो सकता है जिसे मौजूदा कोड में कोई बदलाव की आवश्यकता नहीं होगी जो पहले से ही Alloc :

unsafe trait Dealloc {
    fn dealloc(&mut self, ptr: *mut void, layout: Layout);
}

impl<T> Dealloc for T
where
    T: Alloc
{
    fn dealloc(&self, ptr: *mut void, layout: Layout) {
        <T as Alloc>::dealloc(self, ptr, layout)
    }
}

unsafe trait Alloc {
    type Dealloc: Dealloc = &mut Self;
    fn deallocator(&mut self) -> Self::Dealloc { self }
    ...
}

हालांकि मैं संबंधित प्रकार की चूक से समस्याग्रस्त था?

एक Dealloc जो कि आवंटनकर्ता के लिए एक परस्पर संदर्भ है, यह सब उपयोगी नहीं लगता है - आप केवल एक समय में एक चीज आवंटित कर सकते हैं, है ना?

हालांकि मैं संबंधित प्रकार की चूक से समस्याग्रस्त था?

ओह, मुझे लगता है कि संबद्ध प्रकार की चूक बहुत दूर हैं जो हम उन पर भरोसा नहीं कर सकते हैं।

फिर भी, हम सरल हो सकते हैं:

unsafe trait Dealloc {
    fn dealloc(&mut self, ptr: *mut void, layout: Layout);
}

impl<T> Dealloc for T
where
    T: Alloc
{
    fn dealloc(&self, ptr: *mut void, layout: Layout) {
        <T as Alloc>::dealloc(self, ptr, layout)
    }
}

unsafe trait Alloc {
    type Dealloc: Dealloc;
    fn deallocator(&mut self) -> Self::Dealloc;
    ...
}

और बस आवश्यकता है कि बॉयलर को थोड़ा सा लिखने के लिए कार्यान्वयनकर्ता की आवश्यकता हो।

Dealloc जो कि आवंटनकर्ता के लिए एक परस्पर संदर्भ है, यह सब उपयोगी नहीं लगता है - आप केवल एक समय में एक चीज आवंटित कर सकते हैं, है ना?

हाँ, अच्छी बात है। शायद एक मूट बिंदु ने वैसे भी आपकी अन्य टिप्पणी दी।

deallocator self , &self , या &mut self ?

संभवतः &mut self अन्य विधियों के अनुरूप होना चाहिए।

क्या ऐसे कोई आवंटनकर्ता हैं जो मूल्य के आधार पर स्वयं लेना पसंद करेंगे, ताकि उन्हें क्लोन राज्य न करना पड़े?

मूल्य द्वारा self लेने के साथ समस्या यह है कि यह एक Dealloc और फिर आवंटित करने के लिए जारी रखता है।

मैं एक काल्पनिक "oneshot" आवंटनकर्ता के बारे में सोच रहा हूं, हालांकि मुझे नहीं पता कि यह कितनी वास्तविक चीज है।

ऐसा आवंटनकर्ता मौजूद हो सकता है, लेकिन self मूल्य से लेने पर आवश्यकता होगी कि _all_ एलोकेटर उस तरह से काम करें, और deallocator बाद आवंटन की अनुमति देने वाले किसी भी आवंटनकर्ता को रोक देगा।

इससे पहले कि हम इसे स्थिर करने के बारे में सोचें, मैं इनमें से कुछ को कार्यान्वित और संग्रह में उपयोग करना चाहूंगा।

क्या आपको लगता है कि https://github.com/rust-lang/rust/issues/27336 या https://github.com/rust-lang/rust/issues/32838#issuecomment -339066870 में चर्चा किए गए बिंदु हमें अनुमति देंगे संग्रह पर आगे बढ़ना?

मैं दस्तावेज़ीकरण पठनीयता पर अन्य उपनाम दृष्टिकोण के प्रकार के बारे में चिंतित हूं। प्रगति को अनुमति देने के लिए एक (बहुत ही क्रियात्मक) तरीका प्रकारों को लपेटने के लिए होगा:

pub struct Vec<T>(alloc::Vec<T, Heap>);

impl<T> Vec<T> {
    // forwarding impls for everything
}

मुझे पता है कि यह एक दर्द है, लेकिन ऐसा लगता है कि हम यहां जिन बदलावों पर चर्चा कर रहे हैं, वे काफी बड़े हैं कि अगर हम विभाजित आवंटन / डीललॉक लक्षणों के साथ आगे बढ़ने का फैसला करते हैं, तो हमें उन्हें पहले std और फिर re-FCP में आज़माना चाहिए।

इस सामान को लागू करने के लिए इंतजार करने की समयरेखा क्या है?

grow_in_place विधि किसी भी प्रकार की अतिरिक्त क्षमता वापस नहीं करती है। वर्तमान में यह लेआउट के साथ usable_size कॉल करता है, आवंटन को इस लेआउट में फिट करने के लिए _at कम से कम_ फिट करता है, लेकिन यदि आवंटन उस लेआउट से परे बढ़ाया जाता है, तो उपयोगकर्ताओं को पता करने का कोई तरीका नहीं है।

मुझे alloc और realloc विधियों का alloc_excess और realloc_excess से अधिक का लाभ समझने में कठिनाई हो रही है।

एक आवंटनकर्ता को एक आवंटन करने के लिए एक उपयुक्त मेमोरी ब्लॉक खोजने की आवश्यकता है: इसके लिए मेमोरी ब्लॉक के आकार को जानना आवश्यक है। क्या आवंटनकर्ता तब एक संकेतक लौटाता है, या टपल "पॉइंटर और मेमोरी ब्लॉक का आकार" किसी भी औसत दर्जे का प्रदर्शन अंतर नहीं बनाता है।

इसलिए alloc और realloc केवल API सतह को बढ़ाते हैं और कम प्रदर्शनकारी कोड लिखने के लिए प्रोत्साहित करते हैं। हम उन्हें एपीआई में क्यों रखते हैं? उनका क्या फायदा है?

संपादित करें: या दूसरे शब्दों में: एपीआई में सभी संभावित आवंटन कार्यों को Excess वापस करना चाहिए, जो मूल रूप से सभी _excess विधियों की आवश्यकता को हटा देता है।

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

कंप्यूटिंग में कुछ लागत हो सकती है जो अतिरिक्त है

क्या आप एक उदाहरण दे सकते हैं? मैं नहीं जानता, और कल्पना नहीं कर सकता, एक आवंटनकर्ता जो स्मृति आवंटित करने में सक्षम है, लेकिन यह नहीं जानता कि यह वास्तव में कितनी मेमोरी आवंटित कर रहा है (जो कि Excess है: स्मृति की वास्तविक राशि आवंटित; हम; इसका नाम बदल दें)।

केवल आमतौर पर इस्तेमाल किया जाने वाला Alloc ator जहां यह थोड़ा विवादास्पद हो सकता है, POSIX malloc , जो भले ही आंतरिक रूप से Excess गणना करता है, लेकिन इसे अपने C के हिस्से के रूप में उजागर नहीं करता है एपीआई। हालांकि, Excess रूप में अनुरोधित आकार को वापस करना ठीक है, पोर्टेबल, सरल, बिल्कुल भी खर्च नहीं होता है, और हर कोई POSIX malloc का उपयोग कर रहा है, जो पहले से ही वैसे भी मान रहा है।

jemalloc और मूल रूप से किसी भी अन्य Alloc बाहर वहाँ एपीआई है कि Excess किसी भी लागत के बिना वापसी प्रदान करता है, इसलिए उन आवंटनकर्ताओं के लिए, Excess करना शून्य है साथ ही लागत।

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

अभी हर कोई मेमोरी आवंटित करने के लिए दो एपीआई वाले एलोकेटर विशेषता की कीमत पहले से ही चुका रहा है। और जब कोई Excess one` के शीर्ष पर Excess -रहित API का निर्माण कर सकता है, तो इसके विपरीत सत्य नहीं है। तो मुझे आश्चर्य है कि ऐसा क्यों नहीं किया जाता है:

• Alloc विशेषता तरीके हमेशा Excess
• एक ExcessLessAlloc विशेषता जोड़ें जो Excess को Alloc सभी उपयोगकर्ताओं के लिए Alloc का उपयोग करने के लिए पर्याप्त देखभाल करता है लेकिन 2) नहीं करता है वर्तमान में आवंटित की जा रही स्मृति की वास्तविक मात्रा के बारे में परवाह है (मेरे लिए एक आला की तरह दिखता है, लेकिन मुझे अभी भी लगता है कि इस तरह की एपीआई के लिए अच्छा है)
• अगर एक दिन किसी को Excess तरीकों के लिए फास्ट-पथ वाले Alloc ators को लागू करने का एक तरीका पता चलता है, तो हम हमेशा इसके लिए ExcessLessAlloc का कस्टम कार्यान्वयन प्रदान कर सकते हैं।

एफडब्ल्यूआईडब्ल्यू मैं सिर्फ इस धागे पर फिर से उतरा क्योंकि मैं Alloc शीर्ष पर जो भी चाहता हूं उसे लागू नहीं कर सकता। मैंने उल्लेख किया है कि यह grow_in_place_excess पहले याद कर रहा है, लेकिन मैं बस फिर से अटक गया क्योंकि यह alloc_zeroed_excess भी गायब है (और कौन जानता है)।

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

क्या आप एक उदाहरण दे सकते हैं? मैं नहीं जानता, और कल्पना नहीं कर सकता, एक आवंटनकर्ता जो स्मृति आवंटित करने में सक्षम है, लेकिन यह नहीं जानता कि यह वास्तव में कितनी मेमोरी आवंटित कर रहा है (जो कि Excess है: स्मृति की वास्तविक राशि आवंटित; हम; इसका नाम बदल दें)।

अधिकांश एलोकेटर आज आकार वर्गों का उपयोग करते हैं, जहां प्रत्येक आकार वर्ग एक निश्चित निश्चित आकार की वस्तुओं को आवंटित करता है, और आवंटन अनुरोध जो किसी विशेष आकार वर्ग को फिट नहीं करते हैं उन्हें सबसे छोटे आकार वर्ग तक गोल किया जाता है जो वे अंदर फिट होते हैं। इस योजना में, आकार वर्ग वस्तुओं की एक सरणी होने और फिर classes[size / SIZE_QUANTUM].alloc() करने जैसी चीजें करना आम है। उस दुनिया में, यह पता लगाना कि किस आकार के वर्ग का उपयोग किया जाता है, अतिरिक्त निर्देश लेता है: जैसे, let excess = classes[size / SIZE_QUANTUM].size । यह एक बहुत कुछ नहीं हो सकता है, लेकिन उच्च-प्रदर्शन आवंटन (जैसे जेमलॉक) के प्रदर्शन को एकल घड़ी चक्रों में मापा जाता है, इसलिए यह सार्थक ओवरहेड का प्रतिनिधित्व कर सकता है, खासकर यदि वह आकार समाप्त हो जाता है जो फ़ंक्शन रिटर्न की एक श्रृंखला से गुजर रहा है।

क्या आप एक उदाहरण दे सकते हैं?

कम से कम अपने पीआर के लिए आवंटित करने के लिए जा रहा है_जिमालोक, alloc_excess बहुत स्पष्ट रूप से alloc से अधिक कोड चल रहा है: https://github.com/rust-lang/rust/pull/45514/files।

इस योजना में, आकार वर्ग वस्तुओं की एक सरणी होने और फिर कक्षाएं [आकार / SIZE_ANTANTUM] .alloc () करने जैसी चीजें करना आम है। उस दुनिया में, यह पता लगाना कि किस आकार के वर्ग का उपयोग किया जाता है, अतिरिक्त निर्देश लेता है: जैसे, अतिरिक्त = कक्षाएं [आकार / SIZE_QUANTUM] .size

तो मुझे देखने दो कि क्या मैं ठीक से पालन करूं:

// This happens in both cases:
let size_class = classes[size / SIZE_QUANTUM];
let ptr = size_class.alloc(); 
// This would happen only if you need to return the size:
let size = size_class.size;
return (ptr, size);

क्या यही है?

कम से कम अपने पीआर के लिए जा रहा है आवंटन_जैमलोक को, आवंटन_बहुत बहुत स्पष्ट रूप से आवंटन से अधिक कोड चल रहा है

यह PR एक बगफिक्स था (एक परफेक्ट फिक्स नहीं), हमारे जेमलॉक लेयर परफेक्ट-वार की वर्तमान स्थिति के साथ कई चीजें गलत हैं लेकिन चूंकि पीआर यह कम से कम रिटर्न देता है, इसलिए इसे:

• nallocx GCC अर्थ में एक const कार्य है, अर्थात्, एक सच्चा शुद्ध कार्य। इसका अर्थ है कि इसका कोई साइड-इफेक्ट नहीं है, इसके परिणाम केवल इसके तर्कों पर निर्भर करते हैं, यह किसी वैश्विक स्थिति तक नहीं पहुंचता है, इसके तर्क संकेत नहीं हैं (इसलिए फ़ंक्शन वैश्विक स्थिति तक पहुंच नहीं सकता है), और C / C ++ कार्यक्रमों के लिए LLVM इसका उपयोग कर सकते हैं परिणाम का उपयोग नहीं होने पर कॉल को समाप्त करने की जानकारी। AFAIK जंग वर्तमान में const fn या समान के रूप में FFI C फ़ंक्शन को चिह्नित नहीं कर सकती है। तो यह पहली चीज है जिसे ठीक किया जा सकता है और यह realloc_excess उन लोगों के लिए शून्य-लागत बना देगा जो अतिरिक्त का उपयोग नहीं करते हैं जब तक कि इनलाइनिंग और अनुकूलन ठीक से काम न करें।
• nallocx को हमेशा mallocx अंदर संरेखित आवंटन के लिए गणना की जाती है, अर्थात, सभी कोड पहले से ही इसका अनुपालन कर रहे हैं, लेकिन mallocx इसके परिणाम को दूर फेंकते हैं, इसलिए यहां हम वास्तव में दो बार गणना कर रहे हैं , और कुछ मामलों में nallocx लगभग mallocx रूप में महंगा है ... मेरे पास जैमलोकेटर का एक कांटा है जो इसकी शाखाओं में इस तरह की चीजों के लिए कुछ बेंचमार्क है, लेकिन इसे ऊपर से तय किया जाना चाहिए jemalloc एक एपीआई प्रदान करता है जो इसे दूर नहीं फेंकता है। हालांकि, यह फिक्स केवल उन लोगों को प्रभावित करता है जो वर्तमान में Excess का उपयोग कर रहे हैं।
• और फिर मुद्दा यह है कि हम दो बार संरेखित झंडे की गणना कर रहे हैं, लेकिन यह कुछ ऐसा है जो एलएलवीएम हमारी तरफ से अनुकूलन कर सकता है (और ठीक करने के लिए तुच्छ)।

तो हाँ, यह अधिक कोड की तरह दिखता है, लेकिन यह अतिरिक्त कोड कोड है जिसे हम वास्तव में दो बार कॉल कर रहे हैं, क्योंकि पहली बार जब हमने इसे कॉल किया तो हमने परिणामों को दूर फेंक दिया। इसे ठीक करना असंभव नहीं है, लेकिन मुझे अभी तक ऐसा करने का समय नहीं मिला है।

EDIT: @sfackler आज मैं इसके लिए कुछ समय मुक्त करने में कामयाब रहा और alloc_excess alloc दिए, और यह केवल एक ओवरहेड में ~ 1ns का ओवरहेड है jemallocs का तेज़ पथ। मैंने वास्तव में तेज़ पथ पर बहुत विस्तार से नहीं देखा है, लेकिन आगे इसे सुधारना संभव हो सकता है। विवरण यहाँ हैं: https://github.com/jemalloc/jemalloc/issues/1074#issuecomment -345040339

क्या यही है?

हाँ।

तो यह पहली चीज़ है जिसे ठीक किया जा सकता है और यह वास्तविक-शून्य ज़ीरो-कॉस्ट उन लोगों के लिए होगा जो अतिरिक्त का उपयोग नहीं करते हैं जब तक कि इनलाइनिंग और अनुकूलन ठीक से काम नहीं करते हैं।

जब वैश्विक आवंटनकर्ता के रूप में उपयोग किया जाता है, तो इसमें से कोई भी इनलेट नहीं किया जा सकता है।

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

जीथब पर शाब्दिक शून्य कोड है जो alloc_excess कॉल करता है। यदि यह इतनी महत्वपूर्ण महत्वपूर्ण विशेषता है, तो किसी ने कभी इसका उपयोग क्यों नहीं किया है? C ++ का आबंटन API अतिरिक्त क्षमता तक पहुँच प्रदान नहीं करता है। यह भविष्य में इन सुविधाओं को भविष्य में पीछे की संगत तरीके से जोड़ने / स्थिर करने के लिए अविश्वसनीय रूप से सीधा लगता है यदि वास्तविक ठोस सबूत हैं कि वे प्रदर्शन में सुधार करते हैं और कोई भी वास्तव में उनका उपयोग करने के लिए पर्याप्त परवाह करता है।

जब वैश्विक आवंटनकर्ता के रूप में उपयोग किया जाता है, तो इसमें से कोई भी इनलेट नहीं किया जा सकता है।

फिर यह एक समस्या है जिसे हमें हल करने की कोशिश करनी चाहिए, कम से कम एलटीओ बिल्ड के लिए, क्योंकि jemalloc जैसे वैश्विक आवंटनकर्ता इस पर भरोसा करते हैं: nallocx जिस तरह से यह _by design_ है, और पहला उल्लेख है jemalloc के देवों ने हमें alloc_excess प्रदर्शन के बारे में बनाया है कि हमारे पास इन कॉल इनबिल्ट होनी चाहिए, और हमें C विशेषताओं को ठीक से प्रचारित करना चाहिए, ताकि कंपाइलर कॉल-साइट्स से nallocx कॉल हटा दें जो कि नहीं Excess , जैसे C और C ++ कंपाइलर करते हैं।

यहां तक ​​कि अगर हम ऐसा नहीं कर सकते हैं, तब भी Excess API को jemalloc API पैच करके शून्य-लागत किया जा सकता है (मेरे रस्ट-लैंग / में इस तरह के पैच का प्रारंभिक कार्यान्वयन है / jemalloc कांटा)। हम या तो स्वयं उस एपीआई को बनाए रख सकते हैं, या इसे ऊपर की ओर उतारने की कोशिश कर सकते हैं, लेकिन इसके लिए भूमि के ऊपर की ओर हमें एक अच्छा मामला बनाना चाहिए कि क्यों ये अन्य भाषाएं इन अनुकूलन कर सकती हैं और जंग नहीं कर सकती। या हमारे पास एक और तर्क होना चाहिए, जैसे कि यह नया एपीआई उन उपयोगकर्ताओं के लिए mallocx + nallocx से काफी तेज है जिन्हें Excess ।

यदि यह इतनी महत्वपूर्ण महत्वपूर्ण विशेषता है, तो किसी ने कभी इसका उपयोग क्यों नहीं किया है?

यह एक अच्छा सवाल है। std::Vec Excess API का उपयोग करने के लिए पोस्टर-चाइल्ड है, लेकिन यह वर्तमान में इसका उपयोग नहीं करता है, और मेरी सभी पिछली टिप्पणियां "यह बताते हुए" और Excess से गायब हैं एपीआई "मैं Vec उपयोग करने की कोशिश कर रहा था। Excess API:

• Excess को बिलकुल नहीं लौटा रहा था: https://github.com/rust-lang/rust/pull/45614
• grow_in_place_excess और alloc_zeroed_excess जैसी कार्यक्षमता खो रही है
• FFI में C विशेषताओं को ठीक से प्रचारित नहीं कर सकते हैं: https://github.com/rust-lang/rust/issues/46046
• ... (मुझे संदेह है कि यह यहाँ समाप्त होता है)

मुझे नहीं पता कि कोई भी इस API का उपयोग क्यों नहीं कर रहा है। लेकिन यह देखते हुए कि std लाइब्रेरी डेटा-संरचना के लिए इसका उपयोग नहीं कर सकती है, यह ( Vec ) के लिए सबसे उपयुक्त है, अगर मुझे अनुमान लगाना था, तो मैं कहूंगा कि मुख्य कारण यह है वर्तमान में यह API टूट गया है।

अगर मुझे आगे भी अनुमान लगाना होता है, तो मैं कहूंगा कि इस एपीआई को डिजाइन करने वालों ने भी इसका इस्तेमाल नहीं किया है, इसका मुख्य कारण यह है कि कोई भी std संग्रह इसका उपयोग नहीं करता है (जो कि मुझे उम्मीद है कि इस एपीआई का परीक्षण पहले किया जाएगा) , और इसलिए भी क्योंकि _excess और Excess हर जगह usable_size / allocation_size लिए अत्यंत भ्रामक / कष्टप्रद है।

यह संभवतः इसलिए है क्योंकि अधिक कार्य Excess -रहित API में डाले गए थे, और जब आपके पास दो API हैं, तो उन्हें सिंक में रखना कठिन है, उपयोगकर्ताओं के लिए दोनों की खोज करना और उनका उपयोग करना जानते हैं। और अंत में, उपयोगकर्ताओं को सही काम करने में सुविधा पसंद करना कठिन है।

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

जहाँ तक मैं बता सकता हूँ, ये केवल दो कॉल nallocx हैं जेथालॉक परीक्षणों के बाहर मिथिला पर:

https://github.com/facebook/folly/blob/f2925b23df8d85ebca72d62a69f1282528c086de/folly/detail/ThreadLocalDetail.cpp#L182
https://github.com/louishust/mysql5.6.14_tokudb/blob/4897660dee3e8e340a1e6c8c597f3b2b7420654a/storage/tokudb/ft-index/ftcxx/malloc_utils.hpp#L91

दोनों में से कोई भी वर्तमान alloc_excess API से मिलता-जुलता नहीं है, बल्कि इसका उपयोग किए जाने से पहले आवंटन आकार की गणना करने के लिए स्टैंडअलोन का उपयोग किया जाता है।

अपाचे एरो ने उनके कार्यान्वयन में nallocx का उपयोग किया, लेकिन पाया कि चीजें अच्छी तरह से काम नहीं करती हैं:

https://issues.apache.org/jira/browse/ARROW-464

ये मूल रूप से nallocx लिए केवल संदर्भ हैं। यह क्यों महत्वपूर्ण है कि आवंटनकर्ता एपीआई का प्रारंभिक कार्यान्वयन इस तरह के अस्पष्ट सुविधा का समर्थन करता है?

जहाँ तक मैं बता सकता हूँ, ये गिथूब पर जेमलॉक परीक्षणों के बाहर नालोक्स के लिए केवल दो कॉल हैं:

मेरे सिर के ऊपर से मुझे पता है कि (कम से कम फेसबुक के वेक्टर प्रकार पर फेसबुक के malloc कार्यान्वयन के माध्यम से इसे उपयोग कर रहा है malloc और fbvector विकास नीति , फेसबुक इस प्रयोग में सी के ++ के वैक्टर एक बड़ा हिस्सा है) और यह भी कि चैपल यह प्रयोग किया जाता सुधार करने के लिए उनके String प्रकार ( यहां और ट्रैकिंग समस्या ) का प्रदर्शन। तो शायद आज गितुब का सबसे अच्छा दिन नहीं था?

यह क्यों महत्वपूर्ण है कि आवंटनकर्ता एपीआई का प्रारंभिक कार्यान्वयन इस तरह के अस्पष्ट सुविधा का समर्थन करता है?

एक आवंटन एपीआई के प्रारंभिक कार्यान्वयन को इस सुविधा का समर्थन करने की आवश्यकता नहीं है।

लेकिन इस सुविधा के लिए अच्छा समर्थन ऐसे एपीआई के स्थिरीकरण को रोकना चाहिए।

इसे स्थिरीकरण को क्यों रोकना चाहिए अगर इसे बाद में पीछे से जोड़ा जा सकता है?

इसे स्थिरीकरण को क्यों रोकना चाहिए अगर इसे बाद में पीछे से जोड़ा जा सकता है?

क्योंकि मेरे लिए कम से कम इसका मतलब है कि केवल डिज़ाइन स्पेस का आधा हिस्सा पर्याप्त रूप से खोजा गया है।

क्या आपको लगता है कि एपीआई के गैर-अतिरिक्त संबंधित हिस्से अतिरिक्त-संबंधित कार्यक्षमता के डिजाइन से प्रभावित होंगे? मैं मानता हूं कि मैंने केवल उस चर्चा का आधे-अधूरे मन से पालन किया है, लेकिन यह मेरे लिए संभव नहीं है।

यदि हम यह एपीआई नहीं बना सकते हैं:

fn alloc(...) -> (*mut u8, usize) { 
   // worst case system API:
   let ptr = malloc(...);
   let excess = malloc_excess(...);
   (ptr, excess)
}
let (ptr, _) = alloc(...); // drop the excess

इस एक के रूप में कुशल:

fn alloc(...) -> *mut u8 { 
   // worst case system API:
   malloc(...)
}
let ptr = alloc(...);

तब हमें बड़ी समस्याएं हैं।

क्या आपको लगता है कि एपीआई के गैर-अतिरिक्त संबंधित हिस्से अतिरिक्त-संबंधित कार्यक्षमता के डिजाइन से प्रभावित होंगे?

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

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

जो लोग Excess गिराना चाहते हैं, उन्हें इसे छोड़ देना चाहिए।

स्पष्ट करने के लिए, यदि बैकवर्ड-संगत तरीके से तथ्य के बाद alloc_excess पद्धति जोड़ने का कोई तरीका था, तो आप इसके साथ ठीक होंगे? (लेकिन निश्चित रूप से, alloc_excess बिना स्थिर होने का मतलब है कि बाद में इसे जोड़ना एक ब्रेकिंग परिवर्तन होगा; मैं सिर्फ इतना पूछ रहा हूं इसलिए मैं आपके तर्क को समझता हूं)

@ जोशफ्ले ऐसा करना बहुत सीधा है।

: घंटी: यह अब ऊपर की अपनी अंतिम टिप्पणी अवधि में प्रवेश कर रहा है । : घंटी:

जो लोग अतिरिक्त को छोड़ना चाहते हैं, उन्हें इसे छोड़ देना चाहिए।

वैकल्पिक रूप से, 0.01% लोग जो अधिक क्षमता की देखभाल करते हैं, वे दूसरी विधि का उपयोग कर सकते हैं।

@sfackler यह मुझे जंग से दो सप्ताह का ब्रेक लेने के लिए मिलता है - मैं डिफ़ॉल्ट पद्धति के बारे में भूल जाता हूं :)

वैकल्पिक रूप से, 0.01% लोग जो अधिक क्षमता की देखभाल करते हैं, वे दूसरी विधि का उपयोग कर सकते हैं।

यह नंबर आपको कहां मिल रहा है?

मेरी सभी रस्ट डेटा-संरचनाएं मेमोरी में फ्लैट हैं। ऐसा करने की क्षमता केवल एक ही कारण है कि मैं जंग का उपयोग करता हूं; अगर मैं सिर्फ बॉक्स में सब कुछ कर सकता हूं तो मैं एक अलग भाषा का उपयोग करूंगा। इसलिए मुझे उस समय के Excess 0.01% की परवाह नहीं है, मैं हर समय इसकी परवाह करता हूं।

मैं समझता हूं कि यह डोमेन विशिष्ट है, और यह कि अन्य डोमेन में लोग कभी भी Excess बारे में परवाह नहीं करेंगे, लेकिन मुझे संदेह है कि केवल 0.01% Rust उपयोगकर्ता इस बारे में परवाह करते हैं (मेरा मतलब है, बहुत सारे लोग Vec उपयोग करते हैं String , जो Excess लिए पोस्टर-चाइल्ड डेटा-संरचनाएं हैं)।

मुझे इस तथ्य से वह संख्या मिल रही है कि कुल मिलाकर 4 चीजें हैं जो नालोक्स का उपयोग करती हैं, उन चीजों के सेट की तुलना में जो मॉलॉक का उपयोग करती हैं।

@gnzlbg

क्या आप यह सुझाव दे रहे हैं कि यदि हमने इसे शुरू से "सही" किया, तो हमारे पास बस fn alloc(layout) -> (ptr, excess) और fn alloc(layout) -> ptr बिलकुल नहीं होगा? यह मुझे स्पष्ट से दूर लगता है। यदि अतिरिक्त उपलब्ध है, तो भी ऐसा लगता है कि उपयोग के मामलों के लिए बाद के एपीआई का होना स्वाभाविक है, जहां अधिक मायने नहीं रखता (जैसे, अधिकांश पेड़ संरचनाएं), भले ही इसे alloc_excess(layout).0 रूप में लागू किया गया हो।

@rkruppe

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

वर्तमान में, अतिरिक्त-पूर्ण API को अतिरिक्त-कम एक के ऊपर लागू किया जाता है। अधिक-कम आबंटक के लिए Alloc लागू करने के लिए उपयोगकर्ता को alloc और dealloc विधियाँ प्रदान करने की आवश्यकता होती है।

हालांकि, अगर मैं एक अतिरिक्त-पूर्ण आवंटनकर्ता के लिए Alloc लागू करना चाहता हूं, तो मुझे और अधिक तरीके (कम से कम alloc_excess प्रदान करने की आवश्यकता है, लेकिन यह बढ़ता है अगर हम realloc_excess ,) alloc_zeroed_excess , grow_in_place_excess , ...)।

यदि हम इसे दूसरे तरीके से कर रहे थे, अर्थात, अधिक-पूर्ण एपीआई को अतिरिक्त के रूप में एक शीर्ष के रूप में लागू करें, तो alloc_excess और dealloc समर्थन करने के लिए पर्याप्त है दोनों प्रकार के आवंटनकर्ता।

जिन उपयोगकर्ताओं को परवाह नहीं है या अतिरिक्त रिटर्न नहीं कर सकते हैं या क्वेरी नहीं कर सकते हैं वे केवल इनपुट आकार या लेआउट (जो एक छोटी असुविधा है) वापस कर सकते हैं, लेकिन जो उपयोगकर्ता संभाल सकते हैं और अतिरिक्त को लागू करना चाहते हैं उन्हें लागू करने की आवश्यकता नहीं है। और भी तरीके।

@sfackler

मुझे इस तथ्य से वह संख्या मिल रही है कि कुल मिलाकर 4 चीजें हैं जो नालोक्स का उपयोग करती हैं, उन चीजों के सेट की तुलना में जो मॉलॉक का उपयोग करती हैं।

रुस्ट इकोसिस्टम में _excess उपयोग के बारे में इन तथ्यों को देखते हुए:

• कुल चीजें 0 _excess जंग पारिस्थितिकी तंत्र में उपयोग करती हैं
• कुल चीजें 0 _excess जंग एसटीडी पुस्तकालय में उपयोग करती हैं
• Vec और String _excess std

• _excess API अस्थिर है, अतिरिक्त-कम API के साथ आउट-सिंक, बहुत पहले तक छोटी गाड़ी (जब तक excess बिलकुल भी वापस नहीं किया गया), ...

  और अन्य भाषाओं में _excess के उपयोग के बारे में ये तथ्य दिए गए हैं:

• jemalloc का API मूल रूप से बैकवर्ड संगतता के कारण C या C ++ प्रोग्राम द्वारा समर्थित नहीं है

• सी और सी ++ प्रोग्राम जो कि जेमलॉक की अतिरिक्त एपीआई का उपयोग करना चाहते हैं, उन्हें इसे इस्तेमाल करने के लिए अपने रास्ते से बाहर जाना होगा:
  
  
  
  • सिस्टम एलोकेटर और जेमलॉक (या tcmalloc) से बाहर निकलना
  
  
  • उनकी भाषा के एसटीडी पुस्तकालय को फिर से लागू करें (C ++ के मामले में, असंगत एसटीडी लाइब्रेरी को लागू करें)
  
  
  • इस असंगत std लाइब्रेरी के शीर्ष पर अपना पूरा स्टैक लिखें
  
  
• कुछ समुदाय (फ़ायरफ़ॉक्स इसका उपयोग करता है, फेसबुक C ++ मानक पुस्तकालय में संग्रह को पुन: उपयोग करने में सक्षम बनाता है, ...) अभी भी इसका उपयोग करने के लिए अपने तरीके से बाहर जाते हैं।

ये दो तर्क मेरे लिए प्रशंसनीय हैं:

• excess API std में उपयोग करने योग्य नहीं है, इसलिए std लाइब्रेरी इसका उपयोग नहीं कर सकती है, इसलिए कोई भी नहीं कर सकता है, यही कारण है कि रुस्ट पारिस्थितिकी तंत्र में एक बार भी इसका उपयोग नहीं किया जाता है ।
• भले ही C और C ++ इस API का उपयोग करना असंभव बना देते हैं, लेकिन मैनपावर के साथ बड़ी परियोजनाएं इसका उपयोग करने के लिए बहुत बड़ी लंबाई तक जाती हैं, इसलिए कम से कम कुछ संभावित छोटे समुदाय के लोग इसके बारे में _a lot_ की देखभाल करते हैं।

आपका तर्क:

• कोई भी _excess API का उपयोग नहीं करता है, इसलिए केवल 0.01% लोग इसकी परवाह करते हैं।

नहीं करता।

@alexcrichton -> Result<*mut u8, AllocErr> से -> *mut void पर स्विच करने का निर्णय उन लोगों के लिए एक महत्वपूर्ण आश्चर्य के रूप में आ सकता है जिन्होंने आवंटनकर्ता RFC के मूल विकास का पालन किया।

मैं आपके द्वारा किए गए बिंदुओं से असहमत नहीं हूँ, लेकिन फिर भी ऐसा लग रहा था कि लोगों की एक उचित संख्या Result के "भारी-वजन" के साथ जीने के लिए तैयार है, एक अशक्त लापता होने की संभावना बढ़ गई है। लौटे मूल्य पर जाँच करें।

• मैं एबीआई द्वारा लगाए गए रनटाइम दक्षता के मुद्दों को नजरअंदाज कर रहा हूं क्योंकि मैं @alexcrichton की तरह

क्या कोई रास्ता है जिससे हम अपने आप ही उस देर से बदलाव पर दृश्यता बढ़ा सकते हैं?

एक तरह से (मेरे सिर के ऊपर से): परिवर्तन हस्ताक्षर अब, अपने आप ही एक पीआर, मास्टर शाखा पर में है, जबकि Allocator अभी भी अस्थिर है। और फिर देखें कि पीआर पर शिकायत कौन करता है (और कौन मनाता है!)।

• क्या यह बहुत भारी-भरकम है? ऐसा लगता है कि यह परिभाषाओं द्वारा भारी है-स्थिरीकरण के साथ इस तरह के बदलाव की तुलना में कम भारी-भरकम ...

इस विषय पर कि क्या *mut void वापस करना है या Result<*mut void, AllocErr> : यह संभव है कि हमें अलग-अलग "उच्च-स्तरीय" और "निम्न-स्तरीय" आवंटनकर्ता लक्षणों के विचार पर फिर से विचार करना चाहिए, जैसा कि चर्चा की गई है एलोकेटर आरएफसी के द्वितीय में

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

@pnkfelix

-> Result<*mut u8, AllocErr> -> *mut void से स्विच करने का निर्णय उन लोगों के लिए एक महत्वपूर्ण आश्चर्य के रूप में आ सकता है जिन्होंने एलएफसी के मूल विकास का पालन किया।

उत्तरार्द्ध का तात्पर्य है, जैसा कि चर्चा की गई है, केवल एक त्रुटि जिसे हम व्यक्त करते हैं, वह OOM है। इस प्रकार, थोड़ा हल्का वजन के बीच में अभी भी त्रुटियों के लिए जाँच करने के लिए आकस्मिक विफलता के खिलाफ सुरक्षा का लाभ -> Option<*mut void> ।

@gnzlbg

एसटीडी में अतिरिक्त एपीआई प्रयोग करने योग्य नहीं है, इसलिए एसटीडी लाइब्रेरी इसका उपयोग नहीं कर सकती है, इसलिए कोई भी कर सकता है, यही कारण है कि रुस्ट पारिस्थितिकी तंत्र में एक बार भी इसका उपयोग नहीं किया जाता है।

फिर इसे ठीक करें।

@pnkfelix

उत्परिवर्ती शून्य को वापस करने के लिए या परिणाम < उत्परिवर्ती शून्य, AllocErr> वापस करने के विषय पर: यह संभव है कि हमें अलग "उच्च-स्तरीय" और "निम्न-स्तरीय" आवंटनकर्ता लक्षणों के विचार पर फिर से विचार करना चाहिए, जैसा कि II में चर्चा की गई है। एलोकेटर आरएफसी के।

वे मूल रूप से हमारे विचार थे, सिवाय इसके कि उच्च स्तरीय एपीआई Alloc ही alloc_one , alloc_array आदि के रूप में होगा। हम उन लोगों को भी पारिस्थितिक तंत्र में पहले विस्तार के रूप में विकसित करने दे सकते हैं यह देखने के लिए कि लोग किन APIs पर एकाग्र होते हैं।

@pnkfelix

मैंने लेआउट बनाने का कारण केवल क्लोन को लागू किया है और कॉपी नहीं है कि मैं लेआउट प्रकार में अधिक संरचना जोड़ने की संभावना को छोड़ना चाहता हूं। विशेष रूप से, मैं अभी भी इसे बनाने के लिए उपयोग की जाने वाली किसी भी प्रकार की संरचना को ट्रैक करने के लिए लेआउट प्रयास करने की कोशिश करने में दिलचस्पी रखता हूं (उदाहरण के लिए 16-सरणी की संरचना {x: u8, y: [char; 215]}), ताकि आवंटनकर्ताओं के पास हो; इंस्ट्रूमेंटेशन रूटीन को उजागर करने का विकल्प जो रिपोर्ट करता है कि उनकी वर्तमान सामग्री किस प्रकार से तैयार की गई है।

क्या यह कहीं प्रयोग किया गया है?

@ सैफकलर मैंने इसे पहले से ही कर लिया है, और यह सब डुप्लिकेट एपीआई (कोई अतिरिक्त + _excess विधियों) के साथ नहीं किया जा सकता है। मैं दो API होने के साथ ठीक हो जाऊंगा और अभी पूरा _excess API नहीं होगा।

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

jemallocator Alloc दो बार ( Jemalloc और &Jemalloc ), जहाँ Jemalloc कुछ method लिए कार्यान्वयन सिर्फ (&*self).method(...) कि विधि &Jemalloc कार्यान्वयन के लिए आगे आती है। इसका मतलब यह है कि किसी को मैन्युअल रूप से Alloc Jemalloc सिंक के दोनों कार्यान्वयन रखना चाहिए। &/_ कार्यान्वयन के लिए अलग-अलग व्यवहार प्राप्त करना दुखद हो सकता है या नहीं, मुझे नहीं पता।

मुझे यह पता लगाना बहुत मुश्किल है कि लोग वास्तव में Alloc विशेषता के साथ क्या कर रहे हैं। एकमात्र प्रोजेक्ट जो मैंने पाया है कि इसका उपयोग कर रहे हैं, रात के रास्ते (इमदादी, रेडॉक्स) का उपयोग करते रहने वाले हैं, और केवल इसका उपयोग वैश्विक आवंटनकर्ता को बदलने के लिए कर रहे हैं। यह मुझे बहुत चिंतित करता है कि मुझे ऐसा कोई प्रोजेक्ट नहीं मिला जो इसे एक संग्रह प्रकार के पैरामीटर के रूप में उपयोग करता हो (शायद मैं सिर्फ अशुभ था और कुछ हैं?)। मैं विशेष रूप से SmallVec और ArrayVec Vec -उच्च प्रकार के शीर्ष पर लागू करने के उदाहरणों की तलाश में था ( std::Vec Alloc प्रकार का पैरामीटर अभी तक), और यह भी सोच रहा था कि इन प्रकारों के बीच क्लोनिंग कैसे होगी ( Vec s एक अलग Alloc ator के साथ) काम करेगा (यही शायद क्लोनिंग Box पर लागू होता है) अलग Alloc s के साथ Box es)। क्या इस तरह के उदाहरण हैं कि ये कार्यान्वयन कहीं-कहीं कैसे दिखेंगे?

केवल परियोजनाओं जो मैंने पाया है कि इसका उपयोग कर रहे हैं रात्रिकालीन रास्तों का उपयोग करने जा रहे हैं (सर्वो, रिडॉक्स)

इसके लायक क्या है, सर्वो जहां संभव हो, अस्थिर सुविधाओं से दूर जाने की कोशिश कर रहा है: https://github.com/servo/servo/issues/5286

यह चिकन और अंडे की समस्या भी है। कई परियोजनाएं Alloc नहीं करती हैं क्योंकि यह अभी भी अस्थिर है।

यह मेरे लिए वास्तव में स्पष्ट नहीं है कि हमें पहले स्थान पर _excess API का पूर्ण पूरक क्यों होना चाहिए। वे मूल रूप से jemalloc के प्रायोगिक * एलॉटम एपीआई को मिरर करने के लिए अस्तित्व में थे, लेकिन उन्हें पूरे एपीआई सतह को डुप्लिकेट नहीं करने के पक्ष में कई सालों पहले 4.0 में हटा दिया गया था। ऐसा लगता है कि हम उनके नेतृत्व का अनुसरण कर सकते हैं?

क्या बाद में एलोकेशन के संदर्भ में आवंटन को डिफ़ॉल्ट रूप से लागू करना संभव होगा या क्या यह संभव नहीं है या परिवर्तन नहीं है?

हम की एक डिफ़ॉल्ट कार्यान्वयन में जोड़ सकते हैं alloc के मामले में alloc_excess , लेकिन alloc_excess के मामले में एक डिफ़ॉल्ट कार्यान्वयन की आवश्यकता होगी alloc । यदि आप एक या दोनों को लागू करते हैं, तो सब कुछ ठीक रहता है, लेकिन यदि आप या तो लागू नहीं करते हैं, तो आपका कोड संकलित करेगा, लेकिन असीम रूप से पुनरावृत्ति करेगा। यह पहले आया है (शायद Rand ?), और हमारे पास यह कहने का कोई तरीका हो सकता है कि आपको कम से कम उन कार्यों में से एक को लागू करने की आवश्यकता है लेकिन हम ध्यान नहीं देते हैं।

यह मुझे बहुत चिंतित करता है कि मुझे ऐसा कोई प्रोजेक्ट नहीं मिला जो इसे एक संग्रह प्रकार के पैरामीटर के रूप में उपयोग करता हो (शायद मैं सिर्फ अशुभ था और कुछ हैं?)।

मैं किसी को नहीं जानता कि वह क्या कर रहा है।

केवल परियोजनाओं जो मैंने पाया है कि इसका उपयोग कर रहे हैं रात्रिकालीन रास्तों का उपयोग करने जा रहे हैं (सर्वो, रिडॉक्स)

इसे आगे बढ़ने से रोकने वाली एक बड़ी बात यह है कि stdlib संग्रह पैरामीट्रिक आवंटनकर्ताओं का समर्थन नहीं करता है। यह बहुत अधिक अन्य सभी टोकराओं को भी रोकता है, क्योंकि अधिकांश बाहरी संग्रह हुड के तहत आंतरिक लोगों का उपयोग करते हैं ( Box , Vec , आदि)।

केवल परियोजनाओं जो मैंने पाया है कि इसका उपयोग कर रहे हैं रात्रिकालीन रास्तों का उपयोग करने जा रहे हैं (सर्वो, रिडॉक्स)

इसे आगे बढ़ने से रोकने वाली एक बड़ी बात यह है कि stdlib संग्रह पैरामीट्रिक आवंटनकर्ताओं का समर्थन नहीं करता है। यह बहुत अधिक के रूप में अच्छी तरह से सबसे अन्य बक्से precludes, क्योंकि अधिकांश बाहरी संग्रह हुड (बॉक्स, वीईसी, आदि) के तहत आंतरिक लोगों का उपयोग करते हैं।

यह मेरे लिए लागू होता है - मुझे एक खिलौना कर्नेल मिला है, और अगर मैं Vec<T, A> का उपयोग कर सकता हूं, लेकिन इसके बजाय मुझे एक आंतरिक-परिवर्तनशील वैश्विक आवंटनकर्ता मुखौटा होना चाहिए, जो सकल है।

@remexre आंतरिक परिवर्तनशीलता के साथ वैश्विक स्थिति से बचने के लिए आपके डेटा संरचनाओं को कैसे

अभी भी आंतरिक-उत्परिवर्तित वैश्विक स्थिति होगी जो मुझे लगता है, लेकिन यह एक सेटअप के लिए बहुत अधिक सुरक्षित महसूस करता है जहां वैश्विक आवंटनकर्ता अनुपयोगी है जब तक कि स्मृति पूरी तरह से वैश्विक set_allocator फ़ंक्शन की तुलना में मैप न हो।

संपादित करें : बस एहसास हुआ कि मैंने सवाल का जवाब नहीं दिया। अभी, मुझे कुछ इस तरह मिला है:

struct BumpAllocator{ ... }
struct RealAllocator{ ... }
struct LinkedAllocator<A: 'static + AreaAllocator> {
    head: Mutex<Option<Cons<A>>>,
}
#[global_allocator]
static KERNEL_ALLOCATOR: LinkedAllocator<&'static mut (AreaAllocator + Send + Sync)> =
    LinkedAllocator::new();

जहां AreaAllocator एक विशेषता है जो मुझे (रनटाइम पर) यह सत्यापित करने देती है कि आवंटनकर्ता गलती से "ओवरलैपिंग" नहीं कर रहे हैं (पते की सीमा के संदर्भ में वे जिस में आवंटित होते हैं)। BumpAllocator का उपयोग केवल स्‍क्रैच स्‍पेस के लिए बहुत जल्‍दी किया जाता है, जब RealAllocator s बनाने के लिए शेष मेमोरी की मैपिंग की जाती है।

आदर्श रूप से, मैं एक Mutex<Option<RealAllocator>> (या एक आवरण जो इसे "इन्सर्ट-ओनली" बनाता है) एकमात्र आबंटनकर्ता होना चाहूंगा, और आरंभिक बूट BumpAllocator द्वारा परिचालित होने पर सब कुछ आबंटित किया जाना चाहिए

@sfackler

यह मेरे लिए वास्तव में स्पष्ट नहीं है कि हमें पहले स्थान पर _excess API का पूर्ण पूरक क्यों होना चाहिए। वे मूल रूप से jemalloc के प्रायोगिक * एलॉटम एपीआई को मिरर करने के लिए अस्तित्व में थे, लेकिन उन्हें पूरे एपीआई सतह को डुप्लिकेट नहीं करने के पक्ष में कई सालों पहले 4.0 में हटा दिया गया था। ऐसा लगता है कि हम उनके नेतृत्व का अनुसरण कर सकते हैं?

वर्तमान में shrink_in_place कॉल xallocx जो वास्तविक आवंटन आकार देता है। क्योंकि shrink_in_place_excess मौजूद नहीं है, इसलिए यह इस आकार को दूर फेंक देता है, और उपयोगकर्ताओं को इसे पुनर्प्राप्त करने के लिए nallocx का कॉल करना होगा, जिसकी लागत वास्तव में इस बात पर निर्भर करती है कि आवंटन कितना बड़ा है।

इसलिए कम से कम कुछ जेमलॉक आवंटन कार्य जो हम पहले से उपयोग कर रहे हैं, वे हमें प्रयोग करने योग्य आकार वापस कर रहे हैं, लेकिन वर्तमान एपीआई हमें इसका उपयोग करने की अनुमति नहीं देता है।

@remexre

जब मैं अपने खिलौना कर्नेल पर काम कर रहा था, तो यह सुनिश्चित करने के लिए वैश्विक आवंटनकर्ता से बचने के लिए कि कोई आवंटन नहीं हुआ, जब तक कि एक आवंटनकर्ता स्थापित नहीं हुआ, मेरा भी एक लक्ष्य था। मुझे खुशी है कि मैं एक नहीं हूँ!

मुझे डिफ़ॉल्ट वैश्विक आवंटनकर्ता के लिए Heap शब्द पसंद नहीं है। Default क्यों नहीं?

स्पष्टीकरण का एक और बिंदु: RFC 1974 यह सब सामान std::alloc में रखता है लेकिन वर्तमान में std::heap । स्थिरीकरण के लिए कौन सा स्थान प्रस्तावित किया जा रहा है?

@ जेथ्रोगब "हीप" एक बहुत ही विहित शब्द है "उस बात के लिए जो

@sfackler

"वह बात मल्लोक आपको संकेत देता है"

मेरे दिमाग में सिवाय इसके कि System है।

आह ज़रूर। Global एक और नाम है शायद? चूंकि आप इसे चुनने के लिए #[global_allocator] का उपयोग करते हैं।

कई ढेर आवंटनकर्ता हो सकते हैं (उदाहरण के लिए libc और उपसर्ग jemalloc)। std::heap::Heap से std::heap::Default और #[global_allocator] #[default_allocator] नाम बदलने के बारे में कैसे?

तथ्य यह है कि यह आपको क्या मिलता है यदि आप अन्यथा निर्दिष्ट नहीं करते हैं (संभवतः उदाहरण के लिए जब Vec आवंटन के लिए एक अतिरिक्त प्रकार का पैरामीटर / फ़ील्ड प्राप्त होता है) इस तथ्य से अधिक महत्वपूर्ण है कि यह "प्रति" नहीं है -स्थापना "राज्य (या वास्तव में उदाहरण)।

अंतिम टिप्पणी की अवधि अब पूरी हो गई है।

FCP के बारे में, मुझे लगता है कि स्थिरीकरण के लिए प्रस्तावित एपीआई सबसेट बहुत सीमित उपयोग का है। उदाहरण के लिए, यह jemallocator टोकरा का समर्थन नहीं करता है।

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

यदि jemallocator पर स्थिर रूस्ट उदाहरण के लिए लागू नहीं हो सकता है Alloc::realloc je_rallocx कॉल करके, लेकिन डिफ़ॉल्ट आबंटित + कॉपी + डीलॉक पर भरोसा करने की आवश्यकता है, तो यह स्वीकार्य प्रतिस्थापन नहीं है मानक पुस्तकालय का alloc_jemalloc टोकरा IMO।

ज़रूर, आपको संकलन करने के लिए कुछ मिल सकता है, लेकिन यह विशेष रूप से उपयोगी चीज नहीं है।

क्यों? C ++ के पास इसके एलोकेटर API में realloc की कोई भी अवधारणा नहीं है और यह भाषा को अपंग नहीं करता है। यह स्पष्ट रूप से आदर्श नहीं है, लेकिन मुझे समझ नहीं आता कि यह अस्वीकार्य क्यों होगा।

C ++ संग्रह आमतौर पर realloc का उपयोग नहीं करते हैं क्योंकि C ++ मूव कन्स्ट्रक्टर्स मनमानी कोड चला सकते हैं, ना कि becuse realloc उपयोगी नहीं है।

और तुलना C ++ के साथ नहीं है, यह वर्तमान रुस्तम मानक पुस्तकालय के साथ है जिसमें बिल्ट-इन जेमलॉक सपोर्ट है। Alloc API के केवल इस सबसेट के साथ और आउट-ऑफ-एसटीडी आवंटन करने वाला एक प्रतिगमन होगा।

और realloc एक उदाहरण है। jemallocator वर्तमान में alloc_zeroed , alloc_excess , usable_size , grow_in_place , आदि भी लागू करता है।

आबंटित_जरहित को स्थिर किया जाना प्रस्तावित है। जहाँ तक मैं बता सकता हूँ (ऊपर की ओर देखो), वस्तुतः अस्तित्व में alloc_excess शून्य उपयोग हैं। क्या आप कुछ कोड दिखा सकते हैं जो फिर से लागू होंगे जो डिफ़ॉल्ट कार्यान्वयन पर वापस आते हैं।

आम तौर पर, हालांकि, मैं नहीं देखता कि इन एपीआई के एक हिस्से को स्थिर करने के खिलाफ एक तर्क क्यों है। यदि आप जैमलोकेटर का उपयोग नहीं करना चाहते हैं, तो आप इसका उपयोग जारी नहीं रख सकते।

क्या Layout::array<T>() को एक कॉन्स्टेबल fn बनाया जा सकता है?

यह घबराहट हो सकती है, इसलिए फिलहाल नहीं।

यह घबराहट हो सकती है, इसलिए फिलहाल नहीं।

मैं देखता हूं ... मैं const fn Layout::array_elem<T>() लिए समझौता करता हूं जो Layout::<T>::repeat(1).0 बराबर नॉन-पैनकिंग होगा।

@mzabaluev मुझे लगता है कि आप जो वर्णन कर रहे हैं वह Layout::new<T>() बराबर है। यह वर्तमान में घबरा सकता है, लेकिन यह सिर्फ इसलिए है क्योंकि इसे Layout::from_size_align और फिर .unwrap() का उपयोग करके लागू किया गया है, और मुझे उम्मीद है कि यह अलग तरीके से किया जा सकता है।

@ जोशफेल मुझे लगता है कि इस संरचना का आकार 5 है, जबकि एक सरणी के तत्वों को संरेखण के कारण हर 8 बाइट पर रखा जाता है:

struct Foo {
    bar: u32,
    baz: u8
}

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

जंग में, एक वस्तु का आकार हमेशा इसके संरेखण का एक गुणक होता है ताकि किसी सरणी के n th तत्व का पता हमेशा array_base_pointer + n * size_of<T>() । तो किसी सरणी में किसी वस्तु का आकार हमेशा उस वस्तु के आकार के समान होता है। अधिक विवरण के लिए repr (Rust) पर Rustonomicon पेज देखें।

ठीक है, यह पता चलता है कि एक संरचना इसके संरेखण में गद्देदार है, लेकिन AFAIK यह #[repr(C)] को छोड़कर एक स्थिर गारंटी नहीं है।
वैसे भी, Layout::new एक const fn बनाने का भी स्वागत किया जाएगा।

यह एक स्थिर कार्य का प्रलेखित (और इतना गारंटीकृत) व्यवहार है:

https://doc.rust-lang.org/std/mem/fn.size_of.html

एक प्रकार का आकार बाइट्स में देता है।

अधिक विशेष रूप से, यह एक आइटम में क्रमिक तत्वों के बीच बाइट्स में ऑफसेट है जिसमें उस आइटम प्रकार के साथ संरेखण पैडिंग भी शामिल है। इस प्रकार, किसी भी प्रकार के लिए T और n , [T; n] का आकार n * size_of::<T>() ।

धन्यवाद। मुझे बस एहसास हुआ कि कोई भी const fn जो Layout::new के परिणाम को गुणा करता है, स्वाभाविक रूप से बदले में आतंकित होगा (जब तक कि यह saturating_mul या कुछ इस तरह से नहीं किया जाता है), इसलिए मैं वापस वर्ग एक में आ गया हूं। निरंतर fn ट्रैकिंग मुद्दे में दहशत के बारे में एक

panic!() मैक्रो वर्तमान में निरंतर अभिव्यक्तियों में समर्थित नहीं है, लेकिन जाँच अंकगणित से पैनिक संकलक द्वारा उत्पन्न होते हैं और उस सीमा से प्रभावित नहीं होते हैं:

error[E0080]: constant evaluation error
 --> a.rs:1:16
  |
1 | const A: i32 = i32::max_value() * 2;
  |                ^^^^^^^^^^^^^^^^^^^^ attempt to multiply with overflow

error: aborting due to previous error

यह Alloc::realloc से संबंधित है लेकिन न्यूनतम इंटरफ़ेस के स्थिरीकरण के लिए नहीं ( realloc इसका हिस्सा नहीं है):

वर्तमान में, क्योंकि Vec::reserve/double फोन RawVec::reserve/double जो फोन Alloc::realloc , डिफ़ॉल्ट की impl Alloc::realloc प्रतियां मृत वेक्टर तत्वों (में [len(), capacity()) रेंज) । एक विशाल खाली वेक्टर के बेतुके मामले में, जो capacity() + 1 तत्वों को सम्मिलित करना चाहता है और इस तरह से वास्तविक हो जाता है, उस सभी स्मृति को छूने की लागत नगण्य नहीं है।

सिद्धांत रूप में, यदि डिफ़ॉल्ट Alloc::realloc कार्यान्वयन "बाइट्स_यूस्ड" श्रेणी भी लेगा, तो यह केवल वास्तविक हिस्से पर प्रासंगिक भाग की प्रतिलिपि बना सकता है। व्यवहार में, कम से कम jemalloc Alloc::realloc डिफ़ॉल्ट को rallocx साथ निहित करता है। क्या alloc / dealloc डांस की नकल करने से केवल प्रासंगिक मेमोरी तेज होती है या rallocx की तुलना में धीमी गति से होती है, शायद कॉल कई चीजों पर निर्भर करेगा ( rallocx प्रबंधित करता है जगह में ब्लॉक का विस्तार करने के लिए? कितनी अनावश्यक मेमोरी rallocx कॉपी? आदि) होगी।

https://github.com/QuiltOS/rust/tree/allocator-error मैंने यह प्रदर्शित करना शुरू कर दिया है कि मुझे लगता है कि कैसे संबद्ध त्रुटि प्रकार सामान्यीकरण करके हमारे संग्रह और त्रुटि से निपटने की समस्याओं को हल करता है। विशेष रूप से, ध्यान दें कि मॉड्यूल में मैं कैसे बदलता हूं कि मैं

• हमेशा पुन: उपयोग Result<T, A::Err> के लिए कार्यान्वयन T implemetation
• कभी unwrap या कुछ और आंशिक नहीं
• oom(e) AbortAdapter ।

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

मुझे याद है --- मुझे लगता है कि @Gankro के RFC में? या पूर्व rfc धागा --- गेको / सर्वो लोगों का कहना है कि संग्रह की गिरावट उनके प्रकार का हिस्सा नहीं होना अच्छा था। खैर, मैं एक #[repr(transparent)] से AbortAdapter जोड़ सकता हूं ताकि संग्रह को सुरक्षित रूप से Foo<T, A> और Foo<T, AbortAdapter<A>> (सुरक्षित रैपर के भीतर) के बीच प्रसारित किया जा सके, एक को आज़ादी से हर विधि को दोहराए बिना आगे और पीछे स्विच करें। [बैक-कमिटर्स के लिए, मानक पुस्तकालय संग्रह को किसी भी घटना में डुप्लिकेट करने की आवश्यकता होगी, लेकिन उपयोगकर्ता के तरीकों को Result<T, !> आवश्यकता नहीं होगी क्योंकि इन दिनों के साथ काम करना काफी आसान है।]

दुर्भाग्यवश कोड पूरी तरह से जाँच नहीं करेगा क्योंकि एक लैंग आइटम (बॉक्स) के प्रकार पैरामेट्स को बदलने से कंपाइलर (आश्चर्य) को भ्रमित करता है। ICE- कारण बॉक्स कमिट अंतिम एक है --- इससे पहले कि सब कुछ अच्छा हो। #eddyb ने # 47043 में जंग लगा दी!

@joshlf को संपादित करें मुझे आपके https://github.com/rust-lang/rust/pull/45272 के बारे में बताया गया था, और इसमें शामिल किया गया था। धन्यवाद!

लगातार मेमोरी (जैसे http://pmem.io ) अगली बड़ी चीज है, और इसके साथ काम करने के लिए रस्ट को तैनात करना होगा।

मैं हाल ही में एक लगातार मेमोरी एलोकेटर (विशेष रूप से, libpmemcto) के लिए रस्ट रैपर पर काम कर रहा हूं। इस एपीआई के स्थिरीकरण के संबंध में जो भी निर्णय लिए जाते हैं, उन्हें इसकी आवश्यकता है: -

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

एक तरफ के रूप में, pmem.io विकास (इंटेल का PMDK) कवर के तहत एक संशोधित जेमलॉक आवंटन का भारी उपयोग करता है - इसलिए यह विवेकपूर्ण लगता है कि उदाहरण के लिए एपीआई उपभोक्ता के रूप में जेमलॉक का उपयोग करना विवेकपूर्ण होगा।

जब तक हम संग्रह में Alloc ators का उपयोग करने के साथ अधिक अनुभव प्राप्त नहीं करते हैं, तब तक क्या केवल GlobalAllocator s को कवर करने के लिए इस दायरे को कम करना संभव होगा?

IIUC यह पहले से ही servo की जरूरतों को पूरा करेगा और हमें समानांतर में पैराट्रिएजिंग कंटेनरों के साथ प्रयोग करने की अनुमति देगा। भविष्य में हम या तो GlobalAllocator का उपयोग करने के लिए संग्रह को स्थानांतरित कर सकते हैं या केवल Alloc GlobalAllocator लिए एक कंबल जोड़ सकते हैं ताकि ये सभी संग्रह के लिए उपयोग किए जा सकें।

विचार?

@gnzlbg #[global_allocator] विशेषता उपयोगी होने के लिए ( heap::System चयन करने से परे) Alloc विशेषता को भी स्थिर रखने की आवश्यकता है, ताकि इसे https: / जैसे बक्से द्वारा कार्यान्वित किया जा सके GlobalAllocator नाम का कोई प्रकार या विशेषता नहीं है, क्या आप कुछ नए API का प्रस्ताव कर रहे हैं?

इस समय GlobalAllocator नाम का कोई प्रकार या विशेषता नहीं है, क्या आप कुछ नए एपीआई का प्रस्ताव कर रहे हैं?

मैंने जो सुझाव दिया था उसका नाम बदलकर " मिनिमम " एपीआई रखा गया है कि Alloc से GlobalAllocator यहाँ स्थिर करने का सुझाव दिया, और संग्रह के लिए दरवाजा खुला छोड़ कर एक अलग से पैराट्रिमेड होना भविष्य में एलोकेटर ट्रेस (जिसका अर्थ यह नहीं है कि हम GlobalAllocator ट्रिट द्वारा उन्हें पंगु नहीं कर सकते)।

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

अगर यह समझ में नहीं आता है।

IIUC सर्वो को वर्तमान में केवल वैश्विक आवंटनकर्ता को स्विच करने में सक्षम होने की आवश्यकता है (जैसा कि एक आवंटनकर्ता द्वारा कुछ संग्रहों को भी करने में सक्षम होने के लिए विरोध किया जाता है)।

यह सही है, लेकिन:

• यदि कोई लक्षण और इसकी विधि स्थिर है ताकि इसे लागू किया जा सके, तो इसे std::heap::Heap से गुजरे बिना भी सीधे कहा जा सकता है। तो यह न केवल एक विशेषता वैश्विक आवंटनकर्ता है, यह आवंटनकर्ताओं के लिए एक विशेषता है (भले ही हम अंत में आवंटितकर्ताओं पर संग्रह के लिए एक अलग बनाते हैं) और GlobalAllocator एक विशेष रूप से अच्छा नाम नहीं है।
• जैमलोकेटर टोकरा वर्तमान में alloc_excess , realloc , realloc_excess , usable_size , grow_in_place , और shrink_in_place जो लागू नहीं हैं प्रस्तावित न्यूनतम एपीआई का हिस्सा। ये डिफ़ॉल्ट इम्प्लांट की तुलना में अधिक कुशल हो सकते हैं, इसलिए इन्हें हटाना एक प्रदर्शन प्रतिगमन होगा।

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

[यह अच्छा होगा यदि सर्वो की तरह (स्थिर | आधिकारिक मोज़िला टोकरा) हो सकता है, और कार्गो इसे लागू कर सकता है, यहां थोड़ा दबाव हटाने के लिए।]

@Emon2314 सर्वो एकमात्र प्रोजेक्ट नहीं है जो इन एपीआई का उपयोग करना चाहता है।

@Emon2314 मुझे समझ नहीं आ रहा है कि इसका क्या मतलब है, क्या आप इसे फिर से

संदर्भ के लिए: सर्वो वर्तमान में एक नंबर अस्थिर सुविधाओं ( #[global_allocator] ) का उपयोग करता है, लेकिन हम धीरे-धीरे उस से दूर जाने की कोशिश कर रहे हैं (या तो एक कंपाइलर को अपडेट करके जिसने कुछ सुविधाओं को स्थिर किया है, या स्थिर विकल्प ढूंढकर। ) इसे https://github.com/servo/servo/issues/5286 पर ट्रैक किया गया है #[global_allocator] स्थिर होना अच्छा होगा, लेकिन यह किसी भी सर्वो कार्य को अवरुद्ध नहीं कर रहा है।

फ़ायरफ़ॉक्स इस तथ्य पर निर्भर करता है कि एक cdylib संकलन करते समय Rust std सिस्टम एलोकेटर को डिफॉल्ट करता है, और मोज़ेजमॉलोक जो कि एक ही बाइनरी में जोड़ा जाता है, malloc और free जैसे प्रतीकों को परिभाषित करता है। #[global_allocator] का उपयोग करें।

@SimonSapin अधिक है कि मैं Alloc द्वारा संग्रह को पैरामीट्रिज नहीं करना चाहते हैं, क्योंकि आवंटनकर्ता के आधार पर, एक संग्रह की पेशकश करना चाह सकते हैं अलग-अलग एपीआई, कुछ ऑपरेशनों की जटिलता, कुछ संग्रह विवरण वास्तव में आवंटनकर्ता पर निर्भर करते हैं, आदि।

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

चरण 1: ढेर आवंटनकर्ता

हम उपयोगकर्ताओं को स्थिर जंग में ढेर (या सिस्टम / प्लेटफॉर्म / ग्लोबल / फ्री-स्टोर आवंटनकर्ता, या फिर आप इसे नाम देना पसंद करते हैं) के लिए उपयोगकर्ताओं को आवंटनकर्ता का चयन करने का प्रयास करने के लिए पहले खुद को प्रतिबंधित कर सकते थे।

केवल एक चीज जिसे हम शुरू में इसके द्वारा पैरामीरिज करते हैं वह Box , जिसे केवल ( new ) आवंटित करना और डील करना ( drop ) मेमोरी की आवश्यकता है।

इस आवंटनकर्ता विशेषता में शुरू में एपीआई हो सकता है जो std:: संग्रह का समर्थन करने के लिए थोड़ा विस्तारित एपीआई हो सकता है।

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

चरण 2: प्रदर्शन हिट के बिना हीप आवंटन

उस बिंदु पर, हम उन उपयोगकर्ताओं का पुनर्मूल्यांकन कर सकते हैं जो किसी प्रदर्शन हिट के कारण स्थिर नहीं हो सकते हैं, और यह तय कर सकते हैं कि इस एपीआई को कैसे बढ़ाया जाए और इसे स्थिर किया जाए।

चरण 3 से एन: std कलेक्शन में कस्टम एलोकेटर्स का समर्थन करना।

सबसे पहले, यह कठिन है, इसलिए यह कभी नहीं हो सकता है, और मुझे लगता है कि ऐसा कभी नहीं होता है यह एक बुरी बात नहीं है।

जब मैं एक कस्टम एलोकेटर के साथ एक संग्रह करना चाहता हूं, तो मेरे पास प्रदर्शन समस्या या प्रयोज्य समस्या है।

अगर मुझे कोई यूटिलिटी प्रॉब्लम है तो मैं आमतौर पर एक अलग कलेक्शन एपीआई चाहता हूं जो मेरे कस्टम एलोकेटर की सुविधाओं का फायदा उठाता हो, जैसे कि मेरे SliceDeque crate करता है। कस्टम आवंटनकर्ता द्वारा एक संग्रह को पैरामीट्रिंक करने से मुझे यहाँ मदद नहीं मिलेगी।

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

सिस्टम एलोकेटर कॉल की संख्या कम करें (स्मॉल वेक्टर ऑप्टिमाइज़ेशन)

अगर मैं सिस्टम एलोकेटर को कॉल की संख्या कम करने के लिए Vec ऑब्जेक्ट के अंदर कुछ तत्वों को आवंटित करना चाहता हूं, तो आज मैं सिर्फ SmallVec<[T; M]> उपयोग करता हूं। हालांकि, एक SmallVec Vec :

• तत्वों की संख्या में Vec O (1) है, लेकिन N <M और O (1) के लिए SmallVec<[T; M]> O (N) को स्थानांतरित करना,

• Vec len() <= M पर into_iter जैसे तत्वों को स्थानांतरित करने की आवश्यकता है, यदि नहीं, तो len() <= M तत्वों की ओर इशारा करते हैं। सिर्फ पॉइंटर्स लेने के बजाय इटिलेटर ऑब्जेक्ट ही।

क्या हम इसका समर्थन करने के लिए एक आवंटनकर्ता पर Vec सामान्य कर सकते हैं? सब कुछ संभव है, लेकिन मुझे लगता है कि सबसे महत्वपूर्ण लागत हैं:

• ऐसा करने से Vec अधिक जटिल हो जाता है, जो उपयोगकर्ताओं को इस सुविधा का उपयोग न करने पर प्रभावित कर सकता है
• Vec का प्रलेखन अधिक जटिल हो जाएगा, क्योंकि कुछ संचालन का व्यवहार आवंटनकर्ता पर निर्भर करेगा।

मुझे लगता है कि ये लागत गैर-नगण्य हैं।

आवंटन पैटर्न का उपयोग करें

Vec का विकास-कारक एक विशेष आबंटक के अनुरूप होता है। std हम इसे आम लोगों के लिए दर्जी कर सकते हैं jemalloc / malloc / ... लेकिन अगर आप एक कस्टम एलोकेटर का उपयोग कर रहे हैं, तो संभावना है कि विकास-कारक हम चुनते हैं डिफ़ॉल्ट रूप से आपके उपयोग के मामले के लिए सबसे अच्छा नहीं होगा। क्या प्रत्येक आवंटनकर्ता को vec जैसे आवंटन पैटर्न के लिए विकास-कारक निर्दिष्ट करने में सक्षम होना चाहिए? मुझे नहीं पता, लेकिन मेरी आंत भावना मुझे बताती है: शायद नहीं।

अपने सिस्टम एलोकेटर की अतिरिक्त सुविधाओं का शोषण करें

उदाहरण के लिए, ओवर-कमिंग एलोकेटर टियर 1 और टियर 2 लक्ष्यों में से अधिकांश में उपलब्ध है। लिनक्स की तरह और मैकोस सिस्टम में डिफरेंशियल रूप से ढेर एलोकैमिटर ओवरफिट होता है, जबकि विंडोज एपीआई VirtualAlloc का उपयोग करता है, जिसका उपयोग मेमोरी को आरक्षित करने के लिए किया जा सकता है (जैसे Vec::reserve/with_capacity ) और push पर मेमोरी करें

वर्तमान में Alloc विशेषता विंडोज पर इस तरह के एलोकेटर को लागू करने के तरीके को उजागर नहीं करती है, क्योंकि यह स्मृति को कम करने और संग्रहीत करने की अवधारणाओं को अलग नहीं करता है (लिनक्स पर एक गैर-ओवर-कमिंग आवंटनकर्ता को हैक किया जा सकता है) बस प्रत्येक पृष्ठ को एक बार स्पर्श करके)। यह एक आवंटनकर्ता के लिए यह बताने का भी तरीका नहीं बताता है कि यह alloc पर डिफ़ॉल्ट रूप से ओवर-कमिट करता है या नहीं।

है, हम विस्तार करने के लिए की आवश्यकता होगी Alloc के लिए इस समर्थन करने के लिए एपीआई Vec , और कहा कि छोटे से जीत के लिए IMO होगा। क्योंकि जब आपके पास ऐसा एलोकेटर होता है, तो Vec शब्दार्थ फिर से बदलते हैं:

• Vec को कभी भी फिर से बढ़ने की आवश्यकता नहीं है, इसलिए reserve जैसे ऑपरेशन बहुत कम मायने रखते हैं
• push O(1) बजाय amortized O(1) ।
• जीवित वस्तुओं के पुनरावृत्तियों को कभी भी अमान्य नहीं किया जाता है जब तक कि वस्तु जीवित है, जो कुछ अनुकूलन की अनुमति देता है

अपने सिस्टम एलोकेटर की अधिक अतिरिक्त विशेषताओं का शोषण करें

cudaMalloc / cudaMemcpy ... जैसे कुछ सिस्टम पिनोल्ड और नॉन-पिन किए गए मेमोरी के बीच अंतर करते हैं, जिससे आप असंतुष्ट पते वाले स्थानों पर मेमोरी आवंटित कर सकते हैं (इसलिए हमें संबंधित पॉइंटर प्रकार की आवश्यकता होगी Alloc विशेषता), ...

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

समेट रहा हु

मुझे लगता है कि एक Alloc API के साथ आने की कोशिश की जा सकती है, जो सभी संग्रह (या केवल Vec ) का उपयोग करने के लिए कठिन है, शायद बहुत कठिन है।

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

वैसे भी, मुझे लगता है कि एक ही बार में इन सभी समस्याओं से निपटने की कोशिश की जा रही है और एक Alloc विशेषता के साथ आने की कोशिश की जा रही है जो सब कुछ के लिए अच्छा है। हम चरण ० पर हैं। मुझे लगता है कि चरण १ और चरण २ में जाने का सबसे अच्छा तरीका यह है कि जब तक हम वहाँ हैं, तब तक संग्रह को चित्र से बाहर न छोड़ें।

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

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

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

सब लोग? कम से कम अभी तो। आपके द्वारा शिकायत किए जाने वाले अधिकांश तरीके प्रारंभिक स्थिरीकरण प्रस्ताव ( alloc_excess , उदाहरण के लिए) में गायब हैं, AFAIK अभी तक मानक पुस्तकालय में कुछ भी द्वारा उपयोग नहीं किया जाता है। या यह हाल ही में बदल गया?

Vec (और RawVec अन्य उपयोगकर्ता) realloc push

@SimonSapin

जेमलोसोटर क्रेट वर्तमान में एलोकेशन, एक्सलस, रियललोक, रियललोकएक्सएक्सएक्स, यूजेबल_साइज, ग्रो_इन_प्लेस, और सिक्रेट_इन_प्ले को लागू करता है

इन विधियों से, AFAIK realloc , grow_in_place , और shrink_in_place का उपयोग किया जाता है, लेकिन grow_in_place shrink_in_place , jemalloc पर grow_in_place के मामले में shrink_in_place में Alloc विशेषता यह है कि दो तरीकों में कटौती इसे नीचे: realloc और shrink_in_place ।

कस्टम एलोकेटर चुनना आमतौर पर प्रदर्शन में सुधार के बारे में है,

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

IIUC सर्वो के लिए मुख्य उपयोग का मामला फ़ायरफ़ॉक्स जेमलॉक का उपयोग करने के बजाय एक दूसरा जेमलॉक के आसपास होने का था, क्या यह सही था?

यहां तक ​​कि अगर हम एक प्रारंभिक स्थिरीकरण में realloc और shrink_in_place Alloc विशेषता जोड़ते हैं, तो यह केवल प्रदर्शन शिकायतों में देरी करेगा।

उदाहरण के लिए, जिस पल में हम Alloc विशेषता के लिए कोई अस्थिर API जोड़ते हैं, जो std संग्रहों द्वारा उपयोग किया जा रहा है, आप स्थिर से समान प्रदर्शन प्राप्त नहीं कर पाएंगे। रात को पाने में सक्षम हो। अर्थात्, यदि हम आबंटित गुण में realloc_excess और shrink_in_place_excess जोड़ते हैं और Vec / String ... का उपयोग करते हैं, तो हम realloc स्थिर करते हैं। shrink_in_place ने आपको एक बिट में मदद नहीं की होगी।

IIUC सर्वो के लिए मुख्य उपयोग का मामला फ़ायरफ़ॉक्स जेमलॉक का उपयोग करने के बजाय एक दूसरा जेमलॉक के आसपास होने का था, क्या यह सही था?

हालाँकि वे कुछ कोड साझा करते हैं, फ़ायरफ़ॉक्स और सर्वो दो अलग-अलग प्रोजेक्ट / एप्लिकेशन हैं।

फ़ायरफ़ॉक्स mozjemalloc का उपयोग करता है, जो कि जोड़ा सुविधाओं के एक समूह के साथ jallalloc के पुराने संस्करण का एक कांटा है। मुझे लगता है कि कुछ unsafe FFI कोड Rust std द्वारा उपयोग किए जा रहे mozjemalloc पर शुद्धता और सुदृढ़ता के लिए निर्भर करता है।

सर्वो जीमेलॉक का उपयोग करता है जो इस समय निष्पादन के लिए जंग के लिए डिफ़ॉल्ट है, लेकिन उस डिफ़ॉल्ट को सिस्टम के आवंटनकर्ता में बदलने की योजना है। सर्वो के पास कुछ unsafe मेमोरी उपयोग रिपोर्टिंग कोड भी है जो वास्तव में उपयोग किए जा रहे जेमलॉक पर ध्वनि के लिए निर्भर करता है। (पासिंग Vec::as_ptr() से je_malloc_usable_size ।)

सर्वो जीमेलॉक का उपयोग करता है जो इस समय निष्पादन के लिए जंग के लिए डिफ़ॉल्ट है, लेकिन उस डिफ़ॉल्ट को सिस्टम के आवंटनकर्ता में बदलने की योजना है।

यह जानना अच्छा होगा कि क्या सिस्टम में सिस्टम एलोकेटर्स है कि सर्वो लक्ष्य realloc और shrink_to_fit API प्रदान करता है जैसे कि jemalloc करता है? realloc (और calloc ) बहुत आम हैं, लेकिन shrink_to_fit ( xallocx ) AFAIK jemalloc लिए विशिष्ट हैं। शायद सबसे अच्छा समाधान प्रारंभिक कार्यान्वयन में realloc और alloc_zeroed ( calloc ) को स्थिर करना होगा, और बाद में shrink_to_fit को छोड़ना होगा। कि प्रदर्शन के मुद्दों के बिना सर्वो को अधिकांश प्लेटफार्मों में सिस्टम आवंटनकर्ताओं के साथ काम करने की अनुमति देनी चाहिए।

सर्वो के पास कुछ असुरक्षित मेमोरी उपयोग रिपोर्टिंग कोड भी है जो वास्तव में उपयोग किए जा रहे जेमलॉक पर ध्वनि के लिए निर्भर करता है। (पासिंग वीईसी :: as_ptr () से je_malloc_usable_size।)

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

मुझे नहीं लगता कि malloc_usable_size आवश्यकता Alloc विशेषता में है। #[global_allocator] का उपयोग यह आश्वस्त करने के लिए किया जाता है कि क्या आवंटितकर्ता Vec<T> द्वारा उपयोग किया जाता है और jemallocator टोकरा से एक फ़ंक्शन का उपयोग करके अलग है।

@SimonSapin Alloc ट्रिट स्थिर हो जाने के बाद, हमारे पास संभवतः लिनक्स मॉलॉक और विंडोज के लिए jemallocator जैसा एक टोकरा होगा। इन टोकरों में उन हिस्सों को लागू करने के लिए एक अतिरिक्त सुविधा हो सकती है जो वे अस्थिर Alloc API (जैसे, usable_size malloc_usable_size ) के शीर्ष पर हों और कुछ अन्य चीजें जो Alloc API का हिस्सा नहीं हैं, जैसे mallinfo ऊपर मेमोरी रिपोर्टिंग। एक बार सिस्टम के लिए प्रयोग करने योग्य क्रेट होते हैं, जो सर्वो को लक्षित करता है, यह जानना आसान होगा कि Alloc का कौन सा भाग स्थिर करने को प्राथमिकता देता है, और हम शायद नए एपीआई का पता लगाएंगे जो कम से कम कुछ के साथ प्रयोग किया जाना चाहिए allocators।

@gnzlbg मैं https://github.com/rust-lang/rust/issues/32838#issuecomment -358267292 में चीजों पर थोड़ा संदेह कर रहा हूं। उन सभी सिस्टम-विशिष्ट सामान को छोड़कर, आवंटन के लिए संग्रह को सामान्य बनाना मुश्किल नहीं है - मैंने इसे किया है। एक अलग चुनौती की तरह लगता है कि शामिल करने की कोशिश कर रहा है।

@SimonSapin फ़ायरफ़ॉक्स क्या कोई अस्थिर जंग नीति नहीं है? मुझे लगता है कि मैं भ्रमित हो रहा था: फ़ायरफ़ॉक्स और सर्वो यह चाहते हैं, लेकिन यदि ऐसा है तो फ़ायरफ़ॉक्स का उपयोग-मामला जो स्थिर करने के लिए दबाव जोड़ रहा होगा।

@sfackler देखें कि ^ मैं उन परियोजनाओं के बीच एक अंतर बनाने की कोशिश कर रहा था जिन्हें बनाम इस स्थिर की आवश्यकता है, लेकिन सर्वो उस विभाजन के दूसरी तरफ है।

मेरे पास एक परियोजना है जो यह चाहती है और इसे स्थिर करने की आवश्यकता है। रस्ट के उपभोक्ताओं के रूप में सर्वो या फ़ायरफ़ॉक्स के बारे में कुछ भी विशेष रूप से जादुई नहीं है।

@Emon2314 सही, फ़ायरफ़ॉक्स स्थिर का उपयोग करता है: https://wiki.mozilla.org/Rust_Update_Policy_for_Firefox। जैसा कि मैंने समझाया हालांकि आज काम करने का हल है, इसलिए यह किसी भी चीज़ के लिए वास्तविक अवरोधक नहीं है। यह #[global_allocator] का उपयोग करने के लिए अच्छा / अधिक मजबूत होगा, बस इतना ही।

सर्वो कुछ अस्थिर विशेषताओं का उपयोग करता है, लेकिन जैसा कि हमने उल्लेख किया है कि हम इसे बदलने की कोशिश कर रहे हैं।

एफडब्ल्यूआईडब्ल्यू, पैरामीट्रिक आवंटनकर्ता आवंटन को लागू करने के लिए बहुत उपयोगी हैं। यदि आप विभिन्न डेटा संरचनाओं का आंतरिक रूप से उपयोग कर सकते हैं और कुछ सरल आवंटनकर्ता (जैसे

@ Ericson2314

उन सभी सिस्टम-विशिष्ट सामान को छोड़कर, आवंटन के लिए संग्रह को सामान्य बनाना मुश्किल नहीं है - मैंने इसे किया है। एक अलग चुनौती की तरह लगता है कि शामिल करने की कोशिश कर रहा है।

क्या आपके पास ArrayVec या SmallVec Vec कस्टम एलोकेशन है जिसे मैं देख सकता हूं? यह पहला बिंदु था जिसका मैंने उल्लेख किया था, और यह बिल्कुल भी विशिष्ट प्रणाली नहीं है। संभवत: यह सबसे आसान दो आवंटनकर्ता होगा, जो कल्पना करने योग्य है, एक भंडारण के रूप में एक कच्चा सरणी है, और दूसरा एक हीप के शीर्ष पर बनाया जा सकता है, जब सरणी क्षमता से बाहर हो जाती है। मुख्य अंतर यह है कि वे आवंटनकर्ता "वैश्विक" नहीं हैं, लेकिन Vec s में से प्रत्येक के पास अपने स्वयं के आवंटनकर्ता अन्य सभी से स्वतंत्र हैं, और ये आवंटनकर्ता स्टेटफुल हैं।

इसके अलावा, मैं ऐसा नहीं करने के लिए बहस नहीं कर रहा हूं। मैं सिर्फ यह कह रहा हूं कि यह बहुत कठिन है: C ++ केवल आंशिक सफलता के साथ 30 वर्षों से प्रयास कर रहा है: जेनेरिक पॉइंटर और GC एलोकेटर जेनेरिक पॉइंटर प्रकारों के कारण काम करते हैं, लेकिन ArrayVec और SmallVec Vec C ++ भूमि में शून्य-लागत अमूर्तता के परिणामस्वरूप नहीं होता है ( P0843r1 कुछ मुद्दों पर ArrayVec विस्तार से चर्चा करता है)।

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

मैंने IRC पर @SimonSapin के साथ थोड़ी बात की और अगर हम realloc और alloc_zeroed साथ प्रारंभिक स्थिरीकरण प्रस्ताव का विस्तार करने वाले थे, तो फ़ायरफ़ॉक्स में जंग (जो केवल स्थिर जंग का उपयोग करता है) का उपयोग करने में सक्षम होगा। mozjemalloc किसी भी अतिरिक्त हैक की आवश्यकता के बिना स्थिर जंग में एक वैश्विक आवंटनकर्ता के रूप में। जैसा कि @SimonSapin द्वारा उल्लेख किया गया है, फ़ायरफ़ॉक्स वर्तमान में आज के लिए एक व्यावहारिक समाधान है, इसलिए जब यह अच्छा होगा, तो यह बहुत उच्च प्राथमिकता नहीं लगती है।

फिर भी, हम वहां शुरू कर सकते हैं, और एक बार जब हम वहां होते हैं, तो servo को प्रदर्शन हानि के बिना #[global_allocator] स्थिर करते हैं।

@joshlf

एफडब्ल्यूआईडब्ल्यू, पैरामीट्रिक आवंटनकर्ता आवंटन को लागू करने के लिए बहुत उपयोगी हैं।

क्या आप अपने मतलब के बारे में कुछ और बता सकते हैं? क्या कोई कारण है कि आप Alloc विशेषता के साथ अपने कस्टम आबंटकों को पंगु नहीं बना सकते? या अपने स्वयं के कस्टम एलोकेटर लक्षण और अंतिम आवंटनकर्ताओं पर Alloc विशेषता लागू करें (इन दोनों लक्षणों को समान होने की आवश्यकता नहीं है)?

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

Layout API को देखते हुए, मैं from_size_align और align_to बीच त्रुटि से निपटने के अंतरों के बारे में सोच रहा था, जहां पूर्व में None एक त्रुटि के मामले में , जबकि बाद के दहशत (!)।

क्या यह अधिक उपयोगी और सुसंगत रूप से परिभाषित और जानकारीपूर्ण LayoutErr एनम जोड़ने के लिए और दोनों मामलों में Result<Layout, LayoutErr> वापस करने के लिए संगत नहीं होगा (और शायद वर्तमान में Option लौटाने वाले अन्य कार्यों के लिए इसका उपयोग करें

@rkruppe

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

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

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

सी ++ के साथ मेरे अनुभव में, एक आवंटनकर्ता के साथ एक संग्रह के लिए दो उपयोग मामलों में काम करता है:

• एक विशिष्ट आवंटन पैटर्न, और / या पर लक्षित कस्टम आवंटन का उपयोग करके संग्रह वस्तु के प्रदर्शन में सुधार
• एक संग्रह में एक नई सुविधा जोड़ें, जिससे वह कुछ ऐसा कर सके जो वह पहले नहीं कर सकता था।

संग्रह में नई सुविधाएँ जोड़ना

यह आवंटनकर्ताओं का उपयोग मामला है जिसे मैं C ++ कोड-बेस में 99% बार देखता हूं। तथ्य यह है कि एक संग्रह में एक नई सुविधा जोड़ने से प्रदर्शन में सुधार होता है, मेरी राय में, संयोग है। विशेष रूप से, निम्न में से कोई भी आवंटनकर्ता आवंटन पैटर्न को लक्षित करके प्रदर्शन में सुधार नहीं करता है। वे सुविधाओं को जोड़कर ऐसा करते हैं, कि कुछ मामलों में, @SON2314 उल्लेख के रूप में, "सिस्टम-विशिष्ट" माना जा सकता है। ये कुछ उदाहरण हैं:

• छोटे बफर ऑप्टिमाइज़ेशन करने के लिए स्टैक एलोकेटर (देखें हावर्ड हिनेंट स्टैक_लॉक पेपर )। वे आपको std::vector या flat_{map,set,multimap,...} और इसे एक कस्टम एलोकेटर में पास करके ( SmallVec ) या बिना ( ArrayVec ) जोड़ते हैं ढेर वापस गिर जाते हैं। यह, उदाहरण के लिए, स्टैक या स्थिर मेमोरी (जहां यह अन्यथा ढेर का उपयोग किया होता) पर अपने तत्वों के साथ एक संग्रह डाल रहा है।

• खंडित मेमोरी आर्किटेक्चर (जैसे 16-बिट वाइड पॉइंटर x86 टारगेट और GPGPUs)। उदाहरण के लिए, C ++ 17 समानांतर STL, C ++ 14 के दौरान, समानांतर तकनीकी विशिष्टता थी। यह एक ही लेखक का अग्रदूत पुस्तकालय है NVIDIA का थ्रस्ट लाइब्रेरी, जिसमें GPGPU मेमोरी (जैसे थ्रस्ट :: device_malloc_allocator ) या पिन की गई मेमोरी (जैसे थ्रस्ट - pinned_allocator ) का उपयोग करने के लिए कंटेनर क्लैस को अनुमति देने के लिए एलोकेटर शामिल हैं; पिन की गई मेमोरी होस्ट-डिवाइस के बीच तेज ट्रांसफर की अनुमति देता है। कुछ मामले)।

• समतुल्यता-संबंधी समस्याओं को हल करने के लिए आवंटनकर्ता, जैसे कि गलत साझाकरण (जैसे इंटेल थ्रेड बिल्डिंग ब्लॉक cache_aligned_allocator ) या SIMD प्रकारों की अधिक-संरेखण आवश्यकताओं (जैसे Eigen3 के aligned_allocator )।

• इंटरप्रोसेस शेयर्ड मेमोरी: बूस्ट.इंटरप्रोसेस के पास फैसिलिटीज (जैसे सिस्टम V शेयर्ड मेमोरी) का उपयोग करके कलेक्शन की मेमोरी को आवंटित करने वाले एलोकेटर हैं। यह विभिन्न प्रक्रियाओं के बीच संवाद करने के लिए उपयोग की जाने वाली मेमोरी को प्रबंधित करने के लिए सीधे एक std कंटेनर का उपयोग करने की अनुमति देता है।

• कचरा संग्रह: हर्ब सटर की आस्थगित मेमोरी आवंटन लाइब्रेरी उपयोगकर्ता को परिभाषित करने के लिए उपयोगकर्ता-परिभाषित सूचक प्रकार का उपयोग करती है जो कचरा इकट्ठा करती है। इसलिए, उदाहरण के लिए, जब कोई वेक्टर बढ़ता है, तो मेमोरी का पुराना हिस्सा तब तक जीवित रहता है जब तक कि उस मेमोरी के सभी संकेत नष्ट हो गए हों, जब तक कि पुनरावृत्ति अमान्य न हो जाए।

• इंस्ट्रूमेंटेड एलोकेटर: ब्लूमबर्ग की सॉफ्टवेयर लाइब्रेरी का ब्ल्स्मा_टैस्टलोसैटर आपको उन ऑब्जेक्ट्स की मेमोरी एलोकेशन / डीललोकेशन (और C ++ - विशिष्ट ऑब्जेक्ट कंस्ट्रक्शन / विनाश) पैटर्न को लॉग करने की अनुमति देता है जहां आप इसका उपयोग करते हैं। आप नहीं जानते कि क्या Vec reserve बाद आवंटित होता है? ऐसे आवंटनकर्ता में प्लग करें, और वे आपको बताएंगे कि क्या ऐसा होता है। इन आवंटनकर्ताओं में से कुछ आपको उनका नाम देते हैं, ताकि आप इसे कई वस्तुओं पर उपयोग कर सकें और लॉग कह सकें कि कौन सी वस्तु क्या कर रही है।

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

प्रदर्शन में सुधार के लिए आवंटन पैटर्न को लक्षित करना।

AFAIK वहाँ किसी भी व्यापक रूप से इस्तेमाल नहीं किया जाता है C ++ आवंटनकर्ता ऐसा करते हैं और मैं समझाता हूं कि मुझे क्यों लगता है कि यह एक दूसरे में है। निम्नलिखित पुस्तकालय इस उपयोग के मामले को लक्षित करते हैं:

• C ++ Boost.Pool ,
• C ++ फ़ौनाथन / मेमोरी
• D का std.experimental.allocator

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

सामान्य सलाह जो मैं अपने C ++ दिनों से याद करता हूं वह सिर्फ "उनका उपयोग न करें" (वे बहुत अंतिम उपाय हैं) क्योंकि:

• सिस्टम आबंटक के प्रदर्शन का मिलान बहुत कठिन है, इसे पीटना बहुत कठिन है,
• किसी और के एप्लिकेशन मेमोरी एलोकेशन पैटर्न से मेल खाने की संभावना आपकी पतली है, इसलिए आपको वास्तव में अपने आवंटन पैटर्न को जानना होगा और यह जानना होगा कि आपको कौन से एलोकेटर बिल्डिंग ब्लॉक का मिलान करना है।
• वे पोर्टेबल नहीं हैं क्योंकि विभिन्न विक्रेताओं के पास अलग-अलग सी ++ मानक पुस्तकालय कार्यान्वयन हैं जो विभिन्न आवंटन पैटर्न का उपयोग करते हैं; विक्रेता आमतौर पर अपने सिस्टम आवंटनकर्ताओं पर उनके कार्यान्वयन को लक्षित करते हैं। यही है, एक विक्रेता के अनुरूप एक समाधान दूसरे में बुरी तरह से (सिस्टम आवंटनकर्ता से भी बदतर) प्रदर्शन कर सकता है।
• कई विकल्प हैं जो इनका उपयोग करने से पहले थक सकते हैं: एक अलग संग्रह का उपयोग करना, स्मृति को संग्रहित करना, ... अधिकांश विकल्प कम प्रयास हैं और बड़ी जीत प्रदान कर सकते हैं।

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

समेट रहा हु

IMO मुझे लगता है कि यह बहुत अच्छा है कि C ++ आवंटनकर्ता मॉडल, हालांकि एकदम सही है, दोनों उपयोग के मामलों का समर्थन करता है, और मुझे लगता है कि अगर Rust के std संग्रह को आवंटनकर्ताओं द्वारा पैरामीट्रिज्ड किया जाना है, तो उन्हें दोनों उपयोग के मामलों का समर्थन करना चाहिए, क्योंकि कम से कम दोनों मामलों के लिए C ++ एलोकेटर उपयोगी साबित हुए हैं।

मुझे लगता है कि यह समस्या वैश्विक / प्रणाली / प्लेटफ़ॉर्म / डिफ़ॉल्ट / ढेर / मुफ्त-स्टोर आवंटन को किसी विशेष एप्लिकेशन को अनुकूलित करने में सक्षम होने के लिए थोड़ा ओर्थोगोनल है, और एक ही समय में दोनों समस्याओं को हल करने की कोशिश करने से एक के लिए समाधान में देरी हो सकती है उनमें से अनावश्यक रूप से।

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

@gnzlbg समझदार लिखने के लिए धन्यवाद। इसमें से अधिकांश मेरे मूल प्रश्न को संबोधित नहीं करते हैं और मैं इसमें से कुछ से असहमत हूं, लेकिन यह अच्छा है कि इसे समाप्त कर दिया जाए ताकि हम एक-दूसरे से बात न करें।

मेरा प्रश्न विशेष रूप से इस एप्लिकेशन के बारे में था:

छोटे बफर ऑप्टिमाइज़ेशन करने के लिए स्टैक एलोकेटर (देखें हावर्ड हिनेंट स्टैक_लॉक पेपर)। वे आपको std :: वेक्टर या फ्लैट_ {मैप, सेट, मल्टिमैप, ...} का उपयोग करने देते हैं और इसे एक कस्टम एलोकेटर में पास करके (स्मॉलवेक) या (एरेवेक) हीप बैक के साथ एक छोटे बफर ऑप्टिमाइज़ेशन में जोड़ते हैं। यह, उदाहरण के लिए, स्टैक या स्थिर मेमोरी (जहां यह अन्यथा ढेर का उपयोग किया होता) पर अपने तत्वों के साथ एक संग्रह डाल रहा है।

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

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

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

Stack_alloc के बारे में पढ़ना, मुझे अब एहसास हुआ कि यह कैसे काम कर सकता है। ऐसा नहीं है कि लोग आमतौर पर SmallVec (जहां बफर को संग्रह में इनलाइन संग्रहीत किया जाता है) से मतलब है, यही वजह है कि मैं उस विकल्प से चूक गया, लेकिन यह पक्ष को इंगित करने की समस्या को उठाता है जब संग्रह चलता है (और उन चालों को भी सस्ता बनाता है )।

मैंने stack_alloc उल्लेख किया क्योंकि यह "एक पेपर" के साथ एकमात्र ऐसा आवंटनकर्ता है, लेकिन इसे 2009 में जारी किया गया था और C ++ 11 (C ++ 03 ने संग्रह में राज्यवार आवंटनकर्ताओं का समर्थन नहीं किया)।

जिस तरह से C ++ 11 (जो राज्यवार आवंटन का समर्थन करता है) में यह काम संक्षेप में है:

• std :: वेक्टर एक Allocator वस्तु को इसके अंदर रखता है जैसे रुस्ट RawVec करता है ।
• एलोकेटर इंटरफ़ेस में एक अस्पष्ट संपत्ति होती है जिसे एलोकेटर कहा जाता है true है। यदि यह संपत्ति false , तो असाइनमेंट पर, आवंटनकर्ता को प्रचारित नहीं किया जा सकता है, इसलिए मानक द्वारा इसके प्रत्येक तत्व को नए भंडारण में मैन्युअल रूप से स्थानांतरित करने के लिए एक संग्रह की आवश्यकता होती है।

इसलिए जब सिस्टम एलोकेटर के साथ एक वेक्टर को स्थानांतरित किया जाता है, तो स्टैक पर नए वेक्टर के लिए पहले स्टोरेज आवंटित किया जाता है, फिर एलोकेटर को स्थानांतरित किया जाता है (जो शून्य-आकार है), और फिर 3 पॉइंटर्स को स्थानांतरित किया जाता है, जो अभी भी मान्य हैं। ऐसी चाल O(1) ।

OTOHO, जब POCMA == true एलोकेटर के साथ एक वेक्टर ले जाया जाता है, तो स्टैक पर नए वेक्टर के लिए पहले भंडारण आवंटित किया जाता है और एक खाली वेक्टर के साथ आरंभीकृत किया जाता है, फिर पुराना संग्रह drain ed है। नया, ताकि पुराना खाली हो, और नया भरा हुआ हो। यह उनके चाल असाइनमेंट ऑपरेटरों का उपयोग करते हुए, संग्रह के प्रत्येक तत्व को व्यक्तिगत रूप से स्थानांतरित करता है। यह कदम O(N) और तत्वों के आंतरिक बिंदुओं को ठीक करता है। अंत में, मूल अब खाली संग्रह छोड़ दिया गया है। ध्यान दें कि यह एक क्लोन की तरह दिखता है, लेकिन ऐसा नहीं है क्योंकि तत्व स्वयं क्लोन नहीं किए गए हैं, लेकिन C ++ में चले गए हैं।

क्या इसका कोई मतलब है?

C ++ में इस दृष्टिकोण के साथ मुख्य समस्या यह है कि:

• वेक्टर विकास-नीति कार्यान्वयन को परिभाषित करता है
• आवंटनकर्ता API के पास _excess विधियाँ नहीं हैं
• ऊपर दिए गए दो मुद्दों के संयोजन का मतलब है कि यदि आप जानते हैं कि आपका वेक्टर अधिकतम 9 तत्वों को पकड़ सकता है, तो आपके पास एक स्टैक एलोकेटर नहीं हो सकता है जो 9 तत्वों को पकड़ सकता है, क्योंकि आपका वेक्टर बढ़ने की कोशिश कर सकता है जब इसमें वृद्धि कारक 8 हो। १.५ में से १। तत्वों के लिए आपको जगह कम करने और स्थान आवंटित करने की आवश्यकता है।
• एलोकेटर गुणों के आधार पर वेक्टर ऑपरेशन में बदलाव की जटिलता (POCMA सिर्फ कई गुणों में से एक है जो C ++ Allatorator API के पास है। C ++ आवंटनकर्ता लिखना गैर-तुच्छ है)। यह वेक्टर के एपीआई को एक दर्द के रूप में निर्दिष्ट करता है क्योंकि कभी-कभी एक ही प्रकार के विभिन्न आवंटनकर्ताओं के बीच तत्वों को कॉपी या स्थानांतरित करने पर अतिरिक्त लागत होती है, जो ऑपरेशन की जटिलता को बदल देती है। यह कल्पना को एक विशाल दर्द भी बनाता है। नोटबंदी जैसे दस्तावेज़ के कई ऑनलाइन स्रोतों ने सामान्य मामले को उल्टा कर दिया, और उनके साथ 99% उपयोगकर्ताओं को परेशान करने से बचने के लिए छोटे से छोटे अक्षरों में अगर एक आवंटन संपत्ति सही या गलत है तो क्या होता है, इसके अस्पष्ट विवरण।

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

मैं असहमत हूं कि इस प्रकार के आवंटनकर्ता और cache_aligned_allocator मूल रूप से नई सुविधाएँ जोड़ रहे हैं।

शायद मेरा मतलब यह है कि वे आपको उन स्थितियों में या उन प्रकारों के लिए संग्रह संग्रह का उपयोग करने की अनुमति देते हैं जिनके लिए आप पहले उनका उपयोग नहीं कर सकते थे। उदाहरण के लिए, C ++ में आप स्टैक एलोकेटर जैसी चीज़ के बिना अपने बाइनरी के स्थिर मेमोरी सेगमेंट में एक वेक्टर के तत्वों को नहीं डाल सकते हैं (फिर भी आप अपना खुद का संग्रह लिख सकते हैं जो ऐसा करता है)। OTOH, C ++ मानक SIMD प्रकारों की तरह संरेखित प्रकारों का समर्थन नहीं करता है, और यदि आप new साथ एक को आवंटित करने का प्रयास करते हैं तो आप अपरिभाषित व्यवहार का आह्वान करेंगे (आपको posix_memalign या इसी तरह का उपयोग करने की आवश्यकता है) । ऑब्जेक्ट का उपयोग आम तौर पर एक segfault (*) के माध्यम से अपरिभाषित व्यवहार को प्रकट करता है। aligned_allocator जैसी चीजें आपको इन प्रकारों को आवंटित करने की अनुमति देती हैं, और यहां तक ​​कि एक अलग आवंटनकर्ता का उपयोग करके, अपरिभाषित व्यवहार को लागू किए बिना, उन्हें एसआईडी संग्रह में डाल दिया जाता है। निश्चित रूप से नए आवंटनकर्ता के पास अलग-अलग आवंटन पैटर्न होंगे (ये आवंटन मूल रूप से सभी मेमोरी btw को ओवरलैग करते हैं ...), लेकिन जो लोग उनका उपयोग करते हैं वह कुछ ऐसा करने में सक्षम होने के लिए है जो वे पहले नहीं कर सकते थे।

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

(*) Eigen3 के उपयोगकर्ता इसे गहराई से पीड़ित करते हैं, क्योंकि C ++ और STL कंटेनरों का उपयोग करते समय अपरिभाषित व्यवहार से बचने के लिए, आपको SIMD प्रकारों के विरुद्ध कंटेनरों की रक्षा करने की आवश्यकता होती है, या SIMD प्रकारों ( Eigen3 डॉक्स ) से युक्त और आपको अपने स्वयं की सुरक्षा करने की भी आवश्यकता होती है। कभी भी ओवरलोडिंग ऑपरेटर द्वारा new का उपयोग करके, उनके लिए new ( अधिक Eigen3 डॉक्स )।

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

मैं @rkruppe से भी सहमत आवंटनकर्ता का उपयोग करके संग्रह के लिए नहीं है। कभी-कभी पूर्ण Collection<Allocator> में नए गुण होते हैं (मौजूदा पूरी तरह से पिन की गई मेमोरी में, कहते हैं) लेकिन यह आवंटन का उपयोग करने का सिर्फ एक स्वाभाविक परिणाम है।

यहां जो अपवाद मुझे दिखाई देता है, वह है आवंटनकर्ता जो केवल एक ही आकार / प्रकार आवंटित करते हैं (NVidia वाले ऐसा करते हैं, जैसा कि स्लैब आवंटनकर्ता करते हैं)। हमारे पास एक अलग ObjAlloc<T> विशेषता हो सकती है जो कि सामान्य आवंटनकर्ताओं के लिए लागू होती है: impl<A: Alloc, T> ObjAlloc<T> for A । तब, संग्रह ओब्जालोक सीमा का उपयोग करेंगे यदि उन्हें कुछ वस्तुओं को आवंटित करने की आवश्यकता है। लेकिन, मुझे लगता है कि इसे कुछ हद तक मूर्खतापूर्ण भी कहा जा सकता है क्योंकि इसे बाद में अनुकूल तरीके से पीछे किया जाना चाहिए।

क्या इसका कोई मतलब है?

ज़रूर लेकिन यह वास्तव में जंग के लिए प्रासंगिक नहीं है क्योंकि हमारे पास कोई कदम नहीं है। तो (चल) आवंटन जो सीधे मेमोरी को समाहित करता है वह केवल संभव नहीं है, अवधि के लिए संकेत देता है।

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

यह व्यवहार परिवर्तन नहीं है। नियंत्रण के कई वैध कारण हैं जहाँ संग्रह से उनकी स्मृति मिलती है, लेकिन उनमें से सभी "बाह्यताओं" से संबंधित हैं जैसे प्रदर्शन, लिंकर स्क्रिप्ट, पूरे कार्यक्रम की मेमोरी लेआउट पर नियंत्रण, आदि।

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

यही कारण है कि मैंने विशेष रूप से टीबीबी के cache_aligned_allocator का उल्लेख किया है न कि Eigen के align_allocator का। cache_aligned_allocator अपने प्रलेखन में किसी विशिष्ट संरेखण की गारंटी नहीं देता है (यह सिर्फ कहता है कि यह "आमतौर पर" 128 बाइट है), और यहां तक ​​कि अगर यह किया तो आमतौर पर इस उद्देश्य के लिए उपयोग नहीं किया जाएगा (क्योंकि इसका संरेखण संभवतः आम तौर पर बहुत बड़ा है। SIMD प्रकार और पृष्ठ-संरेखित DMA जैसी चीजों के लिए बहुत छोटा है)। इसका उद्देश्य, जैसा कि आप कहते हैं, झूठे बंटवारे से बचना है।

@gnzlbg

एफडब्ल्यूआईडब्ल्यू, पैरामीट्रिक आवंटनकर्ता आवंटन को लागू करने के लिए बहुत उपयोगी हैं।

क्या आप अपने मतलब के बारे में कुछ और बता सकते हैं? क्या कोई कारण है कि आप एलोक विशेषता के साथ अपने कस्टम आवंटनकर्ताओं को पैरामीट्रिज़ नहीं कर सकते हैं? या आपके स्वयं के कस्टम एलोकेटर लक्षण और अंतिम आवंटनकर्ताओं पर एलोक विशेषता को लागू करने के लिए (इन दो लक्षणों को जरूरी नहीं कि बराबर होना चाहिए)?

मुझे लगता है कि मैं स्पष्ट नहीं था; मुझे बेहतर समझाने की कोशिश करें। मान लीजिए कि मैं एक एलोकेटर को लागू कर रहा हूं जिसकी मुझे उम्मीद है:

• वैश्विक आवंटनकर्ता के रूप में
• नो-एसटीडी माहौल में

और मान लें कि मैं इस आवंटनकर्ता को लागू करने के लिए हूड के नीचे Vec का उपयोग करना चाहता हूं। मैं सीधे तौर पर Vec उपयोग नहीं कर सकता क्योंकि यह आज मौजूद है

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

इस प्रकार, मुझे जो कुछ भी चाहिए वह एक Vec का उपयोग करने में सक्षम होना चाहिए जो कि एक अन्य एलोकेटर पर पैराट्राइज्ड है जिसे मैं आंतरिक आंतरिक बहीखाता के लिए आंतरिक रूप से उपयोग करता हूं। यह bsalloc का लक्ष्य है (और नाम का स्रोत - इसका उपयोग अन्य

एल्फमालॉक में, हम अभी भी एक वैश्विक आवंटनकर्ता बनने में सक्षम हैं:

• जब खुद को संकलित करते हैं, तो वैश्विक आवंटनकर्ता के रूप में सांख्यिकीय रूप से जेमलॉक को संकलित करें
• एक साझा ऑब्जेक्ट फ़ाइल का उत्पादन करें जिसे गतिशील रूप से अन्य कार्यक्रमों द्वारा लोड किया जा सकता है

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

लेकिन यह तब काम नहीं करता है जब:

• कोई हमें "आधिकारिक" तरीके से रस्ट में वैश्विक आवंटनकर्ता के रूप में उपयोग करना चाहता है (जैसा कि एक साझा ऑब्जेक्ट फ़ाइल बनाने से विरोध किया जाता है)
• हम एक no-std वातावरण में हैं

OTOH, C ++ मानक SIMD प्रकारों की तरह संरेखित प्रकारों का समर्थन नहीं करता है, और यदि आप नए के साथ एक को आवंटित करने का प्रयास करते हैं, तो आप अपरिभाषित व्यवहार को आमंत्रित करेंगे (आपको posix_memalign या समान का उपयोग करने की आवश्यकता है)।

चूँकि हमारा वर्तमान Alloc विशेषता एक पैरामीटर के रूप में संरेखण लेता है, इसलिए मुझे इस समस्या का वर्ग ("मैं एक अलग संरेखण के बिना काम नहीं कर सकता" समस्या) हमारे लिए दूर जाती है?

@gnzlbg - एक व्यापक लेखन-अप (धन्यवाद) लेकिन उपयोग के मामलों में से कोई भी लगातार स्मृति * को कवर नहीं करता है।

इस उपयोग के मामले पर विचार किया जाना चाहिए। विशेष रूप से, यह दृढ़ता से प्रभावित करता है कि क्या करना सही है: -

• एक से अधिक आवंटनकर्ता उपयोग में है, और विशेष रूप से, जब उपयोग किया जाता है कि आवंटितकर्ता लगातार स्मृति के लिए है, तो यह कभी भी सिस्टम आवंटनकर्ता नहीं होगा; (वास्तव में, कई लगातार मेमोरी एलोकेटर्स हो सकते हैं)
• मानक संग्रह को फिर से लागू करने की लागत अधिक है, और तीसरे पक्ष के पुस्तकालयों के साथ असंगत कोड की ओर जाता है।
• आवंटनकर्ता का जीवनकाल आवश्यक रूप से 'static ।
• निरंतर मेमोरी में संग्रहीत वस्तुओं को अतिरिक्त स्थिति की आवश्यकता होती है, जो कि ढेर से पॉपुलेटेड होनी चाहिए, अर्थात उन्हें राज्य के पुनर्निवेश की आवश्यकता होती है। यह विशेष रूप से म्यूटेक्स और इस तरह के लिए है। एक बार जो डिस्पोजेबल था वह अब निपटाया नहीं गया है।

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

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

@raphaelcohn

यह वास्तव में लगातार स्मृति बाहर काम करने के लिए जगह नहीं है। उदाहरण के लिए, इंटरफ़ेस के संबंध में आपका एकमात्र विचारधारा नहीं है- उदाहरण के लिए, यह पता चल सकता है कि प्रचलित दृष्टिकोण केवल डेटा अखंडता कारणों के लिए इसे तेज डिस्क की तरह व्यवहार करना है।

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

@rpjohnst

मैं असहमत हूं। यह ठीक उसी तरह का स्थान है जैसा वह है। मैं एक ऐसे निर्णय से बचना चाहता हूं जो एक ऐसा डिज़ाइन बनाता है जो बहुत ही संकीर्ण है और एक साक्ष्य के लिए खोज करता है।

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

जैसा कि इसे प्रोटोटाइप करने के लिए - ठीक है, यह वही है जो मैंने कहा है कि मैंने किया है: -

मैं हाल ही में एक लगातार मेमोरी एलोकेटर (विशेष रूप से, libpmemcto) के लिए रस्ट रैपर पर काम कर रहा हूं।

(आप मेरे टोकरे के शुरुआती दिनों के संस्करण का उपयोग https://crates.io/crates/nvml पर कर सकते हैं। cto_pool मॉड्यूल में स्रोत नियंत्रण में बहुत अधिक प्रयोग है)।

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

वर्तमान इंटरफ़ेस के लिए एक वास्तविक दुनिया के आवंटनकर्ता को फिट करने की कोशिश करने जैसा कुछ भी नहीं है। सच कहूँ, तो Alloc इंटरफ़ेस का उपयोग करने का अनुभव, फिर पूरे Vec नकल करना, फिर इसे ट्विक करना दर्दनाक था। बहुत सारे स्थान मान लेते हैं कि आवंटनकर्ताओं को पास नहीं किया गया है, जैसे Vec::new() ।

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

अच्छी खबर यह है कि https://github.com/rust-lang/rust/issues/32838#issuecomment -358940992 से आपके पहले 3 बुलेट पॉइंट अन्य उपयोग-मामलों द्वारा साझा किए गए हैं।

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

सन 21. जनवरी 2018 को 17:36 पर, जॉनीन सूचनाएँ @ithub.com ने लिखा:

अच्छी खबर # 32838 (टिप्पणी) से आपके पहले 3 बुलेट पॉइंट हैं
https://github.com/rust-lang/rust/issues/32838#issuecomment-358940992
अन्य उपयोग-मामलों द्वारा साझा किए जाते हैं।

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

मैंने जो कुछ लिखा है, उसमें से अधिकांश को मैंने पहले से ही पढ़ने की कोशिश की है, इसलिए यहाँ पहले से ही हो सकता है और इस मामले में मुझे खेद है कि अगर मैं चूक गया, लेकिन यहाँ जाता है:

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

इस स्थिति में नष्ट होने का अर्थ है कि आप आवंटनकर्ता को फिर से शुरू करने की स्थिति में रीसेट कर देते हैं। इन वस्तुओं का कोई भी "विनाश" नहीं है क्योंकि इन वस्तुओं को POD प्रकार का होना है (इस प्रकार कोई भी विनाशकारी निष्पादित नहीं हो रहा है)

मुझे आश्चर्य है कि अगर इस तरह का कुछ रुस्ट में वर्तमान आवंटन डिजाइन के साथ फिट होगा?

(संपादित करें: यह होना चाहिए वस्तुओं का कोई विनाश नहीं है)

@emoon

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

इस स्थिति में नष्ट होने का अर्थ है कि आप आवंटनकर्ता को फिर से शुरू करने की स्थिति में रीसेट कर देते हैं। इन वस्तुओं में "विनाश" होता है क्योंकि इन वस्तुओं को POD प्रकार का होना चाहिए (इस प्रकार कोई भी विनाशकारी निष्पादित नहीं हो रहा है)

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

आप एक कस्टम स्मार्ट पॉइंटर प्रकार का भी उपयोग कर सकते हैं जो Drop लागू नहीं करता है, जिससे बहुत सी चीजें कहीं और आसान हो जाएंगी।

धन्यवाद! मैंने अपने मूल पोस्ट में एक टाइपो बनाया। यह कहना है कि वस्तुओं का विनाश नहीं है ।

उन लोगों के लिए जो आवंटनकर्ताओं में विशेषज्ञ नहीं हैं, और इस सूत्र का पालन नहीं कर सकते, वर्तमान सहमति क्या है: क्या हम stdlib संग्रह प्रकारों के लिए कस्टम आवंटनकर्ताओं का समर्थन करने की योजना बनाते हैं?

@alexreg मुझे यकीन नहीं है कि अंतिम योजना क्या है, लेकिन ऐसा करने में 0 तकनीकी कठिनाइयों की पुष्टि की गई है। OTOH हमारे पास तब अच्छा तरीका नहीं है कि std में प्रकट हो क्योंकि डिफ़ॉल्ट प्रकार के चर संदिग्ध हैं, लेकिन मुझे अभी इसे alloc बनाने की कोई समस्या नहीं है, इसलिए अब हम बिना शर्त के पक्ष में प्रगति कर सकता है।

@Emon2314 ठीक है, सुनकर अच्छा लगा। क्या डिफ़ॉल्ट प्रकार के चर अभी तक लागू किए गए हैं? या RFC स्टेज पर शायद? जैसा कि आप कहते हैं, यदि वे केवल आवंटित / std::heap से संबंधित चीजों तक ही सीमित हैं, तो यह सब ठीक होना चाहिए।

@alexreg देखें https://github.com/rust-lang/rfcs/pull/2321

मुझे सच में लगता है कि AllocErr एरर होना चाहिए। यह एक और मॉड्यूल (जैसे io) के साथ अधिक सुसंगत होगा।

impl Error for AllocError शायद समझ में आता है और चोट नहीं करता है, लेकिन मैंने व्यक्तिगत रूप से Error गुण बेकार पाया है।

मैं आज लेआउट :: From_size_align फ़ंक्शन को देख रहा था, और " align 2 से अधिक नहीं होना चाहिए 31 (यानी 1 << 31 )," सीमा का मेरे लिए कोई मतलब नहीं था। और गिट दोष # 30170 को इंगित किया।

मुझे कहना होगा कि यह एक बहुत ही भ्रामक प्रतिबद्ध संदेश था, जो कि एक u32 में align फिटिंग के बारे में बात कर रहा था, जो केवल आकस्मिक है, जब वास्तविक चीज़ "निश्चित" (अधिक काम किया जाता है) एक सिस्टम एलोकेटर दुर्व्यवहार है।

जो मुझे इस नोट की ओर ले जाता है: "OSX / आवंटन_ सिस्टम भारी संरेखण पर छोटी गाड़ी है" यहां आइटम की जांच नहीं की जानी चाहिए। हालांकि सीधे मुद्दे से निपटा गया है, मुझे नहीं लगता कि यह दीर्घकालिक के लिए ठीक है: क्योंकि सिस्टम आवंटनकर्ता दुर्व्यवहार को व्यवहार करने वाले आवंटन को

@ ग्लैंडियम क्या 4 गीगाबाइट या उससे अधिक के कई से संरेखण का अनुरोध करना उपयोगी है?

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

मैं उन मामलों की कल्पना कर सकता हूं, जहां कोई 4GIB में गठबंधन किए गए 4GiB का आवंटन करना चाहता हो सकता है

वे मामले क्या हैं?

मैं उन मामलों की कल्पना कर सकता हूं, जहां कोई 4GIB में गठबंधन किए गए 4GiB का आवंटन करना चाहता हो सकता है

वे मामले क्या हैं?

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

यहां> 4GiB संरेखण के लिए एक संभावित उपयोग मामला है: एक बड़े पृष्ठ की सीमा के लिए संरेखण। पहले से ही ऐसे प्लेटफ़ॉर्म हैं जो> 4 GiB पृष्ठों का समर्थन करते हैं। यह IBM दस्तावेज़ कहता है "POWER5 + प्रोसेसर चार वर्चुअल मेमोरी पेज साइज़ को सपोर्ट करता है: 4 KB, 64 KB, 16 MB और 16 GB।" यहां तक ​​कि x86-64 भी दूर नहीं है: "विशाल पृष्ठ" आमतौर पर 2 MiB होते हैं, लेकिन यह 1 GiB का भी

Alloc विशेषता में सभी गैर-टाइप किए गए कार्य *mut u8 साथ काम कर रहे हैं। जिसका अर्थ है कि वे अशक्त बिंदुओं को ले या वापस कर सकते हैं, और सभी नरक ढीले हो जाएंगे। क्या उन्हें इसके बजाय NonNull उपयोग करना चाहिए?

कई संकेत हैं कि वे वापस आ सकते हैं, जहां से सभी नरक होंगे
ढीला ब्रेक।
सूर्य पर, मार्च 4, 2018 को 3:56 पूर्वाह्न माइक हॉमेय नोटिफिकेशन @github.com ने लिखा है:

Alloc विशेषता में सभी गैर-टाइप किए गए कार्य * mut u8 के साथ काम कर रहे हैं।
जिसका अर्थ है कि वे अशक्त बिंदुओं को ले या वापस कर सकते हैं, और सभी नरक होंगे
ढीला ब्रेक। क्या उन्हें इसके बजाय नॉनबुल का उपयोग करना चाहिए?

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

NonNull का उपयोग करने के लिए एक अधिक सम्मोहक कारण यह है कि यह Result s को वर्तमान में Alloc विधियों (या Options से वापस लौटा देगा, यदि हम इसमें स्विच करते हैं भविष्य) छोटे होने के लिए।

NonNull का उपयोग करने के लिए एक और सम्मोहक कारण यह है कि यह वर्तमान में Alloc विधियों (या विकल्प, यदि हम भविष्य में उस पर स्विच करते हैं) से छोटे होने की अनुमति देगा।

मुझे नहीं लगता कि ऐसा इसलिए होगा क्योंकि AllocErr के दो संस्करण हैं।

ऐसे कई संकेत हैं कि वे वापस आ सकते थे जिससे सभी नरक ढीले हो जाएंगे।

लेकिन एक अशक्त सूचक स्पष्ट रूप से किसी भी अन्य सूचक की तुलना में अधिक गलत है।

मुझे लगता है कि जंग के प्रकार प्रणाली footguns के साथ मदद करता है, और आक्रमणकारियों को सांकेतिक शब्दों में बदलना करने के लिए उपयोग किया जाता है। alloc लिए दस्तावेज़ीकरण स्पष्ट रूप से कहता है "यदि यह विधि Ok(addr) लौटाती है, तो वापस लौटाया गया गैर-शून्य पता होगा", लेकिन इसका रिटर्न प्रकार नहीं है। जैसा कि चीजें हैं, Ok(malloc(layout.size())) एक वैध कार्यान्वयन होगा, जब यह स्पष्ट रूप से नहीं है।

नोट, गैर-शून्य होने के लिए Layout आकार के बारे में भी नोट हैं, इसलिए मैं यह भी तर्क दूंगा कि इसे नॉनजेरो के रूप में जाना चाहिए।

ऐसा नहीं है क्योंकि वे सभी कार्य स्वाभाविक रूप से असुरक्षित हैं कि हमें कुछ फुटगन की रोकथाम नहीं करनी चाहिए।

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

इसके अलावा, यह संभावना है कि आवंटन कार्यान्वयन केवल NonNull "के अनियंत्रित कंस्ट्रक्टर का उपयोग" प्रदर्शन के लिए "करेंगे: चूंकि एक सही आवंटनकर्ता कभी भी शून्य नहीं लौटेगा, यह NonNell::new(...).unwrap() को छोड़ना चाहेगा। उस मामले में आप वास्तव में किसी भी ठोस फुटगन की रोकथाम नहीं करेंगे, बस अधिक बॉयलरप्लेट। ( Result आकार का लाभ, यदि वास्तविक है, तब भी इसका एक आकर्षक कारण हो सकता है।)

एलोकेशन इंप्लॉइज सिर्फ नॉननुल के अनियंत्रित कंस्ट्रक्टर का उपयोग करेंगे

उनके उपयोगकर्ताओं की मदद करने के लिए आवंटन के कार्यान्वयन में मदद करने के लिए बिंदु कम है। यदि MyVec में NonNull<T> और Heap.alloc() पहले से ही एक NonNull , तो एक कम चेक या असुरक्षित-अनचेक कॉल जिसे मुझे बनाने की आवश्यकता है।

ध्यान दें कि संकेत न केवल रिटर्न प्रकार हैं, वे भी dealloc और realloc जैसे इनपुट प्रकार हैं। क्या उन कार्यों को उनके इनपुट के खिलाफ कठोर माना जाता है जो संभवतः अशक्त हैं या नहीं? दस्तावेज़ कहने के लिए नहीं है, लेकिन प्रकार प्रणाली हाँ कहना होगा।

इसी तरह से लेआउट के साथ काफी। आकार ()। क्या आवंटन कार्य अनुरोधित आकार को किसी तरह से 0 से निपटने के लिए माना जाता है, या नहीं?

(परिणाम आकार लाभ, यदि वास्तविक है, तो अभी भी इसके लिए एक सम्मोहक कारण हो सकता है।)

मुझे संदेह है कि आकार के लाभ हैं, लेकिन # 48741 जैसे कुछ के साथ, कोडजेन लाभ होंगे।

यदि हम API के उपयोगकर्ताओं के लिए अधिक लचीले होने के उस सिद्धांत को जारी रखते हैं, तो पॉइंटर्स को रिटर्न में NonNull होना चाहिए, लेकिन तर्कों में नहीं। (इसका मतलब यह नहीं है कि उन तर्कों को रन-टाइम पर शून्य-जाँच किया जाना चाहिए।)

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

5 मार्च, 2018 8:00 पूर्वाह्न पर, "साइमन सैपिन" सूचनाएं @github.com ने लिखा:

यदि हम API के उपयोगकर्ताओं के लिए अधिक लचीला होने के उस सिद्धांत को जारी रखते हैं,
पॉइंटर्स को रिटर्न टाइप्स में नॉन-नॉन होना चाहिए लेकिन तर्कों में नहीं। (यह
इसका मतलब यह नहीं है कि उन तर्कों को रन-टाइम पर शून्य-जाँच किया जाना चाहिए।]

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

उनके उपयोगकर्ताओं की मदद करने के लिए आवंटन के कार्यान्वयन में मदद करने के लिए बिंदु कम है। यदि MyVec में एक NonNull हैऔर Heap.alloc () पहले से ही एक गैर-रिटर्न देता है, जो कि एक कम जाँच या असुरक्षित-अनियंत्रित कॉल है जिसे मुझे बनाने की आवश्यकता है।

आह यह समझ में आता है। फ़ुटगुन को ठीक नहीं करता है, लेकिन इसके लिए जिम्मेदारी को केंद्रीकृत करता है।

ध्यान दें कि पॉइंटर्स न केवल रिटर्न प्रकार हैं, वे भी उदाहरण के लिए इनपुट प्रकार हैं जैसे डीलॉक और रियललोक। क्या उन कार्यों को उनके इनपुट के खिलाफ कठोर माना जाता है जो संभवतः अशक्त हैं या नहीं? दस्तावेज़ कहने के लिए नहीं है, लेकिन प्रकार प्रणाली हाँ कहना होगा।

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

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

• उन्हें डॉक्स पढ़ने और हमलावरों के बारे में सोचने के लिए याद दिलाना
• सुविधा प्रदान करना ( @SimonSapin का बिंदु wrt आबंटन का वापसी मूल्य)
• कुछ भौतिक लाभ (जैसे, लेआउट अनुकूलन)

मुझे उदाहरण के लिए dealloc NonNull का तर्क देने में कोई मज़बूत फायदा नहीं दिखता। मैं इस एपीआई के उपयोग के लगभग दो वर्ग देखता हूं:

1. अपेक्षाकृत तुच्छ उपयोग, जहां आप alloc , लौटे हुए पॉइंटर को कहीं स्टोर करते हैं, और थोड़ी देर बाद संग्रहीत पॉइंटर को dealloc ।
2. एफएफआई, पॉइंटर अंकगणित आदि से जुड़े जटिल परिदृश्य जहां महत्वपूर्ण तर्क शामिल हैं, यह सुनिश्चित करने के लिए कि आप अंत में dealloc सही चीज पास करते हैं।

मूल रूप से NonNull से केवल पहले प्रकार के उपयोग के मामले में मदद मिलती है, क्योंकि वे NonNull को किसी अच्छी जगह में संग्रहीत करेंगे और इसे NonNull अनवाल्ड में पास करेंगे। सैद्धांतिक रूप से यह कुछ लेखन-त्रुटियों (गुजर रोका जा सकता है foo जब आप मतलब bar ) अगर आपका करतब दिखाने कई संकेत दिए गए और उनमें से केवल एक है NonNull , लेकिन यह प्रतीत नहीं होता बहुत आम या महत्वपूर्ण। dealloc का नुकसान एक कच्चे सूचक को लेने ( alloc NonNull जो @SimonSapin ने मुझे आश्वस्त होना चाहिए था) यह होगा कि इसे as_ptr की आवश्यकता होगी डीललॉक कॉल, जो संभावित रूप से कष्टप्रद है, लेकिन सुरक्षा को प्रभावित नहीं करता है।

दूसरी तरह के उपयोग के मामले में मदद नहीं की जाती है क्योंकि यह पूरी प्रक्रिया के दौरान NonNull का उपयोग करने की संभावना नहीं रख सकता है, इसलिए इसे मैन्युअल रूप से प्राप्त कच्चे सूचक से NonNull फिर से बनाना होगा। जो भी मतलब हो। जैसा कि मैंने पहले तर्क दिया था, यह संभवत: एक वास्तविक रन टाइम चेक के बजाय एक अनियंत्रित / unsafe जोर हो जाएगा, इसलिए कोई फुटगन को रोका नहीं जाता है।

यह कहना नहीं है कि मैं dealloc कच्चे सूचक लेने के पक्ष में हूं। मैं बस किसी भी लाभ का दावा नहीं देख रहा हूँ फुट फुट। प्रकारों की संगति शायद डिफ़ॉल्ट रूप से जीतती है।

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

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

@cramertj हाँ, लेकिन मैं वास्तव में इस तरह के तर्क का आधार नहीं खरीदता। लोग कहते हैं कि Alloc अस्पष्ट, छिपे हुए और बड़े पैमाने पर असुरक्षित उपयोग के मामलों के लिए है। ठीक है, अस्पष्ट, हार्ड-टू-रीड कोड में, मैं जितना संभव हो उतना सुरक्षा करना चाहूंगा --- ठीक है क्योंकि वे शायद ही कभी छुआ हो इसकी संभावना मूल लेखक के आसपास नहीं होगी। इसके विपरीत, यदि कोड को वर्षों बाद पढ़ा जा रहा है, तो egonomics पेंच। कुछ भी हो, यह प्रति-उत्पादक है। कोड को बहुत स्पष्ट होने का प्रयास करना चाहिए ताकि एक अपरिचित पाठक बेहतर समझ सके कि पृथ्वी क्या चल रही है। कम शोर <स्पष्ट हमलावर।

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

यह बस एक समन्वय विफलता है, न कि तकनीकी अनिवार्यता। यकीन है, अभी कई असुरक्षित एपीआई कच्चे संकेत का उपयोग कर सकते हैं। तो कुछ को NonNull या अन्य रैपर का उपयोग करके एक बेहतर इंटरफ़ेस पर स्विच करने के तरीके का नेतृत्व करना है। फिर अन्य कोड अधिक आसानी से सूट का पालन कर सकते हैं। ग्रीनफील्ड में हार्ड-टू-रीड, अनइनफॉर्मेटिव रॉ-पॉइंटर्स, ऑल-रस्ट, असुरक्षित कोड पर लगातार गिरावट का मुझे 0 कारण दिखाई देता है।

नमस्ते!

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

इसके अलावा, मैं यह बताना चाहता हूं कि

मैं @232314 और अन्य लोगों के लिए बहुत अधिक प्रतिक्रिया लिख ​​सकता हूं, लेकिन यह जल्दी से एक बहुत ही अलग और दार्शनिक बहस बन रहा है, इसलिए मैं इसे छोटा कर रहा हूं। मैं इस बात के खिलाफ बहस कर रहा था कि मेरा मानना ​​है कि इस तरह के एपीआई में NonNull के सुरक्षा लाभों का ओवर-स्टेटमेंट है (निश्चित रूप से अन्य लाभ हैं)। यह कहना है कि कोई सुरक्षा लाभ नहीं हैं, लेकिन @cramertj ने कहा, व्यापार में NonNull का उपयोग करने की ओर झुकता हूं - इस कारण से @SimonSapin ने alloc , dealloc में स्थिरता के लिए दिया। तो चलो ऐसा करते हैं और किसी भी अधिक स्पर्शरेखा पर नहीं जाते हैं।

यदि कुछ NonNull उपयोग-मामले हैं जो हर किसी के साथ बोर्ड पर हैं, तो यह एक शानदार शुरुआत है।

हम शायद Unique और दोस्तों को NonNull बजाय NonZero करने के लिए कम से कम liballoc कम के भीतर घर्षण बनाए रखने के लिए अपडेट करना चाहते हैं। लेकिन यह कुछ ऐसा दिखता है जैसे हम पहले से ही आवंटनकर्ता के स्तर पर एक एब्स्ट्रैक्शन स्तर पर कर रहे हैं, और मैं एलोकेटर स्तर पर ऐसा नहीं करने के लिए किसी भी कारण के बारे में नहीं सोच सकता। मेरे लिए एक उचित बदलाव की तरह लग रहा है।

( From विशेषता के पहले से ही दो कार्यान्वयन हैं जो Unique<T> और NonNull<T> बीच सुरक्षित रूप से परिवर्तित होते हैं।)

यह देखते हुए कि मुझे स्थिर जंग में आवंटन एपीआई की तरह बहुत कुछ चाहिए, मैंने जंग रेपो से कोड निकाला और एक अलग टोकरा में डाल दिया:

• https://crates.io/crates/allocator_api
• https://github.com/glandium/allocator_api

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

[बंद विषय] हाँ, यह अच्छा होगा यदि std उस तरह से पेड़ के स्थिर कोड बक्से का उपयोग कर सके, ताकि हम स्थिर कोड में अस्थिर इंटरफेस के साथ प्रयोग कर सकें। यह एक कारण है जो मुझे std एक मुखौटा के रूप में पसंद है।

std crates.io से एक टोकरा की एक प्रति पर निर्भर हो सकता है, लेकिन अगर आपका कार्यक्रम भी उसी टोकरे पर निर्भर करता है तो यह वैसे ही "crate / type / traits" की तरह दिखाई नहीं देगा, इसलिए मैं डॉन यह कैसे मदद करेगा देखें। वैसे भी, चाहे कोई भी पहलू हो, स्थिर सुविधाओं को स्थिर चैनल पर अनुपलब्ध बनाना एक बहुत ही जानबूझकर पसंद है, दुर्घटना नहीं।

ऐसा लगता है कि हमारे पास नॉनन्यूअल का उपयोग करके कुछ समझौते हैं। वास्तव में ऐसा होने के लिए आगे क्या रास्ता है? बस एक पीआर यह कर रहा है? एक आरएफसी

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

उदाहरण:

pub fn bar() -> Box<[u8]> {
    vec![0; 42].into_boxed_slice()
}

pub fn qux() -> Box<[u8]> {
    Box::new([0; 42])
}

के लिए संकलन:

example::bar:
  sub rsp, 56
  lea rdx, [rsp + 8]
  mov edi, 42
  mov esi, 1
  call __rust_alloc_zeroed<strong i="11">@PLT</strong>
  test rax, rax
  je .LBB1_1
  mov edx, 42
  add rsp, 56
  ret
.LBB1_1:
  mov rax, qword ptr [rsp + 8]
  movups xmm0, xmmword ptr [rsp + 16]
  movaps xmmword ptr [rsp + 32], xmm0
  mov qword ptr [rsp + 8], rax
  movaps xmm0, xmmword ptr [rsp + 32]
  movups xmmword ptr [rsp + 16], xmm0
  lea rdi, [rsp + 8]
  call __rust_oom<strong i="12">@PLT</strong>
  ud2

example::qux:
  sub rsp, 104
  xorps xmm0, xmm0
  movups xmmword ptr [rsp + 58], xmm0
  movaps xmmword ptr [rsp + 48], xmm0
  movaps xmmword ptr [rsp + 32], xmm0
  lea rdx, [rsp + 8]
  mov edi, 42
  mov esi, 1
  call __rust_alloc<strong i="13">@PLT</strong>
  test rax, rax
  je .LBB2_1
  movups xmm0, xmmword ptr [rsp + 58]
  movups xmmword ptr [rax + 26], xmm0
  movaps xmm0, xmmword ptr [rsp + 32]
  movaps xmm1, xmmword ptr [rsp + 48]
  movups xmmword ptr [rax + 16], xmm1
  movups xmmword ptr [rax], xmm0
  mov edx, 42
  add rsp, 104
  ret
.LBB2_1:
  movups xmm0, xmmword ptr [rsp + 16]
  movaps xmmword ptr [rsp + 80], xmm0
  movaps xmm0, xmmword ptr [rsp + 80]
  movups xmmword ptr [rsp + 16], xmm0
  lea rdi, [rsp + 8]
  call __rust_oom<strong i="14">@PLT</strong>
  ud2

बक्से बनाने वाली किसी भी जगह को जोड़ने के लिए यह एक बड़ी मात्रा में कोड है। 1.19 के साथ तुलना करें, जिनके पास आवंटनकर्ता नहीं है:

example::bar:
  push rax
  mov edi, 42
  mov esi, 1
  call __rust_allocate_zeroed<strong i="18">@PLT</strong>
  test rax, rax
  je .LBB1_2
  mov edx, 42
  pop rcx
  ret
.LBB1_2:
  call alloc::oom::oom<strong i="19">@PLT</strong>

example::qux:
  sub rsp, 56
  xorps xmm0, xmm0
  movups xmmword ptr [rsp + 26], xmm0
  movaps xmmword ptr [rsp + 16], xmm0
  movaps xmmword ptr [rsp], xmm0
  mov edi, 42
  mov esi, 1
  call __rust_allocate<strong i="20">@PLT</strong>
  test rax, rax
  je .LBB2_2
  movups xmm0, xmmword ptr [rsp + 26]
  movups xmmword ptr [rax + 26], xmm0
  movaps xmm0, xmmword ptr [rsp]
  movaps xmm1, xmmword ptr [rsp + 16]
  movups xmmword ptr [rax + 16], xmm1
  movups xmmword ptr [rax], xmm0
  mov edx, 42
  add rsp, 56
  ret
.LBB2_2:
  call alloc::oom::oom<strong i="21">@PLT</strong>

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

नवीनतम फ़ायरफ़ॉक्स में 1439 __rust_oom कॉल हैं। फ़ायरफ़ॉक्स जंग के आवंटन का उपयोग नहीं करता है, हालांकि, इसलिए हमें मॉलॉक / कॉलोक के लिए सीधे कॉल मिलते हैं, इसके बाद एक शून्य जांच होती है कि ऑम तैयारी कोड में कूदता है, जो आमतौर पर दो movq और एक अक्षर होता है, जो AllocErr को भरता है और अपना पता प्राप्त करता है। इसे पास करने के लिए __rust__oom । यह सबसे अच्छा मामला है, अनिवार्य रूप से, लेकिन यह अभी भी 20 चाल की मशीन कोड के लिए दो movq और lea है।

यह मैं ripgrep को देखता हूं, 85 हैं, और वे सभी समान _ZN61_$LT$alloc..heap..Heap$u20$as$u20$alloc..allocator..Alloc$GT$3oom17h53c76bda5 0c6b65aE.llvm.nnnnnnnnnnnnnnn कार्यों में हैं। वे सभी 16 बाइट्स लंबी हैं। उन आवरण कार्यों के लिए 685 कॉल हैं, जिनमें से अधिकांश कोड से पहले के समान हैं जो मैंने https://github.com/rust-lang/rust/issues/32838#issuecomment -377097485 पर चिपकाए हैं।

@ नोक्स आज mergefunc llvm पास को सक्षम करने के लिए देख रहा था, मुझे आश्चर्य है कि अगर यहां कोई फर्क पड़ता है।

mergefunc जाहिरा तौर पर कई समान _ZN61_$LT$alloc..heap..Heap$u20$as$u20$alloc..allocator..Alloc$GT$3oom17h53c76bda5 0c6b65aE.llvm.nnnnnnnnnnnnnnn कार्यों से छुटकारा नहीं मिलता है ( -C passes=mergefunc RUSTFLAGS )।

लेकिन क्या एक बड़ा फर्क नहीं पड़ता LTO है, जो वास्तव में क्या फ़ायरफ़ॉक्स कॉल malloc सीधे बनाता है, के निर्माण छोड़ने है AllocErr कॉल करने से पहले सही करने के लिए __rust_oom । यही कारण है कि यह भी के निर्माण में आता है Layout संभाजक बुला, यह जब भरने के लिए रवाना होने से पहले अनावश्यक AllocErr ।

इससे मुझे लगता है कि आवंटन कार्यों को छोड़कर, __rust_oom को संभवतः इनलाइन के रूप में चिह्नित किया जाना चाहिए।

Btw, Firefox के लिए तैयार किए गए कोड को देखा है, मैं इसे आदर्श उपयोग करने के लिए वांछनीय होगा सोच रहा हूँ moz_xmalloc के बजाय malloc । यह एलोकेटर लक्षणों के संयोजन के बिना संभव नहीं है और वैश्विक हीप एलोकेटर को बदलने में सक्षम है, लेकिन एलोकेटर विशेषता के लिए एक कस्टम त्रुटि प्रकार की संभावित आवश्यकता को लाता है: moz_xmalloc अचूक है और कभी भी मामले में वापस नहीं आता है। विफलता। IOW, यह OOM खुद को संभालता है, और जंग कोड को उस मामले में __rust_oom कॉल करने की आवश्यकता नहीं होगी। जो इसे संभाजक कार्यों के लिए वांछनीय वैकल्पिक रूप से वापस जाने के लिए होगा ! के बजाय AllocErr ।

हमने AllocErr एक शून्य-आकार की संरचना बनाने पर चर्चा की है, जो यहां भी मदद कर सकती है। सूचक के साथ NonNull , संपूर्ण वापसी मान सूचक-आकार का हो सकता है।

https://github.com/rust-lang/rust/pull/49669 वैश्विक आवंटनकर्ताओं को कवर करने वाले सबसेट को स्थिर करने के लक्ष्य के साथ, इन एपीआई में कई बदलाव करता है। उस सबसेट के लिए ट्रैकिंग मुद्दा: https://github.com/rust-lang/rust/issues/49668। विशेष रूप से, एक नया GlobalAlloc विशेषता पेश की जाती है।

क्या यह पीआर हमें Vec::new_with_alloc(alloc) जैसी चीजें करने की अनुमति देगा जहां alloc: Alloc जल्द ही?

@alexreg नं

@sfackler हम्म, क्यों नहीं? ऐसा करने से पहले हमें क्या चाहिए? मुझे वास्तव में इस पीआर की बात नहीं आती अन्यथा, जब तक कि यह वैश्विक आवंटनकर्ता को बदलने के लिए नहीं है।

@alexreg

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

मुझे लगता है कि यह वैश्विक आवंटनकर्ता को बदलने के लिए है।

@alexreg का मतलब अगर आप स्थिर हैं, तो कई तरह के अनसुलझे सवाल हैं, जिन्हें हम स्थिर करने के लिए तैयार नहीं हैं। रात में, यह RawVec द्वारा समर्थित है और शायद #[unstable] लिए Vec जो कि उस तरह से काम करने का मन करता है के लिए जोड़ने के लिए ठीक है।

और हाँ, जैसा कि पीआर में उल्लेख किया गया है, इसका मतलब है कि वैश्विक आवंटनकर्ता को बदलने की अनुमति है, या Vec::with_capacity पालन ​​किए बिना (एक कस्टम संग्रह प्रकार में) आवंटित करना।

FWIW, https://github.com/rust-lang/rust/issues/32838#issuecomment -376793369 में उल्लिखित allocator_api टोकरा RawVec<T, A> और Box<T, A> शाखा (अभी तक जारी नहीं)। मैं इसे एक इनक्यूबेटर के रूप में सोच रहा हूं कि आवंटन प्रकार से अधिक संग्रह क्या दिख सकता है (प्लस तथ्य यह है कि मुझे स्थिर रस्ट के लिए Box<T, A> प्रकार की आवश्यकता है)। मैंने अभी तक Vec<T, A> जोड़ने के लिए vec.rs को पोर्ट करना शुरू नहीं किया है, लेकिन PRs का स्वागत है। vers। बड़ा है।

मैं ध्यान देता हूं कि https://github.com/rust-lang/rust/issues/32838#issuecomment -377097485 में उल्लिखित कोडजेन "मुद्दों" को # 49669 में हुए बदलावों के साथ जाना चाहिए।

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

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

@cramertj @SimonSapin @glandium ठीक है, स्पष्ट करने के लिए धन्यवाद। मैं सिर्फ कुछ अन्य संग्रह-प्रधान प्रकारों के लिए पीआर प्रस्तुत कर सकता हूं। क्या यह आपके आवंटनकर्ता-एपीओ रेपो / टोकरा,

@alexreg Alloc 49669 में Alloc विशेषता के लिए ब्रेकिंग परिवर्तनों की मात्रा पर विचार करते हुए, शायद पहले विलय करने के लिए इंतजार करना बेहतर है।

@ ग्लैंडियम मेला पर्याप्त यह लैंडिंग से बहुत दूर नहीं लगता https://github.com/pnkfelix/collections-prime repo पर भी ध्यान दिया ... आपके संबंध में ऐसा क्या है?

मैं एक और खुला प्रश्न जोड़ूंगा:

• क्या Alloc::oom को आतंकित करने की अनुमति है? वर्तमान में डॉक्स का कहना है कि इस विधि से प्रक्रिया निरस्त होनी चाहिए। यह कोड के लिए निहितार्थ है जो आवंटनकर्ताओं का उपयोग करता है क्योंकि उन्हें तब मेमोरी को लीक किए बिना अनइंडिंग को ठीक से संभालने के लिए डिज़ाइन किया जाना चाहिए।

मुझे लगता है कि हमें एक स्थानीय आवंटनकर्ता में विफलता के बाद से घबराहट की अनुमति देनी चाहिए, जरूरी नहीं कि वैश्विक आवंटनकर्ता भी विफल हो जाए। सबसे खराब स्थिति में, वैश्विक आवंटनकर्ता के oom को बुलाया जाएगा जो प्रक्रिया को समाप्त कर देगा (ऐसा करने से मौजूदा कोड टूट जाएगा)।

@alexreg यह नहीं है। यह सिर्फ लगता है कि एसटीडी / आवंटन / संग्रह में क्या है की एक सादी प्रति। खैर, इसकी दो साल पुरानी कॉपी। मेरा टोकरा बहुत अधिक दायरे में सीमित है (प्रकाशित संस्करण में कुछ हफ्तों पहले तक Alloc गुण है, मास्टर शाखा में केवल RawVec और Box शीर्ष पर है वह), और मेरा एक लक्ष्य यह है कि इसे स्थिर जंग के साथ बनाए रखा जाए।

@glandium , निष्पक्ष?

@alexreg समझ में आता है। आप / उस पर अभी काम करना शुरू कर सकते हैं, लेकिन इससे आपके पीआर में चीजों को बदलने पर / जब आपके बाइक्स को बदलने की संभावना होगी, तो आपके अंत पर कुछ मंथन होगा।

@ ग्लैंडियम ने मुझे अभी तक

क्या Alloc :: oom को घबराने की अनुमति है? वर्तमान में डॉक्स का कहना है कि इस विधि से प्रक्रिया निरस्त होनी चाहिए। यह कोड के लिए निहितार्थ है जो आवंटनकर्ताओं का उपयोग करता है क्योंकि उन्हें तब मेमोरी को लीक किए बिना अनइंडिंग को ठीक से संभालने के लिए डिज़ाइन किया जाना चाहिए।

@Amanieu इस RFC का विलय कर दिया गया: https://github.com/rust-lang/rfcs/pull/2116 डॉक्स और कार्यान्वयन अभी तक अपडेट नहीं किए गए हैं।

एपीआई में एक बदलाव है जिसे मैं एक पीआर के लिए प्रस्तुत करने पर विचार कर रहा हूं:

दो भागों में Alloc विशेषता विभाजित करें: "कार्यान्वयन" और "सहायक"। पूर्व में alloc , dealloc , realloc , आदि और बाद के कार्य होंगे, alloc_one , dealloc_one , alloc_array , आदि जबकि बाद के लिए कस्टम कार्यान्वयन करने में सक्षम होने से कुछ काल्पनिक लाभ हैं, यह सबसे आम जरूरत से दूर है, और जब आपको जेनेरिक रैपर लागू करने की आवश्यकता होती है (जो मैंने अविश्वसनीय रूप से सामान्य पाया है, उस बिंदु पर जो मैंने वास्तव में उस के लिए एक कस्टम व्युत्पन्न लिखना शुरू किया है), आपको अभी भी उन सभी को लागू करने की आवश्यकता है, क्योंकि रैप्पी उन्हें अनुकूलित कर सकता है।

OTOH, यदि Alloc विशेषता कार्यान्वयनकर्ता जैसे alloc_one में फैंसी चीजें करने का प्रयास करते हैं, तो वे इस बात की गारंटी नहीं देते हैं कि उस आवंटन के लिए dealloc_one का आह्वान किया जाएगा। इसके कई कारण हैं:

• सहायकों का उपयोग लगातार नहीं किया जाता है। बस एक उदाहरण, raw_vec alloc_array , alloc / alloc_zeroed का उपयोग करता है, लेकिन केवल dealloc का उपयोग करता है।
• यहाँ तक कि alloc_array / dealloc_array लगातार उपयोग के साथ, एक अभी भी सुरक्षित रूप से Vec को Box परिवर्तित कर सकता है, जो तब dealloc उपयोग करेगा
• इसके बाद एपीआई के कुछ हिस्से हैं जो मौजूद नहीं हैं ( alloc_one / alloc_array कोई शून्य संस्करण) नहीं

इसलिए, उदाहरण के लिए, alloc_one (और वास्तव में, मैं mozjemalloc के लिए इस तरह की जरूरत है) के विशेषज्ञता के लिए वास्तविक उपयोग के मामले हैं, एक बजाय एक विशेष आवंटन का उपयोग कर बेहतर है।

वास्तव में, यह उससे भी बदतर है, जंग के रेपो में, alloc_array का एक उपयोग होता है, और alloc_one , dealloc_one , realloc_array , dealloc_array । यहां तक ​​कि बॉक्स सिंटैक्स alloc_one का उपयोग नहीं करता है, यह exchange_malloc का उपयोग करता है, जो size और align लेता है। इसलिए उन कार्यों को लागू करने वालों की तुलना में ग्राहकों के लिए एक सुविधा के रूप में अधिक माना जाता है।

impl<A: Alloc> AllocHelpers for A (या AllocExt , जो भी नाम चुना जाता है) जैसी चीज़ों के साथ, हम अभी भी ग्राहकों के लिए उन कार्यों की सुविधा प्राप्त करेंगे, जबकि कार्यान्वयनकर्ताओं को पैर में खुद को गोली मारने की अनुमति नहीं देते यदि वे सोचते हैं वे उन्हें ओवरराइड करके (और प्रॉक्सी आवंटन लागू करने वाले लोगों पर आसान बनाकर) फैंसी चीजें करेंगे।

एपीआई में एक बदलाव है जिसे मैं पीआर के लिए प्रस्तुत करने पर विचार कर रहा हूं

# 50436 में ऐसा किया

@glandium

(और तथ्य की बात के रूप में, मुझे mozjemalloc की इतनी आवश्यकता है),

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

mozjemalloc का एक बेस एलोकेटर है जो उद्देश्यपूर्ण रूप से लीक करता है। एक प्रकार की वस्तुओं को छोड़कर, जहाँ यह एक निःशुल्क सूची रखता है। मैं alloc_one साथ ट्रिक करने के बजाए एलोकेटर को लेट कर ऐसा कर सकता हूं।

क्या यह उस सटीक संरेखण से निपटने के लिए आवश्यक है जिसे आपने आवंटित किया था?

बस यह पुष्ट करने के लिए कि इस प्रश्न का उत्तर हां है , मेरे पास स्वयं Microsoft का यह प्यारा उद्धरण है:

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

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

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

यह शर्म की बात है, लेकिन यह जिस तरह से है। चलो फिर overaligned वैक्टर पर छोड़ दें। : भ्रमित:

चलो फिर overaligned वैक्टर पर छोड़ दें

ऐसा कैसे? आपको केवल Vec<T, OverAlignedAlloc<U16>> जो ओवरलैग्नमेंट के साथ आवंटित और डील करता है।

ऐसा कैसे? आपको केवल Vec<T, OverAlignedAlloc<U16>> जो ओवरलैग्नमेंट के साथ आवंटित और डील करता है।

मुझे और अधिक विशिष्ट होना चाहिए। मेरा मतलब था कि आपके नियंत्रण के बाहर एक एपीआई में ओवरलेग किए गए वैक्टर चलते हैं, यानी एक Vec<T> और Vec<T, OverAlignedAlloc<U16>> । (उदाहरण के लिए CString::new() ।)

आपको बल्कि उपयोग करना चाहिए

#[repr(align(16))]
struct OverAligned16<T>(T);

और फिर Vec<OverAligned16<T>> ।

आपको बल्कि उपयोग करना चाहिए

वह निर्भर करता है। मान लें कि आप f32 s के वेक्टर पर AVX आंतरिक (256 बिट वाइड, 32-बाइट संरेखण आवश्यकता) का उपयोग करना चाहते हैं:

• Vec<T, OverAlignedAlloc<U32>> समस्या हल करती है, कोई AVX आंतरिक तत्वों का सीधे वेक्टर तत्वों (विशेष रूप से, मेमोरी लोड्स) पर उपयोग कर सकता है, और वेक्टर अभी भी &[f32] स्लाइस में डीरेफ़्स का उपयोग करने के लिए इसे मिटा देता है।
• Vec<OverAligned32<f32>> वास्तव में समस्या का समाधान नहीं करता है। प्रत्येक f32 संरेखण आवश्यकता के कारण अंतरिक्ष के 32 बाइट्स लेता है। पेश किए गए पैडिंग f32 s के बाद से AVX संचालन के प्रत्यक्ष उपयोग को रोकता है, निरंतर मेमोरी पर किसी भी अधिक नहीं है। और मैं व्यक्तिगत रूप से निपटने के लिए &[OverAligned32<f32>] थोड़ा थकाऊ के लिए deref लगता है।

एक Box , Box<T, OverAligned<U32>> Box<OverAligned32<T>> में एक तत्व के लिए, दोनों दृष्टिकोण अधिक समान हैं, और दूसरा दृष्टिकोण वास्तव में बेहतर हो सकता है। किसी भी मामले में दोनों विकल्पों के लिए अच्छा है।

Alloc trait में इस wrt बदलाव को पोस्ट करें: https://internals.rust-lang.org/t/pre-rfc-changing-the-alloc-trait/7487

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

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

अलग-अलग चैनलों (rfc रेपो, जंग-लैंग ट्रैकिंग समस्या, वैश्विक आबंटित PFC, आंतरिक पोस्ट, कई) पर हज़ारों कमेंटों का उद्घोष करते हुए "मूल रात्रिकाल में क्या लागू किया गया है" से "क्या वर्तमान में लागू किया गया है" से भिन्न के कई सूत्र हैं। विशाल पीआरएस, आदि), और GlobalAlloc RFC में क्या स्थिर किया जा रहा है, मूल RFC में जो प्रस्तावित किया गया था, उससे बहुत अधिक नहीं दिखता है।

यह कुछ ऐसा है जिसे डॉक्स और संदर्भ को अपडेट करने के लिए हमें किसी भी तरह की आवश्यकता है, और वर्तमान चर्चाओं में भी सहायक होगी।

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

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

हाँ बिल्कुल। विशेष रूप से Box , क्योंकि हम अभी तक Box<T, A> दो शब्द लेने से बचने के लिए नहीं जानते हैं।

हाँ बिल्कुल। विशेष रूप से बॉक्स, क्योंकि हम अभी तक नहीं जानते कि बॉक्स रखने से कैसे बचेंदो शब्द उठाएं।

मुझे नहीं लगता कि हमें प्रारंभिक कार्यान्वयन के लिए Box<T, A> के आकार की चिंता करनी चाहिए, लेकिन यह एक ऐसी चीज है जिसे बाद में DeAlloc विशेषता जोड़कर पिछड़े-संगत तरीके से जोड़ा जा सकता है जो केवल समर्थन करता है आवंटन रद्द करने।

उदाहरण:

trait DeAlloc {
    fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout);
}

trait Alloc {
    // In addition to the existing trait items
    type DeAlloc: DeAlloc = Self;
    fn into_dealloc(self) -> Self::DeAlloc {
        self
    }
}

impl<T: Alloc> DeAlloc for T {
    fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout) {
        Alloc::dealloc(self, ptr, layout);
    }
}

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

मुझे लगता है कि @SON2314 इस पर काम कर रहा है, प्रति https://github.com/rust-lang/rust/issues/42774 पर। उससे अपडेट लेना अच्छा रहेगा।

मुझे नहीं लगता कि हमें प्रारंभिक कार्यान्वयन के लिए Box<T, A> के आकार की चिंता करनी चाहिए, लेकिन यह एक ऐसी चीज है जिसे बाद में DeAlloc विशेषता जोड़कर पिछड़े-संगत तरीके से जोड़ा जा सकता है जो केवल समर्थन करता है आवंटन रद्द करने।

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

@joshlf इस तथ्य को ध्यान में रखते हुए कि Box<T, A> का उपयोग केवल तब ही किया जाता है जब इसे गिरा दिया जाता है, यह सबसे अच्छी बात है कि हम केवल सुरक्षित कोड के साथ ही कर सकते हैं। इस तरह का एक पैटर्न अखाड़े की तरह के आवंटनकर्ताओं के लिए उपयोगी हो सकता है, जिनके पास नॉन-ऑप dealloc और जब एलोकेटर गिरा दिया जाता है तो बस मुफ्त मेमोरी।

अधिक जटिल प्रणालियों के लिए जहां आवंटन कंटेनर के स्वामित्व में है (जैसे LinkedList ) और कई आवंटन प्रबंधित, मुझे उम्मीद है कि Box का आंतरिक रूप से उपयोग नहीं किया जाएगा। इसके बजाय, LinkedList इंटर्नल कच्चे पॉइंटर्स का उपयोग करेंगे, जो Alloc LinkedList ऑब्जेक्ट में निहित Alloc उदाहरण के साथ आवंटित और मुक्त किए गए हैं। यह हर पॉइंटर के आकार को दोगुना करने से बचाएगा।

इस तथ्य को ध्यान में रखते हुए कि Box<T, A> का उपयोग केवल तब ही किया जाता है जब इसे गिरा दिया जाता है, यह सबसे अच्छी बात है कि हम केवल सुरक्षित कोड के साथ कर सकते हैं। इस तरह का एक पैटर्न अखाड़े की तरह के आवंटनकर्ताओं के लिए उपयोगी हो सकता है, जिनके पास नॉन-ऑप dealloc और जब एलोकेटर गिरा दिया जाता है तो बस मुफ्त मेमोरी।

ठीक है, लेकिन Box को पता नहीं है कि dealloc नो-ऑप है।

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

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

सही है, लेकिन बॉक्स को पता नहीं है कि डीलॉक नो-ऑप है।

C ++ unique_ptr क्या करता है?
वह है: यदि "स्टेटफुल" है, तो एलोकेटर के लिए पॉइंटर को स्टोर करना है और अगर एलोकेटर "बेकार" है तो इसे स्टोर न करें
(उदा। वैश्विक रैपर लगभग malloc या mmap )।
इसके लिए वर्तमान Alloc चिह्न दो लक्षणों में विभाजित करना होगा: StatefulAlloc और StatelessAlloc ।
मुझे एहसास है कि यह एक बहुत ही अशिष्ट और असभ्य है (और शायद किसी ने पहले से ही इसे पिछले चर्चाओं में प्रस्तावित किया है)।
अपनी अकुशलता के बावजूद यह समाधान सरल और पिछड़ा संगत है (प्रदर्शन दंड के बिना)।

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

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

तो नोड-आधारित कंटेनरों के कार्यान्वयन में unsafe का सहारा लेना एक आवश्यक बुराई हो सकता है, कम से कम अल्पकालिक परिप्रेक्ष्य में।

@eucpp ध्यान दें कि unique_ptr एक एलोकेटर को स्टोर नहीं करता है - यह एक Deleter स्टोर करता है:

प्रकार्य के लिए एक फ़ंक्शन के साथ कॉल करने योग्य फ़ंक्शन:: pointer`

मैं इसे लगभग Alloc और Dealloc लक्षण प्रदान करते हुए देखता हूँ।

@cramertj हाँ, आप सही हैं। फिर भी, दो लक्षणों की आवश्यकता होती है - स्टेटफुल और स्टेटलेस Dealloc ।

एक ZST Dealloc पर्याप्त नहीं होगा?

Tue पर, Jun 12, 2018 को 3:08 अपराह्न बजे। एवगेनियन मोइज़ेंको सूचनाएं @github.com
लिखा था:

@cramertj https://github.com/cramertj हाँ, आप सही हैं। फिर भी, दो
लक्षण की आवश्यकता होती है - स्टेटफुल और स्टेटलेस डीललोक।

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

एक ZST Dealloc पर्याप्त नहीं होगा?

@ सुप्रीम मुझे लगता है कि यह होगा :)

मुझे नहीं पता था कि जंग संकलक बॉक्स से बाहर ZST का समर्थन करता है।
C ++ में खाली आधार अनुकूलन के आसपास कम से कम कुछ ट्रिक्स की आवश्यकता होगी।
मैं बहुत स्पष्ट कुछ गलतियों के लिए खेद है रस्ट पर नया हूँ।

मुझे नहीं लगता कि हमें स्टेटफुल बनाम स्टेटलेस के लिए अलग लक्षण चाहिए।

Box A प्रकार के पैरामीटर के साथ संवर्धित होने के कारण, इसमें A सीधे होगा, न कि A लिए संदर्भ या सूचक। यह प्रकार एक स्टेटलेस (डी) आवंटनकर्ता के लिए शून्य-आकार का हो सकता है। या A अपने आप में एक संदर्भ या हैंडल की तरह हो सकता है जो एक आवंटित आवंटन के साथ हो सकता है जिसे कई आवंटित वस्तुओं के बीच साझा किया जा सकता है। इसलिए impl Alloc for MyAllocator बजाय, आप impl<'r> Alloc for &'r MyAllocator जैसा कुछ करना चाह सकते हैं

वैसे, एक Box जो केवल डील डील करना जानता है और न कि कैसे आवंटित करना है Clone लागू नहीं होगा।

@SimonSapin मुझे उम्मीद है कि Clone ing को फिर से एक एलोकेटर निर्दिष्ट करने की आवश्यकता होगी, उसी तरह से एक नया Box होगा (अर्थात, यह Clone का उपयोग करके नहीं किया जाएगा)

@cramertj Vec और अन्य कंटेनरों की तुलना में असंगत नहीं होगा जो Clone लागू करते हैं?
Alloc Box बजाय Dealloc Alloc अंदर के इंस्टेंस के डाउनसाइड क्या हैं?
तब Box Clone और clone_with_alloc ।

मुझे नहीं लगता है कि विभाजन के लक्षण वास्तव में क्लोन को एक विशाल तरीके से प्रभावित करते हैं - यह सिर्फ impl<T, A> Clone for Box<T, A> where A: Alloc + Dealloc + Clone { ... } ।

@sfackler मैं उस निहितार्थ का विरोध नहीं करूंगा, लेकिन मुझे एक clone_into या कुछ ऐसा भी मिलेगा जो किसी प्रदत्त आवंटनकर्ता का उपयोग करता है।

यह एक करने के लिए फ़ायदेमंद होगा alloc_copy करने के लिए विधि Alloc ? इसका उपयोग बड़े आवंटन के लिए तेजी से मेम्ची ( Copy/Clone ) कार्यान्वयन प्रदान करने के लिए किया जा सकता है, जैसे पृष्ठों के कॉपी-ऑन-राइट क्लोन करके।

यह बहुत अच्छा होगा, और इसके लिए एक डिफ़ॉल्ट कार्यान्वयन प्रदान करने के लिए तुच्छ होगा।

ऐसे alloc_copy फ़ंक्शन का उपयोग क्या होगा? impl Clone for Box<T, A> ?

हाँ, Vec लिए डिट्टो।

इसे देखने के बाद कुछ और ऐसा लगता है जैसे हैक और असंभव के बीच समान प्रक्रिया सीमा के भीतर कॉपी-ऑन-राइट पेज बनाने के लिए दृष्टिकोण, कम से कम यदि आप इसे एक से अधिक स्तर की गहराई से करना चाहते हैं। तो alloc_copy एक बड़ा लाभ नहीं होगा।

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

इसके बजाय एक अधिक सामान्य एस्केप हैच जो भविष्य की आभासी मेमोरी की अनुमति देता है

मेमोरी एलोकेटर्स (मॉलॉक, जेमालॉक, ...) आम तौर पर आपको उनसे किसी भी तरह की मेमोरी को चोरी करने की अनुमति नहीं देते हैं, और वे आम तौर पर आपको क्वेरी या बदलने नहीं देते हैं कि वे मेमोरी के गुणों को क्या कहते हैं। तो इस सामान्य बचने वाली हैच का मेमोरी एलोकेटर से क्या लेना-देना है?

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

आप सही हे। इस तरह का कोई भी उपयोग-मामला (मैं ज्यादातर प्लेटफ़ॉर्म-विशिष्ट ऑप्टिमाइज़ेशन के बारे में सोच रहा था) पहली जगह में कस्टम एलोकेटर का उपयोग करके संभवतः सबसे अच्छा काम करता है।

अपनी CppCon प्रस्तुति में आंद्रेई अलेक्जेंड्रेस्कु द्वारा वर्णित समग्र एलोकेटर एपीआई पर कोई विचार? वीडियो यहां YouTube पर उपलब्ध है: https://www.youtube.com/watch?v=LIb3L4vKZ7U (वह 26:00 के आसपास अपने प्रस्तावित डिज़ाइन का वर्णन करना शुरू कर देता है, लेकिन बात इतनी मनोरंजक है कि आप इसे देखना पसंद कर सकते हैं) ।

ऐसा लगता है कि यह सब अपरिहार्य निष्कर्ष है कि संग्रह पुस्तकालयों को सामान्य WRT आवंटन होना चाहिए, और एप्लिकेशन प्रोग्रामर को स्वयं निर्माण स्थल पर आवंटितकर्ताओं और संग्रह को स्वतंत्र रूप से बनाने में सक्षम होना चाहिए।

अपनी CppCon प्रस्तुति में आंद्रेई अलेक्जेंड्रेस्कु द्वारा वर्णित समग्र एलोकेटर एपीआई पर कोई विचार?

वर्तमान Alloc API कंपैक्टेबल एलोकैटर लिखने की अनुमति देता है (जैसे MyAlloc<Other: Alloc> ) और आप आंद्रेईस टॉक में हासिल की गई हर चीज को प्राप्त करने के लिए लक्षण और विशेषज्ञता का उपयोग कर सकते हैं। हालांकि, "विचार" से परे, जो ऐसा करने में सक्षम होना चाहिए, आंद्रेई की बात से बहुत ज्यादा कुछ भी रुस्ट पर लागू नहीं हो सकता है क्योंकि आंद्रेई जिस तरह से एपीआई बनाता है, वह अनर्स्ट्रेटेड जेनरिक + SFINAE / स्टेटिक पर होता है यदि बहुत शुरुआत और रुस्ट के जेनरिक सिस्टम से यह पूरी तरह से अलग है।

मैं बाकी Layout विधियों को स्थिर करने का प्रस्ताव देना चाहूंगा। ये वर्तमान वैश्विक आवंटनकर्ता एपीआई के साथ पहले से ही उपयोगी हैं।

क्या ये सभी तरीके आपके मतलब के हैं?

• pub fn align_to(&self, align: usize) -> Layout
• pub fn padding_needed_for(&self, align: usize) -> usize
• pub fn repeat(&self, n: usize) -> Result<(Layout, usize), LayoutErr>
• pub fn extend(&self, next: Layout) -> Result<(Layout, usize), LayoutErr>
• pub fn repeat_packed(&self, n: usize) -> Result<Layout, LayoutErr>
• pub fn extend_packed(&self, next: Layout) -> Result<(Layout, usize), LayoutErr>
• pub fn array<T>(n: usize) -> Result<Layout, LayoutErr>

@gnzlbg हां।

@Amanieu मुझे ठीक लगता है, लेकिन यह मुद्दा पहले से ही बहुत बड़ा है। एक अलग मुद्दे (या यहां तक ​​कि स्थिरीकरण पीआर) को दर्ज करने पर विचार करें जो हम कर सकते हैं FCP अलग से?

आवंटनकर्ताओं और जीवनकाल से :

1. (आबंटक आबंटन के लिए): एक आबंटन मान को स्थानांतरित करने पर इसके बकाया मेमोरी ब्लॉक को अमान्य नहीं करना चाहिए।

   सभी ग्राहक इसे अपने कोड में मान सकते हैं।

   इसलिए यदि कोई क्लाइंट एक एलायेटर से एक ब्लॉक आवंटित करता है (तो इसे a1 कहते हैं) और फिर a1 एक नई जगह (जैसे vialet a2 = a1) पर जाता है, तो यह क्लाइंट के लिए a2 के माध्यम से उस ब्लॉक को हटाने के लिए ध्वनि बनी रहती है।

क्या इसका मतलब यह है कि एक एलोकेटर Unpin होना चाहिए?

अच्छी पकड़!

चूँकि Alloc विशेषता अभी भी अस्थिर है, मुझे लगता है कि अगर हम RFC के इस भाग को संशोधित करना चाहते हैं और संशोधित करना चाहते हैं तो हमें अभी भी नियम बदलने होंगे। लेकिन यह वास्तव में ध्यान में रखने के लिए कुछ है।

@gnzlbg हां, मुझे जेनरिक सिस्टम में भारी अंतर के बारे में पता है, और यह नहीं कि वह जो कुछ भी विवरण देता है वह रस्ट में उसी तरह लागू होता है। मैं पोस्टिंग के बाद से लाइब्रेरी पर काम कर रहा हूं, हालांकि, और मैं अच्छी प्रगति कर रहा हूं।

क्या इसका मतलब यह है कि एक एलोकेटर _must_ Unpin ?

यह नहीं है Unpin एक प्रकार के व्यवहार के बारे में है जब Pin में लिपटे हुए हैं, इस एपीआई से कोई विशेष संबंध नहीं है।

लेकिन उल्लेखित बाधा को लागू करने के लिए Unpin का उपयोग नहीं किया जा सकता है?

dealloc_array के संबंध में एक और सवाल: फ़ंक्शन Result वापस क्यों करता है? वर्तमान कार्यान्वयन में, यह दो मामलों में विफल हो सकता है:

• n शून्य है
• n * size_of::<T>() लिए क्षमता अतिप्रवाह

पहले हमारे पास दो मामले हैं (दस्तावेज़ीकरण के अनुसार, कार्यान्वयनकर्ता इनमें से चुन सकता है):

• आवंटन Ok शून्य पर n => dealloc_array भी Ok वापस लौटना चाहिए।
• आवंटन Err शून्य n => पर लौटाता है कोई संकेतक नहीं है जिसे dealloc_array पास किया जा सकता है।

दूसरा निम्नलिखित सुरक्षा कारणों से सुनिश्चित किया जाता है:

[T; n] का लेआउट मेमोरी के उस ब्लॉक को फिट करना चाहिए।

इसका मतलब है, कि हमें dealloc_array का आवंटन में n साथ कॉल करना चाहिए । यदि n तत्वों के साथ एक सरणी आवंटित की जा सकती है, तो n T लिए मान्य है। अन्यथा, आवंटन विफल हो जाता।

संपादित करें: अंतिम बिंदु के बारे में: भले ही usable_size n * size_of::<T>() से अधिक मूल्य देता हो, यह अभी भी मान्य है। अन्यथा कार्यान्वयन इस लक्षण बाधा का उल्लंघन करता है:

ब्लॉक का आकार [use_min, use_max] में गिरना चाहिए, जहां:

• [...]
• use_max वह क्षमता है जो तब (या तब होती) लौटा दी जाती है जब (यदि) ब्लॉक को alloc_excess या realloc_excess माध्यम से आवंटित किया जाता था।

यह केवल धारण करता है, क्योंकि विशेषता के लिए unsafe impl आवश्यकता होती है।

पहले हमारे पास दो मामले हैं (दस्तावेज़ीकरण के अनुसार, कार्यान्वयनकर्ता इनमें से चुन सकता है):

• आवंटन Ok पर n

आपको यह जानकारी कहां से मिली?

डॉक्स में सभी Alloc::alloc_ विधियाँ निर्दिष्ट करती हैं कि शून्य आकार के आवंटन का व्यवहार उनके "सुरक्षा" खंड के तहत अपरिभाषित है।

core::alloc::Alloc (प्रासंगिक भागों पर प्रकाश डाला गया) के

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

• हालांकि, कुछ उच्च-स्तरीय आवंटन विधियां ( alloc_one , alloc_array ) शून्य-प्रकार के प्रकारों पर अच्छी तरह से परिभाषित हैं और वैकल्पिक रूप से उनका समर्थन कर सकती हैं : इसे Err वापस करने के लिए कार्यान्वयनकर्ता पर छोड़ दिया जाता है Ok वापस करने के लिए ।

• यदि कोई Alloc कार्यान्वयन इस मामले में Ok वापस करने का विकल्प चुनता है (यानी पॉइंटर शून्य आकार के दुर्गम ब्लॉक को दर्शाता है) तो उस पॉइंटर को "वर्तमान में आवंटित" माना जाना चाहिए। ऐसे आवंटनकर्ता पर, सभी विधियाँ जो इनपुट के रूप में वर्तमान में आबंटित बिंदुओं को लेती हैं, अपरिभाषित व्यवहार किए बिना इन शून्य-आकार वाले बिंदुओं को स्वीकार करना चाहिए।

• दूसरे शब्दों में, यदि एक शून्य-आकार का सूचक एक आबंटक से बाहर निकल सकता है, तो उस आबंटक को उसी तरह से स्वीकार करना होगा जो सूचक अपने डील-डौल और पुनः प्राप्ति के तरीकों में वापस बह रहा है ।

तो dealloc_array की त्रुटि स्थितियों में से एक निश्चित रूप से संदिग्ध है:

/// # Safety
///
/// * the layout of `[T; n]` must *fit* that block of memory.
///
/// # Errors
///
/// Returning `Err` indicates that either `[T; n]` or the given
/// memory block does not meet allocator's size or alignment
/// constraints.

यदि [T; N] आवंटन आकार या संरेखण बाधाओं को पूरा नहीं करता है, तो AFAICT यह आवंटन की स्मृति के ब्लॉक को फिट नहीं करता है, और व्यवहार अपरिभाषित है (सुरक्षा खंड के अनुसार)।

अन्य त्रुटि स्थिति यह है "अंकगणितीय अतिप्रवाह पर हमेशा Err रिटर्न मिलता है।" जो बहुत ही सामान्य है। यह बताना मुश्किल है कि क्या यह एक उपयोगी त्रुटि स्थिति है। प्रत्येक Alloc विशेषता कार्यान्वयन के लिए एक अलग से एक साथ आने में सक्षम हो सकता है जो कुछ अंकगणित कर सकता है जो सिद्धांत रैप में हो सकता है, इसलिए 4 4 4

core::alloc::Alloc (प्रासंगिक भागों को हाइलाइट किया गया):

वास्तव में। मुझे यह अजीब लगता है कि इतने सारे तरीके (जैसे Alloc::alloc ) बताते हैं कि शून्य-आकार का आवंटन अपरिभाषित व्यवहार है, लेकिन फिर हम कार्यान्वयन-परिभाषित व्यवहार के साथ Alloc::alloc_array(0) प्रदान करते हैं। कुछ अर्थों में Alloc::alloc_array(0) एक लिटमस टेस्ट है जो यह जांचने के लिए है कि एक आवंटनकर्ता शून्य-आकार के आवंटन का समर्थन करता है या नहीं।

यदि [T; N] आवंटन आकार या संरेखण बाधाओं को पूरा नहीं करता है, तो AFAICT यह आवंटन की स्मृति के ब्लॉक को फिट नहीं करता है, और व्यवहार अपरिभाषित है (सुरक्षा खंड के अनुसार)।

हाँ, मुझे लगता है कि इस त्रुटि की स्थिति को कम किया जा सकता है क्योंकि यह बेमानी है। या तो हमें सुरक्षा क्लॉज़ की आवश्यकता है या त्रुटि स्थिति की, लेकिन दोनों की नहीं।

अन्य त्रुटि स्थिति यह है "अंकगणितीय अतिप्रवाह पर हमेशा Err ।" जो बहुत ही सामान्य है। यह बताना मुश्किल है कि क्या यह एक उपयोगी त्रुटि स्थिति है।

IMO, यह ऊपर के समान सुरक्षा क्लॉज द्वारा संरक्षित है; अगर [T; N] की क्षमता ओवरफ्लो हो जाएगी, तो यह मेमोरी ब्लॉक से निपटने के लिए फिट नहीं है। शायद @pnkfelix इस पर विस्तार कर सकता है?

कुछ अर्थों में Alloc::alloc_array(1) एक लिटमस टेस्ट है जो यह जाँचने के लिए है कि एक एलोकेट शून्य-आकार के आवंटन का समर्थन करता है या नहीं।

क्या आपका मतलब Alloc::alloc_array(0) ?

IMO, यह ऊपर के समान सुरक्षा क्लॉज द्वारा संरक्षित है; अगर [T; N] की क्षमता ओवरफ्लो हो जाएगी, तो यह _fit_ नहीं है कि मेमोरी ब्लॉक को हटा देना है।

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

क्या आपका मतलब Alloc::alloc_array(0) ?

हाँ क्षमा करें।

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

मैं देख रहा हूँ, लेकिन लागू करने Alloc की आवश्यकता है एक unsafe impl और कार्यान्वयन करने वालों में वर्णित सुरक्षा नियमों का पालन करना पड़ता है https://github.com/rust-lang/rust/issues/32838#issuecomment -+४६,७०,९३,५२७ ।

एक ट्रैकिंग मुद्दे के लिए यहां इंगित किया गया प्रत्येक API Alloc विशेषता है या Alloc विशेषता से संबंधित है। @ जंग-लंग / परिवाद, क्या आपको लगता है कि https://github.com/rust-lang/rust/issues/42774 के अलावा इसे खुला रखना उपयोगी है

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

• यह हमेशा ZSTs का समर्थन करने के लिए कार्यान्वयनकर्ता तक है, और वे ZST के लिए Err वापस नहीं कर सकते
• यह हमेशा ZB को आवंटित करने के लिए UB है, और इस मामले में शॉर्ट-सर्किट के लिए कॉलर की जिम्मेदारी है
• कुछ प्रकार के alloc_inner विधि है जो कॉलर्स कार्यान्वित करते हैं, और एक alloc एक डिफ़ॉल्ट कार्यान्वयन के साथ विधि है जो शॉर्ट सर्किटिंग करती है; alloc को ZST का समर्थन करना चाहिए, लेकिन alloc_inner को ZST के लिए नहीं बुलाया जा सकता है (यह सिर्फ इतना है कि हम एक ही स्थान पर शॉर्ट-सर्कुलेटिंग लॉजिक को जोड़ सकते हैं - विशेषता परिभाषा में - क्रम में बचाने के लिए कुछ बॉयलर)

क्या कोई कारण है कि हमारे पास मौजूदा एपीआई के साथ लचीलापन है?

क्या कोई कारण है कि हमारे पास मौजूदा एपीआई के साथ लचीलापन है?

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

इसका मतलब यह होगा कि एलोक विशेषता के कार्यान्वयनकर्ताओं को इस बात का ध्यान रखना होगा, लेकिन इससे भी महत्वपूर्ण बात यह है कि एलोक विशेषता को विकसित करने की कोशिश करने वालों को हर एपीआई परिवर्तन पर ZST को ध्यान में रखना होगा। यह ZST कैसे हैं (या यदि यह "कार्यान्वयन परिभाषित" है) संभाला है यह बताकर एपीआई के डॉक्स को जटिल करता है।

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

मुझे लगता है कि ZST को संभालना, और कच्ची मेमोरी को आवंटित करना / डील करना दो ऑर्थोगोनल और अलग-अलग समस्याएं हैं, और इसलिए हमें एलोक ट्रेल एपीआई को केवल संभाल कर नहीं रखना चाहिए।

एबॉक जैसे लिबस्ट के उपयोगकर्ताओं को प्रत्येक संग्रह पर ZSTs, जैसे, को संभालना होगा। यह निश्चित रूप से हल करने के लिए एक समस्या है, लेकिन मुझे नहीं लगता कि एलोक विशेषता इसके लिए जगह है। मुझे उम्मीद है कि इस समस्या को हल करने के लिए उपयोगिता से बाहर ले जाने की आवश्यकता होगी, और जब ऐसा होता है, तो हम शायद RFC को इस तरह की उपयोगिता की कोशिश कर सकते हैं और इसे std :: heap में उजागर कर सकते हैं।

यह सब उचित लगता है।

मुझे लगता है कि ZST को संभालना, और कच्ची मेमोरी को आवंटित करना / डील करना दो ऑर्थोगोनल और अलग-अलग समस्याएं हैं, और इसलिए हमें एलोक ट्रेल एपीआई को केवल संभाल कर नहीं रखना चाहिए।

क्या इसका मतलब यह नहीं है कि हमारे पास एपीआई होना चाहिए स्पष्ट रूप से कार्यान्वयन-परिभाषित होने के बजाय ZSTs को संभालना नहीं चाहिए? IMO, एक "असमर्थित" त्रुटि रनटाइम के दौरान बहुत मददगार नहीं है क्योंकि कॉलर्स का विशाल बहुमत एक कमबैक पथ को परिभाषित करने में सक्षम नहीं होगा, और इसलिए यह मानना ​​होगा कि ZST वैसे भी असमर्थित हैं। क्लीनर को एपीआई को सरल बनाने और घोषित करें कि वे _never_ समर्थित हैं।

क्या ZST को संभालने के लिए alloc उपयोगकर्ताओं द्वारा विशेषज्ञता का उपयोग किया जाएगा? या सिर्फ if size_of::<T>() == 0 चेक?

क्या ZST को संभालने के लिए alloc उपयोगकर्ताओं द्वारा विशेषज्ञता का उपयोग किया जाएगा? या सिर्फ if size_of::<T>() == 0 चेक?

उत्तरार्द्ध पर्याप्त होना चाहिए; उपयुक्त कोड पथ को संकलन समय पर तुच्छ रूप से हटा दिया जाएगा।

क्या इसका मतलब यह नहीं है कि हमारे पास एपीआई होना चाहिए स्पष्ट रूप से कार्यान्वयन-परिभाषित होने के बजाय ZSTs को संभालना नहीं चाहिए?

मेरे लिए, एक महत्वपूर्ण बाधा यह है कि यदि हम शून्य-आकार के आवंटन पर प्रतिबंध लगाते हैं, तो Alloc विधियों को यह मान लेना चाहिए कि Layout उन्हें पास नहीं किया गया है।

इसे प्राप्त करने के कई तरीके हैं। एक अन्य Safety क्लॉज को सभी Alloc विधियों में जोड़ने के लिए कहा जाएगा कि यदि Layout शून्य-आकार का व्यवहार अपरिभाषित है।

वैकल्पिक रूप से, हम शून्य-आकार Layout s पर प्रतिबंध लगा सकते हैं, फिर Alloc को शून्य-आकार के आवंटन के बारे में कुछ भी कहने की आवश्यकता नहीं है क्योंकि ये सुरक्षित रूप से नहीं हो सकते हैं, लेकिन ऐसा करने से कुछ डाउनसाइड हो सकते हैं।

उदाहरण के लिए, HashMap जैसे कुछ प्रकार Layout कई Layout s से बनाते हैं, और जबकि अंतिम Layout शून्य-आकार नहीं हो सकते हैं, मध्यवर्ती हो सकते हैं (जैसे HashSet )। तो इन प्रकारों के लिए "कुछ और" (जैसे LayoutBuilder प्रकार) का उपयोग करना होगा, अपने अंतिम Layout s का निर्माण करना होगा, और "गैर-शून्य-आकार" चेक (या उपयोग) के लिए भुगतान करना होगा। एक _unchecked ) विधि जब में कनवर्ट Layout ।

क्या ZST को संभालने के लिए आवंटित उपयोगकर्ताओं द्वारा विशेषज्ञता का उपयोग किया जाएगा? या बस अगर size_of ::() == 0 चेक?

हम अभी तक ZST पर विशेषज्ञ नहीं कर सकते। अभी सभी कोड size_of::<T>() == 0 ।

इसे प्राप्त करने के कई तरीके हैं। एक अन्य Safety क्लॉज को सभी Alloc विधियों में जोड़ने के लिए कहा जाएगा कि यदि Layout शून्य-आकार का व्यवहार अपरिभाषित है।

यह विचार करना दिलचस्प होगा कि क्या यह संकलन-समय की गारंटी देने के तरीके हैं, लेकिन यहां तक ​​कि debug_assert कि लेआउट गैर-शून्य-आकार है, 99% बग्स को पकड़ने के लिए पर्याप्त होना चाहिए।

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

तब शायद हमारे पास C ++ के समान ही मुद्दे होंगे और यह आवंटनकर्ता एपीआई है।

लेकिन मैं लंबे समय से कामना करता हूं कि आवंटनकर्ता के पास उसके आवंटन के मूल्य के प्रकार तक पहुंच हो। टी

इसके लिए आपको क्या चाहिए?

@gnzblg @brson आज मेरे पास जानने योग्य मूल्य के प्रकार के बारे में जानने योग्य _ के लिए संभावित उपयोग का मामला था।

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

संभवतः यह जानना आसान होगा कि क्या मैं एक ऐसा मूल्य आवंटित कर रहा हूं जो कि थ्रेड्स (जैसे आर्क) बनाम एक में स्थानांतरित हो सकता है जो नहीं होगा। या यह नहीं हो सकता है। लेकिन यह एक संभावित परिदृश्य है। फिलहाल वैश्विक आवंटनकर्ता के पास एक स्विच होता है, जिसका उपयोग उपयोगकर्ता यह बताने के लिए करता है कि किस आवंटनकर्ता को आवंटन करना है (realloc या मुफ्त में आवश्यक नहीं है; हम सिर्फ उसके लिए मेमोरी एड्रेस देख सकते हैं)।

* [यह भी मुझे NUMA स्थानीय मेमोरी का उपयोग करने की अनुमति देता है जहां भी संभव हो बिना किसी लॉकिंग के, और, कुल मेमोरी उपयोग को कैप करने के लिए 1 कोर 1 थ्रेड मॉडल के साथ]।

@raphaelcohn

मैं वैश्विक आवंटनकर्ता पर काम कर रहा हूं

मुझे नहीं लगता कि इसमें से कोई भी (या) GlobalAlloc trait पर लागू हो सकता है, और Alloc trait में पहले से ही सामान्य विधियाँ हैं जो प्रकार की जानकारी का उपयोग कर सकती हैं (जैसे alloc_array<T>(1) एक एकल T alloc_array<T>(1) आवंटित करता है, जहाँ T वास्तविक प्रकार है, इसलिए आवंटन आवंटित करते समय प्रकार को ध्यान में रखा जा सकता है)। मुझे लगता है कि इस चर्चा के उद्देश्यों के लिए यह अधिक उपयोगी होगा कि वास्तव में कोड को लागू करने वाले आवंटन को देखें जो कि प्रकार की जानकारी का उपयोग करते हैं। मैंने इस बारे में कोई अच्छा तर्क नहीं सुना है कि क्यों इन तरीकों को कुछ सामान्य आवंटनकर्ता विशेषता का हिस्सा होने की आवश्यकता है, जैसा कि बस आवंटनकर्ता एपीआई, या कुछ अन्य आवंटनकर्ता विशेषता का हिस्सा होने का विरोध है।

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

AFAICT, उस के लिए एकमात्र दिलचस्प प्रकार Box क्योंकि यह सीधे T आवंटित करता है। काफी में अन्य सभी प्रकार के std एक आवंटित कभी नहीं T , लेकिन कुछ निजी आंतरिक प्रकार है कि अपने संभाजक बारे में कुछ पता नहीं कर सकते। उदाहरण के लिए, Rc और Arc (InternalRefCounts, T) , List / BTreeSet आवंटित कर सकते हैं / Vec / Deque / ... T s की सरणियाँ आवंटित करें, लेकिन T s स्वयं, आदि नहीं।

Box और Vec हम पश्चगामी संगत तरीकों से जोड़ सकते हैं BoxAlloc और ArrayAlloc कंबल के साथ Alloc लिए निहितार्थ - आवंटनकर्ता यदि वे कभी भी इन समस्याओं को एक सामान्य तरीके से हमला करने की आवश्यकता है, तो कैसे व्यवहार करें, अपहरण करने के लिए विशेषज्ञ। लेकिन क्या कोई कारण है कि अपने स्वयं के MyAllocBox और MyAllocVec प्रकार प्रदान करना जो आपके आवंटनकर्ता के साथ टाइप जानकारी का दोहन करने के लिए एक व्यवहार्य समाधान नहीं है?

जैसा कि अब हमारे पास आवंटनकर्ता डब्ल्यूजी के लिए एक

एक अच्छी बात @TimDiekmann! मैं उस रिपॉजिटरी में चर्चा सूत्र के पक्ष में इसे आगे बढ़ाने जा रहा हूं।

यह अभी भी ट्रैकिंग मुद्दा है कि कुछ #[unstable] विशेषता बिंदु है। मुझे लगता है कि इसे तब तक बंद नहीं किया जाना चाहिए जब तक कि इन सुविधाओं को स्थिर या पदावनत नहीं किया गया हो। (या हम किसी भिन्न समस्या को इंगित करने के लिए विशेषताओं को बदल सकते हैं।)

गिट मास्टर में संदर्भित हाँ अस्थिर विशेषताएं निश्चित रूप से एक खुला ट्रैकिंग मुद्दा होना चाहिए।

माना। ओपी को एक नोटिस और लिंक भी जोड़ा।