सी में लिम्बो के लिए मॉड्यूल का विकास (भाग 1)

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

सामग्री

• मॉड्यूल को कर्नेल में एम्बेड करें
  
  • यह कैसे काम करता है
• कार्य: पैरामीटर प्राप्त करना और परिणाम वापस करना
  
  • संख्या
    
    • यह कैसे काम करता है
  • पंक्तियां
    
    • यह कैसे काम करता है
  • अपवाद
  • वापसी लिंक
• डिस्क ब्लॉक

मॉड्यूल को कर्नेल में एम्बेड करें

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

अपने मॉड्यूल को एम्बेड करने के लिए, आपको कई फ़ाइलों को संशोधित करने की आवश्यकता है: libinterp/mkfile , module/runt.m , emu/Linux/emu और emu/Linux/emu-g । और चूंकि प्रत्येक नया मॉड्यूल समान स्थानों में समान फ़ाइलों में एकीकृत करने का प्रयास करता है, और उपयोगकर्ता अनजान क्रम में कई ऐसे मॉड्यूल, इसके अलावा जोड़ना चाह सकता है, मानक patch कमांड आवश्यक परिवर्तन करने में सक्षम नहीं होगा। वह एक या दो मॉड्यूल जोड़ेगी, लेकिन निम्नलिखित के बाद से उसे समस्या होगी इन फ़ाइलों में संपादन योग्य स्थान वह देखने की अपेक्षा से बहुत अधिक भिन्न होने लगेगा।

इस समस्या को हल करने के लिए, मैंने पर्ल पर एक स्क्रिप्ट को स्केच किया - ज्यादातर मामलों में यह लाइन में जोड़े जाने के लिए मॉड्यूल का नाम बदलने के लिए पर्याप्त है

 my $MODNAME = 'CJSON'; 

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

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

सबसे पहले, दो फ़ाइलें बनाएँ:

1. module/example.m
   

    Example: module { PATH: con "$Example"; }; 

2. libinterp/example.c
   

    #include <lib9.h> #include <isa.h> #include <interp.h> #include "runt.h" #include "examplemod.h" void examplemodinit(void) { builtinmod("$Example", Examplemodtab, Examplemodlen); } 

और ओएस इन्फर्नो का पुनर्निर्माण शुरू करें:

 $ (cd libinterp/; mk nuke) $ rm Linux/386/bin/emu # work around "text file busy" error $ mk install 

अब हम लिम्बो में एक प्रोग्राम लिख सकते हैं जो हमारे मॉड्यूल को सफलतापूर्वक लोड करेगा, जो अब तक कुछ भी उपयोगी नहीं है:

• testexample.b
  

   implement TestExample; include "sys.m"; include "draw.m"; include "example.m"; TestExample: module { init: fn(nil: ref Draw->Context, nil: list of string); }; init(nil: ref Draw->Context, nil: list of string) { sys := load Sys Sys->PATH; example := load Example Example->PATH; if(example == nil) sys->print("fail to load Example: %r\n"); else sys->print("Example module loaded\n"); } 

  
  

और चलाएं:

 $ emu ; limbo testexample.b ; testexample Example module loaded ; 

यह कैसे काम करता है

असेंबली प्रक्रिया के दौरान, module/example.m फ़ाइल का विश्लेषण किया जाता है और आवश्यक C- संरचनाएँ उत्पन्न की जाती हैं जो इस मॉड्यूल का वर्णन करती हैं - एक अलग libinterp/examplemod.h - और इसके संपूर्ण सार्वजनिक इंटरफ़ेस (स्थिरांक, adt-shki, फ़ंक्शंस को libinterp/runt.h फ़ाइल में जोड़ा जाता है) libinterp/runt.h जिसमें सभी C- मॉड्यूल की जानकारी है। ये दो .h फाइलें पहले से ही हमारे libinterp/example.c से जुड़ी हैं।

इसके अलावा, OS Inferno की बूट प्रक्रिया के दौरान, एक बार examplemodinit() जो हमारे मॉड्यूल (यदि कोई हो) के वैश्विक डेटा को examplemodinit() करना चाहिए और इसे (Inferno कोर में builtinmod(…) कहकर) कनेक्ट करना चाहिए। इस मॉड्यूल को load कमांड के साथ लोड करते समय लिम्बो से उपयोग किए जाने वाले PATH builtinmod() में निर्दिष्ट हमारे builtinmod() और $ उदाहरण छद्म-पथ के बीच संबंध स्थापित करता है।

कार्य: पैरामीटर प्राप्त करना और परिणाम वापस करना

संख्या

आइए सरल डेटा प्रकारों से शुरू करें ताकि लिंक के साथ काम करने के उदाहरण को जटिल न करें।

• module/example.m
  

   Example: module { ... increment: fn(i: int): int; }; 

• libinterp/example.c
  

   ... void Example_increment(void *fp) { F_Example_increment *f; int i; f = fp; i = f->i; *f->ret = i + 1; } 

इन्फर्नो का पुनर्निर्माण करें।

• testexample.b
  

   ... init(nil: ref Draw->Context, nil: list of string) { ... sys->print("increment(5) = %d\n", example->increment(5)); } 

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

 $ emu ; limbo testexample.b ; testexample Example module loaded increment(5) = 6 ; 

यह कैसे काम करता है

असेंबली के दौरान, module/example.m में पाए जाने वाले increment() फ़ंक्शन के लिए, इस फ़ंक्शन का विवरण, इसके पैरामीटर और रिटर्न मान स्वचालित रूप से फ़ाइल libinterp/runt.h जोड़ा गया था:

 void Example_increment(void*); typedef struct F_Example_increment F_Example_increment; struct F_Example_increment { WORD regs[NREG-1]; WORD* ret; uchar temps[12]; WORD i; }; 

मुझे अभी तक पता नहीं चला है कि regs क्या regs ; संरेखण के लिए स्पष्ट रूप से जोड़े गए temps ; ret रिटर्न मूल्य के लिए एक सूचक है; और i हमारा पैरामीटर है

पंक्तियां

• module/example.m
  

   Example: module { ... say: fn(s: string); }; 

• libinterp/example.c
  

   ... void Example_say(void *fp) { F_Example_say *f; String *s; char *str; f = fp; s = f->s; str = string2c(s); print("%s\n", str); } 

• testexample.b
  

   ... init(nil: ref Draw->Context, nil: list of string) { ... example->say("Hello!"); } 

हम एकत्रित करते हैं, पुनः आरंभ करते हैं, जांचते हैं:

 $ emu ; limbo testexample.b ; testexample Example module loaded increment(5) = 6 Hello! ; 

यह कैसे काम करता है

यहाँ हमें libinterp/runt.h में मिला है:

 void Example_say(void*); typedef struct F_Example_say F_Example_say; struct F_Example_say { WORD regs[NREG-1]; WORD noret; uchar temps[12]; String* s; }; 

