👌🏻 🌇 😣 भाषाओं के संदर्भ में विश्वसनीय प्रोग्रामिंग। भाग 2

कार्यात्मक आवश्यकताओं वाला पहला भाग यहां है ।

विश्वसनीयता पर एक नज़र के साथ प्रोग्रामिंग भाषाओं के रूप में दावा किया गया।

वर्णानुक्रम में - सक्रिय ओबेरॉन, एडा, बेटर, आईईसी 61131-3 एसटी, सेफ-सी।

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

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

भाषा की स्पष्टता के एक संकेतक के रूप में, मैंने डायजस्ट्रा के प्रसिद्ध बहु-थ्रेडेड कार्य को भोजन दार्शनिकों के कार्यान्वयन के लिए चुना। कार्यान्वयन भाषा और मंचों पर पाठ्यपुस्तकों में है, जिसने मेरे काम को सुगम बना दिया है - यह केवल अनुकूलन के लिए बनी हुई है। उदाहरण के लिए, आधुनिक C ++ के बारे में हाल ही में दिए गए एक लेख में तुलना के लिए C ++ 17 में कार्यान्वयन शामिल है।

सक्रिय ओबेरॉन (2004)

यह 1988 के बाद से पास्कल, मोडुला, पिछले ओबेरोन के अनुभव, जावा, सी #, एडा के साथ-साथ आवेदन में व्यावहारिक अनुभव के लिए एक आंख के साथ बनाया गया था। इसमें OS A2 के रूप में कार्यान्वयन है, जो * nix या Windows के शीर्ष पर रनटाइम के रूप में कार्य कर सकता है। स्रोत A2 और लिंक के लिए संकलक ।

ओबेरोन 2 से सी कंपाइलर (ओओसी) परियोजना भी है जो ओबेरॉन पर्यावरण से जुड़ी नहीं है। यह थोड़ी अलग बोली है, मतभेद नीचे वर्णित हैं।

ओबेरॉन की प्रमुख विशेषता विनिर्देश की असाधारण संक्षिप्तता है। ये बेस ओबेरॉन -2 प्लस 23 पेज पर मल्टी थ्रेडेड एक्टिव एक्सटेंशन पर 16 पेज हैं।

सरल और स्पष्ट सिंटैक्स जो स्पष्ट त्रुटियों को बाहर करता है।

पहचानकर्ता संवेदनशील होते हैं।

कचरा कलेक्टर (जीसी) के साथ ढेर पर वस्तुओं के साथ ओओपी।

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

धाराओं को प्राथमिकता दी जा सकती है और उच्च / वास्तविक समय वे जीसी द्वारा बाधित नहीं होते हैं। UTF-8 सरणियों के रूप में स्ट्रिंग्स।

रनटाइम (ओबेरॉन सिस्टम) एक रनटाइम त्रुटि के मामले में विफल प्रक्रिया / मॉड्यूल / थ्रेड को पुनरारंभ करने के लिए दिलचस्प अवसर प्रदान करता है - मेमोरी एड्रेसिंग, या, उदाहरण के लिए, पूर्णांक अतिप्रवाह।

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

ओबेरॉन -2 ओओसी

यह प्रयोगों के लिए अधिक सुविधाजनक है, क्योंकि ओबेरॉन को ओएस की आवश्यकता नहीं है - यह एएनएसआई सी में संकलित करता है और इसमें कोई अंतर नहीं है। एक्टिव वर्जन से अंतर - कोई अंतर्निहित मल्टीथ्रेडिंग भाषा नहीं है - इसके बजाय PThreads के साथ काम करने के लिए एक मॉड्यूल है, लेकिन अपवादों के साथ काम करने के लिए UTF16, पदानुक्रमित मॉड्युलैरिटी और एक सिस्टम मॉड्यूल है।

मॉड्यूल 3

मोडुला -3 के रूप में थोड़ी अलग विकास शाखा से एक रिश्तेदार भी है। इसका निर्माण ओबेरॉन के आधार पर किया गया था क्योंकि यह अविकसित आद्या के विपरीत था। कार्यान्वयन यहाँ है ।

सक्रिय ओबेरॉन की तुलना में, जेनेरिक और अपवादों को जोड़ा जाता है, यूनिकोड, जीयूआई और यहां तक कि पोस्टग्रेड के साथ व्यावहारिक कार्य के लिए पुस्तकालय हैं। सी। के साथ सरलीकृत एकीकरण। RAII जैसा (C # में उपयोग करने के समान)।

लेकिन ऐसा लगता है कि 2010 में मोडुला 3 का विकास रुक गया।

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

इसके अलावा, एओसी पर्याप्त रूप से आत्म-निहित है, इसके विकास के दृष्टिकोण के साथ।

भोजन के दर्शन के लिए स्रोत

MODULE Philo; (* Dining Philosophers Example from Active Oberon Language Report by Patrik Reali *) (* Adapted for running in AOS by Siemargl *) IMPORT Semaphores := Example8, Out; CONST NofPhilo = 5; (* number of philosophers *) VAR fork: ARRAY NofPhilo OF Semaphores.Semaphore; i: LONGINT; TYPE Philosopher = OBJECT VAR first, second: LONGINT; (* forks used by this philosopher *) PROCEDURE & Init(id: LONGINT); BEGIN IF id # NofPhilo-1 THEN first := id; second := (id+1) ELSE first := 0; second := NofPhilo-1 END END Init; PROCEDURE Think; (* Need lock console output *) BEGIN {EXCLUSIVE} Out.Int(first); Out.String(".... Think...."); Out.Ln; END Think; PROCEDURE Eat; BEGIN {EXCLUSIVE} Out.Int(first); Out.String(".... Eat...."); Out.Ln; END Eat; BEGIN {ACTIVE} LOOP Think; fork[first].P; fork[second].P; Eat; fork[first].V; fork[second].V END END Philosopher; VAR philo: ARRAY NofPhilo OF Philosopher; BEGIN FOR i := 0 TO NofPhilo DO NEW(fork[i], INTEGER(i)); NEW(philo[i], i); END; END Philo. Philo.Philo1 ~

अदा (1980, अंतिम वैध 2016 मानक)

दरअसल, पहली नज़र में वह सब कुछ है जो मैं चाहूंगा।

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

मुझे लगता है कि अगर अडा की विश्वसनीयता के लिए लानत की जरूरत है, तो इसे मुश्किल स्थिति में बुलाने के निर्देशों के साथ संलग्न किया जाएगा।)

कार्यान्वयन - GNUTaya Ada , विकसित हो रहा है, ISO / IEC मानकीकृत है।

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

Ada Reference Manual 2012 में 950 पेज हैं।

जटिलता के अलावा, एडा का नुकसान, इसकी अत्यधिक क्रियाशीलता है, जो हालांकि पठनीयता के लिए कल्पना की गई थी। भाषा सुरक्षा मॉडल की विशिष्टता के कारण, विदेशी पुस्तकालयों के साथ एकीकरण मुश्किल है।

Ada-ru साइट में एक अच्छा समीक्षा अनुवाद लेख है - पहला लिंक।

भोजन के दर्शन के लिए स्रोत

 -- Code from https://rosettacode.org/wiki/Dining_philosophers#Ordered_mutexes -- ADA95 compatible so can run in ideone.com with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random; with Ada.Text_IO; use Ada.Text_IO; procedure Test_Dining_Philosophers is type Philosopher is (Aristotle, Kant, Spinoza, Marx, Russel); protected type Fork is entry Grab; procedure Put_Down; private Seized : Boolean := False; end Fork; protected body Fork is entry Grab when not Seized is begin Seized := True; end Grab; procedure Put_Down is begin Seized := False; end Put_Down; end Fork; Life_Span : constant := 20; -- In his life a philosopher eats 20 times task type Person (ID : Philosopher; First, Second : not null access Fork); task body Person is Dice : Generator; begin Reset (Dice); for Life_Cycle in 1..Life_Span loop Put_Line (Philosopher'Image (ID) & " is thinking"); delay Duration (Random (Dice) * 0.100); Put_Line (Philosopher'Image (ID) & " is hungry"); First.Grab; Second.Grab; Put_Line (Philosopher'Image (ID) & " is eating"); delay Duration (Random (Dice) * 0.100); Second.Put_Down; First.Put_Down; end loop; Put_Line (Philosopher'Image (ID) & " is leaving"); end Person; Forks : array (1..5) of aliased Fork; -- Forks for hungry philosophers -- Start philosophers Ph_1 : Person (Aristotle, Forks (1)'Access, Forks (2)'Access); Ph_2 : Person (Kant, Forks (2)'Access, Forks (3)'Access); Ph_3 : Person (Spinoza, Forks (3)'Access, Forks (4)'Access); Ph_4 : Person (Marx, Forks (4)'Access, Forks (5)'Access); Ph_5 : Person (Russel, Forks (1)'Access, Forks (5)'Access); begin null; -- Nothing to do in the main task, just sit and behold end Test_Dining_Philosophers;

बेटरक (dlang सबसेट 2017, मूल D - 2001, D 2.0 - 2007)

माना जाने वाला सबसे आधुनिक कार्यान्वयन। भाषा का पूरा विवरण काफी लंबा है - 649 पृष्ठ - मूल साइट देखें ।

दरअसल, यह डी लैंग्वेज है, लेकिन इन-फाइटर स्विच के साथ प्रतिबंध है। ऐसा क्यों!

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

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

हालांकि, यह संभव है कि कार्यक्रम का हिस्सा पूर्ण डी में लिखा जाए, और डी-बेटरसी में महत्वपूर्ण हिस्सा। खतरनाक प्रभावों के गैर-उपयोग को नियंत्रित करने के लिए एक सिस्टम विशेषता फ़ंक्शन भी है: शुद्ध सुरक्षित @nogc।

भाषा के निर्माता से शासन का औचित्य ।

और फिर निचोड़ - क्या कट जाता है और क्या उपलब्ध रहता है।

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

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

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

भोजन के दर्शन के लिए स्रोत

 // compile dmd -betterC import core.sys.windows.windows; import core.stdc.stdio; import core.stdc.stdlib : rand; //import std.typecons; // -impossible ( //import std.string; - impossible extern (Windows) alias btex_fptr = void function(void*) /*nothrow*/; //extern (C) uintptr_t _beginthreadex(void*, uint, btex_fptr, void*, uint, uint*) nothrow; /* Dining Philosophers example for a habr.com * by Siemargl, 2019 * BetterC variant. Compile >dmd -betterC Philo_BetterC.d */ extern (C) uintptr_t _beginthread(btex_fptr, uint stack_size, void *arglist) nothrow; alias HANDLE uintptr_t; alias HANDLE Fork; const philocount = 5; const cycles = 20; HANDLE[philocount] forks; struct Philosopher { const(char)* name; Fork left, right; HANDLE lifethread; } Philosopher[philocount] philos; extern (Windows) void PhilosopherLifeCycle(void* data) nothrow { Philosopher* philo = cast(Philosopher*)data; for (int age = 0; age++ < cycles;) { printf("%s is thinking\n", philo.name); Sleep(rand() % 100); printf("%s is hungry\n", philo.name); WaitForSingleObject(philo.left, INFINITE); WaitForSingleObject(philo.right, INFINITE); printf("%s is eating\n", philo.name); Sleep(rand() % 100); ReleaseMutex(philo.right); ReleaseMutex(philo.left); } printf("%s is leaving\n", philo.name); } extern (C) int main() { version(Windows){} else { static assert(false, "OS not supported"); } philos[0] = Philosopher ("Aristotlet".ptr, forks[0], forks[1], null); philos[1] = Philosopher ("Kant".ptr, forks[1], forks[2], null); philos[2] = Philosopher ("Spinoza".ptr, forks[2], forks[3], null); philos[3] = Philosopher ("Marx".ptr, forks[3], forks[4], null); philos[4] = Philosopher ("Russel".ptr, forks[0], forks[4], null); foreach(ref f; forks) { f = CreateMutex(null, false, null); assert(f); } foreach(ref ph; philos) { ph.lifethread = _beginthread(&PhilosopherLifeCycle, 0, &ph); assert(ph.lifethread); } foreach(ref ph; philos) WaitForSingleObject(ph.lifethread, INFINITE); // Close thread and mutex handles for( auto i = 0; i < philocount; i++ ) { CloseHandle(philos[i].lifethread); CloseHandle(forks[i]); } return 0; }

तुलना के लिए, स्रोत पूर्ण डी है।

रोसेट पर आप अन्य भाषाओं के विकल्प भी देख सकते हैं।

IEC 61131-3 ST (1993, नवीनतम मानक 2013)

