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

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

4 కాన్సెప్ట్ ఓవర్‌వ్యూ
4.1 కీలక సంగ్రహణలు
4.1.1 నోడ్
4.1.2 అప్లికేషన్
4.1.3 ఛానెల్
4.1.4 నికర పరికరం
4.1.5 టోపోలాజికల్ సహాయకులు
4.2 మొదటి ns-3 స్క్రిప్ట్
4.2.1 బాయిలర్‌ప్లేట్ కోడ్
4.2.2 ప్లగిన్లు
4.2.3 ns3 నేమ్‌స్పేస్
4.2.4 లాగింగ్
4.2.5 ప్రధాన విధి
4.2.6 టోపోలాజీ సహాయకులను ఉపయోగించడం
4.2.7 అప్లికేషన్ ఉపయోగించి
4.2.8 సిమ్యులేటర్
4.2.9 మీ స్క్రిప్ట్‌ను రూపొందించడం
4.3 ns-3 సోర్స్ కోడ్

చాప్టర్ 4

కాన్సెప్ట్ ఓవర్‌వ్యూ

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

4.1 కీలక సంగ్రహణలు

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

4.1.1 నోడ్

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

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

మీరు అర్థం చేసుకోవాలి నోడ్ మీరు కార్యాచరణను జోడించే కంప్యూటర్ వంటిది. మీరు అప్లికేషన్‌లు, ప్రోటోకాల్ స్టాక్‌లు మరియు పరిధీయ కార్డ్‌ల వంటి వాటిని డ్రైవర్‌లతో జోడిస్తారు, అది కంప్యూటర్‌ను ఉపయోగకరమైన పనిని చేయడానికి అనుమతిస్తుంది. మేము ns-3లో అదే ప్రాథమిక నమూనాను ఉపయోగిస్తాము.

4.1.2 అప్లికేషన్

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

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

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

4.1.3 ఛానెల్

వాస్తవ ప్రపంచంలో, మీరు కంప్యూటర్‌ను నెట్‌వర్క్‌కి కనెక్ట్ చేయవచ్చు. తరచుగా ఈ నెట్‌వర్క్‌లలో డేటా ప్రసారం చేయబడే మీడియాను ఛానెల్‌లు అంటారు. మీరు ఈథర్‌నెట్ కేబుల్‌ను వాల్ అవుట్‌లెట్‌లోకి ప్లగ్ చేసినప్పుడు, మీరు మీ కంప్యూటర్‌ను ఈథర్నెట్ లింక్‌కి కనెక్ట్ చేస్తున్నారు. అనుకరణ ns-3 ప్రపంచంలో, ఒక నోడ్ కమ్యూనికేషన్ ఛానెల్‌ని సూచించే వస్తువుకు కనెక్ట్ చేయబడింది. ఇక్కడ, కమ్యూనికేషన్ సబ్‌నెట్‌వర్క్ యొక్క ప్రాథమిక సంగ్రహణను ఛానెల్ అని పిలుస్తారు మరియు ఛానెల్ క్లాస్ ద్వారా C++లో సూచించబడుతుంది.

Класс ఛానల్ ఛానెల్ సబ్‌నెట్ ఆబ్జెక్ట్‌ల పరస్పర చర్యను నిర్వహించడానికి మరియు వాటికి నోడ్‌లను కనెక్ట్ చేయడానికి పద్ధతులను అందిస్తుంది. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ కోణంలో డెవలపర్‌ల ద్వారా ఛానెల్‌లు కూడా ప్రత్యేకించబడతాయి. ఛానెల్ స్పెషలైజేషన్ వైర్ లాగా సింపుల్ గా మోడల్ చేయగలదు. అంకితమైన ఛానెల్ పెద్ద ఈథర్‌నెట్ స్విచ్ లేదా వైర్‌లెస్ నెట్‌వర్క్‌ల విషయంలో అడ్డంకులతో నిండిన త్రీ-డైమెన్షనల్ స్పేస్ వంటి సంక్లిష్ట విషయాలను కూడా మోడల్ చేయగలదు.

మేము ఈ ట్యుటోరియల్‌లో ఛానెల్ యొక్క ప్రత్యేక సంస్కరణలను ఉపయోగిస్తాము CsmaChannelCsmaChannel, PointToPointChannelPointToPointChannel и WifiChannelWifiChannel. CsmaChannel, ఉదాహరణకు, క్యారియర్-సెన్స్ మల్టిపుల్ యాక్సెస్ కమ్యూనికేషన్స్ ఎన్విరాన్‌మెంట్‌ని అమలు చేసే కమ్యూనికేషన్ సబ్‌నెట్ వెర్షన్‌ను మోడల్ చేస్తుంది. ఇది మాకు ఈథర్నెట్ లాంటి కార్యాచరణను అందిస్తుంది.

4.1.4 నికర పరికరం

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

Сетевая карта не будет работать без программного драйвера, управляющего её оборудованием. В Unix (или Linux), часть периферийного оборудования классифицируется как device. Устройства управляются с помощью драйверов устройств (device drivers), а сетевые устройства (NIC) управляются с использованием драйверов сетевых устройств (నెట్వర్క్ పరికర డ్రైవర్లు) మరియు సమిష్టిగా నెట్‌వర్క్ పరికరాలు అంటారు (నికర పరికరాలు). В Unix и Linux вы обращаетесь к сетевым устройствам по таким именам, как например eth0.

ns-3లో, నెట్‌వర్క్ పరికర సంగ్రహణ డ్రైవర్ సాఫ్ట్‌వేర్ మరియు మోడల్ చేయబడిన హార్డ్‌వేర్ రెండింటినీ విస్తరించింది. అనుకరణలో, ఛానెల్‌ల ద్వారా ఇతర నోడ్‌లతో కమ్యూనికేట్ చేయడానికి నెట్‌వర్క్ పరికరం నోడ్‌లో "ఇన్‌స్టాల్ చేయబడింది". నిజమైన కంప్యూటర్ వలె, నోడ్‌ను బహుళ పరికరాల ద్వారా బహుళ ఛానెల్‌లకు కనెక్ట్ చేయవచ్చు NetDevices.

