Erlang 21 - 1. Overview

1 अवलोकन




erlang

1 अवलोकन

OTP डिज़ाइन सिद्धांत परिभाषित करते हैं कि प्रक्रियाओं, मॉड्यूल और निर्देशिकाओं के संदर्भ में Erlang कोड की संरचना कैसे करें।

1.1 पर्यवेक्षण पेड़

Erlang / OTP में एक मूल अवधारणा पर्यवेक्षण वृक्ष है । यह श्रमिकों और पर्यवेक्षकों के विचार के आधार पर एक प्रक्रिया संरचना मॉडल है:

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

निम्नलिखित आकृति में, चौकोर बक्से पर्यवेक्षकों का प्रतिनिधित्व करते हैं और मंडलियों श्रमिकों का प्रतिनिधित्व करते हैं:

चित्र 1.1: पर्यवेक्षण वृक्ष

1.2 व्यवहार

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

व्यवहार इन सामान्य प्रतिमानों की औपचारिकता है। विचार एक सामान्य भाग (एक व्यवहार मॉड्यूल) और एक विशिष्ट भाग (एक कॉलबैक मॉड्यूल ) में एक प्रक्रिया के लिए कोड को विभाजित करना है।

व्यवहार मॉड्यूल Erlang / OTP का हिस्सा है। पर्यवेक्षक के रूप में एक प्रक्रिया को लागू करने के लिए, उपयोगकर्ता को केवल कॉलबैक मॉड्यूल को लागू करना होगा जो कि कार्यों के पूर्व-निर्धारित सेट, कॉलबैक फ़ंक्शन को निर्यात करना है

निम्नलिखित उदाहरण बताते हैं कि कैसे कोड को एक सामान्य और एक विशिष्ट भाग में विभाजित किया जा सकता है। एक साधारण सर्वर के लिए निम्न कोड (सादे एरलांग में लिखा गया) पर विचार करें, जो कई "चैनलों" का ट्रैक रखता है। अन्य प्रक्रियाएँ क्रमशः आवंटित alloc/0 और free/1 फ़ंक्शन को कॉल करके चैनल को आवंटित और मुक्त कर सकती हैं।

-module(ch1).
-export([start/0]).
-export([alloc/0, free/1]).
-export([init/0]).

start() ->
    spawn(ch1, init, []).

alloc() ->
    ch1 ! {self(), alloc},
    receive
        {ch1, Res} ->
            Res
    end.

free(Ch) ->
    ch1 ! {free, Ch},
    ok.

init() ->
    register(ch1, self()),
    Chs = channels(),
    loop(Chs).

loop(Chs) ->
    receive
        {From, alloc} ->
            {Ch, Chs2} = alloc(Chs),
            From ! {ch1, Ch},
            loop(Chs2);
        {free, Ch} ->
            Chs2 = free(Ch, Chs),
            loop(Chs2)
    end.

सर्वर के लिए कोड एक सामान्य भाग server.erl में फिर से लिखा जा सकता है:

-module(server).
-export([start/1]).
-export([call/2, cast/2]).
-export([init/1]).

start(Mod) ->
    spawn(server, init, [Mod]).

call(Name, Req) ->
    Name ! {call, self(), Req},
    receive
        {Name, Res} ->
            Res
    end.

cast(Name, Req) ->
    Name ! {cast, Req},
    ok.

init(Mod) ->
    register(Mod, self()),
    State = Mod:init(),
    loop(Mod, State).

loop(Mod, State) ->
    receive
        {call, From, Req} ->
            {Res, State2} = Mod:handle_call(Req, State),
            From ! {Mod, Res},
            loop(Mod, State2);
        {cast, Req} ->
            State2 = Mod:handle_cast(Req, State),
            loop(Mod, State2)
    end.

और कॉलबैक मॉड्यूल ch2.erl :

-module(ch2).
-export([start/0]).
-export([alloc/0, free/1]).
-export([init/0, handle_call/2, handle_cast/2]).

start() ->
    server:start(ch2).

alloc() ->
    server:call(ch2, alloc).

free(Ch) ->
    server:cast(ch2, {free, Ch}).

init() ->
    channels().

handle_call(alloc, Chs) ->
    alloc(Chs). % => {Ch,Chs2}

handle_cast({free, Ch}, Chs) ->
    free(Ch, Chs). % => Chs2

निम्नलिखित पर ध्यान दें:

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

ऊपर ch1.erl और ch2.erl , channels/0 के कार्यान्वयन channels/0 , alloc/1 और free/2 को जानबूझकर छोड़ दिया गया है, क्योंकि यह उदाहरण के लिए प्रासंगिक नहीं है। पूर्णता के लिए, इन कार्यों को लिखने का एक तरीका नीचे दिया गया है। यह केवल एक उदाहरण है, एक यथार्थवादी कार्यान्वयन को आवंटित करने के लिए चैनलों से बाहर चलने जैसी स्थितियों को संभालने में सक्षम होना चाहिए, और इसी तरह।

channels() ->
   {_Allocated = [], _Free = lists:seq(1,100)}.

alloc({Allocated, [H|T] = _Free}) ->
   {H, {[H|Allocated], T}}.

free(Ch, {Alloc, Free} = Channels) ->
   case lists:member(Ch, Alloc) of
      true ->
         {lists:delete(Ch, Alloc), [Ch|Free]};
      false ->
         Channels
   end.        

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

व्यवहार का उपयोग करने से अन्य प्रोग्रामर द्वारा लिखे गए कोड को पढ़ना और समझना आसान हो जाता है। बेहतर प्रोग्रामिंग संरचनाएं, जबकि संभवतः अधिक कुशल, हमेशा समझने में अधिक कठिन होती हैं।

server मॉड्यूल से मेल खाती है, बहुत सरल, Erlang / OTP व्यवहार gen_server

मानक Erlang / OTP व्यवहार हैं:

  • gen_server

    क्लाइंट-सर्वर रिलेशन के सर्वर को लागू करने के लिए

  • gen_statem

    राज्य मशीनों को लागू करने के लिए

  • gen_event

    इवेंट हैंडलिंग कार्यक्षमता को लागू करने के लिए

  • supervisor

    एक पर्यवेक्षण पेड़ में एक पर्यवेक्षक को लागू करने के लिए

कंपाइलर मॉड्यूल विशेषता -behaviour(Behaviour) समझता है और -behaviour(Behaviour) कॉलबैक फ़ंक्शंस के बारे में चेतावनी जारी करता है, उदाहरण के लिए:

-module(chs3).
-behaviour(gen_server).
...

3> c(chs3).
./chs3.erl:10: Warning: undefined call-back function handle_call/3
{ok,chs3}

1.3 आवेदन

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

  • कर्नेल - एर्लैंग को चलाने के लिए कार्यक्षमता आवश्यक है
  • STDLIB - एरलंग मानक पुस्तकालय

एप्लिकेशन अवधारणा प्रोग्राम संरचना (प्रक्रियाएं) और निर्देशिका संरचना (मॉड्यूल) दोनों पर लागू होती है।

सरलतम अनुप्रयोगों में कोई प्रक्रिया नहीं होती है, लेकिन इसमें कार्यात्मक मॉड्यूल का संग्रह होता है। ऐसे एप्लिकेशन को लाइब्रेरी एप्लिकेशन कहा जाता है। लाइब्रेरी एप्लिकेशन का एक उदाहरण STDLIB है।

मानक व्यवहार का उपयोग करके पर्यवेक्षण के पेड़ के रूप में प्रक्रियाओं के साथ एक आवेदन को आसानी से लागू किया जाता है।

Applications में प्रोग्राम का वर्णन कैसे किया जाता है।

1.4 रिलीज

एक रिलीज एक पूरी प्रणाली है जो एरलांग / ओटीपी अनुप्रयोगों और उपयोगकर्ता-विशिष्ट अनुप्रयोगों के एक सेट से तैयार की गई है।

कैसे जारी करने के लिए कार्यक्रम विज्ञप्ति में वर्णित है।

किसी लक्ष्य परिवेश में रिलीज़ को स्थापित करने के लिए अनुभाग 2 सिस्टम सिद्धांत में लक्ष्य सिस्टम के बारे में कैसे वर्णन किया गया है।

1.5 रिलीज हैंडलिंग

रिलीज़ हैंडलिंग एक (संभवतः) चल रहे सिस्टम में रिलीज़ के विभिन्न संस्करणों के बीच उन्नयन और डाउनग्रेडिंग है। यह कैसे करें Release Handling में वर्णित है।