💃🏾 🦐 👭 समानांतर कंप्यूटिंग मॉडल 🍛 ➖ 🗾

1। परिचय। प्रतिस्पर्धी धनवाद

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

C ++ मानक में मल्टीथ्रेडिंग के लिए लंबे समय से प्रतीक्षित समर्थन शामिल था [1]। लेकिन हम इस तथ्य की न तो प्रशंसा करेंगे और न ही इसकी आलोचना करेंगे थ्रेड्स के साथ काम को कई स्थितियों, कैविट्स और विशेषताओं द्वारा तौला जाता है, जो कि वास्तविक उदाहरणों के बिना, जो बहुस्तरीय समस्याओं को प्रकट करते हैं, मल्टीथ्रेडेड प्रोग्रामिंग की चर्चा न केवल जल्दबाजी होगी, बल्कि काफी पक्षपाती भी होगी। इसलिए, इसके बाद मुख्य रूप से प्रवाह के बारे में नहीं है, लेकिन ऑटोमेटा के बारे में, मन में असर, निश्चित रूप से, पहले वाले।

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

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

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

2. गणना के समानांतर ऑटोमेटन मॉडल

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

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

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

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

3. क्रमिक संगति

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

ऊपर वर्णित स्थितियों में कार्यों का सही संचालन छाया स्मृति प्रदान करता है। इसमें नए मूल्यों को संग्रहीत करके, एक ही डेटा का उपयोग इनपुट और आउटपुट दोनों के रूप में किया जा सकता है। एक उदाहरण एक आयताकार पल्स जनरेटर का मॉडल है, जिसे y =! Y के रूप में वर्णित किया गया है, जहां y जनरेटर का आउटपुट है। VKPa वातावरण में इसका C ++ कोड लिस्टिंग 1 में दिखाया गया है, और कार्यक्रम के परिणाम अंजीर में दिखाए गए हैं। 1।

लिस्टिंग 1. आयताकार पल्स जनरेटर

#include "lfsaappl.h"

class FSWGenerator :
    public LFsaAppl
{
public:
    LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FSWGenerator(pTAppCore, nameFsa, pCVarFsaLibrary); }
    bool FCreationOfLinksForVariables();
    FSWGenerator(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL);
    virtual ~FSWGenerator(void) {};
    CVar *pVarY;				//  
protected:
    void y1();
};

#include "stdafx.h"
#include "FSWGenerator.h"
// state machine transition table
static LArc TBL_SWGenerator[] = {
    LArc("s1",		"s1","--",	"y1"),			//
    LArc()
};

FSWGenerator::FSWGenerator(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL):
    LFsaAppl(TBL_SWGenerator, strNam, nullptr, pCVFL)
{
    pTAppCore = pInfo;
}
// creating local variables and initialization of pointers
bool FSWGenerator::FCreationOfLinksForVariables() {
// creating local variables
    pVarY = CreateLocVar("y", CLocVar::vtBool, " ");
    return true;
}
// setting output signals
void FSWGenerator::y1() {
    pVarY->SetDataSrc(nullptr, !bool(pVarY->GetDataSrc()));
}

अंजीर। 1. VKPA में आयताकार पल्स जनरेटर के संचालन का अनुकरण

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

1. , . . . .

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

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

लिस्टिंग 2. राज्यों पर स्क्वायर वेव जनरेटर

#include "lfsaappl.h"

extern LArc TBL_SWGenState[];
class FSWGenState :
    public LFsaAppl
{
public:
    FSWGenState(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL):
    LFsaAppl(TBL_SWGenState, strNam, nullptr, pCVFL) {};
};

#include "stdafx.h"
#include "FSWGenState.h"
// state machine transition table
LArc TBL_SWGenState[] = {
    LArc("s0",		"s1","--",	"--"),			//
    LArc("s1",		"s0","--",	"--"),			//
    LArc()
};

