Erlang 21

dbg




erlang

dbg

मॉड्यूल

dbg

मॉड्यूल सारांश

पाठ आधारित ट्रेस सुविधा

विवरण

यह मॉड्यूल trace/3 और trace_pattern/2 बीआईएफ के लिए एक पाठ आधारित इंटरफ़ेस लागू करता है। यह कार्यों, प्रक्रियाओं, बंदरगाहों और संदेशों का पता लगाना संभव बनाता है।

ट्रेसिंग फ़ंक्शन कॉल को जल्दी से आरंभ करने के लिए आप एरलांग शेल में निम्न कोड का उपयोग कर सकते हैं:

1> dbg:tracer(). %% Start the default trace message receiver
{ok,<0.36.0>}
2> dbg:p(all, c). %% Setup call (c) tracing on all processes
{ok,[{matched,[email protected],26}]}
3> dbg:tp(lists, seq, x). %% Setup an exception return trace (x) on lists:seq
{ok,[{matched,[email protected],2},{saved,x}]}
4> lists:seq(1,10).
(<0.34.0>) call lists:seq(1,10)
(<0.34.0>) returned from lists:seq/2 -> [1,2,3,4,5,6,7,8,9,10]
[1,2,3,4,5,6,7,8,9,10]
    

Erlang शेल से dbg का उपयोग कैसे करें के अधिक उदाहरणों के लिए, simple example अनुभाग देखें।

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

निर्यात

fun2ms (लिटरलफ़न) -> माचिस

प्रकार

छद्म फ़ंक्शन जो कि parse_transform माध्यम से फ़ंक्शन मिलान में पैरामीटर के रूप में टाइप किए गए शाब्दिक fun() टाइप करता है, जैसा कि match_spec उपयोगकर्ता गाइड के match_spec मैनुअल में वर्णित है। (शाब्दिक के साथ मेरा मतलब है कि fun() को पाठ के रूप में फ़ंक्शन के पैरामीटर के रूप में लिखा जाना चाहिए, इसे एक चर में आयोजित नहीं किया जा सकता है जो बदले में फ़ंक्शन को पारित किया जाता है)।

पार्स ट्रांस्फ़ॉर्म ms_transform में कार्यान्वित किया ms_transform और स्रोत को इस छद्म फ़ंक्शन को काम करने के लिए ms_transform.hrl में ms_transform.hrl फ़ाइल को शामिल करना चाहिए । स्रोत में hrl फ़ाइल को शामिल करने में विफल होने पर एक रनटाइम त्रुटि होगी, न कि एक संकलन समय ditto। सम्मिलित फ़ाइल लाइन -include_lib("stdlib/include/ms_transform.hrl"). जोड़कर सबसे आसान है -include_lib("stdlib/include/ms_transform.hrl"). स्रोत फ़ाइल के लिए।

fun() बहुत प्रतिबंधित है, यह केवल एक पैरामीटर (मिलान करने के लिए पैरामीटर सूची), एक एकल चर या एक सूची ले सकता है। इसे is_ XXX गार्ड परीक्षणों का उपयोग करने की आवश्यकता होती है और कोई भी भाषा निर्माण का उपयोग नहीं कर सकता है जिसका कोई match_spec में प्रतिनिधित्व नहीं है (जैसे if , case , receive आदि)। मौज-मस्ती से वापसी का मान परिणामी match_spec का रिटर्न मान होगा।

उदाहरण:

1> dbg:fun2ms(fun([M,N]) when N > 3 -> return_trace() end).
[{['$1','$2'],[{'>','$2',3}],[{return_trace}]}]

पर्यावरण से चर आयात किए जा सकते हैं, ताकि यह काम करे:

2> X=3.
3
3> dbg:fun2ms(fun([M,N]) when N > X -> return_trace() end).
[{['$1','$2'],[{'>','$2',{const,3}}],[{return_trace}]}]

आयातित चर को मैच_स्पेक कास्ट एक्सप्रेशन से बदल दिया जाएगा, जो कि एरलांग fun() एस fun() लिए स्थिर स्कोपिंग के अनुरूप है। स्थानीय या वैश्विक फ़ंक्शन कॉल हालांकि मज़े के गार्ड या शरीर में नहीं हो सकते हैं। बिलियन से मेल खाने के लिए कॉल किया जाता है।

4> dbg:fun2ms(fun([M,N]) when N > X, is_atomm(M) -> return_trace() end).
Error: fun containing local erlang function calls ('is_atomm' called in guard)\
 cannot be translated into match_spec
{error,transform_error}
5> dbg:fun2ms(fun([M,N]) when N > X, is_atom(M) -> return_trace() end).
[{['$1','$2'],[{'>','$2',{const,3}},{is_atom,'$1'}],[{return_trace}]}]

जैसा कि आप उदाहरण से देख सकते हैं, फ़ंक्शन को शेल से भी बुलाया जा सकता है। शेल से उपयोग किए जाने पर fun() कॉल fun() शाब्दिक रूप से कॉल करने की आवश्यकता होती है। Parse_transform के अलावा अन्य साधनों का उपयोग शेल मामले में किया जाता है, लेकिन कमोबेश वही प्रतिबंध लागू होते हैं (अपवाद रिकॉर्ड किए जा रहे हैं, क्योंकि वे शेल द्वारा नियंत्रित नहीं किए जाते हैं)।

चेतावनी

यदि parse_transform किसी मॉड्यूल पर लागू नहीं होता है, जो इस छद्म फ़ंक्शन को कॉल करता है, तो कॉल रनटाइम में विफल हो जाएगा (एक badarg साथ)। मॉड्यूल dbg वास्तव में इस नाम के साथ एक फ़ंक्शन निर्यात करता है, लेकिन इसे शेल में फ़ंक्शन का उपयोग करते समय वास्तव में कभी भी नहीं बुलाया जाना चाहिए। यदि ms_transform.hrl हेडर फ़ाइल को शामिल करके ms_transform.hrl ठीक से लागू किया जाता है, तो संकलित कोड फ़ंक्शन को कभी कॉल नहीं करेगा, लेकिन फ़ंक्शन कॉल को शाब्दिक match_spec द्वारा बदल दिया जाता है।

ms_transform में ms_transform मैनुअल पेज द्वारा अधिक जानकारी दी गई है।

h () -> ठीक है

संक्षिप्त ऑनलाइन मदद के लिए मदों की एक सूची देता है।

h (आइटम) -> ठीक है

प्रकार

Dbg मॉड्यूल में कार्यों के लिए एक संक्षिप्त मदद पाठ देता है। उपलब्ध वस्तुओं को dbg:h/0 साथ सूचीबद्ध किया जा सकता है

p (आइटम) -> {ठीक है, माचिस} | {त्रुटिपूर्ण शर्त()}

p(Item, [m]) बराबर p(Item, [m])

p (आइटम, झंडे) -> {ठीक है, माचिस} | {त्रुटिपूर्ण शर्त()}

प्रकार

Flags द्वारा निर्दिष्ट मूल्य के अनुसार Item निशान। Item की विविधता नीचे सूचीबद्ध है:

pid() या port()
इसी प्रक्रिया या पोर्ट का पता लगाया जाता है। प्रक्रिया या पोर्ट एक दूरस्थ प्रक्रिया या पोर्ट (किसी अन्य Erlang नोड पर) हो सकता है। नोड tracer/3 नोड्स की सूची में होना चाहिए ( n/1 और tracer/3 )।
all
सिस्टम में सभी प्रक्रियाओं और बंदरगाहों के साथ-साथ सभी प्रक्रियाओं और बंदरगाहों का निर्माण किया जाता है।
processes
सिस्टम की सभी प्रक्रियाओं के साथ-साथ सभी प्रक्रियाओं को इसके बाद बनाया गया है।
ports
सिस्टम के सभी बंदरगाहों के साथ-साथ सभी बंदरगाहों का निर्माण किया गया।
new
कॉल के बाद बनाई गई सभी प्रक्रियाओं और बंदरगाहों का पता लगाया जाना है।
new_processes
कॉल के बाद बनाई गई सभी प्रक्रियाओं का पता लगाया जाना है।
new_ports
कॉल के बाद बनाए गए सभी पोर्ट का पता लगाया जाना है।
existing
सभी मौजूदा प्रक्रियाओं और बंदरगाहों का पता लगाया जाता है।
existing_processes
सभी मौजूदा प्रक्रियाओं का पता लगाया जाता है।
existing_ports
सभी मौजूदा बंदरगाहों का पता लगाया गया है।
atom()
संबंधित पंजीकृत नाम के साथ प्रक्रिया या पोर्ट का पता लगाया जाता है। प्रक्रिया या पोर्ट एक दूरस्थ प्रक्रिया हो सकती है (दूसरे एर्लांग नोड पर)। नोड को n/1 या tracer/3 फ़ंक्शन के साथ जोड़ा जाना चाहिए।
integer()
प्रक्रिया <0.Item.0> का पता लगाया जाता है।
{X, Y, Z}
प्रक्रिया <XYZ> का पता लगाया जाता है।
string()
यदि Item "<XYZ>" है जैसा कि pid_to_list/1 से लौटा है, तो प्रक्रिया <XYZ> का पता लगाया जाता है।

Item को प्रक्रियाओं के समूह का प्रतिनिधित्व करने वाले को सक्षम करते समय, Item को n/1 या tracer/3 फ़ंक्शन के साथ जोड़े गए सभी नोड्स पर सक्षम किया जाता है।

Flags एकल परमाणु, या झंडे की एक सूची हो सकती है। उपलब्ध झंडे हैं:

s (send)

संदेशों को प्रक्रिया या पोर्ट भेजता है।

r (receive)

संदेशों को प्रक्रिया या पोर्ट प्राप्त करता है।

m (messages)

संदेशों को प्रक्रिया या पोर्ट प्राप्त करता है और भेजता है।

c (call)

ट्रेस वैश्विक फ़ंक्शन कॉल सिस्टम में सेट ट्रेस पैटर्न के अनुसार प्रक्रिया के लिए कहता है (देखें tp / 2)।

p (procs)

ट्रेस प्रक्रिया से संबंधित घटनाओं को संसाधित करता है।

ports

पोर्ट से संबंधित घटनाओं का पता लगाता है।

sos (set on spawn)

ट्रेस प्रक्रिया द्वारा बनाई गई सभी प्रक्रियाओं को ट्रेस की गई प्रक्रिया के ट्रेस झंडे विरासत में मिलते हैं।

sol (set on link)

जब भी ट्रेस प्रक्रिया P2 लिंक होती है, एक और प्रक्रिया, P2 , ट्रेस प्रक्रिया के ट्रेस झंडे को विरासत में देती है।

sofs (set on first spawn)

यह sos जैसा ही है, लेकिन केवल पहली प्रक्रिया के लिए ट्रेस की गई प्रक्रिया द्वारा देखा गया है।

sofl (set on first link)

यह sol के समान है, लेकिन केवल पहली कॉल के लिए link/1 द्वारा ट्रेस की गई प्रक्रिया है।

all

silent को छोड़कर सभी झंडे सेट।

clear

सब झंडे गाड़ देता है।

सूची में erlang:trace/3 में अनुमति दिए गए किसी भी झंडे को भी शामिल किया जा सकता है erlang:trace/3

फ़ंक्शन या तो एक त्रुटि टपल या एक टपल {ok, List} List में कितने प्रक्रियाओं और पोर्ट से मेल खाती है (एक शुद्ध पिड के मामले में) बिल्कुल 1) के विनिर्देशों हैं। मिलान की गई प्रक्रियाओं का विनिर्देश {matched, Node, N} । यदि दूरस्थ प्रोसेसर कॉल, rpc , एक दूरस्थ नोड में विफल रहता है, तो rpc त्रुटि संदेश चौथे तर्क के रूप में दिया जाता है और मिलान प्रक्रियाओं की संख्या 0. है। ध्यान दें कि परिणाम {ठीक है, सूची} में एक सूची हो सकती है जहां rpc कॉल होती है एक, कई या सभी नोड्स विफल रहे।

सी (मॉड, फन, आर्ग्स)

c(Mod, Fun, Args, all)

सी (मॉड, फन, आर्ग्स, झंडे)

Flags सेट में ट्रेस झंडे के साथ अभिव्यक्ति apply(Mod, Fun, Args) । यह एरलैंग शेल से प्रक्रियाओं का पता लगाने का एक सुविधाजनक तरीका है।

i () -> ठीक है

सभी ट्रेस की गई प्रक्रियाओं और बंदरगाहों के बारे में जानकारी प्रदर्शित करता है।

tp (मॉड्यूल, MatchSpec)

Tp ({मॉड्यूल, '_', '_'}, MatchSpec) के समान

tp (मॉड्यूल, समारोह, MatchSpec)

Tp ({मॉड्यूल, फ़ंक्शन, '_'}, MatchSpec) के समान

tp (मॉड्यूल, फंक्शन, एरिटी, माचिस)

Tp के रूप में भी ({मॉड्यूल, फंक्शन, एरिटी}, माचिस)

tp ({मॉड्यूल, फंक्शन, एरिटी}, मैचस्पीक) -> {ठीक है, मैचडेस्क} | {त्रुटिपूर्ण शर्त()}

प्रकार

यह फ़ंक्शन एक या अधिक फ़ंक्शन के लिए कॉल ट्रेस सक्षम करता है। {Module, Function, Arity} तर्क से मेल खाते सभी निर्यात किए गए कार्य चिंतित होंगे, लेकिन match_spec() कॉल को संदेश match_spec() वाले फ़ंक्शन कॉल के सेट से match_spec() आगे संकीर्ण हो सकता है।

match_spec() सिंटैक्स के विवरण के लिए, कृपया रनटाइम सिस्टम ( एरेट्स ) के लिए ऑनलाइन दस्तावेज़ के उपयोगकर्ता गाइड भाग की ओर रुख करें। Match Specifications in Erlang चैप्टर Match Specifications in Erlang सामान्य मैच स्पेसिफिकेशन "भाषा" की व्याख्या करता है। उपयोग किए जाने वाले सबसे सामान्य जेनेरिक मिलान विनिर्देशों को Built-inAlias रूप में पाया जा सकता है, विवरण के लिए नीचे ltp/0 देखें।

ट्यूल के मॉड्यूल, फ़ंक्शन और / या एरिटी भागों को परमाणु '_' रूप में निर्दिष्ट किया जा सकता है, जो सभी मॉड्यूल / फ़ंक्शन / एरिटीज़ से मेल खाता एक "वाइल्ड-कार्ड" है। ध्यान दें, यदि मॉड्यूल को '_' रूप में निर्दिष्ट किया गया है, तो फ़ंक्शन और एरिटी भागों को '_' के रूप में भी निर्दिष्ट किया जाना है। समान कार्य के लिए Arity के संबंध में है।

n/1 या tracer/3 साथ जोड़े गए सभी नोड इस कॉल से प्रभावित होंगे, और यदि मॉड्यूल '_' नहीं है, तो मॉड्यूल सभी नोड पर लोड किया जाएगा।

फ़ंक्शन या तो एक त्रुटि टपल या एक टपल {ok, List} List में कितने कार्य हैं, के विनिर्देशों के होते हैं, उसी तरह जैसे कि प्रक्रियाओं और बंदरगाहों को p/2 के रिटर्न मान में प्रस्तुत किया जाता है।

यदि मैचस्पीक [] के अलावा अन्य हो, तो रिटर्न वैल्यू में टपल {saved, N} हो सकता है। पूर्णांक N को इस फ़ंक्शन के बाद की कॉल में उपयोग किया जा सकता है और दिए गए एक्सप्रेशन के लिए "उपनाम" के रूप में खड़ा होगा। सामान्य अभिव्यक्तियों के लिए अंतर्निहित कुछ उपनाम भी हैं, विवरण के लिए नीचे ltp/0 देखें।

यदि कोई त्रुटि वापस की जाती है, तो यह मैच विनिर्देश के संकलन में त्रुटियों के कारण हो सकता है। इस तरह की त्रुटियों को tuples {error, string()} की सूची के रूप में प्रस्तुत किया जाता है जहां स्ट्रिंग संकलन त्रुटि का एक पाठ विवरण है। एक उदाहरण:

([email protected])4> dbg:tp({dbg,ltp,0},[{[],[],[{message, two, arguments}, {noexist}]}]).
{error,
 [{error,"Special form 'message' called with wrong number of
          arguments in {message,two,arguments}."},
  {error,"Function noexist/1 does_not_exist."}]}
TPL (मॉड्यूल, MatchSpec)

Tpl ({मॉड्यूल, '_', '_'}, MatchSpec) के समान

TPL (मॉड्यूल, समारोह, MatchSpec)

Tpl के समान ({मॉड्यूल, फ़ंक्शन, '_'}, माचिस)

tpl (मॉड्यूल, फंक्शन, एरिटी, माचिस)

Tpl के समान ({मॉड्यूल, फंक्शन, एरिटी}, माचिस)

tpl ({मॉड्यूल, फंक्शन, एरीटी}, माचिस) -> {ठीक है, माचिस} | {त्रुटिपूर्ण शर्त()}

यह फ़ंक्शन tp/2 रूप में काम करता है, लेकिन स्थानीय कॉल (और स्थानीय फ़ंक्शन) के साथ-साथ वैश्विक कॉल (और फ़ंक्शंस) के लिए अनुरेखण सक्षम करता है।

tpe (घटना, माचिस की तीली) -> {ठीक है, माचिस} | {त्रुटिपूर्ण शर्त()}

प्रकार

यह फ़ंक्शन ट्रेस इवेंट send या 'receive' साथ एक मैच विनिर्देश को जोड़ता है। डिफ़ॉल्ट रूप से सभी निष्पादित send और 'receive' घटनाओं का पता लगाया जाता है अगर एक प्रक्रिया के लिए सक्षम किया गया है। एक मेल विनिर्देशन का उपयोग प्रेषक, रिसीवर और / या संदेश सामग्री के आधार पर ट्रेस की गई घटनाओं को फ़िल्टर करने के लिए किया जा सकता है।

match_spec() सिंटैक्स के विवरण के लिए, कृपया रनटाइम सिस्टम ( एरेट्स ) के लिए ऑनलाइन दस्तावेज़ के उपयोगकर्ता गाइड भाग की ओर रुख करें। Match Specifications in Erlang चैप्टर Match Specifications in Erlang सामान्य मैच स्पेसिफिकेशन "भाषा" की व्याख्या करता है।

send के send , मिलान सूची [Receiver, Msg] पर किया जाता है। Receiver की प्रक्रिया या पोर्ट पहचान है और Msg संदेश शब्द है। भेजने की प्रक्रिया के पिड को गार्ड फंक्शन self/0 साथ एक्सेस किया जा सकता है।

'receive' , मिलान सूची [Node, Sender, Msg] Node प्रेषक का नोड नाम है। Sender की प्रक्रिया या बंदरगाह की पहचान है, या परमाणु undefined यदि प्रेषक ज्ञात नहीं है (जो दूरस्थ प्रेषकों के लिए मामला हो सकता है)। Msg संदेश शब्द है। प्राप्त करने की प्रक्रिया के पिड को गार्ड फंक्शन self/0 साथ एक्सेस किया जा सकता है।

n/1 या tracer/3 साथ जोड़े गए सभी नोड इस कॉल से प्रभावित होंगे।

वापसी मान tp/2 लिए समान है। मिलान किए गए ईवेंट की संख्या कभी भी 1 से बड़ी नहीं होती क्योंकि तर्क Event लिए tpe/2 वाइल्डकार्ड के किसी भी रूप को स्वीकार नहीं करता है।

सीटीपी ()

Ctp ({'_', '_', '_'}) के समान

सीटीपी (मॉड्यूल)

Ctp ({मॉड्यूल, '_', '_'}) के समान

ctp (मॉड्यूल, फंक्शन)

Ctp ({मॉड्यूल, फंक्शन, '_'}) के समान

ctp (मॉड्यूल, फंक्शन, एरिटी)

Ctp के रूप में भी ({मॉड्यूल, फंक्शन, एरिटी})

ctp ({मॉड्यूल, फंक्शन, एरिटी}) -> {ओके, मैचडेस्क} | {त्रुटिपूर्ण शर्त()}

प्रकार

यह फ़ंक्शन निर्दिष्ट कार्यों पर कॉल ट्रेसिंग को अक्षम करता है। पैरामीटर का शब्दार्थ tp/2 या tpl/2 में संबंधित फ़ंक्शन विनिर्देश के लिए समान है। स्थानीय और वैश्विक कॉल ट्रेस अक्षम है।

वापसी मान दर्शाता है कि कितने कार्य मेल खाते हैं, और इसका निर्माण tp/2 में वर्णित है। हालांकि {saved, N} कोई टपल {saved, N} को कभी भी लौटाया गया (स्पष्ट कारणों के लिए)।

CTPL ()

Ctpl ({'_', '_', '_'}) के समान

CTPL (मॉड्यूल)

Ctpl ({मॉड्यूल, '_', '_'}) के समान

ctpl (मॉड्यूल, समारोह)

Ctpl ({मॉड्यूल, फ़ंक्शन, '_'}) के समान

ctpl (मॉड्यूल, कार्य, योग्यता)

Ctpl के रूप में भी ({मॉड्यूल, फंक्शन, एरिटी})

ctpl ({मॉड्यूल, फंक्शन, एरिटी}) -> {ओके, मैचडेस्क} | {त्रुटिपूर्ण शर्त()}

यह फ़ंक्शन ctp/1 रूप में काम करता है, लेकिन केवल tpl/2 ( tp/2 साथ नहीं) के साथ सेट किए गए अनुरेखण को अक्षम करता है।

ctpg ()

Ctpg ({'_', '_', '_'}) के समान

ctpg (मॉड्यूल)

Ctpg ({मॉड्यूल, '_', '_'}) के समान

ctpg (मॉड्यूल, समारोह)

Ctpg ({मॉड्यूल, फ़ंक्शन, '_'}) के समान

ctpg (मॉड्यूल, कार्य, योग्यता)

Ctpg ({मॉड्यूल, फंक्शन, एरिटी}) के समान

ctpg ({मॉड्यूल, फंक्शन, एरिटी}) -> {ओके, मैचडेस्क} | {त्रुटिपूर्ण शर्त()}

यह फ़ंक्शन ctp/1 रूप में काम करता है, लेकिन केवल tp/2 ( tpl/2 साथ नहीं) के साथ सेट किए गए अनुरेखण को अक्षम करता है।

ctpe (घटना) -> {ठीक है, माचिस} | {त्रुटिपूर्ण शर्त()}

प्रकार

यह फ़ंक्शन निर्दिष्ट ट्रेस ईवेंट ( send या 'receive' ) के लिए विशिष्टताओं से मेल खाता है। यह सभी ट्रिगर घटनाओं को ट्रेस करने के डिफ़ॉल्ट व्यवहार पर वापस लौट आएगा।

वापसी मान ctp/1 लिए उसी शैली का अनुसरण करता है।

ltp () -> ठीक है

इस फ़ंक्शन का उपयोग सत्र में पहले से उपयोग किए गए सभी मिलान विनिर्देशों को याद करने के लिए करें (यानी पहले कॉल के दौरान tp/2 सहेजे गए, और अंतर्निहित मिलान विनिर्देशों। यह बहुत उपयोगी है, क्योंकि एक जटिल match_spec लिखने के लिए काफी अजीब हो सकता है। ध्यान दें कि यदि stop/0 कहा जाता है तो मैच विनिर्देश खो जाते हैं।

बाद में डिबगिंग सत्रों में उपयोग करने के लिए उपयोग किए जाने वाले मिलान विनिर्देशों को एक फ़ाइल में (यदि एक रीड-राइट फ़ाइल सिस्टम मौजूद है) बचाया जा सकता है, wtp/1 और rtp/1

तीन अंतर्निहित ट्रेस पैटर्न हैं: caller_trace , caller_trace और caller_exception_trace (या क्रमशः x , c और cx )। अपवाद ट्रेस एक ट्रेस सेट करता है जो फ़ंक्शन के नाम, पैरामीटर, रिटर्न मान और फ़ंक्शन से फेंके गए अपवादों को दिखाएगा। कॉलर निशान फ़ंक्शन के नाम, पैरामीटर और जानकारी को प्रदर्शित करता है कि किस फ़ंक्शन ने इसे बुलाया। एक अंतर्निहित उपनाम का उपयोग करके एक उदाहरण:

([email protected])4> dbg:tp(lists,sort,cx).
{ok,[{matched,[email protected],2},{saved,cx}]}
([email protected])4> lists:sort([2,1]).
(<0.32.0>) call lists:sort([2,1]) ({erl_eval,do_apply,5})
(<0.32.0>) returned from lists:sort/1 -> [1,2]
[1,2]
dtp () -> ठीक है

tp/2 लिए कॉल के दौरान सहेजे गए सभी मिलान विनिर्देशों को "भूलने" के लिए इस फ़ंक्शन का उपयोग करें। यह तब उपयोगी होता है जब कोई rtp/1 फ़ाइल से अन्य मिलान विशिष्टताओं को पुनर्स्थापित करना चाहता है। विशिष्ट सहेजे गए मिलान विनिर्देशों को हटाने के लिए dtp/1 का उपयोग करें।

dtp (एन) -> ठीक है

प्रकार

tp/2 कॉल के दौरान सहेजे गए एक विशिष्ट मिलान विनिर्देश को "भूलने" के लिए इस फ़ंक्शन का उपयोग करें।

wtp (नाम) -> ठीक | {त्रुटि, IOError}

प्रकार

यह फ़ंक्शन सत्र के दौरान सहेजे गए सभी मिलान विनिर्देशों ( tp/2 कॉल के दौरान) और नाम से निर्दिष्ट नाम के साथ एक पाठ फ़ाइल में अंतर्निहित मिलान विनिर्देशों को बचाएगा। फ़ाइल का प्रारूप rtp/1 , क्यों इसे एक साधारण पाठ संपादक के साथ संपादित किया जा सकता है, और फिर इसे rtp/1 साथ बहाल किया जा सकता है।

फ़ाइल में प्रत्येक मिलान कल्पना एक पूर्ण विराम ( . ) के साथ समाप्त होती है और नई (वाक्यविन्यास सही) मिलान विनिर्देशों को फ़ाइल में मैन्युअल रूप से जोड़ा जा सकता है।

फ़ंक्शन ok लौटता है या एक त्रुटि ट्यूपल जहां दूसरे तत्व में I / O त्रुटि होती है जिसने लेखन को असंभव बना दिया है।

rtp (नाम) -> ठीक | {त्रुटि, त्रुटि}

प्रकार

यह फ़ंक्शन wtp/1 फ़ंक्शन द्वारा बनाई गई फ़ाइल (संभवतः) से मेल विनिर्देशों को पढ़ता है। यह सभी मिलान विनिर्देशों के सिंटैक्स की जांच करता है और सत्यापित करता है कि वे सही हैं। त्रुटि से निपटने का सिद्धांत "सभी या कुछ भी नहीं" है, अर्थात यदि मैच के कुछ विनिर्देश गलत हैं, तो रनिंग सिस्टम के लिए सहेजे गए मैच विनिर्देशों की सूची में कोई भी विनिर्देश नहीं जोड़े जाते हैं।

फ़ाइल में मैच विनिर्देशों को वर्तमान मैच विनिर्देशों के साथ विलय कर दिया जाता है, ताकि कोई डुप्लिकेट उत्पन्न न हो। फ़ाइल से विनिर्देशों के लिए कौन से नंबर निर्दिष्ट किए गए थे, यह देखने के लिए ltp/0 का उपयोग करें।

फ़ंक्शन, आई / ओ समस्याओं (जैसे गैर मौजूदा या गैर-पठनीय फ़ाइल) या फ़ाइल प्रारूप समस्याओं के कारण या तो एक त्रुटि लौटाएगा। खराब प्रारूप फ़ाइल से त्रुटियां अधिक या कम पाठ प्रारूप में होती हैं, जो इस बात का संकेत देती हैं कि समस्या क्या है।

n (Nodename) -> {ठीक है, Nodename} | {त्रुटि, कारण}

प्रकार

dbg सर्वर उन नोड्स की एक सूची रखता है जहाँ अनुरेखण किया जाना चाहिए। जब भी कोई tp/2 कॉल या p/2 कॉल किया जाता है, तो इसे स्थानीय नोड सहित इस सूची के सभी नोड्स के लिए निष्पादित किया जाता है port() पहले विशेष तर्क के साथ p/2 को छोड़कर pid() या port() पहले तर्क के रूप में, जिसमें मामले को कमांड केवल नोड पर निष्पादित किया जाता है जहां नामित प्रक्रिया या पोर्ट रहता है)।

यह फ़ंक्शन दूरस्थ नोड ( Nodename ) को नोड्स की सूची में जोड़ता है जहां अनुरेखण किया जाता है। यह दूरस्थ नोड पर एक अनुरेखक प्रक्रिया शुरू करता है, जो स्थानीय नोड पर (एरलंग वितरण के माध्यम से) अनुरेखक प्रक्रिया को सभी ट्रेस संदेश भेजेगा। यदि कोई ट्रैसर प्रक्रिया स्थानीय नोड पर नहीं चल रही है, तो त्रुटि कारण no_local_tracer वापस आ गया है। स्थानीय नोड पर अनुरेखक प्रक्रिया को tracer/0/2 फ़ंक्शन के साथ शुरू किया जाना चाहिए।

यदि Nodename स्थानीय नोड है, तो त्रुटि कारण cant_add_local_node वापस किया जाता है।

यदि ट्रेस पोर्ट ( trace_port/2 देखें) स्थानीय नोड पर चल रहा है, तो दूरस्थ नोड्स को एक अनुरेखक प्रक्रिया के साथ नहीं खोजा जा सकता है। त्रुटि कारण cant_trace_remote_pid_to_local_port वापस आ गया है। tracer/3 फ़ंक्शन के साथ दूरस्थ नोड पर एक ट्रेस पोर्ट शुरू किया जा सकता है।

नोड Nodename नहीं होने पर फ़ंक्शन भी एक त्रुटि लौटाएगा।

cn (Nodename) -> ठीक है

प्रकार

ट्रेस नोड्स की सूची से एक नोड को साफ़ करता है। बाद में tp/2 और p/2 लिए कॉल उस नोड पर विचार नहीं करेंगे, लेकिन नोड पर पहले से सक्रिय ट्रेसिंग प्रभाव में रहेगी।

ok , विफल नहीं हो सकता।

ln () -> ठीक है

कंसोल पर ट्रेस किए गए नोड्स की सूची दिखाता है।

अनुरेखक () -> {ठीक है, पिड ()} | {त्रुटि, पहले से ही उपलब्ध है}

यह फ़ंक्शन स्थानीय नोड पर एक सर्वर शुरू करता है जो सभी ट्रेस संदेशों का प्राप्तकर्ता होगा। p/2 बाद की सभी कॉलों के परिणामस्वरूप नए शुरू किए गए ट्रेस सर्वर को भेजे गए संदेश होंगे।

इस तरह से शुरू किया गया एक ट्रेस सर्वर केवल एर्लांग खोल (यानी उपयोग प्रारूप) में एक स्वरूपित तरीके से ट्रेस संदेशों को प्रदर्शित करेगा। tracer/0/2 देखें कि ट्रेस संदेश हैंडलर को कैसे अनुकूलित किया जा सकता है।

दूरस्थ नोड पर एक समान अनुरेखक शुरू करने के लिए, n/1 उपयोग करें।

अनुरेखक (प्रकार, डेटा) -> {ठीक है, पीआईडी ​​()} | {त्रुटि, त्रुटि}

प्रकार

यह फ़ंक्शन स्थानीय नोड पर अतिरिक्त मापदंडों के साथ एक ट्रैसर सर्वर शुरू करता है। पहला पैरामीटर, Type , इंगित करता है कि यदि ट्रेस संदेश एक प्राप्त प्रक्रिया ( process ), एक ट्रेसर पोर्ट ( port ) या एक ट्रेसर मॉड्यूल ( module ) द्वारा नियंत्रित किया जाना चाहिए। ट्रेसर पोर्ट के बारे में वर्णन के लिए trace_port/2 देखें और ट्रेसर मॉड्यूल के लिए erl_tracer देखें।

यदि Type process , तो एक संदेश हैंडलर फ़ंक्शन निर्दिष्ट किया जा सकता है ( HandlerSpec )। हैंडलर फ़ंक्शन, जिसे दो तर्कों को लेने में fun होना चाहिए, प्रत्येक ट्रेस संदेश के लिए बुलाया जाएगा, जिसमें पहला तर्क संदेश के साथ होगा और दूसरा तर्क जिसमें मज़ा के अंतिम आह्वान से वापसी मूल्य शामिल है। दूसरे पैरामीटर का प्रारंभिक मान HandlerSpec के HandlerSpec भाग में निर्दिष्ट है। HandlerFun को आमंत्रित किए जाने पर कोई उचित कार्रवाई करने के लिए चुन सकता है, और इसे वापस करके अगले आह्वान के लिए एक राज्य को बचा सकता है।

यदि Type port , तो दूसरा पैरामीटर एक मजेदार होना चाहिए जो कोई तर्क नहीं लेता है और जब बुलाया जाता है तो एक नया खोला ट्रेस पोर्ट लौटाता है। trace_port/2 कॉल करके ऐसा मज़ा अधिमानतः उत्पन्न होता है।

यदि Type module , तो दूसरा पैरामीटर या तो एक tuple होना चाहिए जिसमें erl_tracer मॉड्यूल का वर्णन किया erl_tracer ट्रेसिंग के लिए उपयोग किया जाए और उस ट्रैसर मॉड्यूल के लिए उपयोग किया जाने वाला राज्य या उसी ट्यूपल को वापस करने वाला मज़ा।

यदि कोई त्रुटि वापस {error,already_started} तो यह या तो पहले से चल रहे ट्रैसर सर्वर ( {error,already_started} पहले से ही {error,already_started} ) {error,already_started} कारण हो सकती है या HandlerFun अपवाद को फेंकने के कारण हो सकती है।

दूरस्थ नोड पर समान अनुरेखक शुरू करने के लिए, tracer/3 उपयोग करें।

tracer (Nodename, प्रकार, डेटा) -> {ठीक है, Nodename} | {त्रुटि, कारण}

प्रकार

यह फ़ंक्शन tracer/0/2 बराबर है, लेकिन दिए गए नोड पर कार्य करता है। नोड ( Nodename ) पर एक ट्रेसर शुरू किया जाता है और नोड को ट्रेस किए गए नोड्स की सूची में जोड़ा जाता है।

ध्यान दें

यह फ़ंक्शन n/1 बराबर नहीं है। जबकि n/1 एक प्रक्रिया अनुरेखक शुरू करता है जो स्थानीय नोड (यानी ट्रेस कंट्रोल नोड) पर एक प्रक्रिया अनुरेखक के लिए सभी ट्रेस जानकारी को पुनर्निर्देशित करता है, tracer/3 किसी भी प्रकार का एक अनुरेखक शुरू करता है जो ट्रेस कंट्रोल नोड पर अनुरेखक से स्वतंत्र है।

विवरण के लिए, tracer/0/2 देखें।

ट्रेस_पोर्ट (प्रकार, पैरामीटर) -> मज़ा ()

प्रकार

यह फ़ंक्शन एक ट्रेस पोर्ट जनरेटिंग फन बनाता है। मज़ा कोई तर्क नहीं लेता है और एक नए खुले ट्रेस पोर्ट को लौटाता है। इस फ़ंक्शन से वापसी मान ट्रैसर / 2, यानी dbg:tracer(port, dbg:trace_port(ip, 4711)) लिए एक दूसरे पैरामीटर के रूप में उपयुक्त है।

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

दो ट्रेस ड्राइवर वर्तमान में लागू किए गए हैं, file और ip ट्रेस ड्राइवर। फ़ाइल ड्रायवर सभी ट्रेस संदेशों को एक या कई बाइनरी फ़ाइलों में भेजता है, जहाँ से बाद में उन्हें ट्रेस किया जा सकता है और trace_client/2 फ़ंक्शन के साथ संसाधित किया जा सकता है। आईपी ​​ड्राइवर एक टीसीपी / आईपी पोर्ट खोलता है जहां यह कनेक्शन के लिए सुनता है। जब एक ग्राहक (अधिमानतः एक और trace_client/2 नोड पर trace_client/2 कॉल करके शुरू होता है) जोड़ता है, तो सभी ट्रेस संदेश दूरस्थ क्लाइंट द्वारा आगे की प्रक्रिया के लिए आईपी नेटवर्क पर भेजे जाते हैं।

ट्रेसिंग पोर्ट का उपयोग करके ट्रेसिंग का उपयोग करके लगाए गए ओवरहेड को काफी कम करता है।

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

एक रैप फाइल स्पेसिफिकेशन ट्रेस द्वारा खपत डिस्क स्थान को सीमित करने के लिए उपयोग किया जाता है। ट्रेस को सीमित आकार वाली प्रत्येक फ़ाइलों की सीमित संख्या के लिए लिखा गया है। वास्तविक फ़ाइलनाम Filename ++ SeqCnt ++ Suffix , जहां SeqCnt एक दशमलव स्ट्रिंग के रूप में 0 से WrapCnt और फिर 0 से फिर से चारों ओर गिना जाता है। जब वर्तमान फ़ाइल में लिखा एक ट्रेस शब्द WrapSize से अधिक लंबा हो WrapSize , तो वह फ़ाइल बंद हो जाती है, यदि इस रैप ट्रेस में फ़ाइलों की संख्या WrapCnt ही है जितनी कि WrapCnt सबसे पुरानी फ़ाइल हटा दी जाती है तो वर्तमान बनने के लिए एक नई फ़ाइल खोली जाती है। इस प्रकार, जब एक रैप ट्रेस को रोक दिया गया है, तो कम से कम WrapSize (लेकिन बहुत बड़ा नहीं) के आकार के साथ सहेजी गई अधिकांश WrapCnt ट्रेस फ़ाइलों में हैं, अंतिम फ़ाइल को छोड़कर जो खाली भी हो सकती हैं। डिफ़ॉल्ट मान WrapSize = 128*1024 और WrapCnt = 8

फ़ाइल नाम में SeqCnt मान गोलाकार अनुक्रम में अंतराल के साथ WrapCnt माध्यम से 0 की सीमा में हैं। ट्रेस के अंत को खोजने के लिए अंतराल की आवश्यकता है।

यदि WrapSize को {time, WrapTime} रूप में निर्दिष्ट किया जाता है, तो वर्तमान फ़ाइल तब बंद हो जाती है, जब वह WrapTime मिलीसेकंड से अधिक खुली हो, चाहे वह खाली हो या न हो।

IP ट्रेस ड्रायवर में QueSize संदेशों की एक कतार होती है जो डिलीवर होने की प्रतीक्षा कर रहा है। यदि ड्राइवर रनटाइम सिस्टम द्वारा उत्पादित किए गए संदेशों को तेजी से वितरित नहीं कर सकता है, तो एक विशेष संदेश भेजा जाता है, जो इंगित करता है कि कितने संदेश गिराए गए हैं। यह संदेश trace_client/3 {drop, N} रूप में trace_client/3 में निर्दिष्ट हैंडलर फ़ंक्शन पर trace_client/3 जहां N लगातार गिराए गए संदेशों की संख्या है। भारी अनुरेखण के मामले में, ड्रॉप होने की संभावना है, और वे निश्चित रूप से होते हैं यदि कोई क्लाइंट ट्रेस संदेशों को नहीं पढ़ रहा है। QueSize का डिफ़ॉल्ट मान 200 है।

flush_trace_port ()

flush_trace_port(node()) बराबर।

flush_trace_port (Nodename) -> ठीक है | {त्रुटि, कारण}

trace_port_control(Nodename,flush) बराबर।

trace_port_control (परिचालन)

trace_port_control(node(),Operation) बराबर।

ट्रेस_पोर्ट_कंट्रोल (नोडेन, ऑपरेशन) -> ठीक | {ठीक है, परिणाम} | {त्रुटि, कारण}

प्रकार

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

यदि वर्तमान ट्रैसर एक प्रक्रिया है या यदि वह पोर्ट है जो ऑपरेशन का समर्थन नहीं कर रहा है, तो ok या {ok, Result} या तो रिटर्न सफल होता है या {error, Reason}

Operation लिए स्वीकृत मूल्य हैं:

flush

इस फ़ंक्शन का उपयोग ट्रेस पोर्ट ड्राइवर द्वारा रखे गए आंतरिक बफ़र्स को फ्लश करने के लिए किया जाता है। वर्तमान में केवल फ़ाइल ट्रेस ड्राइवर इस ऑपरेशन का समर्थन करता है। ok

get_listen_port

रिटर्न {ok, IpPort} जहां IpPort आईपी ​​पोर्ट नंबर है जिसका उपयोग ड्राइवर सुन सॉकेट के लिए करता है। केवल IP ट्रेस ड्रायवर इस ऑपरेशन का समर्थन करता है।

ट्रेस_क्लियर (प्रकार, पैरामीटर) -> पिड ()

प्रकार

यह फ़ंक्शन एक ट्रेस क्लाइंट शुरू करता है जो एक ट्रेस पोर्ट ड्राइवर द्वारा बनाए गए आउटपुट को पढ़ता है और इसे tracer/0 फ़ंक्शन द्वारा बनाई गई अनुरेखक प्रक्रिया के रूप में ज्यादातर उसी तरह से संभालता है।

यदि Type file , तो क्लाइंट फ़ाइल नाम में संग्रहीत सभी ट्रेस संदेशों को पढ़ता है जिसका नाम Filename या WrapFilesSpec द्वारा निर्दिष्ट किया WrapFilesSpec (ट्रेस बनाते समय इसका उपयोग उसी तरह किया जाना चाहिए, ट्रेस_पोर्ट / 2 देखें) और डिफ़ॉल्ट हैंडलर फ़ंक्शन कंसोल पर संदेशों को प्रारूपित करें। । यह फ़ाइल ट्रेस पोर्ट ड्राइवर द्वारा फ़ाइल में संग्रहीत डेटा की व्याख्या करने का एक तरीका है।

यदि Type follow_file , तो क्लाइंट file मामले में व्यवहार करता है, लेकिन stop_trace_client/1 द्वारा रोक दिए जाने तक फ़ाइल से अधिक डेटा (और प्रक्रिया) पढ़ने की कोशिश करता रहता है। WrapFilesSpec को इस Type दूसरे तर्क के रूप में अनुमति नहीं है।

यदि Type ip , तो क्लाइंट होस्ट Hostname पर टीसीपी / आईपी पोर्ट PortNumber कनेक्ट होता है, जहां से यह टीसीपी / आईपी कनेक्शन बंद होने तक ट्रेस संदेशों को पढ़ता है। यदि कोई Hostname निर्दिष्ट नहीं है, तो स्थानीय होस्ट मान लिया गया है।

एक उदाहरण के रूप में, एक नेटवर्क से दूसरे एरलैंग नोड (अधिमानतः वितरित नहीं ) पर संदेश भेज सकते हैं, जहां प्रारूपण प्रारूप हैं:

नोड stack पर शेल में एक एरलैंग नोड [email protected] , निम्न टाइप करें:

[email protected]> dbg:tracer(port, dbg:trace_port(ip,4711)).
<0.17.0>
[email protected]> dbg:p(self(), send).
{ok,1}

सभी ट्रेस संदेश अब ट्रेस पोर्ट ड्राइवर को भेजे जाते हैं, जो टीसीपी / आईपी पोर्ट 4711 पर कनेक्शन के लिए सुनता है। यदि हम संदेशों को दूसरे नोड पर देखना चाहते हैं, तो संभवत: किसी अन्य होस्ट पर, हम इस तरह करते हैं:

-> dbg:trace_client(ip, {"stack", 4711}).
<0.42.0>

यदि हम अब नोड [email protected] पर शेल से एक संदेश भेजते हैं, जहां शेल से भेजे गए सभी निशान का पता लगाया जाता है:

[email protected]> self() ! hello.
hello

निम्नलिखित ट्रेस क्लाइंट को शुरू करने वाले नोड पर कंसोल पर दिखाई देगा:

(<0.23.0>) <0.23.0> ! hello
(<0.23.0>) <0.22.0> ! {shell_rep,<0.23.0>,{value,hello,[],[]}}

एर्लांग खोल में आंतरिक संदेश गुजरने के कारण अंतिम रेखा उत्पन्न होती है। आईडी की प्रक्रिया अलग-अलग होगी।

ट्रेस_क्लियर (टाइप, पैरामीटर्स, हैंडलरस्पीक) -> पिड ()

प्रकार

यह फ़ंक्शन ठीक से trace_client/2 रूप में काम करता है, लेकिन आपको अपना स्वयं का हैंडलर फ़ंक्शन लिखने की अनुमति देता है। हैंडलर फंक्शन ज्यादातर tracer/0/2 में वर्णित के रूप में काम करता है, लेकिन फॉर्म {drop, N} ट्रेस संदेशों को संभालने के लिए भी तैयार रहना होगा, जहां N गिरा संदेशों की संख्या है। यह छद्म ट्रेस संदेश केवल तब होगा जब आईपी ट्रेस ड्राइवर का उपयोग किया जाता है।

ट्रेस टाइप file , छद्म ट्रेस संदेश end_of_trace ट्रेस के अंत में दिखाई देगा। हैंडलर फ़ंक्शन से वापसी मान इस मामले में अनदेखा है।

stop_trace_client (Pid) -> ठीक है

प्रकार

यह फ़ंक्शन पहले से शुरू किए गए ट्रेस क्लाइंट को बंद कर देता है। Pid तर्क trace_client/2 या trace_client/3 कॉल से लौटी प्रक्रिया आईडी है।

get_tracer ()

get_tracer(node()) बराबर।

get_tracer (Nodename) -> {ठीक है, ट्रेसर}

प्रकार

वह प्रक्रिया, पोर्ट या ट्रैसर मॉड्यूल लौटाता है जिसमें सभी ट्रेस संदेश भेजे जाते हैं।

रोक () -> ठीक है

dbg सर्वर को रोकता है और सभी प्रक्रियाओं के लिए सभी ट्रेस झंडे को साफ़ करता है और सभी कार्यों के लिए सभी स्थानीय ट्रेस पैटर्न। इसके अलावा सभी ट्रेस क्लाइंट को बंद कर देता है और सभी ट्रेस पोर्ट को बंद कर देता है।

ध्यान दें कि इस फ़ंक्शन से कोई वैश्विक ट्रेस पैटर्न प्रभावित नहीं होते हैं।

stop_clear () -> ठीक है

स्टॉप / 0 के समान, लेकिन वैश्विक फ़ंक्शन कॉल पर सभी ट्रेस पैटर्न भी साफ़ करता है।

सरल उदाहरण - शेल से ट्रेसिंग

एरलैंग शेल से ट्रेसिंग का सबसे सरल तरीका dbg:c/3 या dbg:c/4 , जैसे फंक्शन dbg:get_tracer/0 ट्रेस करना dbg:get_tracer/0 :

([email protected])84> dbg:c(dbg,get_tracer,[]).
(<0.154.0>) <0.152.0> ! {<0.154.0>,{get_tracer,[email protected]}}
(<0.154.0>) out {dbg,req,1}
(<0.154.0>) << {dbg,{ok,<0.153.0>}}
(<0.154.0>) in {dbg,req,1}
(<0.154.0>) << timeout
{ok,<0.153.0>}
([email protected])85>

शेल से ट्रेस करने का एक अन्य तरीका स्पष्ट रूप से एक ट्रेसर शुरू करना है और फिर उन प्रक्रियाओं पर अपनी पसंद के ट्रेस झंडे सेट करें जिन्हें आप ट्रेस करना चाहते हैं, जैसे संदेश और प्रक्रिया ईवेंट ट्रेस करें:

([email protected])66> Pid = spawn(fun() -> receive {From,Msg} -> From ! Msg end end).
<0.126.0>
([email protected])67> dbg:tracer().
{ok,<0.128.0>}
([email protected])68> dbg:p(Pid,[m,procs]).
{ok,[{matched,[email protected],1}]}
([email protected])69> Pid ! {self(),hello}.
(<0.126.0>) << {<0.116.0>,hello}
{<0.116.0>,hello}
(<0.126.0>) << timeout
(<0.126.0>) <0.116.0> ! hello
(<0.126.0>) exit normal
([email protected])70> flush().
Shell got hello
ok
([email protected])71>

यदि आप call ट्रेस ध्वज सेट करते हैं, तो आपको उन फ़ंक्शन के लिए एक ट्रेस पैटर्न सेट करना होगा जिसे आप ट्रेस करना चाहते हैं:

([email protected])77> dbg:tracer().
{ok,<0.142.0>}
([email protected])78> dbg:p(all,call).
{ok,[{matched,[email protected],3}]}
([email protected])79> dbg:tp(dbg,get_tracer,0,[]).
{ok,[{matched,[email protected],1}]}
([email protected])80> dbg:get_tracer().
(<0.116.0>) call dbg:get_tracer()
{ok,<0.143.0>}
([email protected])81> dbg:tp(dbg,get_tracer,0,[{'_',[],[{return_trace}]}]).
{ok,[{matched,[email protected],1},{saved,1}]}
([email protected])82> dbg:get_tracer().
(<0.116.0>) call dbg:get_tracer()
(<0.116.0>) returned from dbg:get_tracer/0 -> {ok,<0.143.0>}
{ok,<0.143.0>}
([email protected])83>

उन्नत विषय - seq_trace के साथ संयोजन

dbg मॉड्यूल मुख्य रूप से erlang:trace/3 माध्यम से ट्रेसिंग की ओर लक्षित होता है erlang:trace/3 फ़ंक्शन। यह कभी-कभी संदेशों को अधिक नाजुक तरीके से ट्रेस करने के लिए वांछित होता है, जिसे seq_trace मॉड्यूल की मदद से किया जा सकता है।

seq_trace अनुक्रमिक अनुरेखण (AXE10 दुनिया में ज्ञात, और कभी-कभी "forlopp अनुरेखण") कहा जाता है। seq_trace से उत्पन्न संदेशों की व्याख्या कर सकता है और दोनों प्रकार के अनुरेखण के लिए एक ही ट्रैसर फ़ंक्शन का उपयोग किया जा सकता है। seq_trace संदेश को आगे के विश्लेषण के लिए एक ट्रेस पोर्ट पर भी भेजा जा सकता है।

मैच विनिर्देश के रूप में अनुक्रमिक अनुरेखण चालू कर सकते हैं, seq_trace और seq_trace का संयोजन काफी शक्तिशाली हो सकता है। यह संक्षिप्त उदाहरण एक सत्र दिखाता है जहां अनुक्रमिक अनुरेखण का उपयोग किया जाता है:

1> dbg:tracer().
{ok,<0.30.0>}
2> {ok, Tracer} = dbg:get_tracer().
{ok,<0.31.0>}
3> seq_trace:set_system_tracer(Tracer).
false
4> dbg:tp(dbg, get_tracer, 0, [{[],[],[{set_seq_token, send, true}]}]).
{ok,[{matched,[email protected],1},{saved,1}]}
5> dbg:p(all,call).
{ok,[{matched,[email protected],22}]}
6> dbg:get_tracer(), seq_trace:set_token([]).
(<0.25.0>) call dbg:get_tracer()
SeqTrace [0]: (<0.25.0>) <0.30.0> ! {<0.25.0>,get_tracer} [Serial: {2,4}]
SeqTrace [0]: (<0.30.0>) <0.25.0> ! {dbg,{ok,<0.31.0>}} [Serial: {4,5}]
{1,0,5,<0.30.0>,4}

यह सत्र system_tracer को समान ट्रेसर प्रक्रिया (यानी <0.31.0>) के रूप में सेट करता है और फ़ंक्शन dbg:get_tracer लिए ट्रेस पैटर्न सेट करता है जिसमें अनुक्रमिक टोकन सेट करने की क्रिया होती है। जब फ़ंक्शन को एक seq_trace गई प्रक्रिया द्वारा बुलाया जाता है (इस मामले में सभी प्रक्रियाओं का पता लगाया जाता है), तो टोकन और seq_trace संदेशों द्वारा प्रक्रिया को "दूषित" हो जाता है, दोनों सर्वर अनुरोध और प्रतिक्रिया के लिए भेजे जाते हैं। seq_trace:set_token([]) कॉल के बाद seq_trace टोकन को साफ़ करता है, जब उत्तर शेल के माध्यम से कंसोल पोर्ट पर फैलता है तो कोई संदेश क्यों नहीं भेजे जाते हैं। आउटपुट अन्यथा शोर होता।

सावधानी बरतें

जब ट्रेसिंग फ़ंक्शन एक समूह लीडर प्रक्रिया (एक IO प्रक्रिया) पर कॉल करता है, तो गतिरोध पैदा करने का जोखिम होता है। यह तब होगा जब समूह लीडर प्रक्रिया ट्रेस संदेश और ट्रैसर प्रक्रिया उत्पन्न करती है, ट्रेस हैंडलर फ़ंक्शन को कॉल करके, उसी समूह के नेता को एक IO अनुरोध भेजता है। समस्या केवल तभी हो सकती है जब ट्रेस हैंडलर किसी io फ़ंक्शन का उपयोग करके टिकी को प्रिंट करता है format/2 । ध्यान दें कि जब dbg:p(all,call) बुलाया जाता है, तो IO प्रक्रियाओं का भी पता लगाया जाता है। यहाँ एक उदाहरण है:

%% Using a default line editing shell
1> dbg:tracer(process, {fun(Msg,_) -> io:format("~p~n", [Msg]), 0 end, 0}).
{ok,<0.37.0>}
2> dbg:p(all, [call]).
{ok,[{matched,[email protected],25}]}
3> dbg:tp(mymod,[{'_',[],[]}]).
{ok,[{matched,[email protected],0},{saved,1}]}
4> mymod: % TAB pressed here
%% -- Deadlock --

यहाँ एक और उदाहरण है:

%% Using a shell without line editing (oldshell)
1> dbg:tracer(process).
{ok,<0.31.0>}
2> dbg:p(all, [call]).
{ok,[{matched,[email protected],25}]}
3> dbg:tp(lists,[{'_',[],[]}]).
{ok,[{matched,[email protected],0},{saved,1}]}
% -- Deadlock --

पहली मिसाल में हमें एक गतिरोध मिलता है, क्योंकि जब TAB को फ़ंक्शन नाम का विस्तार करने के लिए दबाया जाता है, तो समूह नेता (जो चरित्र इनपुट संभालता है) कॉल करता है mymod:module_info() । यह एक ट्रेस संदेश उत्पन्न करता है, जो बदले में, समूह लीडर को (कॉल करके io:format/2 ) आईओ अनुरोध भेजने के लिए अनुरेखक प्रक्रिया का कारण बनता है । हम एक गतिरोध में समाप्त होते हैं।

दूसरे उदाहरण में हम डिफ़ॉल्ट ट्रेस हैंडलर फ़ंक्शन का उपयोग करते हैं। यह हैंडलर user प्रक्रिया को IO अनुरोध भेजकर टाल देता है । जब Erlang को oldshell मोड में शुरू किया जाता है, तो शेल प्रक्रिया user में इसके समूह के नेता होंगे और इसलिए इस उदाहरण में अनुरेखक प्रक्रिया होगी। चूंकि पहले IO अनुरोध भेजे जाने के बाद हम user कॉल फ़ंक्शंस lists समाप्त हो जाते हैं।

गतिरोध से बचने के लिए यहां कुछ सुझाव दिए गए हैं:

  • अनुरेखक प्रक्रिया के समूह के नेता का पता न लगाएं। यदि सभी प्रक्रियाओं के लिए ट्रेसिंग चालू कर दी गई है, dbg:p(TracerGLPid,clear) तो समूह लीडर ( TracerGLPid ) को ट्रेस करने से रोकने के लिए कॉल करें । process_info(TracerPid,group_leader) आपको बताता है कि यह कौन सी प्रक्रिया है ( TracerPid से लौटा है dbg:get_tracer/0 )।
  • user डिफ़ॉल्ट ट्रेस हैंडलर फ़ंक्शन का उपयोग करते समय प्रक्रिया को ट्रेस न करें ।
  • अपने स्वयं के ट्रेस हैंडलर फ़ंक्शन में, फ़ंक्शन के erlang:display/1 बजाय कॉल करें io या, यदि user समूह लीडर के रूप में उपयोग नहीं किया जाता है , तो user डिफ़ॉल्ट ग्रुप लीडर के बजाय प्रिंट करें । उदाहरण: io:format(user,Str,Args)

Original text