పరికరం యొక్క నెట్‌వర్క్ సంగ్రహణ తరగతి ద్వారా C++లో సూచించబడుతుంది నెట్ డివైస్. తరగతి నెట్ డివైస్ నోడ్ మరియు ఛానెల్ ఆబ్జెక్ట్‌లకు కనెక్షన్‌లను నిర్వహించడానికి పద్ధతులను అందిస్తుంది; మరియు ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ అనే అర్థంలో డెవలపర్‌లచే ప్రత్యేకించబడవచ్చు. ఈ ట్యుటోరియల్‌లో మేము NetDevice యొక్క అనేక ప్రత్యేక సంస్కరణలను ఉపయోగిస్తాము CsmaNetDevice, PointToPointNetDevice и WifiNetDevice. ఈథర్నెట్ నెట్‌వర్క్ అడాప్టర్ నెట్‌వర్క్‌తో పని చేయడానికి రూపొందించబడినట్లే ఈథర్నెట్, CsmaNetDevice పని చేయడానికి రూపొందించబడింది CsmaChannel, PointToPointNetDevice పని చేయడానికి రూపొందించబడింది PointToPointChannelమరియు WifiNetDevice - పని చేయడానికి రూపొందించబడింది WifiChannel.

4.1.5 టోపోలాజికల్ సహాయకులు

నిజమైన నెట్‌వర్క్‌లో, నెట్‌వర్క్ కార్డ్‌లను జోడించిన (లేదా అంతర్నిర్మిత) హోస్ట్ కంప్యూటర్‌లను మీరు కనుగొంటారు. ns-3లో మీరు NetDevices జతచేయబడిన నోడ్‌లను చూస్తారని మేము చెబుతాము. పెద్ద అనుకరణ నెట్‌వర్క్‌లో, మీరు అనేక వస్తువుల మధ్య కనెక్షన్‌లను నిర్వహించాలి నోడ్, నెట్ డివైస్ и ఛానల్.

NetDevices ను నోడ్‌లకు కనెక్ట్ చేయడం వలన, NetDevices లింక్‌లకు కనెక్ట్ చేయడం, IP చిరునామాలను కేటాయించడం మొదలైనవి. ns-3 అనేది ఒక సాధారణ పని, దీన్ని వీలైనంత సులభతరం చేయడానికి మేము టోపోలాజీ సహాయకులు అని పిలవబడే వారిని అందిస్తాము. ఉదాహరణకు, NetDeviceని సృష్టించడానికి, మీరు అనేక ns-3 కెర్నల్ కార్యకలాపాలను నిర్వహించాలి, MAC చిరునామాను జోడించాలి, నెట్‌వర్క్ పరికరాన్ని నోడ్‌లో ఇన్‌స్టాల్ చేయాలి, నోడ్ ప్రోటోకాల్ స్టాక్‌ను కాన్ఫిగర్ చేయాలి, ఆపై నెట్‌డివైస్‌ను ఛానెల్‌కి కనెక్ట్ చేయాలి. బహుళ పరికరాలను మల్టీపాయింట్ లింక్‌లకు కనెక్ట్ చేసి, ఆపై వ్యక్తిగత నెట్‌వర్క్‌లను ఇంటర్నెట్‌వర్క్స్ నెట్‌వర్క్‌కి కనెక్ట్ చేయడానికి ఇంకా ఎక్కువ పని చేయాల్సి ఉంటుంది. మేము మీ సౌలభ్యం కోసం ఈ అనేక కార్యకలాపాలను సులువుగా ఉపయోగించగల మోడల్‌గా మిళితం చేసే టోపోలాజీ సహాయక వస్తువులను అందిస్తాము.

4.2 మొదటి ns-3 స్క్రిప్ట్

మీరు పైన సూచించిన విధంగా సిస్టమ్‌ను ఇన్‌స్టాల్ చేసినట్లయితే, మీరు మీ హోమ్ డైరెక్టరీలోని రెపోస్ అనే డైరెక్టరీలో ns-3 విడుదలను కలిగి ఉంటారు. డైరెక్టరీకి వెళ్లండి విడుదల

మీకు అలాంటి డైరెక్టరీ లేకుంటే, మీరు ns-3 యొక్క విడుదల సంస్కరణను నిర్మించేటప్పుడు అవుట్‌పుట్ డైరెక్టరీని పేర్కొనలేదని దీని అర్థం, ఇలా నిర్మించండి:
$ ./waf కాన్ఫిగర్ —build-profile=release —out=build/release,
$ ./waf బిల్డ్

అక్కడ మీరు ఈ క్రింది వాటికి సమానమైన డైరెక్టరీ నిర్మాణాన్ని చూడాలి:

AUTHORS       examples      scratch       utils       waf.bat*
bindings      LICENSE       src           utils.py    waf-tools
build         ns3           test.py*      utils.pyc   wscript
CHANGES.html  README        testpy-output VERSION     wutils.py
doc           RELEASE_NOTES testpy.supp   waf*        wutils.pyc

డైరెక్టరీకి వెళ్లండి ఉదాహరణలు/ట్యుటోరియల్. మీరు అక్కడ ఉన్న ఫైల్‌ని చూడాలి మొదటి.cc. ఇది రెండు నోడ్‌ల మధ్య సాధారణ పాయింట్-టు-పాయింట్ కనెక్షన్‌ని సృష్టించే స్క్రిప్ట్ మరియు నోడ్‌ల మధ్య ఒక ప్యాకెట్‌ను ప్రసారం చేస్తుంది. దీన్ని చేయడానికి, మీకు ఇష్టమైన ఎడిటర్‌లో first.ccని తెరవండి;

4.2.1 బాయిలర్‌ప్లేట్ కోడ్
ఫైల్‌లోని మొదటి పంక్తి ఎడిటర్ మోడ్ లైన్ Emacs. ఇది మేము మా సోర్స్ కోడ్‌లో ఉపయోగించే ఫార్మాటింగ్ కన్వెన్షన్‌ల (కోడింగ్ స్టైల్) గురించి emacsకి చెబుతుంది.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

