Erlang 21 - 5. Supervisor Behaviour

5 पर्यवेक्षक व्यवहार




erlang

5 पर्यवेक्षक व्यवहार

इस खंड को STDLIB में supervisor(3) मैनुअल पेज के साथ पढ़ा जाना चाहिए, जहां पर्यवेक्षक के व्यवहार के बारे में सभी विवरण दिए गए हैं।

5.1 पर्यवेक्षण सिद्धांत

एक पर्यवेक्षक अपने बच्चे की प्रक्रियाओं को शुरू करने, रोकने और निगरानी करने के लिए जिम्मेदार है। एक पर्यवेक्षक का मूल विचार यह है कि यह आवश्यक होने पर पुनः आरंभ करके अपनी बाल प्रक्रियाओं को जीवित रखना है।

बच्चे को शुरू करने और मॉनिटर करने के लिए कौन सी प्रक्रिया child specifications की सूची द्वारा निर्दिष्ट की जाती है। बच्चे की प्रक्रिया इस सूची द्वारा निर्दिष्ट क्रम में शुरू की जाती है, और उल्टे क्रम में समाप्त हो जाती है।

5.2 उदाहरण

gen_server Behaviour से सर्वर शुरू करने वाले पर्यवेक्षक के लिए कॉलबैक मॉड्यूल निम्नानुसार देख सकते हैं:

-module(ch_sup).
-behaviour(supervisor).

-export([start_link/0]).
-export([init/1]).

start_link() ->
    supervisor:start_link(ch_sup, []).

init(_Args) ->
    SupFlags = #{strategy => one_for_one, intensity => 1, period => 5},
    ChildSpecs = [#{id => ch3,
                    start => {ch3, start_link, []},
                    restart => permanent,
                    shutdown => brutal_kill,
                    type => worker,
                    modules => [cg3]}],
    {ok, {SupFlags, ChildSpecs}}.

init/1 से वापसी मान में SupFlags चर supervisor flags प्रतिनिधित्व करता है।

init/1 से रिटर्न वैल्यू में ChildSpecs चर child specifications की एक सूची है।

5.3 पर्यवेक्षक झंडे

यह पर्यवेक्षक झंडे की प्रकार परिभाषा है:

sup_flags() = #{strategy => strategy(),         % optional
                intensity => non_neg_integer(), % optional
                period => pos_integer()}        % optional
    strategy() = one_for_all
               | one_for_one
               | rest_for_one
               | simple_one_for_one

5.4 पुनः आरंभ करने की रणनीति

पुनः आरंभ की रणनीति कॉलबैक फ़ंक्शन init द्वारा लौटाए गए पर्यवेक्षक झंडे के नक्शे में strategy कुंजी द्वारा निर्दिष्ट की गई है:

SupFlags = #{strategy => Strategy, ...}

इस नक्शे में strategy कुंजी वैकल्पिक है। यदि यह नहीं दिया जाता है, तो यह one_for_one को one_for_one

एक के लिए एक

यदि कोई बच्चा प्रक्रिया समाप्त करता है, तो केवल उस प्रक्रिया को पुनरारंभ किया जाता है।

चित्र 5.1: One_For_One पर्यवेक्षण

सब के लिए एक

यदि एक बच्चे की प्रक्रिया समाप्त हो जाती है, तो अन्य सभी बाल प्रक्रियाओं को समाप्त कर दिया जाता है, और फिर समाप्त एक सहित सभी बाल प्रक्रियाओं को फिर से शुरू किया जाता है।

चित्र 5.2: One_For_All पर्यवेक्षण

rest_for_one

यदि एक बच्चे की प्रक्रिया समाप्त हो जाती है, तो बाकी बच्चे की प्रक्रिया (यानी, बच्चे की प्रक्रिया शुरू क्रम में समाप्त प्रक्रिया के बाद) समाप्त हो जाती है। फिर समाप्त बाल प्रक्रिया और बाल प्रक्रियाओं के बाकी हिस्सों को फिर से शुरू किया जाता है।

simple_one_for_one

simple-one-for-one supervisors

5.5 अधिकतम पुनः आरंभ तीव्रता

पर्यवेक्षकों के पास पुनः आरंभ की संख्या को सीमित करने के लिए एक अंतर्निहित तंत्र है जो एक निश्चित समय अंतराल में हो सकता है। यह कॉलबैक फ़ंक्शन init द्वारा लौटाए गए सुपरवाइज़र फ़्लैग मैप में दो कुंजी की intensity और period द्वारा निर्दिष्ट किया गया है:

SupFlags = #{intensity => MaxR, period => MaxT, ...}

यदि अंतिम MaxT सेकंड में MaxR संख्या से अधिक पुनरारंभ होता है, तो पर्यवेक्षक सभी बाल प्रक्रियाओं को समाप्त कर देता है और फिर स्वयं। उस मामले में खुद पर्यवेक्षक के लिए समाप्ति का कारण shutdown होगा।

जब पर्यवेक्षक समाप्त हो जाता है, तो अगले उच्च-स्तरीय पर्यवेक्षक कुछ कार्रवाई करता है। यह या तो समाप्त पर्यवेक्षक को फिर से शुरू करता है या खुद को समाप्त करता है।

रीस्टार्ट मैकेनिज्म का उद्देश्य ऐसी स्थिति को रोकना है जहां एक प्रक्रिया एक ही कारण से बार-बार मरती है, केवल फिर से शुरू करने की।

पर्यवेक्षकों के झंडे के नक्शे में चाबियाँ intensity और period वैकल्पिक हैं। यदि उन्हें नहीं दिया जाता है, तो वे क्रमशः 1 और 5 लिए डिफ़ॉल्ट होते हैं।

तीव्रता और अवधि ट्यूनिंग

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

सबसे पहले, तीव्रता यह तय करती है कि आप कितने बड़े पैमाने पर पुनरारंभ करना चाहते हैं। उदाहरण के लिए, आप अधिकतम 5 या 10 प्रयासों के फटने को स्वीकार करना चाह सकते हैं, भले ही वह एक सफल पुन: प्रारंभ हो।

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

इसलिए आपको इस अवधि को लंबे समय तक निर्धारित करना चाहिए जिसे आप स्वीकार कर सकें कि पर्यवेक्षक उस दर पर चलता रहता है। उदाहरण के लिए, यदि आपने 5 का तीव्रता मान लिया है, तो 30 सेकंड तक की अवधि निर्धारित करने से आपको अधिक से अधिक 6 सेकंड के लिए प्रति एक बार पुनः आरंभ करने का समय मिलेगा, जिसका अर्थ है कि आपके लॉग बहुत जल्दी नहीं भरेंगे। और आपके पास विफलताओं का निरीक्षण करने और फिक्स लागू करने का मौका होगा।

ये विकल्प आपके समस्या डोमेन पर बहुत निर्भर करते हैं। यदि आपके पास वास्तविक समय की निगरानी और समस्याओं को जल्दी से ठीक करने की क्षमता नहीं है, उदाहरण के लिए एक एम्बेडेड सिस्टम में, आप पर्यवेक्षक को छोड़ देना चाहिए और आगे बढ़ने के लिए अगले स्तर तक बढ़ने से पहले प्रति मिनट एक बार फिर से शुरू करना चाहते हैं। स्वचालित रूप से त्रुटि। दूसरी ओर, अगर यह अधिक महत्वपूर्ण है कि आप उच्च विफलता दर पर भी प्रयास करते रहें, तो आप प्रति सेकंड 1-2 पुनरारंभ जितना निरंतर दर चाहते हैं।

सामान्य गलतियों से बचना:

  • फट दर पर विचार करने के लिए मत भूलना। यदि आप तीव्रता 1 और 6 की अवधि निर्धारित करते हैं, तो यह उसी निरंतर त्रुटि दर को 5/30 या 10/60 के रूप में देता है, लेकिन त्वरित उत्तराधिकार में भी 2 पुनरारंभ प्रयासों की अनुमति नहीं देगा। यह शायद वह नहीं है जो आप चाहते थे।

  • यदि आप बर्स्ट को सहन करना चाहते हैं तो अवधि को बहुत अधिक मूल्य पर सेट न करें। यदि आप 5 से तीव्रता और 3600 (एक घंटे) की अवधि निर्धारित करते हैं, तो पर्यवेक्षक 5 पुनरारंभ की एक छोटी फट की अनुमति देगा, लेकिन तब छोड़ देता है जब यह लगभग एक घंटे बाद एक और एकल पुनरारंभ देखता है। आप शायद उन दुर्घटनाओं को अलग घटनाओं के रूप में मानना ​​चाहते हैं, इसलिए 5 या 10 मिनट की अवधि निर्धारित करना अधिक उचित होगा।

  • यदि आपके आवेदन में पर्यवेक्षण के कई स्तर हैं, तो सभी स्तरों पर समान मूल्यों को पुनरारंभ तीव्रता निर्धारित न करें। ध्यान रखें कि शीर्ष स्तर के पर्यवेक्षकों की कुल संख्या (शीर्ष स्तर के पर्यवेक्षक आवेदन छोड़ने और समाप्त करने से पहले) विफल बच्चे की प्रक्रिया के ऊपर सभी पर्यवेक्षकों के गहन मूल्यों का उत्पाद होगी।

    उदाहरण के लिए, यदि शीर्ष स्तर 10 पुनरारंभ की अनुमति देता है, और अगले स्तर भी 10 की अनुमति देता है, तो उस स्तर से नीचे दुर्घटनाग्रस्त बच्चे को 100 बार पुनरारंभ किया जाएगा, जो संभवतः अत्यधिक है। शीर्ष स्तर के पर्यवेक्षक के लिए अधिकतम 3 पुनरारंभ की अनुमति इस मामले में एक बेहतर विकल्प हो सकती है।

5.6 बाल विशिष्टता

बच्चे के विनिर्देशन की परिभाषा इस प्रकार है:

child_spec() = #{id => child_id(),       % mandatory
                 start => mfargs(),      % mandatory
                 restart => restart(),   % optional
                 shutdown => shutdown(), % optional
                 type => worker(),       % optional
                 modules => modules()}   % optional
    child_id() = term()
    mfargs() = {M :: module(), F :: atom(), A :: [term()]}
    modules() = [module()] | dynamic
    restart() = permanent | transient | temporary
    shutdown() = brutal_kill | timeout()
    worker() = worker | supervisor
  • id का उपयोग पर्यवेक्षक द्वारा आंतरिक रूप से बच्चे के विनिर्देश की पहचान करने के लिए किया जाता है।

    id कुंजी अनिवार्य है।

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

  • start चाइल्ड प्रोसेस शुरू करने के लिए उपयोग किए जाने वाले फंक्शन कॉल को परिभाषित करता है। यह एक मॉड्यूल-फ़ंक्शन-आर्ग्यूमेंट्स टपल है जिसका उपयोग apply(M, F, A) रूप में किया जाता है।

    यह निम्न में से किसी एक कॉल के लिए (या परिणाम में) होना है:

    • supervisor:start_link
    • gen_server:start_link
    • gen_statem:start_link
    • gen_event:start_link
    • इन कार्यों के अनुरूप एक समारोह। विवरण के लिए, supervisor(3) मैनुअल पेज देखें।

    start कुंजी अनिवार्य है।

  • restart परिभाषित करता है जब एक समाप्त बच्चे की प्रक्रिया को फिर से शुरू किया जाना है।

    • एक permanent बच्चे की प्रक्रिया हमेशा पुनरारंभ होती है।
    • एक temporary बच्चे की प्रक्रिया को फिर से शुरू नहीं किया जाता है (तब भी जब पर्यवेक्षक पुनरारंभ की रणनीति rest_for_one या one_for_all और एक भाई की मृत्यु अस्थायी प्रक्रिया को समाप्त करने का कारण बनती है)।
    • एक transient बच्चे की प्रक्रिया को फिर से शुरू किया जाता है, जब वह असामान्य रूप से समाप्त हो जाता है, अर्थात, normal , shutdown या {shutdown,Term} अलावा किसी अन्य कारण से।

    restart कुंजी वैकल्पिक है। यदि यह नहीं दिया जाता है, तो डिफ़ॉल्ट मान का उपयोग किया जाएगा।

  • shutdown परिभाषित करता है कि एक बच्चे की प्रक्रिया को कैसे समाप्त किया जाना है।

    • brutal_kill अर्थ है कि exit(Child, kill) का उपयोग करके बच्चे की प्रक्रिया को बिना शर्त समाप्त कर दिया जाता है।
    • पूर्णांक समय-आउट मान का अर्थ है कि पर्यवेक्षक exit(Child, shutdown) को कॉल करके समाप्त करने के लिए बच्चे की प्रक्रिया को बताता है और फिर बाहर निकलने के संकेत का इंतजार करता है। यदि निर्दिष्ट समय के भीतर कोई निकास संकेत प्राप्त नहीं होता है, तो exit(Child, kill) का उपयोग करके बच्चे की प्रक्रिया को बिना शर्त समाप्त कर दिया जाता है।
    • यदि बाल प्रक्रिया एक और पर्यवेक्षक है, तो इसे बंद करने के लिए पर्याप्त समय देने के लिए infinity को सेट करना है। यह भी infinity लिए इसे सेट करने की अनुमति है, अगर बच्चे की प्रक्रिया एक कार्यकर्ता है। नीचे चेतावनी देखें:
    चेतावनी

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

    shutdown कुंजी वैकल्पिक है। यदि यह नहीं दिया गया है, और बच्चा टाइप worker , तो डिफ़ॉल्ट मान 5000 का उपयोग किया जाएगा; यदि बच्चा टाइप supervisor , तो डिफ़ॉल्ट वैल्यू infinity का उपयोग किया जाएगा।

  • type निर्दिष्ट करता है कि क्या बच्चा प्रक्रिया एक पर्यवेक्षक या एक कार्यकर्ता है।

    type कुंजी वैकल्पिक है। यदि यह नहीं दिया जाता है, तो डिफ़ॉल्ट मान worker का उपयोग किया जाएगा।

  • modules एक तत्व [Module] साथ एक सूची होनी चाहिए, जहां Module कॉलबैक मॉड्यूल का नाम है, अगर बच्चा प्रक्रिया एक पर्यवेक्षक, gen_server, gen_statem है। यदि बच्चा प्रक्रिया एक gen_event है, तो मूल्य dynamic

    इस जानकारी का उपयोग अपग्रेड और डाउनग्रेड के दौरान रिलीज़ हैंडलर द्वारा किया जाता है, Release Handling देखें।

    modules कुंजी वैकल्पिक है। यदि यह नहीं दिया जाता है, तो यह [M] चूक करता है, जहां M बच्चे के प्रारंभ {M,F,A}

उदाहरण: पिछले उदाहरण में सर्वर ch3 को शुरू करने के लिए बच्चा विनिर्देश निम्न है:

#{id => ch3,
  start => {ch3, start_link, []},
  restart => permanent,
  shutdown => brutal_kill,
  type => worker,
  modules => [ch3]}

या सरलीकृत, डिफ़ॉल्ट मानों पर निर्भर:

#{id => ch3,
  start => {ch3, start_link, []}
  shutdown => brutal_kill}

उदाहरण: gen_event बारे में अध्याय से इवेंट मैनेजर शुरू करने के लिए एक बच्चा विनिर्देश:

#{id => error_man,
  start => {gen_event, start_link, [{local, error_man}]},
  modules => dynamic}

सर्वर और इवेंट मैनेजर दोनों ही पंजीकृत प्रक्रियाएं हैं जिनसे हमेशा सुलभ होने की उम्मीद की जा सकती है। इस प्रकार वे permanent होने के लिए निर्दिष्ट हैं।

ch3 को समाप्ति से पहले कोई सफाई करने की आवश्यकता नहीं है। इस प्रकार, कोई शटडाउन समय की आवश्यकता नहीं है, लेकिन brutal_kill पर्याप्त है। error_man को इवेंट हैंडलर्स को साफ करने के लिए कुछ समय की आवश्यकता हो सकती है, इस प्रकार शटडाउन का समय 5000 ms (जो डिफ़ॉल्ट सेटिंग है) पर सेट है।

उदाहरण: एक अन्य पर्यवेक्षक शुरू करने के लिए एक बच्चा विनिर्देश:

#{id => sup,
  start => {sup, start_link, []},
  restart => transient,
  type => supervisor} % will cause default shutdown=>infinity

5.7 एक पर्यवेक्षक शुरू करना

पिछले उदाहरण में, पर्यवेक्षक को ch_sup:start_link() कहकर शुरू किया गया है:

start_link() ->
    supervisor:start_link(ch_sup, []).

ch_sup:start_link कॉल फ़ंक्शन supervisor:start_link/2 , जो एक नई प्रक्रिया, एक पर्यवेक्षक के लिए जुड़ता है और लिंक करता है।

  • पहला तर्क, ch_sup , कॉलबैक मॉड्यूल का नाम है, अर्थात, वह मॉड्यूल जहां init कॉलबैक फ़ंक्शन स्थित है।
  • दूसरा तर्क, [] , एक शब्द है जिसे कॉलबैक फ़ंक्शन init रूप में पास किया गया है। यहाँ, init को किसी भी indata की आवश्यकता नहीं है और तर्क को अनदेखा करता है।

इस मामले में, पर्यवेक्षक पंजीकृत नहीं है। इसके बजाय इसके पिड का उपयोग किया जाना चाहिए। supervisor:start_link({local, Name}, Module, Args) को कॉल करके एक नाम निर्दिष्ट किया जा सकता है supervisor:start_link({local, Name}, Module, Args) या supervisor:start_link({global, Name}, Module, Args)

नई पर्यवेक्षक प्रक्रिया कॉलबैक फ़ंक्शन ch_sup:init([]) कॉल करती है। init लौटेगा {ok, {SupFlags, ChildSpecs}} :

init(_Args) ->
    SupFlags = #{},
    ChildSpecs = [#{id => ch3,
                    start => {ch3, start_link, []},
                    shutdown => brutal_kill}],
    {ok, {SupFlags, ChildSpecs}}.

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

supervisor:start_link तुल्यकालिक है। यह तब तक वापस नहीं आता है जब तक कि सभी बाल प्रक्रियाएं शुरू नहीं हो जाती हैं।

5.8 बाल प्रक्रिया जोड़ना

स्थैतिक पर्यवेक्षण वृक्ष के अलावा, गतिशील बाल प्रक्रियाओं को निम्नलिखित कॉल के साथ मौजूदा पर्यवेक्षक में जोड़ा जा सकता है:

supervisor:start_child(Sup, ChildSpec)

Sup पर्यवेक्षक का पिड, या नाम है। ChildSpec एक child specification

start_child/2 का उपयोग करके बाल प्रक्रियाएं उसी तरह से व्यवहार करती हैं जैसे कि अन्य बाल प्रक्रियाएं, एक महत्वपूर्ण अपवाद के साथ होती हैं: यदि एक पर्यवेक्षक की मृत्यु हो जाती है और उसे फिर से बनाया जाता है, तो पर्यवेक्षक में गतिशील रूप से जोड़े गए सभी बच्चे प्रक्रिया खो जाते हैं।

5.9 बाल प्रक्रिया को रोकना

किसी भी बच्चे की प्रक्रिया, स्थिर या गतिशील, शटडाउन विनिर्देश के अनुसार रोका जा सकता है:

supervisor:terminate_child(Sup, Id)

रुकी हुई बाल प्रक्रिया के लिए चाइल्ड स्पेसिफिकेशन को निम्न कॉल के साथ हटा दिया गया है:

supervisor:delete_child(Sup, Id)

Sup पर्यवेक्षक का पिड, या नाम है। Id child specification में id कुंजी के साथ जुड़ा हुआ मूल्य है।

यदि गतिशील रूप से जोड़े गए बच्चे की प्रक्रियाओं के साथ, एक स्थिर बच्चे की प्रक्रिया को हटाने का प्रभाव खो जाता है यदि पर्यवेक्षक खुद को पुनरारंभ करता है।

5.10 सरलीकृत one_for_one पर्यवेक्षक

पुनरारंभ रणनीति के साथ एक पर्यवेक्षक simple_one_for_one एक सरलीकृत one_for_one पर्यवेक्षक है, जहां सभी बच्चे प्रक्रियाएं गतिशील रूप से एक ही प्रक्रिया के इंस्टेंसेस जोड़े जाते हैं।

निम्नलिखित एक simple_one_for_one पर्यवेक्षक के लिए कॉलबैक मॉड्यूल का एक उदाहरण है:

-module(simple_sup).
-behaviour(supervisor).

-export([start_link/0]).
-export([init/1]).

start_link() ->
    supervisor:start_link(simple_sup, []).

init(_Args) ->
    SupFlags = #{strategy => simple_one_for_one,
                 intensity => 0,
                 period => 1},
    ChildSpecs = [#{id => call,
                    start => {call, start_link, []},
                    shutdown => brutal_kill}],
    {ok, {SupFlags, ChildSpecs}}.

जब शुरू किया जाता है, पर्यवेक्षक किसी भी बच्चे की प्रक्रिया शुरू नहीं करता है। इसके बजाय, सभी बाल प्रक्रियाओं को गतिशील रूप से कॉल करके जोड़ा जाता है:

supervisor:start_child(Sup, List)

Sup पर्यवेक्षक का पिड, या नाम है। List शब्दों की एक मनमानी सूची है, जिसे बाल विनिर्देश में निर्दिष्ट तर्कों की सूची में जोड़ा जाता है। यदि प्रारंभ फ़ंक्शन को {M, F, A} रूप में निर्दिष्ट किया जाता है, तो चाइल्ड प्रोसेस को apply(M, F, A++List) कहकर शुरू किया जाता है।

उदाहरण के लिए, ऊपर के simple_sup एक बच्चा जोड़ना:

supervisor:start_child(Pid, [id1])

इसका परिणाम यह होता है कि चाइल्ड प्रोसेस की शुरुआत apply(call, start_link, []++[id1]) , या वास्तव में apply(call, start_link, []++[id1]) करके की जाती है:

call:start_link(id1)

एक simple_one_for_one पर्यवेक्षक के तहत एक बच्चा निम्नलिखित के साथ समाप्त किया जा सकता है:

supervisor:terminate_child(Sup, Pid)

Sup पर्यवेक्षक का पीआईडी ​​या नाम है, और पीआईडी ​​बच्चे का पिड है।

क्योंकि एक simple_one_for_one सुपरवाइज़र के कई बच्चे हो सकते हैं, यह उन सभी को अतुल्यकालिक रूप से बंद कर देता है। इसका मतलब है कि बच्चे अपनी सफाई समानांतर रूप से करेंगे और इसलिए जिस क्रम में उन्हें रोका गया है, वह परिभाषित नहीं है।

5.11 रोकना

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