नए मॉडल में, राज्य आउटपुट चर को प्रतिस्थापित करते हैं, और यह, जैसा कि देखा जा सकता है, नाटकीय रूप से जनरेटर मॉडल को सरल करता है। नतीजतन, हमें एक "नंगे" मशीन मिली, जिसका प्रतिनिधित्व केवल एक रूपांतरण तालिका द्वारा किया गया था। VKPa में अपनी वर्तमान स्थिति "s1" की निगरानी करने के लिए, SWGenState नाम के साथ fsa (राज्य) प्रकार का एक चर (SW1) मशीन के लिए SWGenState नाम से बनाया गया था। यह राज्य s1 में सही मूल्य लेता है, और जब मशीन एक अलग स्थिति में होती है तो यह गलत होता है। इसके अलावा, यह चर पहले से ही VKPA पर्यावरण के डेटा को प्रदर्शित करने के माध्यम से उपयोग किया जाता है (चित्र 2 में संकेत प्रवृत्ति देखें)।

अंजीर। 2. राज्य जनरेटर मॉडलिंग

4. समानांतर कंप्यूटिंग नियंत्रण मॉडल

इसके अलावा, समानांतर प्रक्रियाओं के एक मॉडल के निर्माण की ओर बढ़ रहा है, यह एक साथ काम करने और परिमित राज्य मशीनों, अर्थात। ऑटोमेटा का नेटवर्क। इस मामले में, एक नेटवर्क टाइम मॉडल चुनने की समस्या दिखाई देती है, जो सभी मशीनों के लिए समान हो सकती है या सीमा में, प्रत्येक के लिए अलग-अलग हो सकती है। VKPa में, चुनाव एक ही समय के पक्ष में किया गया था (ऑटोमेटा के तुल्यकालिक नेटवर्क पर अधिक विवरण के लिए, [5] देखें)।

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

बेशक, बड़ी संख्या में घटकों के एक नेटवर्क के लिए परिणामी ऑटोमैटन बहुत ही चमकदार हो सकता है। लेकिन, सौभाग्य से, बहुत कम संख्या में घटकों के नेटवर्क या नेटवर्क के संचालन की समझ की आवश्यकता होती है, जिसके लिए परिणामी ऑटोमैटन को खोजने से बड़ी समस्याएं नहीं होती हैं। निम्न RS-फ्लिप-फ्लॉप मॉडल उदाहरण यह प्रदर्शित करता है।

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

अंजीर में। चित्र 3 AND-NOT तत्व का सबसे सरल मॉडल प्रस्तुत करता है, जिसमें RS- ट्रिगर सर्किट होता है। यह तत्व की देरी, साथ ही उनके प्रकार (परिवहन या जड़ता में देरी) को ध्यान में नहीं रखता है। हालांकि, इसमें अभी भी कम से कम एक विलंब बीट शामिल है। यह एक राज्य से दूसरे राज्य में संक्रमण का समय है। लिस्टिंग 3 मॉडल कोड दिखाता है

। 3. तत्व का मॉडल और नहीं

लिस्टिंग 3. तत्व मॉडल और नहीं

#include "lfsaappl.h"

class FIne :
    public LFsaAppl
{
public:
    LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FIne(pTAppCore, nameFsa, pCVarFsaLibrary); }
    bool FCreationOfLinksForVariables();
    FIne(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL);
    virtual ~FIne(void) {};
    CVar *pVarX1;				//  
    CVar *pVarX2;				//  
    CVar *pVarY;				//  
    CVar *pVarStrNameX1;		//    
    CVar *pVarStrNameX2;		//    
    CVar *pVarStrNameY;         //   
protected:
    int x1(); int x2(); int x12();
    void y1(); void y2(); void y12();
    bool bX1, bX2, bY;
};


#include "stdafx.h"
#include "FIne.h"
// state machine transition table
static LArc TBL_Ine[] = {
    LArc("st",		"st","^x12","y12"), 		//
    LArc("st",		"s1","x12^x1",	"y1"),		//
    LArc("st",		"s1","x12^x2",	"y1"),		//
    LArc("st",		"s0","x12x1x2",	"y2"),		//
    LArc("s1",		"s0","x1x2",   "y2"),		//
    LArc("s0",		"s1","^x1",    "y1"),		//
    LArc("s0",		"s1","^x2",    "y1"),		//
    LArc()
};

FIne::FIne(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL):
    LFsaAppl(TBL_Ine, strNam, nullptr, pCVFL)
{ }

// creating local variables and initialization of pointers
bool FIne::FCreationOfLinksForVariables() {
// creating local variables
    pVarX1 = CreateLocVar("x1", CLocVar::vtBool, " 1- ");
    pVarX2 = CreateLocVar("x2", CLocVar::vtBool, " 2- ");
    pVarY = CreateLocVar("y", CLocVar::vtBool, " ");
    pVarStrNameX1 = CreateLocVar("strNameX1", CLocVar::vtString, "name of external input variable(x1)");			//   
    pVarStrNameX2 = CreateLocVar("strNameX2", CLocVar::vtString, "name of external input variable(x2)");			//   
    pVarStrNameY = CreateLocVar("strNameY", CLocVar::vtString, "name of external output variable(y)");		//   
// initialization of pointers
    string str;
    if (pVarStrNameX1) {
        str = pVarStrNameX1->strGetDataSrc();
        if (str != "") { pVarX1 = pTAppCore->GetAddressVar(str.c_str(), this);	}
    }
    if (pVarStrNameX2) {
        str = pVarStrNameX2->strGetDataSrc();
        if (str != "") { pVarX2 = pTAppCore->GetAddressVar(str.c_str(), this); }
    }
    if (pVarStrNameY) {
        str = pVarStrNameY->strGetDataSrc();
        if (str != ""){pVarY = pTAppCore->GetAddressVar(str.c_str(), this);}
    }
    return true;
}

int FIne::x1() { return bool(pVarX1->GetDataSrc()); }
int FIne::x2() { return bool(pVarX2->GetDataSrc()); }
int FIne::x12() { return pVarX1 != nullptr && pVarX2 && pVarY; }

void FIne::y1() { pVarY->SetDataSrc(nullptr, 1); }
void FIne::y2() { pVarY->SetDataSrc(nullptr, 0.0); }
void FIne::y12() { FInit(); }

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

समानांतर RS-फ्लिप-फ्लॉप प्रोग्राम और एक अलग AND-NOT तत्व के ऑपरेशन एल्गोरिथ्म के [परिणामी] एल्गोरिदम की तुलना करें। अंतर हड़ताली है। इस स्थिति में, घटक एल्गोरिदम को "हैंडल" द्वारा बनाया जाता है, और समानांतर सिस्टम एल्गोरिदम को अंतर्निहित रूप से बनाया जाता है - नेटवर्क के "कृत्रिम बुद्धिमत्ता" द्वारा। यह समानांतर कार्यक्रमों और अनुक्रमिक लोगों के बीच गुणात्मक अंतर है: केवल संचार (कम से कम एक) को बदलते हुए, हम काम का पूरी तरह से अलग एल्गोरिथ्म प्राप्त करेंगे। और यह निश्चित रूप से अब आरएस ट्रिगर नहीं होगा। और, वैसे, एक और परिणामस्वरूप ऑटोमेटन।

अंजीर। 4. RS-FF और नेटवर्क मॉडल

अंजीर की योजना। 5. परिणामस्वरूप मशीन नेटवर्क मॉडल आरएस-ट्रिगर

अंजीर में परिणामी ऑटोमेटन का विश्लेषण। 5 समानांतर कार्यक्रम के निम्नलिखित "समझ" (और वास्तविक ट्रिगर, निश्चित रूप से) देता है। सबसे पहले, जब एक राज्य से दूसरे राज्य में स्विच किया जाता है, तो ट्रिगर आवश्यक रूप से आउटपुट के "निषिद्ध" राज्य के माध्यम से जाएगा (और पाठ्यपुस्तक इस बारे में क्या कहते हैं?)। दूसरे, यदि ट्रिगर आउटपुट के एक ही राज्य में संचालित होता है (राज्य में "s1w1"), और फिर दो इकाइयों को इनपुट के लिए खिलाया जाता है, यह पीढ़ी मोड में प्रवेश करेगा, अर्थात। "s1w1" और "s0w0" राज्यों के बीच चक्रीय स्विचिंग (और क्या आपने ट्रिगर पीढ़ी के बारे में सुना है?)।

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

टिप्पणी 2. आरएस-ट्रिगर ऑपरेशन का एक विशिष्ट विवरण अधिकांश मामलों में सत्य तालिका के रूप में दिया गया है। लेकिन ऐसा करने के लिए, यह समझना कि ट्रिगर एक अनुक्रमिक योजना है, यह वास्तव में, इस विषय का अध्ययन करने वालों को जानबूझकर भ्रमित करना है। खैर, कोई भी ट्रिगर "निषिद्ध राज्य" नहीं हो सकता है! लेकिन किसी कारण से केवल कुछ लोग ही इस सत्य की खोज करने का निर्णय लेते हैं और विशेष रूप से, इसकी पीढ़ी की समस्या पर चर्चा करते हैं (उदाहरण के लिए, [7])।

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

अंजीर। 6. आरएस-ट्रिगर पीढ़ी मोड

अंजीर। 7. राज्यों के बीच आरएस-ट्रिगर स्विच करना

एक और आरएस-ट्रिगर मॉडल पर विचार करें, जिसमें एक राज्य और एक कार्रवाई शामिल है, अर्थात। लिस्टिंग 1 में मॉडल के समान। इसका कोड लिस्टिंग 4 में दिखाया गया है। जनरेटर मॉडल की तरह इस मॉडल में कोई विधेय नहीं है और बिना किसी मध्यवर्ती परिवर्तनों के संकेत मान एक्शन y1 के लिए इनपुट हैं। यह अच्छा है या बुरा है? एक ओर, ऐसा लगता है कि यह अच्छा है, क्योंकि कोड सरल हो गया है, लेकिन दूसरी ओर ... वास्तव में नहीं। और हम इसके कारणों को अब समझेंगे।

लिस्टिंग 4. एक कार्रवाई से नंद तत्व मॉडल

#include "lfsaappl.h"

class FTwoOperators :
    public LFsaAppl
{
public:
    LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FTwoOperators(pTAppCore, nameFsa, pCVarFsaLibrary); }
    bool FCreationOfLinksForVariables();
    FTwoOperators(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL);
    virtual ~FTwoOperators(void) {};
    CVar *pVarX1;				//  
    CVar *pVarX2;				//  
    CVar *pVarY;				//  
    CVar *pVarStrNameX1;		//    
    CVar *pVarStrNameX2;		//    
    CVar *pVarStrNameY;         //   
protected:
    int x12();
    void y1(); void y12();
    bool bX1, bX2, bY;
};

#include "stdafx.h"
#include "FTwoOperators.h"
// state machine transition table
static LArc TBL_TwoOperators[] = {
    LArc("st",		"st","^x12","y12"), 		//
    LArc("st",		"s1","x12", "--"),		//
    LArc("s1",		"s1","--",  "y1"),		//
    LArc()
};