ఇది ఎల్లప్పుడూ చాలా వివాదాస్పద సమస్య, కాబట్టి మేము దానిని వెంటనే దారిలోకి తీసుకురావడానికి నేరుగా రికార్డును సెట్ చేయాలి. ns-3 ప్రాజెక్ట్, చాలా పెద్ద ప్రాజెక్ట్‌ల వలె, అన్ని సహకార కోడ్‌లకు అనుగుణంగా ఉండే కోడింగ్ శైలిని అవలంబించింది. మీరు ప్రాజెక్ట్‌కు మీ కోడ్‌ను అందించాలనుకుంటే, ఫైల్‌లో వివరించిన విధంగా మీరు చివరికి ns-3 కోడింగ్ ప్రమాణానికి అనుగుణంగా ఉండాలి doc/codingstd.txt లేదా ప్రాజెక్ట్ వెబ్ పేజీలో చూపబడింది: https://www.nsnam.org/develop/contributing-code/coding-style/.

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

ns-3 సిమ్యులేటర్ ఉపయోగించి లైసెన్స్ పొందింది GNU జనరల్ పబ్లిక్ లైసెన్స్. మీరు ప్రతి ns-3 పంపిణీ ఫైల్‌లో తగిన GNU చట్టపరమైన శీర్షికను చూస్తారు. దిగువ చూపిన GPL టెక్స్ట్ మరియు రచయిత పైన ns-3 ప్రాజెక్ట్‌లో పాల్గొనే సంస్థలలో ఒకదాని కోసం మీరు తరచుగా కాపీరైట్ నోటీసును చూస్తారు.

/* 
* This program is free software; you can redistribute it and/or modify 
* it under the terms of the GNU General Public License version 2 as 
* published by the Free Software Foundation; 
*
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU General Public License for more details. 
* 
* You should have received a copy of the GNU General Public License 
* along with this program; if not, write to the Free Software 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
*/

4.2.2 ప్లగిన్లు

కోడ్ కూడా చేరిక ప్రకటనల శ్రేణితో ప్రారంభమవుతుంది (ఉన్నాయి).

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"

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

ప్రతి ns-3 ఫైల్‌లు అనే డైరెక్టరీలో ఉంచబడతాయి ns3 (ఉప డైరెక్టరీని రూపొందించండి) బిల్డ్ ప్రక్రియలో ఫైల్ పేరు వైరుధ్యాలను నివారించడానికి. ఫైల్ ns3/core-module.h మీరు డైరెక్టరీలో కనుగొనే ns-3 మాడ్యూల్‌కు అనుగుణంగా ఉంటుంది src/core మీరు ఇన్‌స్టాల్ చేసిన విడుదలలో. ఈ డైరెక్టరీ యొక్క లిస్టింగ్‌లో మీరు పెద్ద సంఖ్యలో హెడర్ ఫైల్‌లను కనుగొంటారు. మీరు అసెంబ్లీ చేసినప్పుడు, Waf సబ్ డైరెక్టరీలోని ns3 డైరెక్టరీలో పబ్లిక్ హెడర్ ఫైల్‌లను ఉంచుతుంది బిల్డ్/డీబగ్

మీకు అలాంటి డైరెక్టరీ లేకుంటే, మీరు ns-3 యొక్క విడుదల సంస్కరణను నిర్మించేటప్పుడు అవుట్‌పుట్ డైరెక్టరీని పేర్కొనలేదని దీని అర్థం, ఇలా నిర్మించండి:
$ ./waf కాన్ఫిగర్ --build-profile=డీబగ్ --out=బిల్డ్/డీబగ్
$ ./waf బిల్డ్
లేదా
$ ./waf కాన్ఫిగర్ --build-profile=optimized --out=build/optimized
$ ./waf బిల్డ్

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

$ ./waf -d debug --enable-examples --enable-tests configure

ఉదాహరణలు మరియు పరీక్షలను కలిగి ఉన్న డీబగ్ బిల్డ్‌లను అమలు చేయడానికి ప్రాజెక్ట్‌ను కాన్ఫిగర్ చేయడానికి. మీరు కూడా చేసారు

$ ./waf

ప్రాజెక్ట్ను సమీకరించడానికి. కాబట్టి ఇప్పుడు మీరు డైరెక్టరీలో చూసినప్పుడు ../../build/debug/ns3, ఆపై మీరు పైన చూపిన నాలుగు మాడ్యూల్స్ యొక్క హెడర్ ఫైల్‌లను ఇతరులతో పాటు కనుగొంటారు. మీరు ఈ ఫైల్‌ల కంటెంట్‌లను చూడవచ్చు మరియు అవి సంబంధిత మాడ్యూల్స్ ఉపయోగించే అన్ని పబ్లిక్ ఫైల్‌లను కలిగి ఉన్నాయని కనుగొనవచ్చు.

4.2.3 ns3 నేమ్‌స్పేస్

స్క్రిప్ట్‌లో తదుపరి పంక్తి మొదటి.cc అనేది నేమ్‌స్పేస్ డిక్లరేషన్.

using namespace ns3;

ns-3 ప్రాజెక్ట్ ns3 అని పిలువబడే C++ నేమ్‌స్పేస్‌లో అమలు చేయబడుతుంది. ఇది అన్ని ns-3-సంబంధిత డిక్లరేషన్‌లను గ్లోబల్ నేమ్‌స్పేస్ వెలుపల ఒక స్కోప్‌లోకి సమూహపరుస్తుంది, ఇది ఇతర కోడ్‌తో ఏకీకరణకు ఆశాజనకంగా సహాయపడుతుంది. C++ ఆపరేటర్‌ని ఉపయోగించడం వలన ns-3 నేమ్‌స్పేస్ ప్రస్తుత (గ్లోబల్) డిక్లరేటివ్ రీజియన్‌లోకి ప్రవేశపెడుతుంది. ఈ డిక్లరేషన్ తర్వాత, మీరు దీన్ని ఉపయోగించడానికి మీ అన్ని ns-3 కోడ్‌కు ముందు ns3 ::scope పర్మిషన్ ఆపరేటర్‌ని టైప్ చేయనవసరం లేదని చెప్పడానికి ఇది ఒక అద్భుతమైన మార్గం. మీకు నేమ్‌స్పేస్‌లు తెలియకపోతే, దాదాపు ఏదైనా C++ పాఠ్యపుస్తకాన్ని చూడండి మరియు ns3 నేమ్‌స్పేస్‌ని std నేమ్‌స్పేస్ మరియు డిక్లరేషన్ ఉపయోగించి సరిపోల్చండి using namespace std; అవుట్‌పుట్ ఆపరేటర్‌తో పని చేసే ఉదాహరణలలో ధర మరియు ప్రవాహాలు.

4.2.4 లాగింగ్

స్క్రిప్ట్ యొక్క తదుపరి పంక్తి,

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

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

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

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

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

4.2.5 ప్రధాన విధి

స్క్రిప్ట్ యొక్క క్రింది పంక్తులలో మీరు చూస్తారు,

int 
main (int argc, char *argv[])
{ 

ఇది మీ ప్రోగ్రామ్ (స్క్రిప్ట్) యొక్క ప్రధాన విధి యొక్క ప్రకటన మాత్రమే. ఏదైనా C++ ప్రోగ్రామ్ వలె, మీరు ఒక ప్రధాన విధిని నిర్వచించాలి, ఇది ముందుగా అమలు చేయబడుతుంది. ఇక్కడ ప్రత్యేకంగా ఏమీ లేదు. మీ ns-3 స్క్రిప్ట్ కేవలం C++ ప్రోగ్రామ్. కింది పంక్తి సమయ రిజల్యూషన్‌ను 1 నానోసెకండ్‌కి సెట్ చేస్తుంది, ఇది డిఫాల్ట్:

Time::SetResolution (Time::NS);

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

అప్లికేషన్‌లలో రూపొందించబడిన రెండు లాగింగ్ భాగాలను ప్రారంభించడానికి క్రింది రెండు లైన్ల స్క్రిప్ట్ ఉపయోగించబడింది ఎకో క్లయింట్ и EchoServer:

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO); LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);

మీరు లాగింగ్ కాంపోనెంట్ కోసం డాక్యుమెంటేషన్‌ని చదివితే, మీరు ప్రతి కాంపోనెంట్‌పై ఎనేబుల్ చేయగల అనేక స్థాయిల లాగింగ్/గ్రాన్యులారిటీని మీరు చూస్తారు. ఈ రెండు లైన్ల కోడ్‌లు ఎకో క్లయింట్లు మరియు సర్వర్‌ల కోసం INFO స్థాయికి డీబగ్ లాగింగ్‌ను ఎనేబుల్ చేస్తాయి. ఈ స్థాయిలో, అప్లికేషన్ అనుకరణ సమయంలో ప్యాకెట్‌లను పంపినప్పుడు మరియు స్వీకరించినప్పుడు సందేశాలను ప్రింట్ చేస్తుంది.

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

4.2.6 టోపోలాజీ సహాయకులను ఉపయోగించడం

మా స్క్రిప్ట్‌లోని కోడ్ యొక్క తదుపరి రెండు లైన్లు వాస్తవానికి సిమ్యులేషన్‌లోని కంప్యూటర్‌లను సూచించే నోడ్ ns-3 ఆబ్జెక్ట్‌లను సృష్టిస్తాయి.

NodeContainer nodes;
nodes.Create (2);

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

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

స్క్రిప్ట్‌లో సృష్టించబడిన నోడ్‌లు ఇంకా ఏమీ చేయలేదు. టోపోలాజీని నిర్మించడంలో తదుపరి దశ మా నోడ్‌లను నెట్‌వర్క్‌కు కనెక్ట్ చేయడం. మేము మద్దతు ఇచ్చే నెట్‌వర్క్ యొక్క సరళమైన రూపం రెండు నోడ్‌ల మధ్య పాయింట్-టు-పాయింట్ కనెక్షన్. మేము ఇప్పుడు అలాంటి కనెక్షన్‌ని సృష్టిస్తాము.

PointToPointHelper

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

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

మొదటి పంక్తి,

PointToPointHelper pointToPoint;

స్టాక్‌పై ఒక వస్తువు యొక్క ఉదాహరణను సృష్టిస్తుంది PointToPointHelper. ఉన్నత స్థాయి దృక్కోణం నుండి క్రింది లైన్,

pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));

వస్తువు చెబుతుంది PointToPointHelper "5 Mbit/s" (సెకనుకు ఐదు మెగాబిట్లు) విలువను "గా ఉపయోగించండిడేటా రేటు".

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

ఒకేలా "డేటా రేటు" PointToPointNetDeviceలో, మీరు PointToPointChannelతో అనుబంధించబడిన "ఆలస్యం" లక్షణాన్ని కనుగొంటారు. చివరి పంక్తి

pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

అతను మాట్లాడేటప్పుడు PointToPointHelper "2 ms" (రెండు మిల్లీసెకన్లు) విలువను అది తరువాత సృష్టించే పాయింట్-టు-పాయింట్ లింక్ కోసం ప్రచారం ఆలస్యం విలువగా ఉపయోగించండి.

NetDeviceContainer

ప్రస్తుతానికి స్క్రిప్ట్‌లో ఉంది నోడ్‌కంటైనర్, ఇది రెండు నోడ్‌లను కలిగి ఉంటుంది. మన దగ్గర ఉంది PointToPointHelper, ఇది వస్తువులను సృష్టించడానికి సిద్ధం చేయబడింది PointToPointNetDevices మరియు వాటిని PointToPointChannel ఆబ్జెక్ట్ ఉపయోగించి కనెక్ట్ చేయడం. మేము నోడ్‌లను సృష్టించడానికి NodeContainer టోపోలాజీ హెల్పర్ ఆబ్జెక్ట్‌ని ఉపయోగించినట్లే, మేము అడుగుతాము PointToPointHelper మా పరికరాల సృష్టి, కాన్ఫిగరేషన్ మరియు ఇన్‌స్టాలేషన్‌కు సంబంధించి మా కోసం పని చేయండి. మాకు సృష్టించబడిన అన్ని వస్తువుల జాబితా అవసరం నెట్ డివైస్, కాబట్టి మేము ఉపయోగిస్తాము NetDeviceContainer మేము ఉపయోగించిన అదే విధంగా వాటిని నిల్వ చేయడానికి నోడ్‌కంటైనర్ మేము సృష్టించిన నోడ్‌లను నిల్వ చేయడానికి. కోడ్ యొక్క తదుపరి రెండు పంక్తులు,

NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);

పూర్తి పరికరం మరియు ఛానెల్ సెటప్. మొదటి పంక్తి పైన పేర్కొన్న పరికర కంటైనర్‌ను ప్రకటిస్తుంది మరియు రెండవది ప్రధాన పనిని చేస్తుంది. పద్ధతి ఇన్స్టాల్ వస్తువు PointToPointHelper అంగీకరిస్తుంది నోడ్‌కంటైనర్ పరామితిగా. లోపల NetDeviceContainer లో ఉన్న ప్రతి నోడ్ కోసం నోడ్‌కంటైనర్ సృష్టించబడింది (పాయింట్-టు-పాయింట్ కమ్యూనికేషన్ కోసం ఖచ్చితంగా వాటిలో రెండు ఉండాలి) PointToPointNetDevice పరికరం కంటైనర్‌లో సృష్టించబడింది మరియు సేవ్ చేయబడుతుంది. PointToPointChannel సృష్టించబడింది మరియు దానికి రెండు జోడించబడ్డాయి PointToPointNetDevices. వస్తువులను సృష్టించిన తర్వాత, గుణాలు నిల్వ చేయబడతాయి PointToPointHelper, సృష్టించబడిన వస్తువులలో సంబంధిత లక్షణాలను ప్రారంభించేందుకు ఉపయోగించబడతాయి.

కాల్ చేసిన తర్వాత pointToPoint.ఇన్‌స్టాల్ చేయండి (నోడ్స్) మనకు రెండు నోడ్‌లు ఉంటాయి, ఒక్కొక్కటి పాయింట్-టు-పాయింట్ నెట్‌వర్క్ పరికరం ఇన్‌స్టాల్ చేయబడి ఉంటాయి మరియు వాటి మధ్య ఒక పాయింట్-టు-పాయింట్ లింక్ ఉంటుంది. ఛానెల్‌లో రెండు మిల్లీసెకన్ల ప్రసార ఆలస్యంతో సెకనుకు ఐదు మెగాబిట్ల వేగంతో డేటాను ప్రసారం చేయడానికి రెండు పరికరాలు కాన్ఫిగర్ చేయబడతాయి.

InternetStackHelper

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

InternetStackHelper stack;
stack.Install (nodes);

InternetStackHelper - పాయింట్-టు-పాయింట్ నెట్‌వర్క్ పరికరాల కోసం PointToPointHelper మాదిరిగానే ఇంటర్నెట్ స్టాక్‌ల కోసం టోపోలాజీ సహాయకం. పద్ధతి ఇన్స్టాల్ NodeContainerని పారామీటర్‌గా తీసుకుంటుంది. అమలు చేసినప్పుడు, ఇది ప్రతి కంటైనర్ నోడ్‌లో ఇంటర్నెట్ స్టాక్‌ను (TCP, UDP, IP, మొదలైనవి) ఇన్‌స్టాల్ చేస్తుంది.

IPv4అడ్రస్ హెల్పర్

అప్పుడు మనం మన పరికరాలను IP చిరునామాలతో అనుబంధించాలి. IP చిరునామా కేటాయింపును నిర్వహించడానికి మేము టోపోలాజీ సహాయకుడిని అందిస్తాము. వినియోగదారుకు కనిపించే ఏకైక API, అసలు చిరునామా పంపిణీని (ఇది సహాయకుడిలో తక్కువ స్థాయిలో జరుగుతుంది) చేస్తున్నప్పుడు ఉపయోగించేందుకు బేస్ IP చిరునామా మరియు నెట్‌మాస్క్‌ని సెట్ చేయడం. మా ఉదాహరణ స్క్రిప్ట్‌లో కోడ్ యొక్క తదుపరి రెండు పంక్తులు మొదటి.cc,

Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");

అడ్రస్ హెల్పర్ ఆబ్జెక్ట్‌ను డిక్లేర్ చేయండి మరియు అది నెట్‌వర్క్ 10.1.1.0 నుండి IP చిరునామాలను కేటాయించడం ప్రారంభించాలని, 255.255.255.0 బిట్‌మాస్క్‌ని ఉపయోగించి గుర్తించాలని చెప్పండి. డిఫాల్ట్‌గా, కేటాయించిన చిరునామాలు ఒకదానిలో ప్రారంభమవుతాయి మరియు మార్పు లేకుండా పెరుగుతాయి, కాబట్టి ఈ బేస్ నుండి కేటాయించబడిన మొదటి చిరునామా 10.1.1.1, ఆపై 10.1.1.2, మొదలైనవి. వాస్తవానికి, తక్కువ స్థాయిలో, ns-3 సిస్టమ్ కేటాయించిన అన్ని IP చిరునామాలను గుర్తుంచుకుంటుంది మరియు మీరు అనుకోకుండా ఒకే చిరునామాను రెండుసార్లు సృష్టించే పరిస్థితిని సృష్టించినట్లయితే (మార్గం ద్వారా, ఈ లోపం డీబగ్ చేయడం కష్టం) ప్రమాదకరమైన లోపాన్ని సృష్టిస్తుంది.

క్రింది కోడ్ లైన్,

Ipv4InterfaceContainer interfaces = address.Assign (devices);

అసలు చిరునామా కేటాయింపును నిర్వహిస్తుంది. ns-3లో మనం IP చిరునామా మరియు ఆబ్జెక్ట్‌ని ఉపయోగించే పరికరానికి మధ్య కనెక్షన్‌ని ఏర్పాటు చేస్తాము IPv4 ఇంటర్ఫేస్. తర్వాత ఉపయోగం కోసం మనకు కొన్నిసార్లు సహాయకం సృష్టించిన నెట్‌వర్క్ పరికరాల జాబితా అవసరం అయినట్లే, మనకు కొన్నిసార్లు వస్తువుల జాబితా అవసరం IPv4 ఇంటర్ఫేస్. IPv4 ఇంటర్‌ఫేస్ కంటైనర్ ఈ కార్యాచరణను అందిస్తుంది.

స్టాక్‌లు ఇన్‌స్టాల్ చేయబడి, IP చిరునామాలు కేటాయించబడిన పాయింట్-టు-పాయింట్ నెట్‌వర్క్‌ను మేము రూపొందించాము. ఇప్పుడు ట్రాఫిక్‌ని రూపొందించడానికి ప్రతి నోడ్‌లో అప్లికేషన్‌లు అవసరం.

4.2.7 అప్లికేషన్ ఉపయోగించి

ns-3 వ్యవస్థ యొక్క ప్రధాన సంగ్రహణలలో మరొకటి అప్లికేషన్ (అప్లికేషన్). ఈ దృష్టాంతంలో మేము రెండు బేస్ క్లాస్ స్పెషలైజేషన్‌లను ఉపయోగిస్తున్నాము అప్లికేషన్ ns-3 అంటారు UdpEchoServerApplication и UdpEchoClient అప్లికేషన్. మునుపటి సందర్భాలలో వలె, మేము ప్రాథమిక వస్తువులను కాన్ఫిగర్ చేయడానికి మరియు నిర్వహించడానికి సహాయక వస్తువులను ఉపయోగిస్తాము. ఇక్కడ మేము ఉపయోగిస్తాము UdpEchoServerHelper и UdpEchoClientHelper వస్తువులు మన జీవితాలను సులభతరం చేస్తాయి.

UdpEchoServerHelper

మేము ముందుగా సృష్టించిన నోడ్‌లలో ఒకదానిలో UDP ఎకో సర్వర్ అప్లికేషన్‌ను కాన్ఫిగర్ చేయడానికి మా first.cc ఉదాహరణ స్క్రిప్ట్‌లోని క్రింది కోడ్ లైన్‌లు ఉపయోగించబడతాయి.

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

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

అనేక ఇతర సహాయక వస్తువుల వలె, వస్తువు UdpEchoServerHelper ఒక పద్ధతి ఉంది ఇన్స్టాల్. ఈ పద్ధతిని అమలు చేయడం వలన ప్రాథమిక ప్రతిధ్వని సర్వర్ అప్లికేషన్‌ను సమర్థవంతంగా సృష్టిస్తుంది మరియు దానిని హోస్ట్‌కు బంధిస్తుంది. ఆసక్తికరంగా, పద్ధతి ఇన్స్టాల్ అంగీకరిస్తుంది నోడ్‌కంటైనర్ ఇతరుల మాదిరిగానే పారామీటర్‌గా ఇన్స్టాల్ మేము చూసిన పద్ధతులు.

ఇక్కడ పనిచేస్తున్న C++ అవ్యక్త మార్పిడి పద్ధతి యొక్క ఫలితాన్ని తీసుకుంటుంది node.Get(1) (ఇది నోడ్ ఆబ్జెక్ట్‌కు స్మార్ట్ పాయింటర్‌ను తిరిగి ఇస్తుంది - Ptr ) మరియు దానిని అనామక వస్తువు కోసం కన్స్ట్రక్టర్‌లో ఉపయోగిస్తుంది నోడ్‌కంటైనర్ఇది తరువాత పద్ధతికి పంపబడుతుంది ఇన్స్టాల్. మీరు C++ కోడ్‌లో ఏ పద్ధతిలో సంతకం కంపైల్ చేయబడి అమలు చేయబడిందో గుర్తించలేకపోతే, అవ్యక్త మార్పిడుల మధ్య చూడండి.

ఇప్పుడు మనం చూస్తాం echoServer.Install అప్లికేషన్‌ను ఇన్‌స్టాల్ చేయబోతున్నారు UdpEchoServerApplication లో కనుగొనబడింది నోడ్‌కంటైనర్మేము మా నోడ్‌లను నిర్వహించడానికి ఉపయోగిస్తాము, సూచికతో నోడ్ 1. పద్ధతి ఇన్స్టాల్ అన్ని అప్లికేషన్‌లకు పాయింటర్‌లను కలిగి ఉన్న కంటైనర్‌ను తిరిగి పంపుతుంది (ఈ సందర్భంలో ఒకటి, మేము అనామకంగా ఆమోదించినందున నోడ్‌కంటైనర్, ఒక నోడ్‌ని కలిగి ఉంది) సహాయకుడు సృష్టించాడు.

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

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

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

UdpEchoClientHelper

క్లయింట్ అప్లికేషన్ echo దాదాపు సర్వర్‌కు సమానమైన పద్ధతిలో కాన్ఫిగర్ చేయబడింది. ఒక మూల వస్తువు ఉంది UdpEchoClient అప్లికేషన్, ఇది నియంత్రించబడుతుంది
UdpEchoClientHelper.

UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));;

అయితే, ఎకో క్లయింట్ కోసం మనం ఐదు విభిన్న లక్షణాలను సెట్ చేయాలి. మొదటి రెండు లక్షణాలు సృష్టి సమయంలో సెట్ చేయబడ్డాయి UdpEchoClientHelper. మేము లక్షణాలను సెట్ చేయడానికి ఉపయోగించే (సహాయకుడు లోపల) పారామితులను పాస్ చేస్తాము "రిమోట్ అడ్రస్" и "రిమోట్ పోర్ట్" సహాయక కన్స్ట్రక్టర్‌కు అవసరమైన పారామితులను పంపడానికి మా ఒప్పందానికి అనుగుణంగా.

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

