समवर्ती पास्कल

Concurrent Pascal

Paradigms	Imperative, structured, concurrent
परिवार	Wirth Pascal
द्वारा डिज़ाइन किया गया	Per Brinch Hansen
पहली प्रस्तुति	April 1974 (1974-04)
टाइपिंग अनुशासन	Static and dynamic, strong, safe
प्लेटफॉर्म	DEC PDP 11
Influenced by
ALGOL 60, Simula 67, Pascal

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

भाषा विवरण

सरलता और सुरक्षा के लिए पास्कल में कई निर्माणों को समवर्ती पास्कल से हटा दिया गया था:* वेरिएंट रिकॉर्ड

• के लिए जाओ स्टेटमेंट, और लेबल
• सबरूटीन्स
• डेटा संरचना संरेखण
• सूचक (कंप्यूटर प्रोग्रामिंग)
• फ़ाइल प्रकार, और संबंधित मानक इनपुट/आउटपुट प्रक्रियाएं

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

समवर्ती पास्कल में क्लास, मॉनिटर और प्रोसेस डेटा प्रकार शामिल हैं। इस प्रकार के उदाहरणों को चर के रूप में घोषित किया जाता है और एक में आरंभ किया जाता है init कथन।

कक्षाएं और मॉनिटर समान हैं: पैकेज निजी चर और सार्वजनिक प्रक्रियाओं के साथ प्रक्रियाएं (प्रक्रिया प्रविष्टियां कहा जाता है)। एक वर्ग उदाहरण का उपयोग केवल एक प्रक्रिया द्वारा किया जा सकता है, जबकि एक मॉनिटर उदाहरण प्रक्रियाओं द्वारा साझा किया जा सकता है। समवर्ती पास्कल प्रोग्राम में इंटरप्रोसेस संचार के लिए मॉनिटर एकमात्र तंत्र प्रदान करते हैं।

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

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

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

उदाहरण

निम्नलिखित उदाहरण एक साधारण मॉनिटर की घोषणा और दो संचार प्रक्रियाओं द्वारा इसके उपयोग को दर्शाता है।

type
    "Bounded buffer monitor"
    buffer = Monitor
        var
            saved         : Integer;  "saved item is an integer"
            fullq, emptyq : Queue;    "used by only two processes"
            full          : Boolean;  "true if an item is saved:"

        "Puts item in buffer"
        procedure entry put(item : Integer);
            begin
               if full then
                   delay(fullq);      "block if full"
               saved := item;         "save the item"
               full := true;          "mark as full"
               continue(emptyq)       "unblock consumer"
            end;

        "Gets item from the buffer"
        procedure entry get(var item : Integer);
            begin
               if not full then
                   delay(emptyq);     "block if empty"
               item := saved;         "get the item"
               full := false;         "mark as not full"
               continue(fullq)        "unblock producer"
            end;

        "Initialize the monitor"
        begin
            full := false
        end;

    "Producer uses a buffer"
    producer = process(pass : Buffer);
        var item : Integer;
        begin
            cycle                     "execute in a loop forever"
                "produce an item"
                pass.put(item)        "pass an item to the monitor"
            end
        end;

    "Consumer uses a buffer"
    consumer = process(pass : Buffer);
        var item : Integer;
        begin
            cycle
                pass.get(item);       "get an item from the monitor"
                "consume the item"
            end
        end;

"declare instances of the monitor, producer, and consumer"
"give the producer and consumer access to the monitor"
var
   pass : Buffer;
   prod : Producer;
   cons : Consumer;
begin
   init pass,        "initialize the monitor"
        prod(pass),  "start the producer process"
        cons(pass)   "start the consumer process"
end.