noret साथ noret बजाय ret सब कुछ स्पष्ट है, say() फ़ंक्शन कुछ भी नहीं देता है। String* प्रकार लिम्बो स्ट्रिंग्स का C कार्यान्वयन है। आप include/interp.h struct String पा सकते हैं, स्ट्रिंग्स (जैसे string2c() हमारे उदाहरण में उपयोग किए गए string2c() साथ काम करने के लिए कार्य libinterp/string.c ।

अन्य लिम्बो डेटा प्रकारों के साथ काम एक समान तरीके से कार्यान्वित किया जाता है: Array* , List* , आदि के माध्यम से। सभी संरचनाओं में स्ट्रिंग्स के साथ काम करने के लिए तैयार किए गए सहायक कार्य नहीं हैं, लेकिन आप libinterp/xec.c वर्चुअल मशीन के उदाहरणों के कार्यान्वयन में पर्याप्त उदाहरण पा सकते हैं (उदाहरण के लिए, सरणियों के स्लाइस के साथ कैसे काम करें)।

module/example.m में घोषित कस्टम adt को नियमित C- शर्मीली संरचना में बदला जाता है (और adt को यूनियन में चुना जाता है)। टुपल्स को भी नियमित रूप से संरचित किया जाता है।

सबसे अधिक संभावना है, module/example.m बदलते समय के बाद module/example.m आपको libinterp/runt.h को libinterp/runt.h करने के लिए असेंबली (जो कि गलती से विफल हो जाएगी) को शुरू libinterp/runt.h होगा और आप देखेंगे कि आपके डेटा के लिए कौन से स्ट्रक्चर बनाए गए हैं और यह समझें कि libinterp/example.c में उनके साथ काम करना कैसे लागू करें ।

अपवाद

अपवाद फेंकने के लिए, बस error() फ़ंक्शन को कॉल करें। आप libinterp/raise.c में वर्णित मानक त्रुटियों को वापस करने या उसी तरह से libinterp/example.c में अपनी खुद की घोषणा करने के raise.h को raise.h कर सकते हैं।

बेशक, अगर आपने खुद को malloc() माध्यम से मेमोरी आवंटित की है, तो कॉलिंग error() से पहले आपको इस मेमोरी को मुक्त करने की आवश्यकता है, अन्यथा एक रिसाव होगा। ढेर के माध्यम से मानक तरीके से आवंटित वस्तुओं (जैसे String* और Array* ) को मुक्त करने की आवश्यकता नहीं है, वैसे भी वे कचरा कलेक्टर द्वारा थोड़ी देर बाद पाए जाएंगे और हटाए जाएंगे। ( भाग 2 में ढेर और कचरा संग्रहकर्ता के काम के बारे में अधिक विस्तार से)

वापसी लिंक

फ़ंक्शन से परिणाम लौटाते समय एक निहित क्षण इस तथ्य से जुड़ा होता है कि *f->ret मेमोरी सेल में भौतिक रूप से *f->ret पॉइंट्स जहां फ़ंक्शन के परिणाम को उसके सफल समापन के बाद स्थित होना चाहिए। इससे दो परिणाम सामने आते हैं:

1. यदि आप पहली बार परिणाम को *f->ret में डालते हैं, और फिर तय करते हैं कि कोई त्रुटि हुई है और एक अपवाद फेंक दें, तो कुछ असंभव हो सकता है लिम्बो के दृष्टिकोण से: और फ़ंक्शन मान वापस करेगा और एक अपवाद फेंक देगा।
2. यदि वह चर जहां आपके फ़ंक्शन का परिणाम पहले से ही है, में कुछ मूल्य होता है (जो कि एक संदर्भ भी है, निश्चित रूप से, क्योंकि इस चर का प्रकार आपके फ़ंक्शन द्वारा दिए गए मान के समान है), तो आपको इसे पहले मेमोरी से मुक्त करना होगा आपके साथ इस लिंक को फिर से कैसे लिखना है।

पहली समस्या को प्रदर्शित करने के लिए, आइए अपने फ़ंक्शन को संशोधित करें
increment() इस प्रकार है:

• libinterp/example.c
  

   ... void Example_increment(void *fp) { ... *f->ret = i + 1; error("some error"); } 

• testexample.b
  

   ... init(nil: ref Draw->Context, nil: list of string) { ... i := 0; { i = example->increment(5); } exception e { "*" => sys->print("catched: %s\n", e); } sys->print("i = %d\n", i); } 

 ; testexample ... catched: some error i = 6 ; 

सी-फ़ंक्शंस में दूसरी समस्या को हल करने के लिए, रिटर्न वैल्यू को *f->ret से बचाने से पहले *f->ret वर्तमान मूल्य को मुक्त करना आवश्यक है। यह आमतौर पर इस तरह से किया जाता है:

 destroy(*f->ret); *f->ret = new_value; 

या तो ( H लिम्बो-निल्स nil का सी-वें एनालॉग है):

 void *tmp; ... tmp = *f->ret; *f->ret = H; destroy(tmp); ... *f->ret = new_value; 

जैसा कि मैं इसे समझता हूं, फिलहाल इन विकल्पों में कोई अंतर नहीं है, लेकिन अगर डिस्क को कई सीपीयू / कोर पर एक साथ काम करने के लिए फिर से लिखा जाता है, तो दूसरा विकल्प सही ढंग से काम करेगा, लेकिन पहले वाला नहीं होगा।

डिस्क ब्लॉक

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

लेकिन अगर आपके फ़ंक्शन को कुछ लंबा ऑपरेशन करने की आवश्यकता है (उदाहरण के लिए, पढ़ना / लिखना या किसी बाहरी लाइब्रेरी से "भारी" फ़ंक्शन को कॉल करना या कुछ लंबी गणना करना), तो आपको इस ऑपरेशन से पहले release() करने की आवश्यकता है ताकि डिस्क को किसी अन्य थ्रेड में निष्पादित किया जा सके अपने फ़ंक्शन के साथ समानांतर में, और फिर acquire() फिर से डालें (अन्यथा, परिणाम को वापस करना और लिंबो कोड पर वापस लौटना संभव नहीं होगा जो इस फ़ंक्शन को कहते हैं)। एक उदाहरण sys->read() emu/port/inferno.c में कार्यान्वयन में पाया जा सकता है:

 void Sys_read(void *fp) { ... release(); *f->ret = kread(fdchk(f->fd), f->buf->data, n); acquire(); } 

भाग २