"MaxPackets" లక్షణం క్లయింట్‌కి అనుకరణ సమయంలో మనం పంపగల గరిష్ట ప్యాకెట్ల సంఖ్యను తెలియజేస్తుంది. ప్యాకెట్ల మధ్య ఎంతసేపు వేచి ఉండాలో "ఇంటర్వెల్" లక్షణం క్లయింట్‌కి చెబుతుంది మరియు ప్యాకెట్ పేలోడ్ ఎంత పెద్దదిగా ఉండాలో "ప్యాకెట్‌సైజ్" లక్షణం క్లయింట్‌కి తెలియజేస్తుంది. ఈ అట్రిబ్యూట్ కలయికతో మేము క్లయింట్‌కి ఒకే 1024-బైట్ ప్యాకెట్‌ని పంపమని చెబుతాము.

ఎకో సర్వర్ వలె, మేము ఎకో క్లయింట్ యొక్క లక్షణాలను సెట్ చేస్తాము ప్రారంభం и ఆపు, కానీ ఇక్కడ మేము సర్వర్ ఆన్ చేయబడిన తర్వాత క్లయింట్‌ను సెకను ప్రారంభిస్తాము (అనుకరణ ప్రారంభమైన రెండు సెకన్ల తర్వాత).

4.2.8 సిమ్యులేటర్

ఈ సమయంలో మనం అనుకరణను అమలు చేయాలి. ఇది గ్లోబల్ ఫంక్షన్ ఉపయోగించి చేయబడుతుంది సిమ్యులేటర్:: రన్.

Simulator::Run ();

మేము గతంలో పద్ధతులను పిలిచినప్పుడు,

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
... 
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));

మేము వాస్తవానికి సిమ్యులేటర్‌లో ఈవెంట్‌లను 1,0 సెకన్లు, 2,0 సెకన్లు మరియు రెండు ఈవెంట్‌లను 10,0 సెకన్లకు షెడ్యూల్ చేసాము. కాల్ తర్వాత సిమ్యులేటర్:: రన్, సిస్టమ్ షెడ్యూల్ చేయబడిన ఈవెంట్‌ల జాబితాను వీక్షించడం మరియు వాటిని అమలు చేయడం ప్రారంభిస్తుంది. ఇది మొదట 1,0 సెకన్ల తర్వాత ఈవెంట్‌ను కాల్చివేస్తుంది, ఇది ఎకో సర్వర్ అప్లికేషన్‌ను ట్రిగ్గర్ చేస్తుంది (ఈ ఈవెంట్ అనేక ఇతర ఈవెంట్‌లను షెడ్యూల్ చేయవచ్చు). ఇది ఎకో క్లయింట్ అప్లికేషన్‌ను ప్రారంభించే t=2,0 సెకన్లలో షెడ్యూల్ చేయబడిన ఈవెంట్‌ను కాల్చివేస్తుంది. మళ్ళీ, ఈ ఈవెంట్‌లో మరిన్ని ఈవెంట్‌లు ప్లాన్ చేయబడవచ్చు. ప్రారంభ ఈవెంట్ యొక్క ఎకో క్లయింట్ అమలు సర్వర్‌కు ప్యాకెట్‌ను పంపడం ద్వారా అనుకరణ యొక్క డేటా బదిలీ దశను ప్రారంభిస్తుంది.

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

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

మీ తర్వాత శుభ్రం చేసుకోవడం మాత్రమే మిగిలి ఉంది. ఇది గ్లోబల్ ఫంక్షన్‌ని పిలవడం ద్వారా జరుగుతుంది సిమ్యులేటర్:: నాశనం. ఎందుకంటే సహాయక విధులు (లేదా తక్కువ-స్థాయి ns-3 కోడ్) అని పిలువబడతాయి, ఇవి నిర్వహించబడతాయి, తద్వారా సృష్టించబడిన అన్ని వస్తువులను నాశనం చేయడానికి సిమ్యులేటర్‌లోకి హుక్స్ చొప్పించబడతాయి. మీరు ఈ వస్తువులలో దేనినైనా ట్రాక్ చేయవలసిన అవసరం లేదు - మీరు చేయాల్సిందల్లా కాల్ చేయడం సిమ్యులేటర్:: నాశనం మరియు బయటకు వెళ్ళు. ns-3 సిస్టమ్ మీ కోసం ఈ కష్టమైన పనిని చేస్తుంది. మా మొదటి ns-3 స్క్రిప్ట్ యొక్క మిగిలిన పంక్తులు, first.cc, ఇలా చేయండి:

Simulator::Destroy ();
return 0;
}

సిమ్యులేటర్ ఎప్పుడు ఆగిపోతుంది?

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

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

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

• ఫ్లోమానిటర్ - పోగొట్టుకున్న ప్యాకెట్ల కోసం క్రమానుగతంగా తనిఖీ చేయడం;

• RIPng – రూటింగ్ టేబుల్ అప్‌డేట్‌ల యొక్క ఆవర్తన ప్రసారం;

• మొదలైనవి.

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

పాఠ్యపుస్తకంలోని అనేక అనుకరణ ప్రోగ్రామ్‌లు కాల్ చేయవు సిమ్యులేటర్:: ఆపు స్పష్టంగా, క్యూలో ఉన్న ఈవెంట్‌లు అయిపోయినప్పుడు అవి స్వయంచాలకంగా ముగుస్తాయి. అయితే, ఈ ప్రోగ్రామ్‌లు సిమ్యులేటర్:: స్టాప్ కాల్‌ని కూడా అంగీకరిస్తాయి. ఉదాహరణకు, మొదటి ఉదాహరణ ప్రోగ్రామ్‌లోని క్రింది అదనపు ప్రకటన 11 సెకన్లలో స్పష్టమైన స్టాప్‌ను షెడ్యూల్ చేస్తుంది:

+ Simulator::Stop (Seconds (11.0));
  Simulator::Run ();
  Simulator::Destroy ();
  return 0;
}

ఈ నిర్దిష్ట అనుకరణ సహజంగా 10 సెకన్ల తర్వాత ముగుస్తుంది కాబట్టి పైన పేర్కొన్నవి వాస్తవానికి ఈ ప్రోగ్రామ్ యొక్క ప్రవర్తనను మార్చవు. కానీ మీరు పై స్టేట్‌మెంట్‌లోని స్టాప్ సమయాన్ని 11 సెకన్ల నుండి 1 సెకనుకు మార్చినట్లయితే, ఏదైనా అవుట్‌పుట్ స్క్రీన్‌పైకి రాకముందే సిమ్యులేషన్ ఆగిపోతుందని మీరు గమనించవచ్చు (అవుట్‌పుట్ దాదాపు 2 సెకన్ల సిమ్యులేషన్ సమయం తర్వాత జరుగుతుంది కాబట్టి).

సిమ్యులేటర్‌కు కాల్ చేయడం ముఖ్యం:: సిమ్యులేటర్‌కి కాల్ చేసే ముందు ఆపు::రన్; లేకపోతే సిమ్యులేటర్:: రన్ స్టాప్‌ను అమలు చేయడానికి ప్రధాన ప్రోగ్రామ్‌కు నియంత్రణను తిరిగి ఇవ్వకపోవచ్చు!

4.2.9 మీ స్క్రిప్ట్‌ను రూపొందించడం

మేము మీ సాధారణ స్క్రిప్ట్‌లను సృష్టించడాన్ని పనికిమాలినదిగా చేసాము. మీరు చేయాల్సిందల్లా మీ స్క్రిప్ట్‌ను స్క్రాచ్ డైరెక్టరీలో ఉంచడం మరియు మీరు అమలు చేస్తే అది స్వయంచాలకంగా నిర్మించబడుతుంది Waf. ప్రయత్నిద్దాం. ఉన్నత స్థాయి డైరెక్టరీకి తిరిగి వెళ్లి కాపీ చేయండి ఉదాహరణలు/ట్యుటోరియల్/first.cc కేటలాగ్‌కు మొదటి

$ cd ../.. 
$ cp examples/tutorial/first.cc scratch/myfirst.cc

ఇప్పుడు ఉపయోగించి మీ మొదటి నమూనా స్క్రిప్ట్‌ను రూపొందించండి వాఫ్:

$ ./waf

మీ మొదటి ఉదాహరణ విజయవంతంగా సృష్టించబడిందని సూచించే సందేశాలను మీరు చూడాలి.

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
[614/708] cxx: scratch/myfirst.cc -> build/debug/scratch/myfirst_3.o
[706/708] cxx_link: build/debug/scratch/myfirst_3.o -> build/debug/scratch/myfirst
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (2.357s)

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

$ ./waf --run scratch/myfirst

మీరు ఇలాంటి అవుట్‌పుట్‌ని చూడాలి:

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) Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2

ఫైల్ నిర్మించబడిందని బిల్డ్ సిస్టమ్ ధృవీకరిస్తుంది మరియు దానిని అమలు చేస్తుందని ఇక్కడ మీరు చూడవచ్చు. ఎకో క్లయింట్‌లోని కాంపోనెంట్ ఎంట్రీ అది ఎకో సర్వర్ 1024కి ఒకే 10.1.1.2-బైట్ ప్యాకెట్‌ను పంపిందని సూచిస్తుంది. మీరు కూడా 1024 నుండి 10.1.1.1 బైట్‌లను అందుకున్నారని చెప్పడానికి ఎకో సర్వర్‌లోని లాగింగ్ కాంపోనెంట్‌ని చూడండి. ఎకో సర్వర్ ప్యాకెట్‌ని నిశ్శబ్దంగా రీప్లే చేస్తుంది మరియు సర్వర్ నుండి దాని ప్యాకెట్‌ను తిరిగి పొందినట్లు మీరు ఎకో క్లయింట్ లాగ్‌లో చూడవచ్చు.

4.3 ns-3 సోర్స్ కోడ్

ఇప్పుడు మీరు కొన్ని ns-3 సహాయకులను ఉపయోగించారు, మీరు ఈ కార్యాచరణను అమలు చేసే కొన్ని సోర్స్ కోడ్‌లను పరిశీలించవచ్చు. తాజా కోడ్‌ను మా వెబ్ సర్వర్‌లో క్రింది లింక్‌లో చూడవచ్చు: https://gitlab.com/nsnam/ns-3-dev.git. అక్కడ మీరు మా ns-3 డెవలప్‌మెంట్ ట్రీ కోసం మెర్క్యురియల్ సారాంశం పేజీని చూస్తారు. పేజీ ఎగువన మీరు అనేక లింక్‌లను చూస్తారు,

summary | shortlog | changelog | graph | tags | files

కొనసాగి, ఫైల్‌ల లింక్‌ని ఎంచుకోండి. మా రిపోజిటరీలలో చాలా వరకు ఉన్నత స్థాయి ఇలా ఉంటుంది:

drwxr-xr-x                               [up]
drwxr-xr-x                               bindings python  files
drwxr-xr-x                               doc              files
drwxr-xr-x                               examples         files
drwxr-xr-x                               ns3              files
drwxr-xr-x                               scratch          files
drwxr-xr-x                               src              files
drwxr-xr-x                               utils            files
-rw-r--r-- 2009-07-01 12:47 +0200 560    .hgignore        file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1886   .hgtags          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1276   AUTHORS          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 30961  CHANGES.html     file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 17987  LICENSE          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 3742   README           file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 16171  RELEASE_NOTES    file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 6      VERSION          file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 88110  waf              file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 28     waf.bat          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 35395  wscript          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 7673   wutils.py        file | revisions | annotate

మా ఉదాహరణ స్క్రిప్ట్‌లు డైరెక్టరీలో ఉన్నాయి ఉదాహరణలు. మీరు ఉదాహరణలపై క్లిక్ చేస్తే మీరు ఉప డైరెక్టరీల జాబితాను చూస్తారు. సబ్ డైరెక్టరీలోని ఫైల్‌లలో ఒకటి ట్యుటోరియల్ - first.cc. మీరు క్లిక్ చేస్తే మొదటి.cc మీరు ఇప్పుడే నేర్చుకున్న కోడ్‌ని చూస్తారు.

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

మూలం: www.habr.com