FTwoOperators::FTwoOperators(TAppCore *pInfo, string strNam, CVarFsaLibrary *pCVFL):
    LFsaAppl(TBL_TwoOperators, strNam, nullptr, pCVFL)
{ }
// creating local variables and initialization of pointers
bool FTwoOperators::FCreationOfLinksForVariables() {
// creating local variables
    pVarX1 = CreateLocVar("x1", CLocVar::vtBool, " 1- ");
    pVarX2 = CreateLocVar("x2", CLocVar::vtBool, " 2- ");
    pVarY = CreateLocVar("y", CLocVar::vtBool, " ");
    pVarStrNameX1 = CreateLocVar("strNameX1", CLocVar::vtString, "name of external input variable(x1)");			//   
    pVarStrNameX2 = CreateLocVar("strNameX2", CLocVar::vtString, "name of external input variable(x2)");			//   
    pVarStrNameY = CreateLocVar("strNameY", CLocVar::vtString, "name of external output variable(y)");		//   
// initialization of pointers
    string str;
    if (pVarStrNameX1) {
        str = pVarStrNameX1->strGetDataSrc();
        if (str != "") { pVarX1 = pTAppCore->GetAddressVar(str.c_str(), this);	}
    }
    if (pVarStrNameX2) {
        str = pVarStrNameX2->strGetDataSrc();
        if (str != "") { pVarX2 = pTAppCore->GetAddressVar(str.c_str(), this); }
    }
    if (pVarStrNameY) {
        str = pVarStrNameY->strGetDataSrc();
        if (str != "") { pVarY = pTAppCore->GetAddressVar(str.c_str(), this);	}
    }
    return true;
}

int FTwoOperators::x12() { return pVarX1 != nullptr && pVarX2 && pVarY; }

void FTwoOperators::y1() {
// reading input signals
    bX1 = bool(pVarX1->GetDataSrc());
    bX2 = bool(pVarX2->GetDataSrc());
// setting output signals
    bY = !(bX1&&bX2);
    pVarY->SetDataSrc(nullptr, bY);
}
// initialization of pointers
void FTwoOperators::y12() { FInit(); }

यदि हम "शैडो मेमोरी" मोड में नए मॉडल का परीक्षण करते हैं, तो हमें इसके ऑपरेशन में पिछले एक, यानी, से कोई अंतर नहीं दिखेगा। और, स्विचिंग, यह निषिद्ध राज्यों के माध्यम से जाएगा और नियमित रूप से पीढ़ी मोड में प्रवेश करेगा। यदि हम सामान्य मोड में डेटा के साथ काम सेट करते हैं, तो हमें अंजीर में दिखाए गए परिणाम मिलेंगे। 8 और अंजीर। 9.

अंजीर। 8. आरएस-ट्रिगर मॉडल की पीढ़ी मोड की विफलता

। 9. आरएस-ट्रिगर

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

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

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

5। निष्कर्ष

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

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

और, ऐसा लगता है, लक्ष्य प्राप्त किया गया था। आरएस-ट्रिगर मॉडल, समानांतरवाद प्रणालियों के संभावित परीक्षणों में से एक [8] के रूप में, हमें इस बात के लिए आश्वस्त करता है ... जैसा कि जीवन ने दिखाया है, अन्य सभी समानांतर कार्यक्रम, बशर्ते कि पर्यावरण ने आरएस-ट्रिगर परीक्षण समानांतरवाद कार्यान्वयन को सफलतापूर्वक पारित किया है, बस सही ढंग से, मज़बूती और दृढ़ता से काम करें। । वैसे, एक ही MATLAB "आरएस-ट्रिगर परीक्षण" पास नहीं हुआ, और यह पहले से ही बहुत कुछ कहता है ...

साहित्य

1. . ++ . . . . .. – .: , 2012. – 672 .
2. . : . . – .: , 1981. – 360 .
3. . [ ], : habr.com/ru/post/484588 . . . ( 07.01.2020).
4. .. . .: , 1962.
5. .., - .. . – 2- ., . . – .: , 1988. – 480 .
6. .. . [ ], : cloud.mail.ru/public/HwsK/T95PMM8Ed . . . ( 01.02.2020).
7. . . 2- . – .: , 2004. – 432.
8. .. ? “ ”, №10/97, .116-119. [ ], : www.osp.ru/pcworld/1997/10/158015 . . . ( 01.02.2020).

समानांतर कंप्यूटिंग मॉडल

1। परिचय। प्रतिस्पर्धी धनवाद

2. गणना के समानांतर ऑटोमेटन मॉडल

3. क्रमिक संगति

4. समानांतर कंप्यूटिंग नियंत्रण मॉडल

5। निष्कर्ष

More articles: