ns-3 నెట్‌వర్క్ సిమ్యులేటర్ ట్యుటోరియల్. అధ్యాయం 5

అధ్యాయం 1,2
అధ్యాయం 3
అధ్యాయం 4

5 సెట్టింగ్‌లు
5.1 లాగింగ్ మాడ్యూల్‌ని ఉపయోగించడం
5.1.1 లాగింగ్ ఓవర్‌వ్యూ
5.1.2 లాగింగ్‌ని ప్రారంభించండి
5.1.3 మీ కోడ్‌కి లాగింగ్‌ని జోడిస్తోంది
5.2 కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ఉపయోగించడం
5.2.1 డిఫాల్ట్ అట్రిబ్యూట్ విలువలను భర్తీ చేయడం
5.2.2 మీ స్వంత ఆదేశాలను సంగ్రహించడం
5.3 ట్రేసింగ్ సిస్టమ్‌ని ఉపయోగించడం
5.3.1 ASCII ట్రేసింగ్
ASCII ట్రేస్‌లను అన్వయించడం
5.3.2 PCAP ట్రేస్

చాప్టర్ 5

సర్దుబాటు

5.1 లాగింగ్ మాడ్యూల్‌ని ఉపయోగించడం

స్క్రిప్ట్‌ని చూడటం ద్వారా మేము ఇప్పటికే ns-3 లాగింగ్ మాడ్యూల్‌ని క్లుప్తంగా చూశాము మొదటి.cc. ఈ అధ్యాయంలో, లాగింగ్ సబ్‌సిస్టమ్ కోసం సాధ్యమయ్యే ఉపయోగాలను మేము నిశితంగా పరిశీలిస్తాము.

5.1.1 లాగింగ్ ఓవర్‌వ్యూ

చాలా పెద్ద సిస్టమ్‌లు కొన్ని రకాల మెసేజ్ లాగింగ్ సదుపాయానికి మద్దతిస్తాయి మరియు ns-3 మినహాయింపు కాదు. కొన్ని సందర్భాల్లో, దోష సందేశాలు మాత్రమే "ఆపరేటర్ కన్సోల్"కి వ్రాయబడతాయి (ఇది సాధారణంగా Unix-ఆధారిత సిస్టమ్‌లలో stderr అవుతుంది). ఇతర సిస్టమ్‌లలో, హెచ్చరిక సందేశాలు అలాగే మరింత వివరణాత్మక సమాచారం ప్రదర్శించబడవచ్చు. కొన్ని సందర్భాల్లో, అవుట్‌పుట్‌ను త్వరగా బ్లర్ చేసే డీబగ్ సందేశాలను అవుట్‌పుట్ చేయడానికి లాగింగ్ సాధనాలు ఉపయోగించబడతాయి.

ns-3లో ఉపయోగించిన సబ్‌హెచ్‌ఆర్‌డి ఈ స్థాయి సమాచార కంటెంట్ అంతా ఉపయోగకరంగా ఉంటుందని ఊహిస్తుంది మరియు మేము మెసేజ్ లాగింగ్‌కి ఎంపిక చేసిన, లేయర్డ్ విధానాన్ని అందిస్తాము. లాగింగ్ పూర్తిగా నిలిపివేయబడుతుంది, ఒక్కో భాగం ఆధారంగా లేదా ప్రపంచవ్యాప్తంగా ప్రారంభించబడుతుంది. ఈ ప్రయోజనం కోసం, సమాచార కంటెంట్ యొక్క సర్దుబాటు స్థాయిలు ఉపయోగించబడతాయి. ns-3 లాగింగ్ మాడ్యూల్ మీ అనుకరణ నుండి ఉపయోగకరమైన సమాచారాన్ని పొందేందుకు సాపేక్షంగా సులభమైన మార్గాన్ని అందిస్తుంది.

మీ మోడల్‌ల నుండి డేటాను సంగ్రహించడం కోసం మేము సాధారణ ప్రయోజన మెకానిజం - ట్రేసింగ్‌ని అందిస్తాము, ఇది అనుకరణల కోసం ప్రాధాన్య అవుట్‌పుట్ అయి ఉండాలి (మా ట్రేసింగ్ సిస్టమ్‌పై మరింత సమాచారం కోసం, ట్యుటోరియల్ విభాగం 5.3 చూడండి). డీబగ్గింగ్ సమాచారం, హెచ్చరికలు, ఎర్రర్ మెసేజ్‌లు లేదా మీ స్క్రిప్ట్‌లు లేదా మోడల్‌ల నుండి సందేశాలను త్వరగా అవుట్‌పుట్ చేయడం కోసం ఎప్పుడైనా లాగింగ్ అనేది ప్రాధాన్య పద్ధతిగా ఉండాలి.

ప్రస్తుతం, సిస్టమ్ సమాచార కంటెంట్ యొక్క పెరుగుతున్న క్రమంలో లాగ్ సందేశాల యొక్క ఏడు స్థాయిలను (రకాలు) నిర్వచిస్తుంది.

• LOG_ERROR - లాగింగ్ దోష సందేశాలు (సంబంధిత మాక్రో: NS_LOG_ERROR);
• LOG_WARN - లాగ్ హెచ్చరిక సందేశాలు (సంబంధిత మాక్రో: NS_LOG_WARN);
• LOG_DEBUG - సాపేక్షంగా అరుదైన ప్రత్యేక డీబగ్ సందేశాలను లాగ్ చేయండి (సంబంధిత మాక్రో: NS_LOG_DEBUG);
• LOG_INFO - ప్రోగ్రామ్ యొక్క పురోగతి గురించి సమాచార సందేశాల నమోదు (సంబంధిత మాక్రో: NS_LOG_INFO);
• LOG_FUNCTION - ప్రతి ఫంక్షన్‌ని వివరించే సందేశాలను లాగ్ చేస్తుంది (రెండు సంబంధిత మాక్రోలు: NS_LOG_FUNCTION, సభ్యుల ఫంక్షన్‌ల కోసం ఉపయోగించబడుతుంది మరియు NS_LOG_FUNCTION_NOARGS, స్టాటిక్ ఫంక్షన్‌ల కోసం ఉపయోగించబడుతుంది);
• LOG_LOGIC - ఒక ఫంక్షన్‌లోని తార్కిక ప్రవాహాన్ని వివరించే సందేశాలను లాగింగ్ చేయడం (సంబంధిత మాక్రో: NS_LOG_LOGIC);
• LOG_ALL - పైన పేర్కొన్న ప్రతిదానిని లాగ్ చేస్తుంది (అనుబంధ స్థూల లేదు).
  ప్రతి రకానికి (LOG_TYPE) LOG_LEVEL_TYPE కూడా ఉంది, ఇది ఉపయోగించినట్లయితే, దాని స్వంత స్థాయికి అదనంగా అన్ని స్థాయిలను లాగిన్ చేయడానికి అనుమతిస్తుంది. (పర్యవసానంగా, LOG_ERROR మరియు LOG_LEVEL_ERROR, మరియు LOG_ALL మరియు LOG_LEVEL_ALL క్రియాత్మకంగా సమానం.) ఉదాహరణకు, LOG_INFOని ప్రారంభించడం వలన NS_LOG_INFO ద్వారా అందించబడిన సందేశాలు మాత్రమే అనుమతించబడతాయి, అయితే macro ద్వారా అందించబడిన సందేశాలను LOG_INFO లు కూడా కలిగి ఉంటాయి , NS_LOG_WARN మరియు NS_LOG_ERROR.

మేము లాగింగ్ స్థాయి లేదా ఎంపిక భాగంతో సంబంధం లేకుండా ఎల్లప్పుడూ ప్రదర్శించబడే షరతులు లేని లాగింగ్ మాక్రోని కూడా అందిస్తాము.

• NS_LOG_UNCOND - అనుబంధిత సందేశం యొక్క షరతులు లేని లాగింగ్ (సంబంధిత లాగింగ్ స్థాయి లేదు).

ప్రతి స్థాయిని వ్యక్తిగతంగా లేదా సంచితంగా ప్రశ్నించవచ్చు. sh ఎన్విరాన్మెంట్ వేరియబుల్ NS_LOG ఉపయోగించి లేదా సిస్టమ్ ఫంక్షన్ కాల్‌ని లాగిన్ చేయడం ద్వారా లాగింగ్‌ని కాన్ఫిగర్ చేయవచ్చు. ముందుగా చూపినట్లుగా, లాగింగ్ సిస్టమ్ డాక్సిజెన్ డాక్యుమెంటేషన్‌ని కలిగి ఉంది మరియు మీరు దీన్ని ఇప్పటికే సమీక్షించకుంటే ఇప్పుడు దాన్ని సమీక్షించడానికి మంచి సమయం.

ఇప్పుడు మీరు డాక్యుమెంటేషన్‌ను చాలా వివరంగా చదివారు, ఉదాహరణ స్క్రిప్ట్ నుండి కొంత ఆసక్తికరమైన సమాచారాన్ని పొందడానికి ఆ పరిజ్ఞానాన్ని ఉపయోగించుకుందాం స్క్రాచ్/myfirst.ccమీరు ఇదివరకే కంపైల్ చేసారు.

5.1.2 లాగింగ్‌ని ప్రారంభించండి

