डेल्फी + असेंबलर में अनंत मूल्य जनरेटर

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

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

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

procedure Fibonacci( Generator: TGeneratorWithParam<UInt64, UInt64> ); var V1, V2, V: UInt64; begin V1 := 1; V2 := 1; V := V1 + V2; while Generator.Yield( V ) and ( V >= V2 ) do begin V1 := V2; V2 := V; V := V1 + V2; end; end; 

फ़ंक्शन जनरेटर उत्पन्न करता है और जेनरेटर को कॉल करके "एन्यूमरेटर" को "देता है"।
जब मान बिट ग्रिड ("और" के बाद दूसरी स्थिति) से परे जाते हैं, तो फ़ंक्शन अपना काम समाप्त कर देता है।
ध्यान दें कि यदि जेनरेटर.Yield गलत लौटाता है, तो फ़ंक्शन भी बाहर निकल जाएगा। ऐसा तब होगा जब एन्यूमरेटर को 2 ^ 64 तक के सभी नंबरों को सूचीबद्ध करने से पहले नष्ट कर दिया गया था, अर्थात्, इन-लूप को ब्रेक, निकास बयान, या अपवाद द्वारा समाप्त किया गया था।

आउटपुट नंबर के लिए कोड इस तरह होगा:

  for X in TGenerator<UInt64>.Create( Fibonacci ) do begin WriteLn( X ); end; 

अब हमें ऐसे वर्ग TGeneratorWithParam <T1, T2> को लिखने की आवश्यकता है ताकि उपरोक्त फ़ंक्शन और इसे उपयोग करने वाले कोड एक साथ काम कर सकें।

कोड नवीनतम डेल्फी सुविधाओं (XE2, XE3) का उपयोग करेगा और 32-बिट और 64-बिट कंपाइलर (लेख के अंत में पूर्ण कोड स्पॉइलर के तहत) दोनों के साथ सफलतापूर्वक संकलित करेगा।

ताकि फ़ंक्शन विभिन्न प्रकारों के मूल्यों को "वापस" कर सके, हम TGenerator वर्ग को मानकीकृत कर देंगे।
फिर आपको डेटा का चयन करने की आवश्यकता है जो एक अलग वर्ग में रिटर्न प्रकार पर निर्भर नहीं करता है ताकि इस वर्ग को कोडांतरक कोड से एक्सेस किया जा सके।

  TGeneratorContext = record SP: NativeUInt; //  . //   -    //     , //    -     //  . Stack: PNativeUIntArray; //   . //     VirtualAlloc StackLen: NativeUInt; //   Generator: TObject; //     Active: Boolean; //    end; TGeneratorBase = class protected Context: TGeneratorContext; //  ( ..  ) FFinished: Boolean; //    end; TGeneratorWithParam<ParamT, ResultT> = class( TGeneratorBase ) protected FFunc: TGeneratorFunction<ParamT, ResultT>; FValue: ResultT; FParam: ParamT; public procedure Stop; function Yield( const Value: ResultT ): Boolean; public function GetCurrent: ResultT; function MoveNext: Boolean; property Current: ResultT read GetCurrent; function GetEnumerator: TGeneratorWithParam<ParamT, ResultT>; constructor Create( Func: TGeneratorFunction<ParamT, ResultT>; const Param: ParamT ); overload; constructor Create( Func: TGeneratorFunction<ParamT, ResultT> ); overload; destructor Destroy; override; property Param: ParamT read FParam; property Value: ResultT read FValue; end; TGenerator<T> = class( TGeneratorWithParam<T, T> ); //       : //TGenerator<T> = TGeneratorWithParam<T, T>; //   Delphi    

आपको प्रोग्राम पक्ष (दोनों से-चक्र से बाहर) और फ़ंक्शन पक्ष (फ़ंक्शन से बाहर निकलने) से गणना को पूरा करने की क्षमता प्रदान करने की आवश्यकता है।
जैसे ही मुख्य कार्यक्रम फॉर-इन लूप को पूरा करता है, TGenerator ऑब्जेक्ट नष्ट हो जाता है, जिसके विनाशकर्ता में फ़ंक्शन समाप्त होता है:
1. फिर, फ़ंक्शन के निष्पादन पर संदर्भ बदल जाता है।
2. जनरेटर समारोह पक्ष पर यील्ड विधि गलत रिटर्न करती है
3. जनरेटर फ़ंक्शन चक्र से बाहर निकलता है और सामान्य रूप से अपना काम पूरा करता है। यह अपने चरों को सही ढंग से अंतिम रूप दे सकता है, संसाधन मुक्त कर सकता है, आदि

आइए TGenerator वर्ग के साथ एक दिलचस्प ट्रिक करें। हम GetEnumerator विधि और साथ ही MoveNext और GetCurrent तरीकों की घोषणा करेंगे (हम वर्तमान संपत्ति के बारे में नहीं भूलेंगे)।
GetEnumerator विधि इस तरह दिखाई देगी:

 function TGeneratorWithParam<ParamT, ResultT>.GetEnumerator: TGeneratorWithParam<ParamT, ResultT>; begin Result := Self; end; 

यहां क्या हो रहा है? फ़ंक्शन जनरेटर ऑब्जेक्ट को एक एन्यूमरेटर ऑब्जेक्ट के रूप में वापस करता है।
यह वर्ग के उपयोग को सरल बनाने के लिए किया गया था, और इस तरह की विशेषता के आधार पर भी: यदि फ़ंक्शन ने फ़ॉर-इन लूप से बाहर निकलने के बाद अपना निष्पादन पूरा किया, तो अगले चक्र के लिए इसे फिर से शुरू करने का कोई आसान तरीका नहीं है। इसलिए, बार-बार एन्यूमरेटर का उपयोग रद्द करने का निर्णय लिया गया था। वह है:
1. एक जनरेटर बनाया
2. एक एन्यूमरेटर (उर्फ जनरेटर) प्राप्त किया
3. सभी मूल्यों को सूचीबद्ध किया
4. नष्ट कर दिया प्रगणक (उर्फ जनरेटर)

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

जनरेटर बनाते समय, आपको निम्न चरणों का पालन करना चाहिए:

1. स्टैक के लिए मेमोरी आवंटित करें।

  Context.Stack := VirtualAlloc( nil, MinStackSize, MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE ); Context.StackLen := MinStackSize div SizeOf( NativeUInt ); 

2. सूचक सपा सेट करें।

  Context.SP := NativeUInt( @Context.Stack^[Context.StackLen - 8 {$IFDEF CPUX64} - 6 {$ENDIF}] ); 

2. स्टैक पर प्रारंभिक मान लिखें।

  Context.Stack^[Context.StackLen - 4] := GetFlags; //    (EFLAGS/RFLAGS) Pointer( Context.Stack^[Context.StackLen - 3] ) := @Func; //    (EIP/RIP) Pointer( Context.Stack^[Context.StackLen - 2] ) := @TGeneratorContext.Return; //     ,   - Pointer( Context.Stack^[Context.StackLen - 1] ) := Self; // Self   TGeneratorContext.Return 

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

  FillChar( Context.Stack^, Context.StackLen * SizeOf( NativeUInt ), $DD ); 

विध्वंसक में, आपको फ़ंक्शन को रोकने और स्टैक के लिए आवंटित मेमोरी को मुक्त करने की आवश्यकता है।

  if not FFinished then Stop; VirtualFree( Context.Stack, 0, MEM_RELEASE ); 

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

 function TGeneratorWithParam<ParamT, ResultT>.MoveNext: Boolean; begin if not Context.Active then //     ... begin Context.Active := True; Context.Enter( NativeUInt( Self ) ); //  :   ->   //    Enter    //    (Self),   EAX ( RCX  x64) //   .     //     . end else begin Context.Enter( Ord( True ) ); //  ,    ,   //   EAX  True.     //   Yield    //    . end; Result := not FFinished; //         FValue, //      True,    // ,  False,  - //   (   ). end; 

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

 function TGeneratorWithParam<ParamT, ResultT>.Yield( const Value: ResultT ): Boolean; begin FValue := Value; //      Context.Leave; //  :   ->   Result := not FFinished; //     ,   , //   Yield,     //     (    ), //         // Delphi     // . end; 

इस फ़ंक्शन का मुख्य कार्य जेनरेटर फ़ंक्शन के परिणाम को बिल्कुल वापस नहीं करना है, बल्कि उत्पन्न मूल्य को बचाने और मुख्य संदर्भ पर वापस लौटना है, ताकि यह मान फॉर-इन लूप के अंदर संसाधित किया जा सके, उदाहरण के लिए, स्क्रीन पर प्रदर्शित। वास्तव में, Context.Leave प्रक्रिया में स्टैक को बदल दिए जाने के बाद, कंट्रोल को कॉल को Context.Enter प्रक्रिया (MoveNext विधि में) के बाद तुरंत लाइन में स्थानांतरित कर दिया जाएगा।

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

 procedure TGeneratorWithParam<ParamT, ResultT>.Stop; begin FFinished := True; if Context.Active then //      ... Context.Enter( Ord( False ) ); //  :   ->   //     EAX  False, //     ,    Yield. end; 

स्टैक को स्विच करने के लिए हमारे पास एक अलग प्रक्रिया होगी। इसका उपयोग दोनों दिशाओं में स्विच करने के लिए किया जाएगा।
उनके कार्यों में राज्य को वर्तमान स्टैक में सहेजना और नए स्टैक से नए राज्य को लोड करना शामिल है।

 procedure SwitchContext; asm //   SwitchContext   ECX   //     TGeneratorContext pushfd //  EFLAGS push EBX //    push EBP //  EAX,ECX,EDX  //  ,     //  push ESI //     . push EDI // //    : //      SP   xchg ESP, dword ptr [ECX].TGeneratorContext.&SP //      pop EDI pop ESI pop EBP pop EBX popfd //  EFLAGS // ret end; 

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

यह Enter प्रक्रिया की तरह दिखेगा:

 procedure TGeneratorContext.Enter( Input: NativeUInt ); asm mov ECX, EAX // Self,   TGeneratorContext mov EAX, EDX // Input,  EAX     jmp SwitchContext //   end; 

और इसलिए छुट्टी:

 procedure TGeneratorContext.Leave; asm mov ECX, EAX // Self,   TGeneratorContext jmp SwitchContext end; 

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

 procedure TGeneratorContext.Return; asm pop ECX //    Self,   TGeneratorContext mov [ECX].TGeneratorBase.FFinished, 1 //  Finished := True lea ECX, [ECX].TGeneratorBase.Context //    Context. jmp SwitchContext //     end; 

जो कुछ भी रहता है वह एक छोटा उपयोगिता फ़ंक्शन है जो ध्वज रजिस्टर का मूल्य प्राप्त करता है:

 function GetFlags: NativeInt; asm pushfd pop EAX end; 

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