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 ട്രെയ്‌സുകൾ പാഴ്‌സ് ചെയ്യുന്നു
5.3.2 പിസിഎപി ട്രെയ്സ്

ചാപ്റ്റർ 5

കമപ്പെടുത്തല്

5.1 ലോഗിംഗ് മൊഡ്യൂൾ ഉപയോഗിക്കുന്നു

സ്‌ക്രിപ്റ്റ് നോക്കി ഞങ്ങൾ ഇതിനകം ns-3 ലോഗിംഗ് മൊഡ്യൂളിലേക്ക് ചുരുക്കമായി നോക്കി ആദ്യം.cc. ഈ അധ്യായത്തിൽ, ലോഗിംഗ് സബ്സിസ്റ്റത്തിൻ്റെ സാധ്യമായ ഉപയോഗങ്ങൾ ഞങ്ങൾ സൂക്ഷ്മമായി പരിശോധിക്കും.

5.1.1 ലോഗിംഗ് അവലോകനം

പല വലിയ സിസ്റ്റങ്ങളും ചില തരത്തിലുള്ള മെസേജ് ലോഗിംഗ് സൗകര്യത്തെ പിന്തുണയ്ക്കുന്നു, കൂടാതെ ns-3 ഒരു അപവാദമല്ല. ചില സന്ദർഭങ്ങളിൽ, "ഓപ്പറേറ്റർ കൺസോളിൽ" പിശക് സന്ദേശങ്ങൾ മാത്രമേ എഴുതുകയുള്ളൂ (ഇത് സാധാരണയായി Unix-അധിഷ്ഠിത സിസ്റ്റങ്ങളിൽ stderr ആണ്). മറ്റ് സിസ്റ്റങ്ങളിൽ, മുന്നറിയിപ്പ് സന്ദേശങ്ങളും കൂടുതൽ വിശദമായ വിവരങ്ങളും പ്രദർശിപ്പിച്ചേക്കാം. ചില സന്ദർഭങ്ങളിൽ, ഔട്ട്പുട്ട് പെട്ടെന്ന് മങ്ങിക്കാൻ കഴിയുന്ന ഡീബഗ് സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യാൻ ലോഗിംഗ് ടൂളുകൾ ഉപയോഗിക്കുന്നു.

ns-3-ൽ ഉപയോഗിച്ചിരിക്കുന്ന subHRD, ഈ തലത്തിലുള്ള എല്ലാ വിവര ഉള്ളടക്കവും ഉപയോഗപ്രദമാണെന്ന് അനുമാനിക്കുന്നു, കൂടാതെ സന്ദേശ ലോഗിംഗിന് ഞങ്ങൾ തിരഞ്ഞെടുത്തതും ലേയേർഡ് സമീപനവും നൽകുന്നു. ലോഗിംഗ് പൂർണ്ണമായും പ്രവർത്തനരഹിതമാക്കാം, ഓരോ ഘടകത്തിൻ്റെ അടിസ്ഥാനത്തിലോ ആഗോളതലത്തിലോ പ്രവർത്തനക്ഷമമാക്കാം. ഈ ആവശ്യത്തിനായി, വിവര ഉള്ളടക്കത്തിൻ്റെ ക്രമീകരിക്കാവുന്ന ലെവലുകൾ ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ സിമുലേഷനിൽ നിന്ന് ഉപയോഗപ്രദമായ വിവരങ്ങൾ നേടുന്നതിന് 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 മാക്രോ നൽകുന്ന സന്ദേശങ്ങളെ മാത്രമേ അനുവദിക്കൂ, അതേസമയം 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

നിങ്ങൾ മുകളിൽ കാണുന്ന "അയച്ച", "സ്വീകരിച്ച" സന്ദേശങ്ങൾ യഥാർത്ഥത്തിൽ ലോഗ് ചെയ്ത സന്ദേശങ്ങളാണെന്ന് ഇത് മാറുന്നു UdpEchoClientApplication и 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 സിസ്റ്റം ആവശ്യമില്ല എന്നത് ശ്രദ്ധിക്കുക. എത്ര വിവരങ്ങൾ രേഖപ്പെടുത്തുന്നു എന്നതിനെക്കുറിച്ചുള്ള തീരുമാനം വ്യക്തിഗത മോഡൽ ഡെവലപ്പർക്ക് വിട്ടുകൊടുത്തിരിക്കുന്നു. എക്കോ ആപ്ലിക്കേഷനുകളുടെ കാര്യത്തിൽ, വലിയ അളവിലുള്ള ലോഗിംഗ് ഔട്ട്പുട്ട് ലഭ്യമാണ്.

ആപ്ലിക്കേഷൻ നടത്തിയ ഫംഗ്‌ഷൻ കോളുകളുടെ ഒരു ലോഗ് നിങ്ങൾക്ക് ഇപ്പോൾ കാണാൻ കഴിയും. നിങ്ങൾ സൂക്ഷ്മമായി നോക്കിയാൽ, വരയ്ക്കിടയിൽ ഒരു കോളൻ നിങ്ങൾ കാണും UdpEchoClientApplication നിങ്ങൾ 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()

യുഡിപി എക്കോ ക്ലയൻ്റ് ആപ്ലിക്കേഷനിൽ നിന്ന് വരുന്ന എല്ലാ സന്ദേശങ്ങളും അത്തരത്തിലുള്ളതായി തിരിച്ചറിഞ്ഞതായി ഇപ്പോൾ നിങ്ങൾക്ക് കാണാം. സന്ദേശം"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 മില്ലിസെക്കൻഡ് ആണെന്ന് ശ്രദ്ധിക്കുക. പാക്കറ്റിനോട് പ്രതികരിച്ചുവെന്ന സന്ദേശം എക്കോ സെർവർ ലോഗ് ചെയ്യുന്നത് നിങ്ങൾക്ക് കാണാൻ കഴിയും, തുടർന്ന്, ഒരു ചാനൽ കാലതാമസത്തിന് ശേഷം, എക്കോ ക്ലയൻ്റ് അതിൻ്റെ HandleRead രീതിയിൽ എക്കോ പാക്കറ്റ് സ്വീകരിക്കുന്നത് നിങ്ങൾ കാണും.

ഈ സിമുലേഷനിൽ, നിങ്ങൾ ശ്രദ്ധിക്കാതെ തന്നെ പലതും സംഭവിക്കുന്നു. എന്നാൽ സിസ്റ്റത്തിലെ എല്ലാ ലോഗിംഗ് ഘടകങ്ങളും പ്രവർത്തനക്ഷമമാക്കുന്നതിലൂടെ നിങ്ങൾക്ക് മുഴുവൻ പ്രക്രിയയും വളരെ എളുപ്പത്തിൽ ട്രാക്കുചെയ്യാനാകും. 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: 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. ഞങ്ങൾ എന്താണ് നൽകേണ്ടതെന്ന് സഹായ പട്ടിക പറയുന്നു ടൈപ്പ് ഐഡി. താൽപ്പര്യത്തിൻ്റെ ആട്രിബ്യൂട്ടുകൾ ഉൾപ്പെടുന്ന ക്ലാസിൻ്റെ പേരാണ് ഇത്. നമ്മുടെ കാര്യത്തിൽ അതായിരിക്കും ns3::PointToPointNetDevice. നമുക്ക് മുന്നോട്ട് പോകാം, പ്രവേശിക്കാം,

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

ഈ നെറ്റ്‌വർക്ക് ഉപകരണ തരത്തിൻ്റെ എല്ലാ ആട്രിബ്യൂട്ടുകളും സിസ്റ്റം പ്രിൻ്റ് ചെയ്യും. ലിസ്റ്റിലെ ആട്രിബ്യൂട്ടുകളിൽ ഇവയാണെന്ന് നിങ്ങൾ കാണും,

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

ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ സിസ്റ്റം ഉപയോഗിക്കുന്ന ഡിഫോൾട്ട് മൂല്യമാണിത് PointToPointNetDevice. പാരാമീറ്റർ ഉപയോഗിച്ച് ഞങ്ങൾ ഈ ഡിഫോൾട്ട് മൂല്യം അസാധുവാക്കും ഗുണങ്ങളെ в PointToPointHelper ഉയർന്നത്. പോയിൻ്റ്-ടു-പോയിൻ്റ് ഉപകരണങ്ങൾക്കും ചാനലുകൾക്കുമായി ഡിഫോൾട്ട് മൂല്യങ്ങൾ ഉപയോഗിക്കാം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ കോളുകൾ ഇല്ലാതാക്കും SetDeviceAtribute и സെറ്റ്ചാനൽ ആട്രിബ്യൂട്ട് നിന്ന് myfirst.cc, നമുക്ക് ഒരു ക്ലീൻ ഡയറക്‌ടറിയിൽ ഉണ്ട്.

നിങ്ങളുടെ സ്ക്രിപ്റ്റ് ഇപ്പോൾ ലളിതമായി പ്രഖ്യാപിക്കണം PointToPointHelper താഴെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഇൻസ്റ്റലേഷൻ പ്രവർത്തനങ്ങളൊന്നും നടത്തരുത്,

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

മുന്നോട്ട് പോയി ഒരു പുതിയ സ്ക്രിപ്റ്റ് സൃഷ്‌ടിക്കുക വഫ് (./വാഫ്) നമുക്ക് തിരികെ പോയി 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.

നിങ്ങൾ അത് എങ്ങനെ ഉപയോഗിക്കും? ശ്രമിച്ചു നോക്ക്. ഞങ്ങൾ ഡിഫോൾട്ട് ആട്രിബ്യൂട്ട് മൂല്യം അസാധുവാക്കുകയും വ്യക്തമായി സജ്ജീകരിക്കുകയും ചെയ്യുന്ന സ്ഥലം നിങ്ങൾ കമൻ്റ് ചെയ്യണമെന്ന് ഓർമ്മിക്കുക മാക്സ്പാക്കറ്റുകൾ തിരക്കഥയിൽ. അപ്പോൾ നിങ്ങൾ സ്ക്രിപ്റ്റ് പുനർനിർമ്മിക്കണം. ഒരു പുതിയ ഡിഫോൾട്ട് ആട്രിബ്യൂട്ട് മൂല്യം സജ്ജീകരിക്കുന്നതിന് സിൻ്റാക്സ് സഹായം ലഭിക്കുന്നതിന് നിങ്ങൾക്ക് കമാൻഡ് ലൈൻ ഉപയോഗിക്കാം. നിങ്ങൾ ഇത് മനസ്സിലാക്കിയാൽ, കമാൻഡ് ലൈനിൽ പ്രദർശിപ്പിക്കുന്ന പാക്കേജുകളുടെ എണ്ണം നിങ്ങൾക്ക് നിയന്ത്രിക്കാനാകും. ഞങ്ങൾ പഠിക്കുന്ന ആളുകളായതിനാൽ, ഞങ്ങളുടെ കമാൻഡ് ലൈൻ ഇതുപോലെയായിരിക്കണം:

$ ./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" ആർഗ്യുമെൻ്റ് തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ രജിസ്റ്റർ ചെയ്ത എല്ലാ ഗ്രൂപ്പുകളുടെയും ഒരു ലിസ്റ്റ് നിങ്ങൾ കാണും ടൈപ്പ് ഐഡി. ഗ്രൂപ്പിൻ്റെ പേരുകൾ ഉറവിട ഡയറക്ടറിയിലെ മൊഡ്യൂളുകളുടെ പേരുകളുമായി പൊരുത്തപ്പെടുന്നു (വലിയ അക്ഷരങ്ങളാണെങ്കിലും). എല്ലാ വിവരങ്ങളും ഒരേസമയം അച്ചടിക്കുന്നത് വളരെ വലുതായിരിക്കും, അതിനാൽ ഗ്രൂപ്പ് പ്രകാരം വിവരങ്ങൾ അച്ചടിക്കാൻ ഒരു അധിക ഫിൽട്ടർ ലഭ്യമാണ്. അതിനാൽ, പോയിൻ്റ്-ടു-പോയിൻ്റ് മൊഡ്യൂളിൽ വീണ്ടും ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു:

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

ആട്രിബ്യൂട്ട് ലുക്കപ്പുകൾക്കായി നിങ്ങൾക്ക് ലഭ്യമായ TypeId പേരുകൾ ഇവിടെ കണ്ടെത്താം, ഉദാഹരണത്തിന്
--PrintAttributes = ns3 :: PointToPointChannelമുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ.

ആട്രിബ്യൂട്ടുകളെക്കുറിച്ച് അറിയാനുള്ള മറ്റൊരു മാർഗ്ഗം ഡോക്‌സിജൻ എൻഎസ്-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 മാനുവൽ അല്ലെങ്കിൽ എങ്ങനെ-ടു എന്ന വിഭാഗങ്ങൾ കാണുക.

5.3.1 ആസ്കി ട്രേസിംഗ്

ലളിതമായ പാക്കറ്റ് ട്രെയ്‌സുകൾ സജ്ജീകരിക്കുമ്പോൾ വിശദാംശങ്ങളുമായി നിങ്ങളെ സഹായിക്കുന്നതിന് താഴ്ന്ന-ലെവൽ ട്രെയ്‌സിംഗ് സിസ്റ്റം നൽകുന്ന സഹായ പ്രവർത്തനക്ഷമത ns-3 നൽകുന്നു. നിങ്ങൾ ഈ സവിശേഷത പ്രവർത്തനക്ഷമമാക്കുകയാണെങ്കിൽ, നിങ്ങൾ ASCII ഫയലുകളിൽ ഔട്ട്പുട്ട് കാണും. ns-2 ഔട്ട്പുട്ട് പരിചയമുള്ളവർക്ക്, ഇത്തരത്തിലുള്ള ട്രെയ്സ് സമാനമാണ് പുറത്ത്.tr, ഇത് നിരവധി സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിച്ചതാണ്.

നമുക്ക് ബിസിനസ്സിലേക്ക് ഇറങ്ങാം, നമ്മുടെ സ്ക്രാച്ച്/myfirst.cc സ്ക്രിപ്റ്റിലേക്ക് കുറച്ച് ASCII ട്രെയ്സിംഗ് ഫലങ്ങൾ ചേർക്കുക. കോളിന് തൊട്ടുമുമ്പ് Simulator :: Run (), കോഡിൻ്റെ ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:
AsciiTraceHelper ascii;

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

മറ്റ് പല ns-3 ഐഡിയമുകൾ പോലെ, ഈ കോഡും ASCII ട്രെയ്‌സുകൾ സൃഷ്ടിക്കാൻ ഒരു സഹായ ഒബ്‌ജക്റ്റ് ഉപയോഗിക്കുന്നു. രണ്ടാമത്തെ വരിയിൽ രണ്ട് നെസ്റ്റഡ് മെത്തേഡ് കോളുകൾ അടങ്ങിയിരിക്കുന്നു. "അകത്ത്" രീതി CreateFileStream() സ്റ്റാക്കിൽ ഒരു ഫയൽ സ്ട്രീം ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കാൻ അജ്ഞാത ഒബ്‌ജക്റ്റ് ഐഡിയം ഉപയോഗിക്കുന്നു (ഒരു ഒബ്‌ജക്റ്റ് നാമമില്ലാതെ) അത് വിളിക്കുന്ന രീതിയിലേക്ക് കൈമാറുന്നു. ഭാവിയിൽ ഞങ്ങൾ ഇതിലേക്ക് കൂടുതൽ ആഴത്തിൽ പോകും, ​​എന്നാൽ ഈ ഘട്ടത്തിൽ നിങ്ങൾ അറിയേണ്ടത് നിങ്ങൾ ഒരു ഫയലിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു എന്നതാണ് myfirst.tr അത് ns-3 ലേക്ക് മാറ്റുക. സൃഷ്‌ടിച്ച ഒബ്‌ജക്‌റ്റിനെ അതിൻ്റെ ജീവിതകാലം മുഴുവൻ പരിപാലിക്കാൻ ഞങ്ങൾ ns-3-നെ ഭരമേൽപ്പിക്കുന്നു, ഈ സമയത്ത് അത് C++ സ്ട്രീം ഒബ്‌ജക്റ്റ് കോപ്പി കൺസ്‌ട്രക്‌റ്ററുകളുമായി ബന്ധപ്പെട്ട കുറച്ച് അറിയപ്പെടുന്ന (മനപ്പൂർവം) പരിമിതി മൂലമുണ്ടാകുന്ന പ്രശ്‌നങ്ങൾ പരിഹരിക്കുന്നു.

ബാഹ്യ കോൾ പ്രവർത്തനക്ഷമമാക്കുകAsciiAll() എല്ലാ പോയിൻ്റ്-ടു-പോയിൻ്റ് ഉപകരണ കണക്ഷനുകൾക്കുമായി നിങ്ങളുടെ സിമുലേഷനിൽ ASCII ട്രെയ്‌സിംഗ് ഉൾപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്നും ASCII ഫോർമാറ്റിൽ പാക്കറ്റ് ചലന വിവരങ്ങൾ രേഖപ്പെടുത്താൻ നിങ്ങൾക്ക് (നിർദ്ദിഷ്‌ടമായ) ട്രെയ്‌സ് റിസീവറുകൾ വേണമെന്നും അസിസ്റ്റൻ്റിനോട് പറയുന്നു.

ns-2 പരിചയമുള്ളവർക്ക്, ട്രാക്ക് ചെയ്‌ത ഇവൻ്റുകൾ "+", "-", "d", "r" ഇവൻ്റുകൾ ലോഗ് ചെയ്യുന്ന അറിയപ്പെടുന്ന ട്രേസ് പോയിൻ്റുകൾക്ക് തുല്യമാണ്.
ഇപ്പോൾ നിങ്ങൾക്ക് സ്ക്രിപ്റ്റ് നിർമ്മിക്കാനും കമാൻഡ് ലൈനിൽ നിന്ന് പ്രവർത്തിപ്പിക്കാനും കഴിയും:

$ ./waf --run scratch/myfirst

മുമ്പത്തെ പലതവണ പോലെ, Waf-ൽ നിന്നുള്ള നിരവധി സന്ദേശങ്ങൾ നിങ്ങൾ കാണും, തുടർന്ന് പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമിൽ നിന്നുള്ള ചില സന്ദേശങ്ങൾക്കൊപ്പം "'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി".

പ്രവർത്തിക്കുമ്പോൾ, പ്രോഗ്രാം പേരുള്ള ഒരു ഫയൽ സൃഷ്ടിക്കും myfirst.tr. ജോലിയുടെ സ്വഭാവം കാരണം വഫ്, സ്ഥിരസ്ഥിതിയായി ഫയൽ സൃഷ്ടിക്കുന്നത് ലോക്കൽ ഡയറക്‌ടറിയിലല്ല, റിപ്പോസിറ്ററിയുടെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിലാണ്. ട്രെയ്‌സുകൾ സംരക്ഷിച്ചിരിക്കുന്ന പാത മാറ്റണമെങ്കിൽ, അത് വ്യക്തമാക്കാൻ നിങ്ങൾക്ക് വാഫ് പാരാമീറ്റർ ഉപയോഗിക്കാം. --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). ഞങ്ങൾ ചോദിച്ചത് നിങ്ങൾ ഓർക്കുന്നുണ്ടാകും UdpEchoClientApplication രണ്ട് സെക്കൻഡിനുള്ളിൽ പാക്കറ്റുകൾ അയയ്ക്കാൻ തുടങ്ങുക. ഇത് തീർച്ചയായും സംഭവിക്കുന്നു എന്നതിൻ്റെ സ്ഥിരീകരണം ഇവിടെ കാണാം.

ട്രെയ്‌സ് ഉദാഹരണത്തിൻ്റെ അടുത്ത വിഭാഗം (ലൈൻ 2 മുതൽ) ഏത് ട്രെയ്‌സ് ഉറവിടമാണ് ഈ ഇവൻ്റ് സൃഷ്‌ടിച്ചതെന്ന് കാണിക്കുന്നു (നെയിംസ്‌പേസ് ട്രേസ് സൂചിപ്പിക്കുന്നു). നിങ്ങൾ ഒരു ഫയൽസിസ്റ്റം നെയിംസ്പേസ് പോലെ ട്രേസ് നെയിംസ്പേസിനെക്കുറിച്ച് ചിന്തിക്കാം. നെയിംസ്പേസിൻ്റെ റൂട്ട് ആണ് നോഡ് ലിസ്റ്റ്. ഇത് പ്രധാന ns-3 കോഡിൽ കൈകാര്യം ചെയ്യുന്ന കണ്ടെയ്‌നറുമായി യോജിക്കുന്നു. സ്ക്രിപ്റ്റിൽ സൃഷ്ടിച്ച എല്ലാ നോഡുകളും ഇതിൽ അടങ്ങിയിരിക്കുന്നു. ഒരു ഫയൽ സിസ്റ്റത്തിന് അതിൻ്റെ റൂട്ടിൽ ഡയറക്ടറികൾ ഉണ്ടാകുന്നത് പോലെ, നോഡ് ലിസ്റ്റ് നമുക്ക് ധാരാളം നോഡുകൾ ഉണ്ടാകാം. അതിനാൽ /NodeList/0 എന്ന വരി നോഡ്‌ലിസ്റ്റിലെ നൾ നോഡിനെ സൂചിപ്പിക്കുന്നു, അത് നമ്മൾ സാധാരണയായി "നോഡ് 0" എന്ന് കരുതുന്നു. ഓരോ നോഡിനും ഇൻസ്റ്റാൾ ചെയ്ത ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉണ്ട്. നെയിംസ്പേസിൽ അടുത്തതായി ഈ ലിസ്റ്റ് സ്ഥിതി ചെയ്യുന്നു. ഈ ട്രെയ്സ് ഇവൻ്റ് വരുന്നത് നിങ്ങൾക്ക് കാണാൻ കഴിയും ഉപകരണ ലിസ്റ്റ്/0, നോഡിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ശൂന്യമായ ഉപകരണമാണിത്.

അടുത്ത സബ്‌സ്ട്രിംഗ്, $ ns3 :: PointToPointNetDevice, ഏത് ഉപകരണമാണ് പൂജ്യം സ്ഥാനത്തുള്ളതെന്ന് പറയുന്നു: നോഡ് പൂജ്യത്തിൻ്റെ ഉപകരണ ലിസ്റ്റ്. 0 വരിയിൽ കാണുന്ന + പ്രവർത്തനം ഉപകരണത്തിൻ്റെ ട്രാൻസ്മിറ്റ് ക്യൂവിൽ ഒരു ഘടകം ചേർത്തിട്ടുണ്ടെന്നാണ് അർത്ഥമാക്കുന്നത്. "ട്രാക്ക് പാത" യുടെ അവസാന ഭാഗങ്ങളിൽ ഇത് പ്രതിഫലിക്കുന്നു: TxQueue/Enqueue.

ട്രെയ്‌സിലെ ശേഷിക്കുന്ന ഭാഗങ്ങൾ തികച്ചും അവബോധജന്യമായിരിക്കണം. പോയിൻ്റ്-ടു-പോയിൻ്റ് പ്രോട്ടോക്കോളിൽ പാക്കറ്റ് പൊതിഞ്ഞതായി വരികൾ 3-4 സൂചിപ്പിക്കുന്നു. 5-7 വരികൾ പാക്കറ്റിന് IP4 പതിപ്പ് തലക്കെട്ടുണ്ടെന്നും IP വിലാസത്തിൽ നിന്നാണ് ഉത്ഭവിച്ചതെന്നും കാണിക്കുന്നു 10.1.1.1 എന്നിവയ്ക്കായി ഉദ്ദേശിച്ചിട്ടുള്ളതാണ് 10.1.1.2. ഈ പാക്കറ്റിന് UDP ഹെഡർ ഉണ്ടെന്ന് 8-9 വരികൾ കാണിക്കുന്നു, അവസാനം ലൈൻ 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) കൂടാതെ പാക്കറ്റ് ട്രെയ്‌സ് ഉറവിടം (/MacRx). ഫയലിലെ അവശേഷിക്കുന്ന ട്രെയ്‌സുകൾ നോക്കി ടോപ്പോളജിയിലൂടെ പാക്കറ്റിൻ്റെ ചലനം പിന്തുടരുന്നത് നിങ്ങൾക്ക് വളരെ എളുപ്പമായിരിക്കണം.

5.3.2 പിസിഎപി ട്രെയ്സ്

.pcap ഫോർമാറ്റിൽ ട്രെയ്സ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിനും ns-3 ഉപകരണ സഹായികൾ ഉപയോഗിക്കാം. സംക്ഷേപം pcap (സാധാരണയായി ചെറിയക്ഷരത്തിൽ എഴുതിയത്) എന്നത് പാക്കറ്റ് ക്യാപ്‌ചറിനെ സൂചിപ്പിക്കുന്നു, ഇത് യഥാർത്ഥത്തിൽ .pcap ഫയൽ ഫോർമാറ്റ് നിർവചിക്കുന്ന ഒരു API ആണ്. ഈ ഫോർമാറ്റ് വായിക്കാനും പ്രദർശിപ്പിക്കാനും കഴിയുന്ന ഏറ്റവും ജനപ്രിയമായ പ്രോഗ്രാം വയറുകൾഷാർക്ക് (മുമ്പ് വിളിച്ചിരുന്നു എറ്റെവേൽ). എന്നിരുന്നാലും, ഈ പാക്കറ്റ് ഫോർമാറ്റ് ഉപയോഗിക്കുന്ന നിരവധി ട്രാഫിക് ട്രെയ്സ് അനലൈസറുകൾ ഉണ്ട്. 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 സെക്കൻഡിൽ ആദ്യത്തെ ഡംപിൽ ക്ലയൻ്റ് പാക്കറ്റ് തിരികെ ലഭിച്ചതും നിങ്ങൾ കാണും.

വയർഷാർക്ക് ഉപയോഗിച്ച് ഔട്ട്പുട്ട് റീഡിംഗ്

നിങ്ങൾക്ക് പരിചയമില്ലെങ്കിൽ വയറുകൾഷാർക്ക്, നിങ്ങൾക്ക് പ്രോഗ്രാമുകളും ഡോക്യുമെൻ്റേഷനും ഡൗൺലോഡ് ചെയ്യാൻ കഴിയുന്ന ഒരു വെബ്സൈറ്റ് ഉണ്ട്: http://www.wireshark.org/. വയറുകൾഷാർക്ക് ഈ ട്രെയ്സ് ഫയലുകൾ പ്രദർശിപ്പിക്കാൻ ഉപയോഗിക്കാവുന്ന ഒരു GUI ആണ്. നിങ്ങൾക്ക് വയർഷാർക്ക് ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഏതെങ്കിലും ട്രേസ് ഫയലുകൾ തുറന്ന് പാക്കറ്റ് സ്നിഫർ ഉപയോഗിച്ച് പാക്കറ്റുകൾ ക്യാപ്‌ചർ ചെയ്‌തതുപോലെ ഉള്ളടക്കം പ്രദർശിപ്പിക്കാൻ കഴിയും.

അവലംബം: www.habr.com