మరికొన్ని లాగ్‌లను అమలు చేయడానికి NS_LOG ఎన్విరాన్‌మెంట్ వేరియబుల్‌ని ఉపయోగిస్తాము, అయితే ముందుగా, మీ బేరింగ్‌లను పొందడానికి, మీరు ఇంతకు ముందు చేసినట్లుగా చివరి స్క్రిప్ట్‌ను అమలు చేయండి,

$ ./waf --run scratch/myfirst

మీరు మొదటి ns-3 ఉదాహరణ ప్రోగ్రామ్ నుండి తెలిసిన అవుట్‌పుట్‌ని చూడాలి

$ Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' 'build'
finished successfully (0.413s)
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2

మీరు పైన చూసే "పంపబడిన" మరియు "స్వీకరించబడిన" సందేశాలు వాస్తవానికి లాగ్ చేయబడిన సందేశాలు అని తేలింది UdpEchoClient అప్లికేషన్ и UdpEchoServerApplication. ఉదాహరణకు, NS_LOG ఎన్విరాన్మెంట్ వేరియబుల్ ద్వారా దాని లాగింగ్ స్థాయిని సెట్ చేయడం ద్వారా అదనపు సమాచారాన్ని ప్రింట్ చేయమని క్లయింట్ అప్లికేషన్‌ను మేము అడగవచ్చు.

ఇప్పటి నుండి, మీరు "VARIABLE=value" సింటాక్స్‌ని ఉపయోగించే sh-లాంటి షెల్‌ని ఉపయోగిస్తున్నారని నేను ఊహించబోతున్నాను. మీరు csh-వంటి షెల్‌ని ఉపయోగిస్తుంటే, మీరు నా ఉదాహరణలను ఆ షెల్‌లకు అవసరమైన "setenv వేరియబుల్ విలువ" సింటాక్స్‌కి మార్చాలి.

ప్రస్తుతం, UDP ఎకో క్లయింట్ అప్లికేషన్ క్రింది కోడ్ లైన్‌కు ప్రతిస్పందిస్తుంది స్క్రాచ్/myfirst.cc,

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);

ఇది లాగింగ్ స్థాయి LOG_LEVEL_INFOని ప్రారంభిస్తుంది. మేము లాగింగ్ స్థాయి ఫ్లాగ్‌ను పాస్ చేసినప్పుడు, మేము వాస్తవానికి ఆ స్థాయిని మరియు అన్ని దిగువ స్థాయిలను ప్రారంభిస్తాము. ఈ సందర్భంలో, మేము NS_LOG_INFO, NS_LOG_DEBUG, NS_LOG_WARN మరియు NS_LOG_ERRORలను ప్రారంభించాము. NS_LOG ఎన్విరాన్మెంట్ వేరియబుల్‌ను ఈ క్రింది విధంగా సెట్ చేయడం ద్వారా మేము స్క్రిప్ట్ మార్పులు మరియు రీకంపైలేషన్ లేకుండా లాగింగ్ స్థాయిని పెంచుకోవచ్చు మరియు మరింత సమాచారాన్ని పొందవచ్చు:

$ export NS_LOG=UdpEchoClientApplication=level_all

కాబట్టి మేము sh షెల్ వేరియబుల్ NS_LOGని క్రింది విలువకు సెట్ చేసాము,

UdpEchoClientApplication=level_all

అసైన్‌మెంట్ యొక్క ఎడమ వైపు మనం కాన్ఫిగర్ చేయాలనుకుంటున్న లాగ్ చేసిన కాంపోనెంట్ పేరు మరియు కుడి వైపు మనం దరఖాస్తు చేయాలనుకుంటున్న ఫ్లాగ్. ఈ సందర్భంలో, మేము అప్లికేషన్‌లో అన్ని స్థాయిల డీబగ్గింగ్‌ను ప్రారంభించబోతున్నాము. మీరు ఈ విధంగా NS_LOG సెట్‌తో స్క్రిప్ట్‌ను అమలు చేస్తే, ns-3 లాగింగ్ సిస్టమ్ మార్పులను అంగీకరిస్తుంది మరియు మీరు ఈ క్రింది అవుట్‌పుట్‌ని చూడాలి:

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.404s)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
Received 1024 bytes from 10.1.1.2
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

అప్లికేషన్ అందించిన అదనపు డీబగ్గింగ్ సమాచారం ఇప్పుడు NS_LOG_FUNCTION స్థాయిలో ఉంది. ఇది స్క్రిప్ట్ అమలు సమయంలో ఫంక్షన్ కాల్ యొక్క ప్రతి ఉదాహరణను చూపుతుంది. సాధారణ నియమంగా, పద్ధతి ఫంక్షన్లలో (కనీసం) ఉపయోగించడం ఉత్తమం.NS_LOG_FUNCTION (this)... వా డు NS_LOG_FUNCTION_NOARGS ()
స్టాటిక్ ఫంక్షన్లలో మాత్రమే. అయితే, ఏదైనా లాగింగ్ ఫంక్షనాలిటీకి మద్దతు ఇవ్వడానికి ns-3 సిస్టమ్ అవసరం లేదని గమనించండి. ఎంత సమాచారం నమోదు చేయబడిందనే నిర్ణయం వ్యక్తిగత మోడల్ డెవలపర్‌కు వదిలివేయబడుతుంది. ఎకో అప్లికేషన్‌ల విషయంలో, పెద్ద మొత్తంలో లాగింగ్ అవుట్‌పుట్ అందుబాటులో ఉంటుంది.

మీరు ఇప్పుడు అప్లికేషన్ ద్వారా చేసిన ఫంక్షన్ కాల్‌ల లాగ్‌ను వీక్షించవచ్చు. మీరు దగ్గరగా చూస్తే, మీరు లైన్ మధ్య పెద్దప్రేగును గమనించవచ్చు UdpEchoClient అప్లికేషన్ మరియు మీరు C++ స్కోప్ ఆపరేటర్ (: :)ని చూడాలని ఆశించే పద్ధతి పేరు. ఇది ఉద్దేశపూర్వకం.

ఇది వాస్తవానికి తరగతి పేరు కాదు, కానీ లాగింగ్ భాగం పేరు. సోర్స్ ఫైల్ మరియు క్లాస్ మధ్య సరిపోలిక ఉన్నప్పుడు, అది సాధారణంగా క్లాస్ పేరు, కానీ అది నిజానికి క్లాస్ పేరు కాదని, డబుల్ కోలన్‌కు బదులుగా ఒకే కోలన్ ఉందని మీరు గ్రహించాలి. లాగింగ్ బీన్ పేరును తరగతి పేరు నుండి సాపేక్షంగా సూక్ష్మంగా వేరు చేయడంలో మీకు సహాయపడే మార్గం ఇది.

అయితే, కొన్ని సందర్భాల్లో వాస్తవానికి లాగ్ సందేశాన్ని ఏ పద్ధతి రూపొందిస్తుందో గుర్తించడం కష్టంగా ఉంటుంది. మీరు పై వచనాన్ని చూస్తే, "లైన్ ఎక్కడ ఉంది" అని మీరు ఆశ్చర్యపోవచ్చు.Received 1024 bytes from 10.1.1.2" మీరు స్థాయిని సెట్ చేయడం ద్వారా ఈ సమస్యను పరిష్కరించవచ్చు ఉపసర్గ_ఫంక్ NS_LOG ఎన్విరాన్మెంట్ వేరియబుల్‌కి. కింది వాటిని ప్రయత్నించండి:

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func'

OR ఆపరేషన్‌ని సూచించడానికి మనం ఉపయోగించే నిలువు పట్టీ కూడా Unix పైప్ కనెక్టర్ అయినందున కొటేషన్ గుర్తులు అవసరమని గమనించండి. ఇప్పుడు మీరు స్క్రిప్ట్‌ని అమలు చేస్తే, ఇచ్చిన లాగ్‌లోని ప్రతి సందేశం కాంపోనెంట్ పేరుతో ప్రిఫిక్స్ చేయబడిందని లాగింగ్ సిస్టమ్ నిర్ధారిస్తుంది.

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.417s)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

ఇప్పుడు మీరు UDP ఎకో క్లయింట్ అప్లికేషన్ నుండి వచ్చే అన్ని మెసేజ్‌లు అలాగే గుర్తించబడడాన్ని చూడవచ్చు. సందేశం"Received 1024 bytes from 10.1.1.2"ఎకో క్లయింట్ అప్లికేషన్ నుండి వచ్చినట్లు ఇప్పుడు స్పష్టంగా గుర్తించబడింది. మిగిలిన సందేశం తప్పనిసరిగా UDP ఎకో సర్వర్ అప్లికేషన్ నుండి రావాలి. NS_LOG ఎన్విరాన్మెంట్ వేరియబుల్‌లో కోలన్-వేరు చేయబడిన భాగాల జాబితాను నమోదు చేయడం ద్వారా మేము ఈ భాగాన్ని ప్రారంభించవచ్చు.

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func:
               UdpEchoServerApplication=level_all|prefix_func'

హెచ్చరిక: ఎగువ ఉదాహరణ టెక్స్ట్‌లో, మీరు పత్రాన్ని ఫార్మాట్ చేయడానికి ఉపయోగించే పెద్దప్రేగు (:) తర్వాత కొత్త లైన్ అక్షరాన్ని తీసివేయాలి. ఇప్పుడు మీరు స్క్రిప్ట్‌ను అమలు చేస్తే, క్లయింట్ మరియు సర్వర్ ఎకో అప్లికేషన్‌ల నుండి అన్ని లాగ్ సందేశాలను మీరు చూస్తారు. డీబగ్గింగ్ చేసేటప్పుడు ఇది చాలా ఉపయోగకరంగా ఉంటుందని మీరు చూడవచ్చు.

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.406s)
UdpEchoServerApplication:UdpEchoServer()
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoServerApplication:StartApplication()
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
UdpEchoServerApplication:HandleRead(): Echoing packet
UdpEchoClientApplication:HandleRead(0x624920, 0x625160)
UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
UdpEchoServerApplication:StopApplication()
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

లాగ్ సందేశం రూపొందించబడిన అనుకరణ సమయాన్ని చూడగలగడం కూడా కొన్నిసార్లు ఉపయోగకరంగా ఉంటుంది. మీరు OR బిట్‌ని జోడించడం ద్వారా దీన్ని చేయవచ్చు ఉపసర్గ_సమయం:

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func|prefix_time: UdpEchoServerApplication=level_all|prefix_func|prefix_time'

మళ్లీ, మీరు ఎగువ కొత్త లైన్ అక్షరాన్ని తీసివేయాలి. మీరు ఇప్పుడు స్క్రిప్ట్‌ను అమలు చేస్తే, మీరు క్రింది అవుట్‌పుట్‌ని చూడాలి:

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.418s)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:SetDataSize(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
2.00369s UdpEchoServerApplication:HandleRead(): Echoing packet
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

కన్స్ట్రక్టర్ కోసం దయచేసి గమనించండి UdpEchoServer అనుకరణ 0 సెకన్ల సమయంలో పిలువబడింది. ఇది వాస్తవానికి అనుకరణ ప్రారంభానికి ముందు జరుగుతుంది, కానీ సమయం సున్నా సెకన్లుగా చూపబడుతుంది. కన్స్ట్రక్టర్ సందేశానికి కూడా ఇది వర్తిస్తుంది UdpEchoClient.

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.418s)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:SetDataSize(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
2.00369s UdpEchoServerApplication:HandleRead(): Echoing packet
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

స్క్రిప్ట్ గుర్తుకు తెచ్చుకోండి స్క్రాచ్/first.cc అనుకరణ ప్రారంభానికి ఒక సెకను ముందు ఎకో సర్వర్ అప్లికేషన్‌ను ప్రారంభించింది. ఇప్పుడు మీరు ఆ పద్ధతిని చూడవచ్చు అప్లికేషన్ ప్రారంభం సర్వర్ నిజానికి మొదటి సెకనులో పిలువబడుతుంది. మేము స్క్రిప్ట్‌లో అడిగినట్లుగా, ఎకో క్లయింట్ అనుకరణ యొక్క రెండవ సెకనులో ప్రారంభమవుతుందని కూడా మీరు గమనించవచ్చు.

మీరు ఇప్పుడు కాల్‌లో అనుకరణ పురోగతిని అనుసరించవచ్చు షెడ్యూల్ ట్రాన్స్మిట్ హ్యాండిల్‌రీడ్ కాల్‌బ్యాక్‌కి కాల్ చేసే క్లయింట్‌లో ఎకో సర్వర్ అప్లికేషన్‌లో పంపండి. పాయింట్-టు-పాయింట్ లింక్ ద్వారా ప్యాకెట్‌ను పంపడానికి గడిచిన సమయం 3,69 మిల్లీసెకన్లు అని గమనించండి. ఎకో సర్వర్ ప్యాకెట్‌కి ప్రతిస్పందించిన సందేశాన్ని లాగ్ చేయడాన్ని మీరు చూడవచ్చు, ఆపై, ఛానెల్ ఆలస్యం అయిన తర్వాత, ఎకో క్లయింట్ దాని హ్యాండిల్ రీడ్ పద్ధతిలో ఎకో ప్యాకెట్‌ను స్వీకరించడాన్ని మీరు చూడవచ్చు.

ఈ అనుకరణలో, మీరు గమనించకుండానే చాలా జరుగుతాయి. కానీ మీరు సిస్టమ్‌లోని అన్ని లాగింగ్ భాగాలను ప్రారంభించడం ద్వారా మొత్తం ప్రక్రియను చాలా సులభంగా ట్రాక్ చేయవచ్చు. NS_LOG వేరియబుల్‌ను క్రింది విలువకు సెట్ చేయడానికి ప్రయత్నించండి,

$ export 'NS_LOG=*=level_all|prefix_func|prefix_time'

పైన ఉన్న నక్షత్రం లాగింగ్ భాగం కోసం వైల్డ్‌కార్డ్ అక్షరం. ఇది అనుకరణలో ఉపయోగించిన అన్ని భాగాలలోని అన్ని ఎంట్రీలను కలిగి ఉంటుంది. నేను ఇక్కడ అవుట్‌పుట్‌ను పునరుత్పత్తి చేయను (వ్రాసే సమయంలో ఇది ఒక ఎకో ప్యాకెట్ కోసం 1265 లైన్‌ల అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది), కానీ మీరు ఈ సమాచారాన్ని ఫైల్‌కి మళ్లించవచ్చు మరియు మీకు ఇష్టమైన ఎడిటర్‌లో వీక్షించవచ్చు.

$ ./waf --run scratch/myfirst > log.out 2>&1

నాకు సమస్య ఉన్నప్పుడు మరియు ఎక్కడ తప్పు జరిగిందో తెలియనప్పుడు నేను వ్యక్తిగతంగా ఈ అత్యంత వెర్బోస్ లాగింగ్ వెర్షన్‌ని ఉపయోగిస్తాను. నేను బ్రేక్‌పాయింట్‌లను సెట్ చేయకుండా మరియు డీబగ్గర్‌లో కోడ్ ద్వారా అడుగు పెట్టకుండా చాలా సులభంగా కోడ్ అమలును అనుసరించగలను. నేను నాకు ఇష్టమైన ఎడిటర్‌లో అవుట్‌పుట్‌ని ఎడిట్ చేయగలను మరియు నేను ఆశించిన దాని కోసం వెతకగలను మరియు నేను ఊహించనిది జరగడాన్ని చూడగలను. నాకు ఏమి తప్పు జరుగుతోందనే సాధారణ ఆలోచన వచ్చిన తర్వాత, సమస్యలోకి దిగడానికి నేను డీబగ్గర్‌లోకి దూకుతాను. మీ స్క్రిప్ట్ పూర్తిగా ఊహించని పనిని చేసినప్పుడు ఈ రకమైన అవుట్‌పుట్ చాలా ఉపయోగకరంగా ఉంటుంది. మీరు డీబగ్గర్‌ను మాత్రమే ఉపయోగిస్తే, మీరు పూర్తిగా ట్విస్ట్‌ను కోల్పోవచ్చు. నమోదు అటువంటి మలుపులను గుర్తించదగినదిగా చేస్తుంది.

5.1.3 మీ కోడ్‌కి లాగింగ్‌ని జోడిస్తోంది

మీరు బహుళ మాక్రోల నుండి లాగ్ కాంపోనెంట్‌కి కాల్‌లు చేయడం ద్వారా మీ అనుకరణలకు కొత్త ఎంట్రీలను జోడించవచ్చు. స్క్రిప్ట్‌లో చేద్దాం myfirst.cc, మేము "క్లీన్" డైరెక్టరీలో కలిగి ఉన్నాము. ఈ దృష్టాంతంలో మేము లాగింగ్ కాంపోనెంట్‌ని నిర్వచించామని గుర్తుచేసుకోండి:

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

మీరు వివిధ స్థాయిలలో NS_LOG ఎన్విరాన్మెంట్ వేరియబుల్‌ని సెట్ చేయడం ద్వారా ఈ భాగం నుండి అన్ని సందేశాల లాగింగ్‌ను ప్రారంభించవచ్చని మీకు తెలుసు. స్క్రిప్ట్‌కి కొన్ని ఎంట్రీలను జోడించి ముందుకు వెళ్దాం. లాగ్‌కు సమాచార స్థాయి సందేశాలను జోడించడానికి ఉపయోగించే మాక్రో NS_LOG_INFO. స్క్రిప్ట్ "టోపోలాజీని సృష్టించడం" దశలో ఉందని మీకు తెలియజేసే సందేశాన్ని (మేము నోడ్‌లను సృష్టించడం ప్రారంభించే ముందు) జోడిద్దాము. ఇది క్రింది కోడ్ స్నిప్పెట్‌లో చేయబడుతుంది,
తెరవండి స్క్రాచ్/myfirst.cc మీకు ఇష్టమైన ఎడిటర్‌లో మరియు పంక్తిని జోడించండి,
NS_LOG_INFO ("Creating Topology");
లైన్ల ముందు,

NodeContainer nodes;
nodes.Create (2);

ఇప్పుడు ఉపయోగించి స్క్రిప్ట్‌ను కంపైల్ చేయండి వాఫ్, మరియు మేము ముందుగా ప్రారంభించిన లాగింగ్ స్ట్రీమ్‌ను నిలిపివేయడానికి NS_LOG వేరియబుల్‌ను క్లియర్ చేయండి:

$ ./waf
$ export NS_LOG=
Теперь, если вы запустите скрипт,
$ ./waf --run scratch/myfirst

అనుబంధిత లాగింగ్ భాగం (FirstScriptExample) ప్రారంభించబడనందున మీరు కొత్త సందేశాన్ని చూడలేరు. మీ సందేశాన్ని చూడటానికి మీరు లాగింగ్ కాంపోనెంట్‌ని ఎనేబుల్ చేయాలి ఫస్ట్‌స్క్రిప్ట్ ఉదాహరణ స్థాయి NS_LOG_INFO కంటే తక్కువ కాదు. మీరు ఈ నిర్దిష్ట లాగింగ్ స్థాయిని చూడాలనుకుంటే, మీరు దీన్ని ఇలా ప్రారంభించవచ్చు,

$ export NS_LOG=FirstScriptExample=info

మీరు ఇప్పుడు స్క్రిప్ట్‌ని అమలు చేస్తే, మీరు "టోపోలాజీని సృష్టిస్తోంది" అనే కొత్త సందేశాన్ని చూస్తారు,

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.404s)
Creating Topology
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2

5.2 కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ఉపయోగించడం

5.2.1 డిఫాల్ట్ అట్రిబ్యూట్ విలువలను భర్తీ చేయడం

సవరించడం లేదా నిర్మించకుండా ns-3 స్క్రిప్ట్‌ల ప్రవర్తనను మార్చడానికి మరొక మార్గం కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ఉపయోగించడం. మేము కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను అన్వయించడానికి మరియు ఫలితాల ఆధారంగా లోకల్ మరియు గ్లోబల్ వేరియబుల్‌లను స్వయంచాలకంగా సెట్ చేయడానికి ఒక యంత్రాంగాన్ని అందిస్తాము.

కమాండ్ లైన్ ఆర్గ్యుమెంట్ సిస్టమ్‌ను ఉపయోగించడంలో మొదటి దశ కమాండ్ లైన్ పార్సర్‌ను ప్రకటించడం. కింది కోడ్‌లో వలె (మీ ప్రధాన ప్రోగ్రామ్‌లో) దీన్ని చేయడం చాలా సులభం,

int
main (int argc, char *argv[])
{
...
CommandLine cmd;
cmd.Parse (argc, argv);
...
}

ఈ సాధారణ రెండు-లైన్ స్నిప్పెట్ నిజానికి దాని స్వంత హక్కులో చాలా ఉపయోగకరంగా ఉంటుంది. ఇది ns-3 గ్లోబల్ వేరియబుల్ మరియు అట్రిబ్యూట్ సిస్టమ్‌కు తలుపులు తెరుస్తుంది. ప్రధాన స్క్రిప్ట్ ఫంక్షన్ ప్రారంభానికి కోడ్ యొక్క రెండు లైన్లను జోడిద్దాం స్క్రాచ్/myfirst.cc. కొనసాగుతూనే, మేము స్క్రిప్ట్‌ను కంపైల్ చేసి, దాన్ని అమలు చేస్తాము, రన్ చేస్తున్నప్పుడు మేము ఈ క్రింది విధంగా సహాయ అభ్యర్థన చేస్తాము,

$ ./waf --run "scratch/myfirst --PrintHelp"

ఈ ఆదేశం అడుగుతుంది Waf స్క్రిప్ట్‌ని అమలు చేయండి స్క్రాచ్/నా ఫస్ట్ మరియు దానిని కమాండ్ లైన్ ఆర్గ్యుమెంట్ పాస్ చేయండి - ప్రింట్ హెల్ప్. ఆర్గ్యుమెంట్ ఏ ప్రోగ్రామ్ కోసం ఉద్దేశించబడిందో సూచించడానికి కొటేషన్ గుర్తులు అవసరం. కమాండ్ లైన్ పార్సర్ వాదనను గుర్తిస్తుంది - ప్రింట్ హెల్ప్ మరియు సమాధానాన్ని ప్రదర్శిస్తుంది,

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.413s)
TcpL4Protocol:TcpStateMachine()
CommandLine:HandleArgument(): Handle arg name=PrintHelp value=
--PrintHelp: Print this help message.
--PrintGroups: Print the list of groups.
--PrintTypeIds: Print all TypeIds.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintGlobals: Print the list of globals.

ఇప్పుడు ఎంపికను చూద్దాం - ప్రింట్ అట్రిబ్యూట్స్. first.cc స్క్రిప్ట్‌ని అధ్యయనం చేస్తున్నప్పుడు మేము ఇప్పటికే ns-3 అట్రిబ్యూట్ సిస్టమ్‌ని ప్రస్తావించాము. మేము ఈ క్రింది కోడ్ లైన్లను చూశాము,

PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

మరియు వారు చెప్పారు డేటా రేటు నిజానికి ఒక లక్షణం PointToPointNetDevice. లక్షణాలను వీక్షించడానికి కమాండ్ లైన్ ఆర్గ్యుమెంట్ పార్సర్‌ని ఉపయోగిస్తాము PointToPointNetDevice. సహాయ జాబితా మనం తప్పక ఏమి అందించాలి అని చెబుతుంది TypeId. ఆసక్తి గుణాలు ఉండే తరగతి పేరు ఇది. మా విషయంలో అది ఉంటుంది ns3::PointToPointNetDevice. ముందుకు వెళదాం, ప్రవేశించండి,

$ ./waf --run "scratch/myfirst --PrintAttributes=ns3::PointToPointNetDevice"

సిస్టమ్ ఈ నెట్‌వర్క్ పరికర రకం యొక్క అన్ని లక్షణాలను ముద్రిస్తుంది. జాబితాలోని లక్షణాలలో ఇవి ఉన్నాయని మీరు చూస్తారు,

--ns3::PointToPointNetDevice::DataRate=[32768bps]:
The default data rate for point to point links

ఇది ఆబ్జెక్ట్‌ను సృష్టించేటప్పుడు సిస్టమ్ ఉపయోగించే డిఫాల్ట్ విలువ PointToPointNetDevice. మేము పరామితిని ఉపయోగించి ఈ డిఫాల్ట్ విలువను భర్తీ చేస్తాము గుణం в PointToPointHelper ఉన్నత. పాయింట్-టు-పాయింట్ పరికరాలు మరియు ఛానెల్‌ల కోసం డిఫాల్ట్ విలువలను ఉపయోగిస్తాము. దీన్ని చేయడానికి, మేము కాల్‌లను తొలగిస్తాము సెట్ డివైస్ అట్రిబ్యూట్ и ఛానెల్ అట్రిబ్యూట్ సెట్ చేయండి నుండి myfirst.cc, ఇది మనకు క్లీన్ డైరెక్టరీలో ఉంది.

మీ స్క్రిప్ట్ ఇప్పుడు కేవలం ప్రకటించాలి PointToPointHelper మరియు దిగువ ఉదాహరణలో చూపిన విధంగా ఎటువంటి సంస్థాపనా కార్యకలాపాలను నిర్వహించవద్దు,

...
NodeContainer nodes;
nodes.Create (2);
PointToPointHelper pointToPoint;
NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);
...

కొనసాగండి మరియు దీనితో కొత్త స్క్రిప్ట్‌ని సృష్టించండి Waf (./వాఫ్) మరియు తిరిగి వెళ్లి UDP ఎకో సర్వర్ అప్లికేషన్ నుండి కొంత ఎంట్రీని చేర్చండి మరియు సమయ ఉపసర్గను చేర్చండి.

$ export 'NS_LOG=UdpEchoServerApplication=level_all|prefix_time'

మీరు స్క్రిప్ట్‌ను అమలు చేస్తే, మీరు ఈ క్రింది అవుట్‌పుట్‌ని చూడాలి:

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.405s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.25732s Received 1024 bytes from 10.1.1.1
2.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

మేము చివరిసారి అనుకరణ సమయాన్ని చూసినప్పుడు, ప్యాకెట్‌ను ఎకో సర్వర్ స్వీకరించిన క్షణం, అది 2,00369 సెకన్లు అని గుర్తుంచుకోండి.

2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1

ఇప్పుడు అతను 2.25732 సెకన్లలో ప్యాకెట్‌ను అందుకున్నాడు. ఎందుకంటే మేము PointToPointNetDevice డేటా రేటును సెకనుకు ఐదు మెగాబిట్ల నుండి డిఫాల్ట్ విలువకు రీసెట్ చేస్తాము, ఇది సెకనుకు 32768 బిట్‌లు. మేము కమాండ్ లైన్‌ని ఉపయోగించి కొత్త డేటా రేట్‌ను ప్రత్యామ్నాయం చేస్తే, మన అనుకరణను మళ్లీ వేగవంతం చేయవచ్చు. సహాయ మూలకం ద్వారా సూచించబడిన ఫార్ములా ప్రకారం మేము దీన్ని ఈ క్రింది విధంగా చేస్తాము:

$ ./waf --run "scratch/myfirst --ns3::PointToPointNetDevice::DataRate=5Mbps"

ఇది DataRate అట్రిబ్యూట్‌ని సెకనుకు ఐదు మెగాబిట్‌ల డిఫాల్ట్ విలువకు అందిస్తుంది. ఫలితం చూసి మీరు ఆశ్చర్యపోతున్నారా? స్క్రిప్ట్ యొక్క అసలు ప్రవర్తనను తిరిగి ఇవ్వడానికి, మేము కాంతి వేగానికి సరిపోయేలా ఛానెల్ ఆలస్యాన్ని కూడా సెట్ చేయాల్సి ఉంటుంది. మేము నెట్‌వర్క్ పరికరం కోసం చేసినట్లుగా, ఛానెల్ లక్షణాలను ముద్రించమని కమాండ్ లైన్ సిస్టమ్‌ను అడగవచ్చు:

$ ./waf --run "scratch/myfirst --PrintAttributes=ns3::PointToPointChannel"

ఛానెల్ ఆలస్యం లక్షణం క్రింది విధంగా సెట్ చేయబడిందని మేము కనుగొంటాము:

--ns3::PointToPointChannel::Delay=[0ns]:
Transmission delay through the channel

మేము కమాండ్ లైన్ సిస్టమ్ ద్వారా, ఈ రెండు డిఫాల్ట్ విలువలను సెట్ చేయవచ్చు.

$ ./waf --run "scratch/myfirst
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms"

ఈ సందర్భంలో మేము స్క్రిప్ట్‌లో డేటారేట్ మరియు ఆలస్యాన్ని స్పష్టంగా సెట్ చేసినప్పుడు మనకు ఉన్న సమయాన్ని పునరుద్ధరిస్తాము:

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.417s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.00369s Received 1024 bytes from 10.1.1.1
2.00369s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

2,00369 సెకన్ల తర్వాత ప్యాకెట్ మళ్లీ సర్వర్ ద్వారా స్వీకరించబడిందని గమనించండి. స్క్రిప్ట్‌లో ఉపయోగించిన ఏవైనా లక్షణాలను మనం ఈ విధంగా సెట్ చేయవచ్చు. ప్రత్యేకించి, మేము MaxPackets అట్రిబ్యూట్‌లను నాన్-వన్ విలువలకు సెట్ చేయవచ్చు UdpEchoClient.

మీరు దానిని ఎలా ఉపయోగించాలి? దీనిని ఒకసారి ప్రయత్నించండి. మేము డిఫాల్ట్ అట్రిబ్యూట్ విలువను భర్తీ చేసే మరియు స్పష్టంగా సెట్ చేసిన ప్రదేశాన్ని మీరు తప్పనిసరిగా వ్యాఖ్యానించాలని గుర్తుంచుకోండి MaxPackets స్క్రిప్ట్‌లో. అప్పుడు మీరు స్క్రిప్ట్‌ను పునర్నిర్మించాలి. మీరు కొత్త డిఫాల్ట్ అట్రిబ్యూట్ విలువను సెట్ చేయడం కోసం సింటాక్స్ సహాయం పొందడానికి కమాండ్ లైన్‌ని కూడా ఉపయోగించవచ్చు. మీరు దీన్ని అర్థం చేసుకున్న తర్వాత, కమాండ్ లైన్‌లో ప్రదర్శించబడే ప్యాకేజీల సంఖ్యను మీరు నియంత్రించవచ్చు. మేము అధ్యయనం చేసే వ్యక్తులం కాబట్టి, మా కమాండ్ లైన్ ఇలా ఉండాలి:

$ ./waf --run "scratch/myfirst
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms
--ns3::UdpEchoClient::MaxPackets=2"

ఈ సమయంలో తలెత్తే సహజమైన ప్రశ్న ఏమిటంటే, ఈ అన్ని లక్షణాల ఉనికి గురించి ఎలా తెలుసుకోవాలి. మళ్ళీ, కమాండ్ లైన్ సిస్టమ్ ఈ విషయానికి సహాయ ఫంక్షన్‌ను కలిగి ఉంది. మేము సహాయం కోసం కమాండ్ లైన్‌ని అడిగితే, మనం చూడాలి:

$ ./waf --run "scratch/myfirst --PrintHelp"
myfirst [Program Arguments] [General Arguments]
General Arguments:
--PrintGlobals: Print the list of globals.
--PrintGroups: Print the list of groups.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintTypeIds: Print all TypeIds.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintHelp: Print this help message.

మీరు "PrintGroups" ఆర్గ్యుమెంట్‌ని ఎంచుకుంటే, మీరు అన్ని నమోదిత సమూహాల జాబితాను చూడాలి TypeId. సమూహ పేర్లు సోర్స్ డైరెక్టరీలోని మాడ్యూల్స్ పేర్లతో స్థిరంగా ఉంటాయి (అయితే క్యాపిటలైజ్ చేయబడినప్పటికీ). మొత్తం సమాచారాన్ని ఒకేసారి ముద్రించడం చాలా పెద్దదిగా ఉంటుంది, కాబట్టి సమూహం వారీగా సమాచారాన్ని ప్రింట్ చేయడానికి అదనపు ఫిల్టర్ అందుబాటులో ఉంది. కాబట్టి, మళ్లీ పాయింట్-టు-పాయింట్ మాడ్యూల్‌పై దృష్టి సారిస్తోంది:

./waf --run "scratch/myfirst --PrintGroup=PointToPoint"
TypeIds in group PointToPoint:
ns3::PointToPointChannel
ns3::PointToPointNetDevice
ns3::PointToPointRemoteChannel
ns3::PppHeader

ఇక్కడ మీరు అట్రిబ్యూట్ లుకప్‌ల కోసం అందుబాటులో ఉన్న TypeId పేర్లను కనుగొనవచ్చు, ఉదాహరణకు
--PrintAttributes = ns3 :: PointToPointChannelపైన చూపిన విధంగా.

డాక్సిజెన్ ns‑3 ద్వారా లక్షణాల గురించి తెలుసుకోవడానికి మరొక మార్గం. సిమ్యులేటర్‌లో నమోదు చేయబడిన అన్ని లక్షణాలను జాబితా చేసే పేజీ ఉంది.

5.2.2 మీ స్వంత ఆదేశాలను సంగ్రహించడం

మీరు కమాండ్ లైన్ సిస్టమ్ ద్వారా మీ స్వంత హుక్స్‌లను కూడా జోడించవచ్చు. ఇది కమాండ్ లైన్ పార్సర్ పద్ధతిని ఉపయోగించి చాలా సరళంగా చేయబడుతుంది అదనపు విలువ.
పూర్తిగా భిన్నమైన రీతిలో ప్రదర్శించబడే ప్యాకేజీల సంఖ్యను పేర్కొనడానికి ఈ లక్షణాన్ని ఉపయోగిస్తాము. అనే లోకల్ వేరియబుల్‌ని యాడ్ చేద్దాం nప్యాకెట్లు ఒక ఫంక్షన్ లోకి ప్రధాన. మా మునుపటి డిఫాల్ట్ ప్రవర్తనకు సరిపోయేలా మేము దానిని ఒకదానికి సెట్ చేస్తాము. ఈ విలువను మార్చడానికి కమాండ్ లైన్ పార్సర్‌ను అనుమతించడానికి, మేము ఈ విలువను పార్సర్‌లో క్యాప్చర్ చేయాలి. మేము కాల్‌ని జోడించడం ద్వారా దీన్ని చేస్తాము అదనపు విలువ. వెళ్లి స్క్రిప్ట్ మార్చండి స్క్రాచ్/myfirst.cc కాబట్టి కింది కోడ్‌తో ప్రారంభించడానికి,

int
main (int argc, char *argv[])
{
uint32_t nPackets = 1;
CommandLine cmd;
cmd.AddValue("nPackets", "Number of packets to echo", nPackets);
cmd.Parse (argc, argv);
...

మేము MaxPackets లక్షణాన్ని సెట్ చేసే స్క్రిప్ట్‌లోని పాయింట్‌కి క్రిందికి స్క్రోల్ చేయండి మరియు దిగువ చూపిన విధంగా స్థిరమైన 1కి బదులుగా nPackets వేరియబుల్‌కి సెట్ చేయబడేలా మార్చండి.

echoClient.SetAttribute ("MaxPackets", UintegerValue (nPackets));

ఇప్పుడు మీరు స్క్రిప్ట్‌ని అమలు చేసి, -PrintHelp ఆర్గ్యుమెంట్‌ని సరఫరా చేస్తే, మీరు కొత్త యూజర్ ఆర్గ్యుమెంట్‌ని చూడాలి. సహాయ ప్రదర్శనలో జాబితా చేయబడింది. నమోదు చేయండి,

$ ./waf --run "scratch/myfirst --PrintHelp"
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.403s)
--PrintHelp: Print this help message.
--PrintGroups: Print the list of groups.
--PrintTypeIds: Print all TypeIds.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintGlobals: Print the list of globals.
User Arguments:
--nPackets: Number of packets to echo

మీరు ప్రసారం చేయబడిన ప్యాకెట్ల సంఖ్యను మార్చాలనుకుంటే, మీరు కమాండ్ లైన్ ఆర్గ్యుమెంట్ - -nPacketsని సెట్ చేయడం ద్వారా అలా చేయవచ్చు.

$ ./waf --run "scratch/myfirst --nPackets=2"

ఇప్పుడు మీరు చూడాలి

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.404s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.25732s Received 1024 bytes from 10.1.1.1
2.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
Sent 1024 bytes to 10.1.1.2
3.25732s Received 1024 bytes from 10.1.1.1
3.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

మీరు ఇప్పుడు రెండు ప్యాకేజీలను పంపారు. చాలా సులభం, కాదా?
మీరు ns-3 వినియోగదారుగా, ప్రపంచ విలువలు మరియు లక్షణాలను మార్చటానికి కమాండ్ లైన్ ఆర్గ్యుమెంట్ సిస్టమ్‌ను ఉపయోగించవచ్చని మీరు చూడవచ్చు. మీరు మోడల్ రచయిత అయితే, మీరు మీ వస్తువులకు కొత్త లక్షణాలను జోడించవచ్చు మరియు కమాండ్ లైన్ సిస్టమ్ ద్వారా మీ వినియోగదారులచే కాన్ఫిగరేషన్ కోసం అవి స్వయంచాలకంగా అందుబాటులో ఉంటాయి. మీరు స్క్రిప్ట్ రచయిత అయితే, మీరు మీ స్క్రిప్ట్‌లకు కొత్త వేరియబుల్స్‌ని జోడించవచ్చు మరియు వాటిని మీ కమాండ్ లైన్ సిస్టమ్‌లోకి సజావుగా ప్లగ్ చేయవచ్చు.

5.3 ట్రేసింగ్ సిస్టమ్‌ని ఉపయోగించడం

మోడలింగ్ యొక్క మొత్తం పాయింట్ తదుపరి అధ్యయనం కోసం అవుట్‌పుట్‌ను రూపొందించడం మరియు దీనికి ns-3 ట్రేస్ సిస్టమ్ ప్రధాన విధానం. ns-3 అనేది C++ ప్రోగ్రామ్ కాబట్టి, C++ ప్రోగ్రామ్ నుండి అవుట్‌పుట్‌ను రూపొందించడానికి ప్రామాణిక మార్గాలను ఉపయోగించవచ్చు:

#include <iostream>
...
int main ()
{
...
std::cout << "The value of x is " << x << std::endl;
...
}

మీరు మీ పరిష్కారానికి కొద్దిగా నిర్మాణాన్ని జోడించడానికి లాగింగ్ మాడ్యూల్‌ని కూడా ఉపయోగించవచ్చు. ఈ విధానం వల్ల తెలిసిన అనేక సమస్యలు ఉన్నాయి, అందువల్ల మేము ఈ సమస్యలను పరిష్కరించడానికి సాధారణ ఈవెంట్ ట్రేసింగ్ సబ్‌సిస్టమ్‌ను అందించాము.

ns-3 ట్రేసింగ్ సిస్టమ్ యొక్క ప్రధాన లక్ష్యాలు:

• ప్రాథమిక పనుల కోసం, ట్రేసింగ్ సిస్టమ్ వినియోగదారుని జనాదరణ పొందిన మూలాల కోసం ప్రామాణిక ట్రేస్‌ను రూపొందించడానికి మరియు ట్రేస్‌ను రూపొందించే వస్తువులను ఎంచుకోవడానికి అనుమతించాలి;

• మధ్యంతర వినియోగదారులు సిమ్యులేటర్ కోర్‌ను సవరించకుండా, ఉత్పత్తి చేయబడిన అవుట్‌పుట్ ఆకృతిని మార్చడానికి లేదా కొత్త ట్రేస్ సోర్స్‌లను ఇన్‌సర్ట్ చేయడానికి ట్రేసింగ్ సిస్టమ్‌ను విస్తరించగలరు;

• అధునాతన వినియోగదారులు కొత్త ట్రేస్ సోర్స్‌లు మరియు సింక్‌లను జోడించడానికి సిమ్యులేటర్ కోర్‌ని సవరించవచ్చు. ns-3 ట్రేసింగ్ సిస్టమ్ స్వతంత్ర ట్రాకింగ్ మూలాలు మరియు రిసీవర్‌ల సూత్రాలపై నిర్మించబడింది, అలాగే వినియోగదారులకు మూలాలను కనెక్ట్ చేయడానికి ఏకీకృత యంత్రాంగం.

ns-3 ట్రేసింగ్ సిస్టమ్ స్వతంత్ర ట్రేసింగ్ మూలాలు మరియు రిసీవర్‌ల సూత్రాలపై నిర్మించబడింది, అలాగే మూలాలను రిసీవర్‌లకు కనెక్ట్ చేయడానికి ఏకీకృత యంత్రాంగం. ట్రేస్ సోర్స్‌లు అనుకరణలో సంభవించే ఈవెంట్‌లను సూచించగల వస్తువులు మరియు ఆసక్తికి సంబంధించిన అంతర్లీన డేటాకు ప్రాప్యతను అందిస్తాయి. ఉదాహరణకు, నెట్‌వర్క్ పరికరం ఎప్పుడు ప్యాకెట్‌ను స్వీకరించిందో ట్రేస్ సోర్స్ సూచిస్తుంది మరియు ఆసక్తి గల ట్రేస్ రిసీవర్‌లకు ప్యాకెట్‌లోని కంటెంట్‌లను అందుబాటులో ఉంచుతుంది.

సింక్ అందించిన సమాచారంతో వాస్తవానికి ఉపయోగకరమైన ఏదైనా చేసే కోడ్‌లోని ఇతర భాగాలతో "కలిపివేయబడినట్లయితే" వాటి స్వంత ట్రేస్ సోర్స్‌లు పనికిరావు. ట్రేసర్‌లు ట్రేస్ సోర్స్‌ల ద్వారా అందించబడిన ఈవెంట్‌లు మరియు డేటా యొక్క వినియోగదారులు. ఉదాహరణకు, మీరు ట్రేస్ సింక్‌ని సృష్టించవచ్చు, అది (మునుపటి ఉదాహరణ యొక్క ట్రేస్ సోర్స్‌కి కనెక్ట్ చేసినప్పుడు) అందుకున్న ప్యాకెట్‌లోని ఆసక్తి భాగాలను ప్రింట్ చేస్తుంది.

సిమ్యులేటర్ కోర్‌ని ఎడిట్ మరియు రీకంపైల్ చేయకుండా కొత్త సింక్ రకాలను ఇప్పటికే ఉన్న ట్రేస్ సోర్స్‌లకు కనెక్ట్ చేయడానికి వినియోగదారులను అనుమతించడం ఈ స్పష్టమైన విభజనకు కారణం. కాబట్టి పై ఉదాహరణలో, వినియోగదారు వారి స్క్రిప్ట్‌లో కొత్త ట్రేసర్‌ను నిర్వచించవచ్చు మరియు వినియోగదారు స్క్రిప్ట్‌ను సవరించడం ద్వారా మాత్రమే అనుకరణ కోర్‌లో నిర్వచించబడిన ఇప్పటికే ఉన్న ట్రేస్ సోర్స్‌కి దానిని కనెక్ట్ చేయవచ్చు.

ఈ ట్యుటోరియల్‌లో, మేము కొన్ని ముందే నిర్వచించబడిన మూలాధారాలు మరియు సింక్‌లను పరిశీలిస్తాము మరియు వినియోగదారు భాగస్వామ్య ప్రయత్నాల ద్వారా వాటిని ఎలా కాన్ఫిగర్ చేయవచ్చో చూపుతాము. ట్రేస్ నేమ్‌స్పేస్‌ను విస్తరించడం మరియు కొత్త ట్రేస్ సోర్స్‌లను సృష్టించడం వంటి అధునాతన ట్రేస్ కాన్ఫిగరేషన్‌పై సమాచారం కోసం ns-3 మాన్యువల్ లేదా ఎలా-to విభాగాలను చూడండి.

5.3.1 ASCII ట్రేసింగ్

ns-3 సాధారణ ప్యాకెట్ ట్రేస్‌లను సెటప్ చేసేటప్పుడు వివరాలతో మీకు సహాయం చేయడానికి తక్కువ-స్థాయి ట్రేసింగ్ సిస్టమ్‌ను అందించే సహాయక కార్యాచరణను అందిస్తుంది. మీరు ఈ లక్షణాన్ని ప్రారంభించినట్లయితే, మీరు ASCII ఫైల్‌లలో అవుట్‌పుట్‌ని చూస్తారు. ns-2 అవుట్‌పుట్ గురించి తెలిసిన వారికి, ఈ రకమైన ట్రేస్ ఇలాగే ఉంటుంది out.tr, ఇది అనేక స్క్రిప్ట్‌ల ద్వారా రూపొందించబడింది.

వ్యాపారానికి దిగి, మా స్క్రాచ్/myfirst.cc స్క్రిప్ట్‌కి కొన్ని ASCII ట్రేసింగ్ ఫలితాలను జోడిద్దాము. కాల్‌కు ముందు Simulator :: Run (), కోడ్ యొక్క క్రింది పంక్తులను జోడించండి:
AsciiTraceHelper ascii;

pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));

అనేక ఇతర ns-3 ఇడియమ్‌ల వలె, ఈ కోడ్ ASCII ట్రేస్‌లను సృష్టించడానికి సహాయక వస్తువును ఉపయోగిస్తుంది. రెండవ పంక్తిలో రెండు సమూహ పద్ధతి కాల్‌లు ఉన్నాయి. "లోపల" పద్ధతి FileStreamని సృష్టించండి() స్టాక్‌పై ఫైల్ స్ట్రీమ్ ఆబ్జెక్ట్‌ను సృష్టించడానికి అనామక ఆబ్జెక్ట్ ఇడియమ్‌ని ఉపయోగిస్తుంది (ఆబ్జెక్ట్ పేరు లేకుండా) మరియు దానిని కాల్ చేసిన పద్ధతికి పంపుతుంది. మేము భవిష్యత్తులో దీని గురించి మరింత లోతుగా వెళ్తాము, అయితే ఈ సమయంలో మీరు తెలుసుకోవలసినది ఏమిటంటే, మీరు ఫైల్‌ను సూచించే వస్తువును సృష్టిస్తున్నారు myfirst.tr మరియు దానిని ns-3కి బదిలీ చేయండి. మేము సృష్టించిన ఆబ్జెక్ట్‌ను దాని మొత్తం జీవితకాలం పాటు చూసుకోవడానికి ns-3కి అప్పగిస్తాము, ఈ సమయంలో ఇది C++ స్ట్రీమ్ ఆబ్జెక్ట్ కాపీ కన్‌స్ట్రక్టర్‌లతో అనుబంధించబడిన తక్కువ-తెలిసిన (ఉద్దేశపూర్వక) పరిమితి కారణంగా ఏర్పడే సమస్యలను పరిష్కరిస్తుంది.

బాహ్య కాల్ AsciiAll()ని ప్రారంభించండి మీరు అన్ని పాయింట్-టు-పాయింట్ పరికర కనెక్షన్‌ల కోసం మీ అనుకరణలో ASCII ట్రేసింగ్‌ను చేర్చాలనుకుంటున్నారని మరియు ASCII ఫార్మాట్‌లో ప్యాకెట్ కదలిక సమాచారాన్ని రికార్డ్ చేయడానికి (పేర్కొన్న) ట్రేస్ రిసీవర్‌లను మీరు కోరుకుంటున్నారని అసిస్టెంట్‌కి చెబుతుంది.

ns-2 గురించి తెలిసిన వారికి, ట్రాక్ చేయబడిన ఈవెంట్‌లు "+", "-", "d" మరియు "r" ఈవెంట్‌లను లాగ్ చేసే తెలిసిన ట్రేస్‌పాయింట్‌లకు సమానం.
ఇప్పుడు మీరు స్క్రిప్ట్‌ను నిర్మించవచ్చు మరియు కమాండ్ లైన్ నుండి దాన్ని అమలు చేయవచ్చు:

$ ./waf --run scratch/myfirst

మునుపు అనేక సార్లు వలె, మీరు Waf నుండి అనేక సందేశాలను చూస్తారు, ఆపై నడుస్తున్న ప్రోగ్రామ్ నుండి కొన్ని సందేశాలతో "'బిల్డ్' విజయవంతంగా పూర్తయింది".

నడుస్తున్నప్పుడు, ప్రోగ్రామ్ పేరుతో ఫైల్‌ను సృష్టిస్తుంది myfirst.tr. పని స్వభావం కారణంగా Waf, డిఫాల్ట్‌గా ఫైల్ స్థానిక డైరెక్టరీలో కాదు, రిపోజిటరీ యొక్క ఉన్నత-స్థాయి డైరెక్టరీలో సృష్టించబడుతుంది. మీరు ట్రేస్‌లు సేవ్ చేయబడిన మార్గాన్ని మార్చాలనుకుంటే, దానిని పేర్కొనడానికి మీరు Waf పరామితిని ఉపయోగించవచ్చు. --cwd. మేము దీన్ని చేయలేదు, కాబట్టి మీకు ఇష్టమైన ఎడిటర్‌లో ASCII ట్రేస్ ఫైల్ myfirst.trని చూడటానికి, మేము మా రిపోజిటరీ యొక్క ఉన్నత-స్థాయి డైరెక్టరీకి నావిగేట్ చేయాలి.

ASCII ట్రేస్‌లను అన్వయించడం

చాలా దట్టమైన రూపంలో చాలా సమాచారం ఉంది, కానీ మీరు గమనించవలసిన మొదటి విషయం ఏమిటంటే ఫైల్ వ్యక్తిగత పంక్తులను కలిగి ఉంటుంది. మీరు వీక్షణ విండోను విస్తృతంగా విస్తరించినట్లయితే ఇది స్పష్టంగా కనిపిస్తుంది.

ఫైల్‌లోని ప్రతి పంక్తి ట్రేస్ ఈవెంట్‌కు అనుగుణంగా ఉంటుంది. ఈ సందర్భంలో, మేము అనుకరణలోని ప్రతి పాయింట్-టు-పాయింట్ నెట్‌వర్క్ పరికరంలో ఉన్న ట్రాన్స్‌మిషన్ క్యూలో ఈవెంట్‌లను ట్రాక్ చేస్తాము. ట్రాన్స్‌మిషన్ క్యూ అనేది పాయింట్-టు-పాయింట్ లింక్ కోసం ప్రతి ప్యాకెట్ తప్పనిసరిగా పాస్ అయ్యే క్యూ. ట్రేస్ ఫైల్‌లోని ప్రతి పంక్తి ఒకే అక్షరంతో ప్రారంభమవుతుందని గమనించండి (మరియు దాని తర్వాత ఖాళీ ఉంటుంది). ఈ గుర్తుకు ఈ క్రింది అర్థం ఉంటుంది:

+: పరికర క్యూలో క్యూయింగ్ ఆపరేషన్ జరిగింది;
-: పరికరం క్యూలో మూలకం తిరిగి పొందే ఆపరేషన్ జరిగింది;
d: ప్యాకెట్ పడిపోయింది, సాధారణంగా క్యూ నిండుగా ఉన్నందున;
r: ప్యాకెట్ నెట్‌వర్క్ పరికరం ద్వారా స్వీకరించబడింది.

ట్రేస్ ఫైల్‌లోని మొదటి పంక్తిని నిశితంగా పరిశీలిద్దాం. నేను దానిని భాగాలుగా (స్పష్టత కోసం ఇండెంటేషన్‌లతో) మరియు ఎడమ వైపున ఉన్న లైన్ నంబర్‌గా విభజిస్తాను:

0 +
1 2
2 /NodeList/0/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Enqueue
3 ns3::PppHeader (
4   Point-to-Point Protocol: IP (0x0021))
6   ns3::Ipv4Header (
7     tos 0x0 ttl 64 id 0 protocol 17 offset 0 flags [none]
8     length: 1052 10.1.1.1 > 10.1.1.2)
9     ns3::UdpHeader (
10      length: 1032 49153 > 9)
11      Payload (size=1024)

ఈ పొడిగించిన ట్రేస్ ఈవెంట్ (లైన్ 0) యొక్క మొదటి విభాగం ఆపరేషన్. మేము ఇక్కడ + గుర్తును కలిగి ఉన్నాము, ఇది ప్రసారం కోసం క్యూయింగ్ యొక్క ఆపరేషన్కు అనుగుణంగా ఉంటుంది. రెండవ విభాగం (లైన్ 1) అనుకరణ సమయం, సెకన్లలో వ్యక్తీకరించబడింది. మేము అడిగినది మీకు గుర్తుండవచ్చు UdpEchoClient అప్లికేషన్ రెండు సెకన్లలో ప్యాకెట్లను పంపడం ప్రారంభించండి. ఇది నిజంగా జరుగుతోందనే నిర్ధారణను ఇక్కడ చూస్తాము.

ట్రేస్ ఉదాహరణ యొక్క తదుపరి విభాగం (పంక్తి 2 నుండి) ఏ ట్రేస్ సోర్స్ ఈ ఈవెంట్‌ను రూపొందించిందో చూపిస్తుంది (నేమ్‌స్పేస్ ట్రేస్‌ను సూచిస్తుంది). మీరు ఫైల్‌సిస్టమ్ నేమ్‌స్పేస్ లాగా ట్రేస్ నేమ్‌స్పేస్ గురించి ఆలోచించవచ్చు. నేమ్‌స్పేస్ యొక్క మూలం నోడ్‌లిస్ట్. ఇది ప్రధాన ns-3 కోడ్‌లో నిర్వహించబడే కంటైనర్‌కు అనుగుణంగా ఉంటుంది. ఇది స్క్రిప్ట్‌లో సృష్టించబడిన అన్ని నోడ్‌లను కలిగి ఉంటుంది. ఫైల్ సిస్టమ్ దాని మూలంలో డైరెక్టరీలను కలిగి ఉన్నట్లే, నోడ్‌లిస్ట్ మేము అనేక నోడ్లను కలిగి ఉండవచ్చు. కాబట్టి లైన్ /NodeList/0 అనేది నోడ్‌లిస్ట్‌లోని శూన్య నోడ్‌ను సూచిస్తుంది, దీనిని మనం సాధారణంగా "నోడ్ 0"గా భావిస్తాము. ప్రతి నోడ్‌లో ఇన్‌స్టాల్ చేయబడిన పరికరాల జాబితా ఉంటుంది. ఈ జాబితా నేమ్‌స్పేస్‌లో తదుపరి స్థానంలో ఉంది. ఈ ట్రేస్ ఈవెంట్ నుండి వచ్చినట్లు మీరు చూడవచ్చు పరికర జాబితా/0, ఇది నోడ్‌లో ఇన్‌స్టాల్ చేయబడిన శూన్య పరికరం.

తదుపరి సబ్‌స్ట్రింగ్, $ ns3 :: PointToPointNetDevice, ఏ పరికరం సున్నా స్థానంలో ఉందో తెలియజేస్తుంది: నోడ్ సున్నా యొక్క పరికర జాబితా. పంక్తి 0లో కనుగొనబడిన + ఆపరేషన్ అంటే పరికరం యొక్క ప్రసార క్యూలో ఒక మూలకం జోడించబడిందని గుర్తుంచుకోండి. ఇది "ట్రాక్ పాత్" యొక్క చివరి విభాగాలలో ప్రతిబింబిస్తుంది: TxQueue/Enqueue.

ట్రేస్‌లోని మిగిలిన విభాగాలు చాలా స్పష్టంగా ఉండాలి. 3-4 లైన్లు ప్యాకెట్ పాయింట్-టు-పాయింట్ ప్రోటోకాల్‌లో కప్పబడి ఉందని సూచిస్తున్నాయి. ప్యాకెట్ IP5 వెర్షన్ హెడర్‌ను కలిగి ఉందని మరియు IP చిరునామాలో ఉద్భవించిందని 7-4 లైన్లు చూపుతాయి 10.1.1.1 మరియు ఉద్దేశించబడింది 10.1.1.2. 8-9 పంక్తులు ఈ ప్యాకెట్‌కు UDP హెడర్ ఉందని చూపిస్తుంది మరియు చివరగా 10వ పంక్తి పేలోడ్ ఊహించిన 1024 బైట్‌లు అని చూపిస్తుంది.

ట్రేస్ ఫైల్‌లోని తదుపరి పంక్తి అదే నోడ్‌లోని ట్రాన్స్‌మిషన్ క్యూ నుండి అదే ప్యాకెట్ లాగబడిందని చూపిస్తుంది.

ట్రేస్ ఫైల్‌లోని మూడవ పంక్తి ఎకో సర్వర్ హోస్ట్‌లోని నెట్‌వర్క్ పరికరం ద్వారా ప్యాకెట్ స్వీకరించబడిందని చూపిస్తుంది. నేను ఈవెంట్‌ను క్రింద పునరుత్పత్తి చేసాను.

0 r
1 2.25732
2 /NodeList/1/DeviceList/0/$ns3::PointToPointNetDevice/MacRx
3   ns3::Ipv4Header (
4     tos 0x0 ttl 64 id 0 protocol 17 offset 0 flags [none]
5     length: 1052 10.1.1.1 > 10.1.1.2)
6     ns3::UdpHeader (
7       length: 1032 49153 > 9)
8       Payload (size=1024)

ట్రేస్ ఆపరేషన్ ఇప్పుడు r మరియు అనుకరణ సమయం 2,25732 సెకన్లకు పెంచబడిందని గమనించండి. మీరు ట్యుటోరియల్‌ని జాగ్రత్తగా అనుసరించినట్లయితే, మీరు నెట్‌వర్క్ పరికరాల డేటా రేటు మరియు లింక్ ఆలస్యాన్ని వాటి డిఫాల్ట్ విలువలలో వదిలివేసినట్లు అర్థం. మీరు మునుపటి విభాగంలో చూసినట్లుగా, ఈ కాలం బాగా తెలిసి ఉండాలి.

ఈ ఈవెంట్ నోడ్ 2 (/) నుండి ఉద్భవించిందని ప్రతిబింబించేలా ట్రేస్ సోర్స్ నేమ్‌స్పేస్ ఎంట్రీ (లైన్ 1) సవరించబడిందినోడ్‌లిస్ట్/1) మరియు ప్యాకెట్ ట్రేస్ సోర్స్ (/MacRx) ఫైల్‌లోని మిగిలిన ట్రేస్‌లను చూడటం ద్వారా టోపోలాజీ ద్వారా ప్యాకెట్ యొక్క కదలికను అనుసరించడం మీకు చాలా సులభం.

5.3.2 PCAP ట్రేస్

ns-3 పరికర సహాయకులు .pcap ఫార్మాట్‌లో ట్రేస్ ఫైల్‌లను సృష్టించడానికి కూడా ఉపయోగించవచ్చు. ఎక్రోనిం pcap (సాధారణంగా చిన్న అక్షరాలతో వ్రాయబడుతుంది) అంటే ప్యాకెట్ క్యాప్చర్ మరియు వాస్తవానికి .pcap ఫైల్ ఫార్మాట్‌ని నిర్వచించే API. ఈ ఆకృతిని చదవగలిగే మరియు ప్రదర్శించగల అత్యంత ప్రజాదరణ పొందిన ప్రోగ్రామ్ Wireshark (గతంలో పిలిచేవారు అంతరిక్ష) అయితే, ఈ ప్యాకెట్ ఆకృతిని ఉపయోగించే అనేక ట్రాఫిక్ ట్రేస్ ఎనలైజర్‌లు ఉన్నాయి. pcap ట్రేస్‌లను విశ్లేషించడానికి అందుబాటులో ఉన్న అనేక సాధనాలను ఉపయోగించమని మేము వినియోగదారులను ప్రోత్సహిస్తున్నాము. ఈ ట్యుటోరియల్‌లో మేము ఉపయోగించి pcap ట్రేస్‌లను వీక్షించడంపై దృష్టి పెడతాము tcpdump.

pcap ట్రేసింగ్‌ని ప్రారంభించడం అనేది ఒక లైన్ కోడ్‌తో చేయబడుతుంది.

pointToPoint.EnablePcapAll ("myfirst");

మేము ఇప్పుడే జోడించిన ASCII ట్రేస్ కోడ్ తర్వాత ఈ లైన్ కోడ్‌ను అతికించండి స్క్రాచ్/myfirst.cc. మేము "myfirst" స్ట్రింగ్‌ను మాత్రమే పాస్ చేసాము, "myfirst.pcap" లేదా అలాంటిదేమీ కాదు. దీనికి కారణం పరామితి ఒక ఉపసర్గ, పూర్తి ఫైల్ పేరు కాదు. అనుకరణ సమయంలో, అసిస్టెంట్ వాస్తవానికి ప్రతి పాయింట్-టు-పాయింట్ పరికరం కోసం ట్రేస్ ఫైల్‌ను సృష్టిస్తుంది. ఫైల్ పేర్లు ప్రిఫిక్స్, నోడ్ నంబర్, డివైజ్ నంబర్ మరియు ప్రత్యయం ఉపయోగించి నిర్మించబడతాయి.pcap".

మా ఉదాహరణ స్క్రిప్ట్ కోసం, మేము "" అనే ఫైల్‌లను చూస్తాముmyfirst-0-0.pcap"మరియు"myfirst-1-0.pcap", ఇవి వరుసగా నోడ్ 0-డివైస్ 0 మరియు నోడ్ 1-డివైస్ 0 కోసం pcap ట్రేస్‌లు. మీరు pcap ట్రేసింగ్‌ను ఎనేబుల్ చేయడానికి కోడ్ లైన్‌ను జోడించిన తర్వాత, మీరు స్క్రిప్ట్‌ను సాధారణ మార్గంలో అమలు చేయవచ్చు:

$ ./waf --run scratch/myfirst

మీరు మీ పంపిణీ యొక్క అగ్ర-స్థాయి డైరెక్టరీలో చూస్తే, మీకు మూడు ఫైల్‌లు కనిపిస్తాయి: ASCII ట్రేస్ ఫైల్ myfirst.tr, మేము గతంలో అధ్యయనం చేసిన, ఫైల్స్ myfirst-0-0.pcap и myfirst-1-0.pcap - మేము ఇప్పుడే రూపొందించిన కొత్త pcap ఫైల్‌లు.

tcpdumpతో అవుట్‌పుట్ చదవడం

ప్రస్తుతానికి, pcap ఫైల్‌లను వీక్షించడానికి సులభమైన మార్గం tcpdumpని ఉపయోగించడం.

$ tcpdump -nn -tt -r myfirst-0-0.pcap
reading from file myfirst-0-0.pcap, link-type PPP (PPP)
2.000000 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, length 1024
2.514648 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, length 1024
tcpdump -nn -tt -r myfirst-1-0.pcap
reading from file myfirst-1-0.pcap, link-type PPP (PPP)
2.257324 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, length 1024
2.257324 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, length 1024

డంప్ లో myfirst-0-0.pcap (క్లయింట్ పరికరం) 2 సెకన్ల అనుకరణ తర్వాత ఎకో ప్యాకెట్ పంపబడడాన్ని మీరు చూడవచ్చు. మీరు రెండవ డంప్‌ను చూస్తే (myfirst-1-0.pcap), ప్యాకెట్ 2,257324 సెకన్లలో స్వీకరించబడిందని మీరు చూస్తారు. మీరు రెండవ డంప్‌లో 2.257324 సెకన్లలో ప్యాకెట్ తిరిగి వచ్చిందని మరియు చివరకు 2.514648 సెకన్లలో మొదటి డంప్‌లో క్లయింట్ ద్వారా ప్యాకెట్ తిరిగి పొందబడిందని మీరు చూస్తారు.

వైర్‌షార్క్‌తో అవుట్‌పుట్ చదవడం

మీకు పరిచయం లేకుంటే Wireshark, మీరు ప్రోగ్రామ్‌లు మరియు డాక్యుమెంటేషన్‌ను డౌన్‌లోడ్ చేయగల వెబ్‌సైట్ ఉంది: http://www.wireshark.org/. Wireshark అనేది ఈ ట్రేస్ ఫైల్‌లను ప్రదర్శించడానికి ఉపయోగించే GUI. మీకు వైర్‌షార్క్ ఉంటే, మీరు ట్రేస్ ఫైల్‌లలో దేనినైనా తెరవవచ్చు మరియు ప్యాకెట్ స్నిఫర్‌ని ఉపయోగించి ప్యాకెట్‌లను క్యాప్చర్ చేసినట్లుగా కంటెంట్‌లను ప్రదర్శించవచ్చు.

మూలం: www.habr.com