माइक्रोकंट्रोलर के लिए एक आला प्रोग्रामिंग भाषा। मानक का अर्थ है 5 प्रोग्रामिंग विकल्प, लेकिन सीढ़ी तर्क में उदाहरण के लिए एक आवेदन लिखना अभी भी एक साहसिक कार्य है। इसलिए, हम एक विकल्प पर ध्यान केंद्रित करते हैं - संरचित पाठ।
मानक GOST R IEC 61131-3-2016 का पाठ - 230 पृष्ठ।

पीसी / x86 और एआरएम के लिए कार्यान्वयन हैं - और वाणिज्यिक वाले, जिनमें से सबसे प्रसिद्ध CODESYS है (अक्सर अलग-अलग नामों से वशीभूत भी) और खुले - बेरीमीज़ - सी के माध्यम से प्रसारित।

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

उपयोगकर्ता प्रोग्राम के लिए मल्टीथ्रेडेड प्रोग्रामिंग अपेक्षाकृत हाल ही में दिखाई दी है - माइक्रोकंट्रोलर में यह पहले की आवश्यकता नहीं थी।

टाइप कास्टिंग ज्यादातर केवल स्पष्ट (नवीनतम मानक में आराम) है। लेकिन अतिप्रवाह नियंत्रण कार्यान्वयन पर निर्भर है।

मानक के नवीनतम संस्करण में, OOP दिखाई दिया। कस्टम हैंडलिंग हैंडलर्स द्वारा एरर हैंडलिंग की जाती है।

हम कह सकते हैं कि उपयोगकर्ता के लिए कोई डायनामिक मेमोरी आवंटन नहीं है। यह ऐतिहासिक रूप से हुआ - माइक्रोकंट्रोलर द्वारा संसाधित डेटा की मात्रा हमेशा ऊपर से निरंतर सीमित होती है।

स्रोत (सत्यापित नहीं)

 (* Dining Philosophers example for a habr.com * by Siemargl, 2019 * ISO61131 ST language variant. Must be specialized 4 ur PLC * ) CONFIGURATION PLC_1 VAR_GLOBAL Forks : USINT; Philo_1: Philosopher; (* Instance block - static vars *) Philo_2: Philosopher; Philo_3: Philosopher; Philo_4: Philosopher; Philo_5: Philosopher; END_VAR RESOURCE Station_1 ON CPU_1 TASK Task_1 (INTERVAL := T#100MS, PRIORITY := 1); TASK Task_2 (INTERVAL := T#100MS, PRIORITY := 1); TASK Task_3 (INTERVAL := T#100MS, PRIORITY := 1); TASK Task_4 (INTERVAL := T#100MS, PRIORITY := 1); TASK Task_5 (INTERVAL := T#100MS, PRIORITY := 1); PROGRAM Life_1 WITH Task_1: Philo_1(Name := 'Kant', 0, 1, Forks); PROGRAM Life2 WITH Task_2: Philo_2(Name := 'Aristotel', 1, 2, Forks); PROGRAM Life3 WITH Task_3: Philo_3(Name := 'Spinoza', 2, 3, Forks); PROGRAM Life4 WITH Task_4: Philo_4(Name := 'Marx', 3, 4, Forks); PROGRAM Life5 WITH Task_5: Philo_5(Name := 'Russel', 4, 0, Forks); END_RESOURCE END_CONFIGURATION FUNCTION_BLOCK Philosopher; USING SysCpuHandling.library; VAR_INPUT Name: STRING; Left: UINT; Right: UINT; END_VAR VAR_IN_OUT Forks: USINT; END_VAR VAR Thinking: BOOL := TRUE; (* States *) Hungry: BOOL; Eating: BOOL; HaveLeftFork: BOOL; TmThink: TON; TmEating: TON; END_VAR TmThink(In := Thinking; PT := T#3s); TmEating(In := Eating; PT := T#5s); IF Thinking THEN (* Just waiting Timer *) Thinking := NOT TmThink.Q; Hungry := TmThink.Q; ELSIF Hungry (* Try Atomic Lock Forks *) IF HaveLeftFork IF SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Right, bSet := 1) = ERR_OK THEN Hungry := FALSE; Eating := TRUE; ELSE RETURN; END_IF ELSIF IF SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Left, bSet := 1) = ERR_OK THEN HaveLeftFork := TRUE; ELSE RETURN; END_IF END_IF ELSIF Eating (* Waiting Timer, then lay forks *) IF TmEating.Q THEN Thinking := TRUE; Eating := FALSE; HaveLeftFork := FALSE; SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Right, bSet := 0); SysCpuTestAndSetBit(Address := Forks, Len := 1, iBit := Left, bSet := 0); END_IF END_IF END_FUNCTION_BLOCK

सेफ-सी (2011)

खतरनाक चिप्स को हटाने और प्रतिरूपकता और मल्टीथ्रेडिंग के साथ प्रायोगिक सी। परियोजना स्थल
लगभग 103 पृष्ठों का विवरण। यदि आप सी से मतभेदों को उजागर करते हैं - बहुत कम, लगभग 10 ।

एरे और पॉइंटर्स के साथ काम करना सुरक्षित है, डायनामिक मेमोरी ऑटोमैटिक रेफरेंस काउंटिंग के साथ - डबल रिलीज चेक और डैंगलिंग लिंक के साथ।

मानक लाइब्रेरी में GUI, मल्टीथ्रेडिंग, नेटवर्क फ़ंक्शंस (एक HTTP सर्वर सहित) के लिए फ़ंक्शंस का न्यूनतम सेट है।

लेकिन - यह कार्यान्वयन केवल विंडोज x86 के लिए है। हालांकि कंपाइलर और लाइब्रेरी कोड खुला है।

एक अन्य शोध कार्य के हिस्से के रूप में, मैंने एक वेब सर्वर लेआउट को एक साथ रखा, जो IoT सेंसर से डेटा एकत्र करता है: एक 75 Kb कार्यकारी मॉड्यूल, और एक <1 एमबी आंशिक मेमोरी सेट।

भोजन के दर्शन के लिए स्रोत

 /* Dining Philosophers example for a habr.com * by Siemargl, 2019 * Safe-C variant. Compile >mk.exe philosafec.c */ from std use console, thread, random; enum philos (ushort) { Aristotle, Kant, Spinoza, Marx, Russell, }; const int cycles = 10; const ushort NUM = 5; uint lived = NUM; packed struct philosopher // 32-bit { philos name; byte left, right; } philosopher philo_body[NUM]; SHARED_OBJECT forks[NUM]; void philosopher_life(philosopher philo) { int age; for (age = 0; age++ < cycles; ) { printf("%s is thinking\n", philo.name'string); delay((uint)rnd(1, 100)); printf("%s is hungry\n", philo.name'string); enter_shared_object(ref forks[philo.left]); enter_shared_object(ref forks[philo.right]); printf("%s is eating\n", philo.name'string); delay((uint)rnd(1, 100)); leave_shared_object(ref forks[philo.right]); leave_shared_object(ref forks[philo.left]); } printf("%s is leaving\n", philo.name'string); InterlockedExchange(ref lived, lived-1); } void main() { philos i; assert philosopher'size == 4; philo_body[0] = {Aristotle, 0, 1}; philo_body[1] = {Kant, 1, 2}; philo_body[2] = {Spinoza, 2, 3}; philo_body[3] = {Marx, 3, 4}; philo_body[4] = {Russell, 0, 4}; for (i = philos'first; i <= philos'last; i++) { assert run philosopher_life(philo_body[(uint)i]) == 0; } while (lived > 0) sleep 0; // until all dies for (i = philos'first; i <= philos'last; i++) { destroy_shared_object(ref forks[(uint)i]); } }

अंत में - कार्यात्मक आवश्यकताओं के अनुपालन का सारांश तालिका ।
निश्चित रूप से मैं कुछ याद किया या गलत व्याख्या की - तो इसे सही करें।

गितुब पर लेख के स्रोत ।

भाषाओं के संदर्भ में विश्वसनीय प्रोग्रामिंग। भाग 2 - चैलेंजर्स

सक्रिय ओबेरॉन (2004)

ओबेरॉन -2 ओओसी

मॉड्यूल 3

अदा (1980, अंतिम वैध 2016 मानक)

बेटरक (dlang सबसेट 2017, मूल D - 2001, D 2.0 - 2007)

IEC 61131-3 ST (1993, नवीनतम मानक 2013)

सेफ-सी (2011)

More articles: