Rust: जंग के कार्य जिन्हें C . से बुलाया जा सकता है

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

इसलिए मैं एक ऐसा समाधान पसंद करूंगा जो तेज़ हो, भले ही यह प्रतिबंधित हो कि रस्ट साइड पर क्या कार्य कर सकता है।

साथ ही, क्या "क्रस्ट एफएन" के स्थान पर "देशी एफएन" का उपयोग करना एक विचार नहीं होगा या क्या इसका कोई अन्य नियोजित अर्थ है?

@beoran आपके पास यह पिछड़ा हुआ है। हम बात कर रहे हैं C कॉलिंग रस्ट की। रस्ट से C फ़ंक्शन को कॉल करना पहले से ही बहुत तेज़ है (इसे कुछ तेज़ बनाया जा सकता है)।

ठीक है मैं समझा। क्या कोई तरीका है जिससे मैं जंग से C को कॉल करने में तेजी लाने में मदद कर सकता हूं?

@beoran जैसा कि मैंने कहा, यह इस मुद्दे के लिए एक तरह का ऑर्थोगोनल है ... :)

ठीक है, मैं यह करूँगा कि जब मैं एलेग्रो को लपेटने में काफी दूर हो जाऊंगा तो इसे रस्ट रस्ट से कॉल करने के ऊपरी हिस्से की तुलना सी से कॉल करने के साथ करूंगा। मैं इस मुद्दे को अभी के लिए अकेला छोड़ दूंगा और एक बार मेरे पास एक नया खोल दूंगा बेंचमार्क।

क्या हम सी फ़ंक्शन को सीधे रस्ट स्टैक पर लिखने के द्वारा तर्कों की प्रतियों में से एक से बच सकते हैं, जैसा कि रस्ट-> सी कॉल वर्तमान में करते हैं?

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

मेरा मानना ​​​​है कि हमारे सी कॉल वर्तमान में जंग के ढेर पर एक संरचना में तर्कों की प्रतिलिपि बनाते हैं और फिर उस संरचना को सी स्टैक पर कॉपी करते हैं।

@pcwalton Rust- >C वर्तमान में सीधे C स्टैक में नहीं लिखता है क्योंकि यह i386 के लिए विशिष्ट है। मैं 64-बिट काम करने के लिए, कुछ प्रदर्शन की कीमत पर भी, किसी विशेष कॉलिंग सम्मेलन के लिए विशिष्ट कोड लिखने से बचना चाहता था। (मुझे लगता है कि इस तरह के अनुकूलन अब समझ में आ सकते हैं, हालांकि --- विशेष रूप से # 1402 बताते हैं कि एलएलवीएम वास्तव में कॉलिंग सम्मेलनों को पूरी तरह से संभाल नहीं पाता है _anyway_)

स्टैक स्विचिंग फ़ंक्शन को पढ़ने के बाद, arg संरचना को स्टैक में बिल्कुल भी कॉपी नहीं किया जाता है, पिछले स्टैक के पॉइंटर को नए स्टैक पर चलने वाले फ़ंक्शन को पास किया जाता है, जो सही समझ में आता है।

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

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

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

तो जब कोई शीर्ष-स्तरीय कार्य विफल हो जाता है, तो वह अपने बच्चों को त्रुटियों का प्रचार करता है? मुझे लगता है कि मैं हमारे त्रुटि प्रसार मॉडल को नहीं समझता, मुझे लगा कि यह पत्तियों से ऊपर चला गया है। ऐसा लगता है कि सी स्टैक पर चल रहे कोड को एक असुरक्षित कार्य या ऐसा कुछ चलाने में सक्षम होना चाहिए।

यह मूल रूप से कार्य करता है जैसे कि कर्नेल द्वारा 'मुख्य' की निगरानी की जाती है, इसलिए यदि मुख्य विफल रहता है तो सब कुछ विफल हो जाता है।

मैं इसे किया हुआ कह रहा हूँ। थोड़ी सफाई हुई है, और मैंने शेष मुद्दों के लिए अलग-अलग बग दायर किए हैं।

कृपया इस पुनरुत्थान को क्षमा करें, लेकिन यह मुद्दा एक y-combinator टुकड़ा और कुछ अन्य साइटों से जुड़ा हुआ है, और मुझे हाल ही में इसके बारे में कोई पूछने वाला नहीं था, इसलिए मैं ध्यान दे रहा हूं कि, इस मुद्दे के अनुसार और बाद में परिवर्तन, सी से जंग को बुला रहा है सरल है :

#[no_mangle]
pub extern fn hello_rust() -> *const u8 {
    "Hello, world!\0".as_ptr()
}

#include "stdio.h"
const char *hello_rust(void);
int main(void) {
    printf("%.32s\n", hello_rust());
}