ns-3-ട്യൂട്ടോറിയൽ - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

ns-3-tutorial - ns-3 ട്യൂട്ടോറിയൽ

ഇതാണ് ns-3 ട്യൂട്ടോറിയൽ. ns-3 പ്രോജക്റ്റിനായുള്ള പ്രാഥമിക ഡോക്യുമെന്റേഷൻ അഞ്ചിൽ ലഭ്യമാണ്
ഫോമുകൾ:

· ns-3 ഡോക്സിജൻ: സിമുലേറ്ററിന്റെ പൊതു API-കളുടെ ഡോക്യുമെന്റേഷൻ

· ട്യൂട്ടോറിയൽ (ഈ പ്രമാണം), മാനുവൽ, മോഡൽ ലൈബ്രറി എന്നിവ ഏറ്റവും പുതിയ റിലീസ് ഒപ്പം
വികസനം വൃക്ഷം

· ns-3 വിക്കി

ഈ പ്രമാണം എഴുതിയിരിക്കുന്നു പുനഃസംഘടിപ്പിച്ച ടെക്സ്റ്റ് വേണ്ടി സ്ഫിംക്സ് യിൽ പരിപാലിക്കപ്പെടുന്നു
doc/tutorial ns-3 ന്റെ സോഴ്സ് കോഡിന്റെ ഡയറക്ടറി.

ആമുഖം

ദി ns-3 സിമുലേറ്റർ പ്രാഥമികമായി ഗവേഷണത്തിനായി ലക്ഷ്യമിടുന്ന ഒരു വ്യതിരിക്ത-ഇവന്റ് നെറ്റ്‌വർക്ക് സിമുലേറ്ററാണ്
വിദ്യാഭ്യാസ ഉപയോഗവും. ദി ns-3 പദ്ധതി2006-ൽ ആരംഭിച്ച ഒരു ഓപ്പൺ സോഴ്‌സ് പ്രോജക്റ്റാണ്
വികസിക്കുന്നു ns-3.

ഈ ട്യൂട്ടോറിയലിന്റെ ഉദ്ദേശം പുതിയത് പരിചയപ്പെടുത്തുക എന്നതാണ് ns-3 ഒരു ഘടനാപരമായ സിസ്റ്റത്തിൽ ഉപയോക്താക്കൾ
വഴി. വിശദവിവരങ്ങളിൽ നിന്ന് അവശ്യ വിവരങ്ങൾ ശേഖരിക്കുന്നത് പുതിയ ഉപയോക്താക്കൾക്ക് ചിലപ്പോൾ ബുദ്ധിമുട്ടാണ്
മാനുവലുകൾ, ഈ വിവരങ്ങൾ വർക്കിംഗ് സിമുലേഷനുകളായി പരിവർത്തനം ചെയ്യുക. ഈ ട്യൂട്ടോറിയലിൽ, ഞങ്ങൾ
നിരവധി ഉദാഹരണ സിമുലേഷനുകൾ നിർമ്മിക്കും, പ്രധാന ആശയങ്ങൾ അവതരിപ്പിക്കുകയും വിശദീകരിക്കുകയും ചെയ്യും
ഞങ്ങൾ പോകുമ്പോൾ സവിശേഷതകൾ.

ട്യൂട്ടോറിയൽ തുറക്കുമ്പോൾ, ഞങ്ങൾ മുഴുവൻ പരിചയപ്പെടുത്തും ns-3 ഡോക്യുമെന്റേഷനും നൽകലും
യുടെ പ്രവർത്തനങ്ങളെക്കുറിച്ച് കൂടുതൽ ആഴത്തിൽ പരിശോധിക്കാൻ താൽപ്പര്യമുള്ളവർക്ക് സോഴ്സ് കോഡിലേക്കുള്ള പോയിന്ററുകൾ
സിസ്റ്റം.

തുടക്കത്തിൽ തന്നെ ചില പ്രധാന കാര്യങ്ങൾ ശ്രദ്ധിക്കേണ്ടതാണ്:

· ns-3 ഓപ്പൺ സോഴ്‌സ് ആണ്, കൂടാതെ ഒരു തുറന്ന അന്തരീക്ഷം നിലനിർത്താൻ പദ്ധതി പരിശ്രമിക്കുന്നു
ഗവേഷകർ അവരുടെ സോഫ്റ്റ്‌വെയർ സംഭാവന ചെയ്യാനും പങ്കിടാനും.

· ns-3 എന്നതിന്റെ പിന്നാക്ക-അനുയോജ്യമായ വിപുലീകരണമല്ല ns-2; ഇതൊരു പുതിയ സിമുലേറ്ററാണ്. രണ്ട്
സിമുലേറ്ററുകൾ രണ്ടും C++ ലാണ് എഴുതിയിരിക്കുന്നത് ns-3 പിന്തുണയ്ക്കാത്ത ഒരു പുതിയ സിമുലേറ്ററാണ്
ns-2 API-കൾ. നിന്നുള്ള ചില മോഡലുകൾ ns-2 നിന്ന് ഇതിനകം പോർട്ട് ചെയ്തിട്ടുണ്ട് ns-2 ലേക്ക് ns-3. ദി
പദ്ധതി പരിപാലിക്കുന്നത് തുടരും ns-2 സമയത്ത് ns-3 പണിയുന്നു, പഠിക്കും
സംക്രമണ, സംയോജന സംവിധാനങ്ങൾ.

കുറിച്ച് ns-3
ns-3 ഒരു തുറന്നതും വിപുലീകരിക്കാവുന്നതുമായ നെറ്റ്‌വർക്ക് സിമുലേഷൻ പ്ലാറ്റ്‌ഫോം ലഭ്യമാക്കുന്നതിനായി വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്
നെറ്റ്‌വർക്കിംഗ് ഗവേഷണവും വിദ്യാഭ്യാസവും. ചുരുക്കത്തിൽ, ns-3 പാക്കറ്റ് ഡാറ്റ എങ്ങനെ എന്നതിന്റെ മാതൃകകൾ നൽകുന്നു
നെറ്റ്‌വർക്കുകൾ പ്രവർത്തിക്കുകയും പ്രവർത്തിക്കുകയും ചെയ്യുന്നു, കൂടാതെ ഉപയോക്താക്കൾക്ക് നടത്തുന്നതിന് ഒരു സിമുലേഷൻ എഞ്ചിൻ നൽകുന്നു
സിമുലേഷൻ പരീക്ഷണങ്ങൾ. ഉപയോഗിക്കാനുള്ള ചില കാരണങ്ങൾ ns-3 എന്ന പഠനങ്ങൾ നടത്താൻ ഉൾപ്പെടുത്തുക
സിസ്റ്റം സ്വഭാവം പഠിക്കാൻ, യഥാർത്ഥ സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കാൻ കൂടുതൽ ബുദ്ധിമുട്ടാണ് അല്ലെങ്കിൽ സാധ്യമല്ല
വളരെ നിയന്ത്രിതവും പുനരുൽപ്പാദിപ്പിക്കാവുന്നതുമായ പരിതസ്ഥിതിയിൽ, നെറ്റ്‌വർക്കുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് അറിയാൻ.
ലഭ്യമായ മോഡൽ സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് ഉപയോക്താക്കൾ ശ്രദ്ധിക്കും ns-3 ഇന്റർനെറ്റ് എങ്ങനെ മോഡലിംഗിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു
പ്രോട്ടോക്കോളുകളും നെറ്റ്‌വർക്കുകളും പ്രവർത്തിക്കുന്നു, പക്ഷേ ns-3 ഇന്റർനെറ്റ് സംവിധാനങ്ങളിൽ മാത്രം ഒതുങ്ങുന്നില്ല; നിരവധി ഉപയോക്താക്കൾ
ഉപയോഗിക്കുന്നു ns-3 ഇന്റർനെറ്റ് അധിഷ്ഠിതമല്ലാത്ത സിസ്റ്റങ്ങളെ മാതൃകയാക്കാൻ.

നെറ്റ്‌വർക്ക് സിമുലേഷൻ പഠനങ്ങൾക്കായി നിരവധി സിമുലേഷൻ ടൂളുകൾ നിലവിലുണ്ട്. ചിലത് താഴെ
യുടെ വ്യതിരിക്ത സവിശേഷതകൾ ns-3 മറ്റ് ഉപകരണങ്ങളിൽ നിന്ന് വ്യത്യസ്തമായി.

· ns-3 ഒരു കൂട്ടം ലൈബ്രറികളായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു, അത് ഒന്നിച്ചും മറ്റുള്ളവയുമായി സംയോജിപ്പിക്കാൻ കഴിയും
ബാഹ്യ സോഫ്റ്റ്വെയർ ലൈബ്രറികൾ. ചില സിമുലേഷൻ പ്ലാറ്റ്‌ഫോമുകൾ ഉപയോക്താക്കൾക്ക് എ
എല്ലാ ജോലികളും നിർവഹിക്കുന്ന ഒറ്റ, സംയോജിത ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് എൻവയോൺമെന്റ്
ഔട്ട്, ns-3 ഇക്കാര്യത്തിൽ കൂടുതൽ മോഡുലാർ ആണ്. നിരവധി ബാഹ്യ ആനിമേറ്ററുകളും ഡാറ്റ വിശകലനവും
ഒപ്പം വിഷ്വലൈസേഷൻ ടൂളുകളും ഉപയോഗിക്കാം ns-3. എന്നിരുന്നാലും, ഉപയോക്താക്കൾ പ്രവർത്തിക്കുമെന്ന് പ്രതീക്ഷിക്കണം
കമാൻഡ് ലൈൻ കൂടാതെ C++ കൂടാതെ/അല്ലെങ്കിൽ Python സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെന്റ് ടൂളുകളും.

· ns-3 FreeBSD, Cygwin എന്നിവയ്‌ക്ക് പിന്തുണ നിലവിലുണ്ടെങ്കിലും പ്രാഥമികമായി Linux സിസ്റ്റങ്ങളിൽ ഉപയോഗിക്കുന്നു
(വിൻഡോസിനായി), നേറ്റീവ് വിൻഡോസ് വിഷ്വൽ സ്റ്റുഡിയോ സപ്പോർട്ട് നിലവിൽ വരുന്ന പ്രക്രിയയിലാണ്
വികസിപ്പിച്ചെടുത്തു.

· ns-3 ഒരു കമ്പനിയുടെയും ഔദ്യോഗികമായി പിന്തുണയ്‌ക്കുന്ന സോഫ്റ്റ്‌വെയർ ഉൽപ്പന്നമല്ല. പിന്തുണ ns-3
ns-3-ഉപയോക്താക്കളുടെ മെയിലിംഗ് ലിസ്റ്റിൽ മികച്ച പ്രയത്നത്തിന്റെ അടിസ്ഥാനത്തിലാണ് ഇത് ചെയ്യുന്നത്.

വേണ്ടി ns-2 ഉപയോക്താക്കൾ
പരിചയമുള്ളവർക്ക് ns-2 (മുമ്പുണ്ടായിരുന്ന ഒരു ജനപ്രിയ ഉപകരണം ns-3), പുറത്തേക്ക് ഏറ്റവും ദൃശ്യമായത്
നീങ്ങുമ്പോൾ മാറ്റുക ns-3 സ്ക്രിപ്റ്റിംഗ് ഭാഷയുടെ തിരഞ്ഞെടുപ്പാണ്. ലെ പ്രോഗ്രാമുകൾ ns-2 ആകുന്നു
OTcl-ൽ സ്‌ക്രിപ്റ്റ് ചെയ്‌തതും സിമുലേഷനുകളുടെ ഫലങ്ങളും നെറ്റ്‌വർക്ക് ആനിമേറ്റർ ഉപയോഗിച്ച് ദൃശ്യവൽക്കരിക്കാൻ കഴിയും
നാം. ഒരു സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുന്നത് സാധ്യമല്ല ns-2 പൂർണ്ണമായും C++ ൽ നിന്ന് (അതായത്, ഒരു പ്രധാനമായി()
OTcl ഇല്ലാതെ പ്രോഗ്രാം). കൂടാതെ, ചില ഘടകങ്ങൾ ns-2 C++ ൽ എഴുതിയിരിക്കുന്നു
മറ്റുള്ളവർ OTcl-ൽ. ഇൻ ns-3, സിമുലേറ്റർ പൂർണ്ണമായും C++ ൽ, ഓപ്ഷണൽ പൈത്തൺ ഉപയോഗിച്ച് എഴുതിയിരിക്കുന്നു
ബന്ധനങ്ങൾ. അതിനാൽ സിമുലേഷൻ സ്ക്രിപ്റ്റുകൾ C++ അല്ലെങ്കിൽ പൈത്തണിൽ എഴുതാം. പുതിയ ആനിമേറ്റർമാർ
വിഷ്വലൈസറുകൾ ലഭ്യമാണ്, നിലവിലുള്ള വികസനത്തിലാണ്. മുതലുള്ള ns-3 pcap സൃഷ്ടിക്കുന്നു
പാക്കറ്റ് ട്രേസ് ഫയലുകൾ, മറ്റ് യൂട്ടിലിറ്റികൾ എന്നിവയും ട്രെയ്‌സുകൾ വിശകലനം ചെയ്യാൻ ഉപയോഗിക്കാം. ഇതിൽ
ട്യൂട്ടോറിയൽ, ഞങ്ങൾ ആദ്യം C++ ൽ നേരിട്ട് സ്ക്രിപ്റ്റ് ചെയ്യുന്നതിലും ഫലങ്ങൾ വ്യാഖ്യാനിക്കുന്നതിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കും
ട്രേസ് ഫയലുകൾ വഴി.

എന്നാൽ സമാനതകളും ഉണ്ട് (രണ്ടും, ഉദാഹരണത്തിന്, C++ ഒബ്ജക്റ്റുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, ചിലത്
എന്നതിൽ നിന്നുള്ള കോഡ് ns-2 ലേക്ക് ഇതിനകം പോർട്ട് ചെയ്തിട്ടുണ്ട് ns-3). വ്യത്യാസങ്ങൾ ഹൈലൈറ്റ് ചെയ്യാൻ ഞങ്ങൾ ശ്രമിക്കും
തമ്മിലുള്ള ns-2 ഒപ്പം ns-3 ഞങ്ങൾ ഈ ട്യൂട്ടോറിയലിൽ തുടരുമ്പോൾ.

നമ്മൾ പലപ്പോഴും കേൾക്കുന്ന ഒരു ചോദ്യം ഇതാണ് "ഞാൻ ഇപ്പോഴും ഉപയോഗിക്കണോ ns-2 അല്ലെങ്കിൽ നീങ്ങുക ns-3?" ഇതിൽ
രചയിതാവിന്റെ അഭിപ്രായം, ഉപയോക്താവ് എങ്ങനെയെങ്കിലും നിക്ഷിപ്തമല്ലെങ്കിൽ ns-2 (ഒന്നുകിൽ നിലവിലുള്ളതിനെ അടിസ്ഥാനമാക്കി
വ്യക്തിപരമായ സുഖവും അറിവും ns-2, അല്ലെങ്കിൽ ഒരു നിർദ്ദിഷ്ട സിമുലേഷൻ മോഡലിനെ അടിസ്ഥാനമാക്കി
ൽ മാത്രം ലഭ്യമാണ് ns-2), ഒരു ഉപയോക്താവ് കൂടുതൽ ഉൽപ്പാദനക്ഷമതയുള്ളവനായിരിക്കും ns-3 ഇനിപ്പറയുന്നവയ്‌ക്കായി
കാരണങ്ങൾ:

· ns-3 സജീവമായ, പ്രതികരിക്കുന്ന ഉപയോക്താക്കളുടെ മെയിലിംഗ് ലിസ്റ്റ് ഉപയോഗിച്ച് സജീവമായി പരിപാലിക്കപ്പെടുന്നു ns-2 is
ചെറുതായി പരിപാലിക്കപ്പെടുന്നു, മാത്രമല്ല അതിന്റെ പ്രധാന കോഡ് ട്രീയിൽ കാര്യമായ വികസനം കണ്ടിട്ടില്ല
ഒരു ദശാബ്ദത്തിലേറെയായി.

· ns-3 ൽ ലഭ്യമല്ലാത്ത സവിശേഷതകൾ നൽകുന്നു ns-2, ഒരു നടപ്പാക്കൽ കോഡ് എക്സിക്യൂഷൻ പോലെ
പരിസ്ഥിതി (സിമുലേറ്ററിൽ യഥാർത്ഥ നടപ്പാക്കൽ കോഡ് പ്രവർത്തിപ്പിക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്നു)

· ns-3 യുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ അമൂർത്തീകരണത്തിന്റെ താഴ്ന്ന അടിസ്ഥാന നില നൽകുന്നു ns-2, അതിനെ വിന്യസിക്കാൻ അനുവദിക്കുന്നു
യഥാർത്ഥ സംവിധാനങ്ങൾ എങ്ങനെ സംയോജിപ്പിക്കുന്നു എന്നതിലാണ് നല്ലത്. ചില പരിമിതികൾ കണ്ടെത്തി ns-2 (അതുപോലെ
നോഡുകളിൽ ഒന്നിലധികം തരം ഇന്റർഫേസുകളെ ശരിയായി പിന്തുണയ്ക്കുന്നു) പരിഹരിക്കപ്പെട്ടു ns-3.

ns-2 സംഭാവന ചെയ്ത മൊഡ്യൂളുകളുടെ വൈവിധ്യമാർന്ന സെറ്റ് ഉണ്ട് ns-3, അതിന്റെ നീളം കാരണം
ചരിത്രം. എന്നിരുന്നാലും, ns-3 ഗവേഷണത്തിന്റെ നിരവധി ജനപ്രിയ മേഖലകളിൽ കൂടുതൽ വിശദമായ മോഡലുകൾ ഉണ്ട്
(അത്യാധുനിക എൽടിഇ, വൈഫൈ മോഡലുകൾ ഉൾപ്പെടെ), നടപ്പാക്കൽ കോഡിന്റെ പിന്തുണയും
ഉയർന്ന വിശ്വാസ്യതയുള്ള മോഡലുകളുടെ വളരെ വിശാലമായ സ്പെക്ട്രം സമ്മതിക്കുന്നു. അത് അറിയുമ്പോൾ ഉപയോക്താക്കൾ ആശ്ചര്യപ്പെട്ടേക്കാം
ലിനക്സ് നെറ്റ്‌വർക്കിംഗ് സ്റ്റാക്ക് മുഴുവനും ഒരു-ൽ ഉൾപ്പെടുത്താം ns-3 നോഡ്, ഡയറക്ട് ഉപയോഗിച്ച്
കോഡ് എക്സിക്യൂഷൻ (DCE) ചട്ടക്കൂട്. ns-2 മോഡലുകൾ ചിലപ്പോൾ പോർട്ട് ചെയ്യപ്പെടാം ns-3, പ്രത്യേകിച്ച്
അവ C++ ൽ നടപ്പിലാക്കിയിട്ടുണ്ടെങ്കിൽ.

സംശയമുണ്ടെങ്കിൽ, രണ്ട് സിമുലേറ്ററുകളും (അതുപോലെ മറ്റുള്ളവയും) നോക്കുന്നതാണ് നല്ല മാർഗ്ഗനിർദ്ദേശം
സിമുലേറ്ററുകൾ), പ്രത്യേകിച്ചും നിങ്ങളുടെ ഗവേഷണത്തിനായി ലഭ്യമായ മോഡലുകൾ, എന്നാൽ മനസ്സിൽ വയ്ക്കുക
സജീവമായി വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്ന ഉപകരണം ഉപയോഗിക്കുന്നതിൽ നിങ്ങളുടെ അനുഭവം മികച്ചതായിരിക്കാം
പരിപാലിക്കുന്നത് (ns-3).

സംഭാവന ചെയ്യുന്നു
ns-3 ഗവേഷണ സമൂഹത്തിന് വേണ്ടിയുള്ള ഒരു ഗവേഷണ വിദ്യാഭ്യാസ സിമുലേറ്ററാണ്. ഇത് ചെയ്യും
പുതിയ മോഡലുകൾ വികസിപ്പിക്കുന്നതിനും ഡീബഗ് ചെയ്യുന്നതിനും കമ്മ്യൂണിറ്റിയുടെ നിലവിലുള്ള സംഭാവനകളെ ആശ്രയിക്കുക
നിലവിലുള്ളവ നിലനിർത്തുക, ഫലങ്ങൾ പങ്കിടുക. ഞങ്ങൾ പ്രതീക്ഷിക്കുന്ന ചില നയങ്ങളുണ്ട്
സംഭാവന ചെയ്യാൻ ആളുകളെ പ്രോത്സാഹിപ്പിക്കുക ns-3 അവർക്കുള്ളത് പോലെ ns-2:

GNU GPLv2 അനുയോജ്യതയെ അടിസ്ഥാനമാക്കിയുള്ള ഓപ്പൺ സോഴ്‌സ് ലൈസൻസിംഗ്

· വിക്കി

· സംഭാവന ചെയ്തു കോഡ് പേജ്, സമാനമായത് ns-2ന്റെ ജനപ്രിയ സംഭാവന കോഡ് പേജ്

· തുറക്കുക മൂട്ട ട്രാക്കർ

നിങ്ങൾ ഈ പ്രമാണം വായിക്കുകയാണെങ്കിൽ, പ്രോജക്റ്റിലേക്ക് തിരികെ സംഭാവന ചെയ്യുകയാണെന്ന് ഞങ്ങൾ മനസ്സിലാക്കുന്നു
ഒരുപക്ഷേ ഈ ഘട്ടത്തിൽ നിങ്ങളുടെ പ്രധാന ആശങ്കയല്ല, പക്ഷേ നിങ്ങൾ അത് അറിഞ്ഞിരിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
സംഭാവന നൽകുന്നത് പ്രോജക്റ്റിന്റെ ആത്മാവിലാണ്, മാത്രമല്ല ഞങ്ങൾക്ക് ഒരു കുറിപ്പ് ഇടുന്നത് പോലും
നിങ്ങളുടെ ആദ്യകാല അനുഭവത്തെക്കുറിച്ച് ns-3 (ഉദാ: "ഈ ട്യൂട്ടോറിയൽ വിഭാഗം വ്യക്തമായിരുന്നില്ല..."),
പഴകിയ ഡോക്യുമെന്റേഷന്റെ റിപ്പോർട്ടുകൾ മുതലായവ വളരെ വിലമതിക്കപ്പെടുന്നു.

ട്യൂട്ടോറിയൽ സംഘടന
പുതിയ ഉപയോക്താക്കൾ തുടക്കത്തിൽ ഇനിപ്പറയുന്നതുപോലുള്ള ഒരു പാത പിന്തുടരുമെന്ന് ട്യൂട്ടോറിയൽ അനുമാനിക്കുന്നു:

ഒരു പകർപ്പ് ഡൗൺലോഡ് ചെയ്ത് നിർമ്മിക്കാൻ ശ്രമിക്കുക;

· കുറച്ച് സാമ്പിൾ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കുക;

· സിമുലേഷൻ ഔട്ട്പുട്ട് നോക്കുക, അത് ക്രമീകരിക്കാൻ ശ്രമിക്കുക.

തൽഫലമായി, മുകളിലുള്ള വിശാലമായ ശ്രേണിയിൽ ട്യൂട്ടോറിയൽ സംഘടിപ്പിക്കാൻ ഞങ്ങൾ ശ്രമിച്ചു
ഇവന്റുകൾ.

റിസോർസുകൾ

ദി വെബ്
അവയിൽ പ്രധാനപ്പെട്ട നിരവധി ഉറവിടങ്ങളുണ്ട് ns-3 ഉപയോക്താവ് അറിഞ്ഞിരിക്കണം. പ്രധാന വെബ്
സൈറ്റ് സ്ഥിതി ചെയ്യുന്നത് http://www.nsnam.org എന്നതിനെക്കുറിച്ചുള്ള അടിസ്ഥാന വിവരങ്ങളിലേക്ക് പ്രവേശനം നൽകുന്നു
ns-3 സിസ്റ്റം. പ്രധാന വെബ്‌സൈറ്റ് വഴി വിശദമായ ഡോക്യുമെന്റേഷൻ ലഭ്യമാണ്
http://www.nsnam.org/documentation/. സിസ്റ്റവുമായി ബന്ധപ്പെട്ട രേഖകളും നിങ്ങൾക്ക് കണ്ടെത്താം
ഈ പേജിൽ നിന്നുള്ള വാസ്തുവിദ്യ.

പ്രധാനമായതിനെ പൂരകമാക്കുന്ന ഒരു വിക്കിയുണ്ട് ns-3 നിങ്ങൾ കണ്ടെത്തുന്ന വെബ് സൈറ്റ്
http://www.nsnam.org/wiki/. ഉപയോക്താവിന്റെയും ഡെവലപ്പറുടെയും പതിവുചോദ്യങ്ങളും നിങ്ങൾ അവിടെ കണ്ടെത്തും
ട്രബിൾഷൂട്ടിംഗ് ഗൈഡുകൾ, മൂന്നാം കക്ഷി സംഭാവന ചെയ്ത കോഡ്, പേപ്പറുകൾ മുതലായവ.

സോഴ്സ് കോഡ് ഇവിടെ കണ്ടെത്തുകയും ബ്രൗസ് ചെയ്യുകയും ചെയ്യാം http://code.nsnam.org/. അവിടെ നിങ്ങൾ കണ്ടെത്തും
റിപ്പോസിറ്ററിയിലെ നിലവിലെ വികസന ട്രീ എന്ന് പേരിട്ടിരിക്കുന്നു ns-3-dev. കഴിഞ്ഞ റിലീസുകളും
കോർ ഡെവലപ്പർമാരുടെ പരീക്ഷണ ശേഖരങ്ങളും അവിടെ കാണാവുന്നതാണ്.

മെർക്കുറിയൽ
സങ്കീർണ്ണമായ സോഫ്‌റ്റ്‌വെയർ സിസ്റ്റങ്ങൾക്ക് ഓർഗനൈസേഷനും മാറ്റങ്ങളും നിയന്ത്രിക്കാൻ ചില വഴികൾ ആവശ്യമാണ്
അടിസ്ഥാന കോഡും ഡോക്യുമെന്റേഷനും. ഈ നേട്ടം നടപ്പിലാക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്, നിങ്ങൾക്ക് കഴിയും
ഇതിനായി നിലവിൽ ഉപയോഗിക്കുന്ന ചില സംവിധാനങ്ങളെക്കുറിച്ച് കേട്ടിട്ടുണ്ട്. കൺകറന്റ്
പതിപ്പ് സിസ്റ്റം (സിവിഎസ്) ഒരുപക്ഷേ ഏറ്റവും അറിയപ്പെടുന്നത്.

ദി ns-3 പ്രോജക്റ്റ് അതിന്റെ സോഴ്സ് കോഡ് മാനേജ്മെന്റ് സിസ്റ്റമായി മെർക്കുറിയൽ ഉപയോഗിക്കുന്നു. നിങ്ങൾ ചെയ്യുന്നില്ലെങ്കിലും
ഈ ട്യൂട്ടോറിയൽ പൂർത്തിയാക്കാൻ മെർക്കുറിയലിനെക്കുറിച്ച് കൂടുതൽ അറിയേണ്ടതുണ്ട്, ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു
മെർക്കുറിയലുമായി പരിചയപ്പെടുകയും സോഴ്സ് കോഡ് ആക്സസ് ചെയ്യാൻ അത് ഉപയോഗിക്കുകയും ചെയ്യുന്നു. മെർക്കുറിയൽ എ ഉണ്ട്
എന്ന വെബ് സൈറ്റ് http://www.selenic.com/mercurial/, അതിൽ നിന്ന് നിങ്ങൾക്ക് ബൈനറി അല്ലെങ്കിൽ ഉറവിടം ലഭിക്കും
ഈ സോഫ്റ്റ്‌വെയർ കോൺഫിഗറേഷൻ മാനേജ്‌മെന്റ് (SCM) സിസ്റ്റത്തിന്റെ റിലീസുകൾ. സെലെനിക് (ഡെവലപ്പർ
എന്നതിൽ ഒരു ട്യൂട്ടോറിയലും നൽകുന്നു
http://www.selenic.com/mercurial/wiki/index.cgi/Tutorial/, കൂടാതെ ഒരു ക്വിക്ക്സ്റ്റാർട്ട് ഗൈഡ്
http://www.selenic.com/mercurial/wiki/index.cgi/QuickStart/.

മെർക്കുറിയൽ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചുള്ള സുപ്രധാന വിവരങ്ങളും നിങ്ങൾക്ക് കണ്ടെത്താനാകും ns-3 പ്രധാനമായും ns-3 വെബ്
സൈറ്റ്.

വഫ്
നിങ്ങളുടെ പ്രാദേശിക സിസ്റ്റത്തിലേക്ക് സോഴ്സ് കോഡ് ഡൗൺലോഡ് ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങൾ അത് കംപൈൽ ചെയ്യേണ്ടതുണ്ട്
ഉപയോഗയോഗ്യമായ പ്രോഗ്രാമുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഉറവിടം. സോഴ്സ് കോഡ് മാനേജ്മെന്റിന്റെ കാര്യത്തിലെന്നപോലെ, അവിടെയും
ഈ ഫംഗ്‌ഷൻ നിർവഹിക്കുന്നതിന് നിരവധി ഉപകരണങ്ങൾ ലഭ്യമാണ്. ഒരുപക്ഷേ ഇവയിൽ ഏറ്റവും അറിയപ്പെടുന്നത്
ഉപകരണങ്ങൾ ആണ് ഉണ്ടാക്കുക. ഏറ്റവും അറിയപ്പെടുന്ന വ്യക്തി എന്നതിനൊപ്പം, ഉണ്ടാക്കുക ഒരുപക്ഷേ ഏറ്റവും ബുദ്ധിമുട്ടാണ്
വളരെ വലുതും ഉയർന്ന കോൺഫിഗർ ചെയ്യാവുന്നതുമായ ഒരു സിസ്റ്റത്തിൽ ഉപയോഗിക്കുന്നതിന്. ഇക്കാരണത്താൽ, നിരവധി ബദലുകൾ
വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്. അടുത്തിടെ ഈ സംവിധാനങ്ങൾ പൈത്തൺ ഉപയോഗിച്ച് വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്
ഭാഷ.

ബിൽഡ് സിസ്റ്റം വാഫ് ഉപയോഗിക്കുന്നു ns-3 പദ്ധതി. ഇത് പുതിയ തലമുറയിൽ പെട്ട ഒന്നാണ്
പൈത്തൺ അടിസ്ഥാനമാക്കിയുള്ള ബിൽഡ് സിസ്റ്റങ്ങൾ. ഒരു പൈത്തണും നിർമ്മിക്കാൻ നിങ്ങൾ മനസ്സിലാക്കേണ്ടതില്ല
നിലവിലുള്ളത് ns-3 സിസ്റ്റം.

വാഫിന്റെ വിശദാംശങ്ങളിൽ താൽപ്പര്യമുള്ളവർക്കായി, പ്രധാന വെബ്‌സൈറ്റ് ഇവിടെ കാണാം
http://code.google.com/p/waf/.

വികസനം പരിസ്ഥിതി
മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, സ്ക്രിപ്റ്റിംഗ് ഇൻ ns-3 C++ അല്ലെങ്കിൽ പൈത്തണിലാണ് ചെയ്യുന്നത്. ഭൂരിഭാഗവും ns-3 API ആണ്
പൈത്തണിൽ ലഭ്യമാണ്, എന്നാൽ രണ്ട് സാഹചര്യങ്ങളിലും മോഡലുകൾ C++ ൽ എഴുതിയിരിക്കുന്നു. ഒരു ജോലി
C++, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് ആശയങ്ങൾ എന്നിവയെക്കുറിച്ചുള്ള അറിവ് ഈ പ്രമാണത്തിൽ അനുമാനിക്കപ്പെടുന്നു. ഞങ്ങൾ എടുക്കും
കൂടുതൽ വിപുലമായ ആശയങ്ങൾ അല്ലെങ്കിൽ ഒരുപക്ഷേ പരിചിതമല്ലാത്ത ഭാഷ അവലോകനം ചെയ്യാൻ കുറച്ച് സമയം
സവിശേഷതകൾ, ഭാഷകൾ, ഡിസൈൻ പാറ്റേണുകൾ എന്നിവ ദൃശ്യമാകുമ്പോൾ. ഈ ട്യൂട്ടോറിയൽ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല
എന്നിരുന്നാലും, ഒരു C++ ട്യൂട്ടോറിയലിലേക്ക് വികസിപ്പിച്ചെടുക്കുക, അതിനാൽ ഭാഷയുടെ അടിസ്ഥാന കമാൻഡ് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.
C++ ൽ സങ്കൽപ്പിക്കാൻ പോലും കഴിയാത്തത്ര വിവര സ്രോതസ്സുകൾ ലഭ്യമാണ്
വെബ് അല്ലെങ്കിൽ അച്ചടിയിൽ.

നിങ്ങൾ C++-ൽ പുതിയ ആളാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ട്യൂട്ടോറിയൽ- അല്ലെങ്കിൽ കുക്ക്ബുക്ക് അടിസ്ഥാനമാക്കിയുള്ള പുസ്തകം അല്ലെങ്കിൽ വെബ് സൈറ്റ് കണ്ടെത്തേണ്ടി വന്നേക്കാം.
തുടരുന്നതിന് മുമ്പ് ഭാഷയുടെ അടിസ്ഥാന സവിശേഷതകളെങ്കിലും പരിശോധിക്കുക. വേണ്ടി
ഉദാഹരണത്തിന്, ഈ ട്യൂട്ടോറിയൽ.

ദി ns-3 സിസ്റ്റം വികസനത്തിനായി ഗ്നു "ടൂൾചെയിനിന്റെ" നിരവധി ഘടകങ്ങൾ ഉപയോഗിക്കുന്നു. എ
നൽകിയിരിക്കുന്ന പരിതസ്ഥിതിയിൽ ലഭ്യമായ പ്രോഗ്രാമിംഗ് ടൂളുകളുടെ ഒരു കൂട്ടമാണ് സോഫ്റ്റ്‌വെയർ ടൂൾചെയിൻ. വേണ്ടി
ഗ്നു ടൂൾചെയിനിൽ എന്താണ് ഉൾപ്പെടുത്തിയിരിക്കുന്നത് എന്നതിന്റെ ഒരു ദ്രുത അവലോകനം കാണുക,
http://en.wikipedia.org/wiki/GNU_toolchain. ns-3 gcc, GNU binutils, gdb എന്നിവ ഉപയോഗിക്കുന്നു.
എന്നിരുന്നാലും, ഞങ്ങൾ GNU ബിൽഡ് സിസ്റ്റം ടൂളുകൾ ഉപയോഗിക്കുന്നില്ല, നിർമ്മിക്കുകയോ ഓട്ടോടൂളുകളോ അല്ല. ഞങ്ങൾ വാഫ് ഉപയോഗിക്കുന്നു
ഈ പ്രവർത്തനങ്ങൾക്കായി.

സാധാരണ ഒരു ns-3 രചയിതാവ് ലിനക്സിലോ ലിനക്സ് പോലുള്ള പരിതസ്ഥിതിയിലോ പ്രവർത്തിക്കും. അവയ്ക്ക് വേണ്ടി
വിൻഡോസിന് കീഴിൽ പ്രവർത്തിക്കുന്നു, ലിനക്സ് എൻവയോൺമെന്റിനെ അനുകരിക്കുന്ന പരിതസ്ഥിതികൾ നിലവിലുണ്ട്
വിവിധ ഡിഗ്രികൾ. ദി ns-3 പ്രോജക്റ്റ് മുമ്പ് (എന്നാൽ ഇപ്പോൾ അല്ല) പിന്തുണച്ചിട്ടുണ്ട്
ഈ ഉപയോക്താക്കൾക്കായി സിഗ്വിൻ പരിതസ്ഥിതിയിൽ വികസനം. കാണുക http://www.cygwin.com/ വേണ്ടി
ഡൗൺലോഡ് ചെയ്യുന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ, സന്ദർശിക്കുക ns-3 സിഗ്വിൻ എന്നതിനെ കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് വിക്കി
ns-3. MinGW നിലവിൽ ഔദ്യോഗികമായി പിന്തുണയ്‌ക്കുന്നില്ല. സിഗ്വിന് മറ്റൊരു ബദലാണ്
VMware സെർവർ പോലുള്ള ഒരു വെർച്വൽ മെഷീൻ എൻവയോൺമെന്റ് ഇൻസ്റ്റാൾ ചെയ്ത് ഒരു Linux വെർച്വൽ ഇൻസ്റ്റാൾ ചെയ്യുക
യന്ത്രം.

സോക്കറ്റ് പ്രോഗ്രാമിംഗ്
ഇതിൽ ഉപയോഗിച്ചിരിക്കുന്ന ഉദാഹരണങ്ങളിൽ ബെർക്ക്‌ലി സോക്കറ്റ്‌സ് API ഉള്ള ഒരു അടിസ്ഥാന സൗകര്യം ഞങ്ങൾ അനുമാനിക്കും
ട്യൂട്ടോറിയൽ. നിങ്ങൾ സോക്കറ്റുകളിൽ പുതിയ ആളാണെങ്കിൽ, API-യും ചില സാധാരണ ഉപയോഗവും അവലോകനം ചെയ്യാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു
കേസുകൾ. പ്രോഗ്രാമിംഗ് TCP/IP സോക്കറ്റുകളുടെ ഒരു നല്ല അവലോകനത്തിനായി ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു TCP / IP സോക്കറ്റുകൾ in
C, ഡോണഹൂ ഒപ്പം കാൽവർട്ട്.

പുസ്തകത്തിലെ ഉദാഹരണങ്ങളുടെ ഉറവിടം ഉൾക്കൊള്ളുന്ന ഒരു അനുബന്ധ വെബ്‌സൈറ്റ് ഉണ്ട്
നിങ്ങൾക്ക് ഇവിടെ കണ്ടെത്താനാകും: http://cs.baylor.edu/~donahoo/practical/CSockets/.

പുസ്‌തകത്തിന്റെ ആദ്യ നാല് അധ്യായങ്ങൾ നിങ്ങൾ മനസ്സിലാക്കുകയാണെങ്കിൽ (അല്ലെങ്കിൽ ആക്‌സസ് ഇല്ലാത്തവർക്ക്
പുസ്തകത്തിന്റെ ഒരു പകർപ്പിലേക്ക്, മുകളിലെ വെബ്‌സൈറ്റിൽ കാണിച്ചിരിക്കുന്ന എക്കോ ക്ലയന്റുകളും സെർവറുകളും) നിങ്ങൾ ചെയ്യും
ട്യൂട്ടോറിയൽ മനസ്സിലാക്കാൻ നല്ല നിലയിലായിരിക്കുക. മൾട്ടികാസ്റ്റിൽ സമാനമായ ഒരു പുസ്തകമുണ്ട്
സോക്കറ്റുകൾ, മൾട്ടികാസ്റ്റ് സോക്കറ്റുകൾ, മകോഫ്സ്കെ ഒപ്പം അൽമെറോത്ത്. അത് നിങ്ങൾക്ക് ആവശ്യമായേക്കാവുന്ന മെറ്റീരിയൽ ഉൾക്കൊള്ളുന്നു
വിതരണത്തിലെ മൾട്ടികാസ്റ്റ് ഉദാഹരണങ്ങൾ നോക്കിയാൽ മനസ്സിലാകും.

നേടുന്നു ആരംഭിച്ചത്

ഈ വിഭാഗം ഒരു മെഷീൻ ഉപയോഗിച്ച് ആരംഭിക്കുന്ന പ്രവർത്തന നിലയിലേക്ക് ഒരു ഉപയോക്താവിനെ എത്തിക്കാൻ ലക്ഷ്യമിടുന്നു
ഒരിക്കലും ഉണ്ടായിട്ടുണ്ടാകില്ല ns-3 ഇൻസ്റ്റാൾ ചെയ്തു. ഇത് പിന്തുണയ്ക്കുന്ന പ്ലാറ്റ്‌ഫോമുകൾ, മുൻവ്യവസ്ഥകൾ, വഴികൾ എന്നിവ ഉൾക്കൊള്ളുന്നു
നേടുക ns-3, നിർമ്മിക്കാനുള്ള വഴികൾ ns-3, നിങ്ങളുടെ ബിൽഡ് പരിശോധിച്ചുറപ്പിക്കുന്നതിനും ലളിതമായ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള വഴികൾ.

പൊതു അവലോകനം
ns-3 ഒരുമിച്ച് പ്രവർത്തിക്കുന്ന സോഫ്‌റ്റ്‌വെയർ ലൈബ്രറികളുടെ ഒരു സംവിധാനമായാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ഉപയോക്തൃ പ്രോഗ്രാമുകൾ ആകാം
ഈ ലൈബ്രറികളുമായി ലിങ്ക് ചെയ്യുന്നു (അല്ലെങ്കിൽ ഇറക്കുമതി ചെയ്യുന്നു) എന്ന് എഴുതിയിരിക്കുന്നു. ഉപയോക്തൃ പ്രോഗ്രാമുകൾ എഴുതിയിരിക്കുന്നു
C++ അല്ലെങ്കിൽ പൈത്തൺ പ്രോഗ്രാമിംഗ് ഭാഷകൾ.

ns-3 സോഴ്സ് കോഡായി വിതരണം ചെയ്യുന്നു, അതായത് ടാർഗെറ്റ് സിസ്റ്റത്തിന് a ഉണ്ടായിരിക്കണം
ആദ്യം ലൈബ്രറികൾ നിർമ്മിക്കാനും തുടർന്ന് ഉപയോക്താവിനെ നിർമ്മിക്കാനുമുള്ള സോഫ്റ്റ്വെയർ വികസന അന്തരീക്ഷം
പ്രോഗ്രാം. ns-3 തിരഞ്ഞെടുത്തവയ്ക്ക് മുൻകൂട്ടി നിർമ്മിച്ച ലൈബ്രറികളായി തത്ത്വത്തിൽ വിതരണം ചെയ്യാവുന്നതാണ്
സിസ്റ്റങ്ങൾ, ഭാവിയിൽ അത് അങ്ങനെ വിതരണം ചെയ്തേക്കാം, എന്നാൽ നിലവിൽ, നിരവധി ഉപയോക്താക്കൾ
യഥാർത്ഥത്തിൽ എഡിറ്റിംഗിലൂടെ അവരുടെ ജോലി ചെയ്യുക ns-3 തന്നെ, അതിനാൽ പുനർനിർമ്മിക്കുന്നതിന് ചുറ്റും സോഴ്സ് കോഡ് ഉണ്ട്
ലൈബ്രറികൾ ഉപയോഗപ്രദമാണ്. ആരെങ്കിലും മുൻകൂട്ടി നിർമ്മിച്ച ജോലി ഏറ്റെടുക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കായുള്ള ലൈബ്രറികളും പാക്കേജുകളും, ദയവായി ns-developers മെയിലിംഗുമായി ബന്ധപ്പെടുക
പട്ടിക.

ഇനിപ്പറയുന്നതിൽ, ഡൗൺലോഡ് ചെയ്യുന്നതിനും നിർമ്മിക്കുന്നതിനുമുള്ള രണ്ട് വഴികൾ ഞങ്ങൾ നോക്കാം ns-3. ആദ്യത്തേത്
പ്രധാന വെബ്‌സൈറ്റിൽ നിന്ന് ഒരു ഔദ്യോഗിക റിലീസ് ഡൗൺലോഡ് ചെയ്യാനും നിർമ്മിക്കാനും. രണ്ടാമത്തേത് കൊണ്ടുവരിക എന്നതാണ്
കൂടാതെ വികസന പകർപ്പുകൾ നിർമ്മിക്കുക ns-3. ടൂളുകൾ മുതൽ ഞങ്ങൾ രണ്ട് ഉദാഹരണങ്ങളിലൂടെയും നടക്കും
ഉൾപ്പെട്ടിരിക്കുന്നത് അല്പം വ്യത്യസ്തമാണ്.

ഡൗൺലോഡുചെയ്യുന്നു ns-3
ദി ns-3 സിസ്റ്റം മൊത്തത്തിൽ വളരെ സങ്കീർണ്ണമായ ഒരു സംവിധാനമാണ്, കൂടാതെ നിരവധി ആശ്രിതത്വങ്ങളുമുണ്ട്
മറ്റ് ഘടകങ്ങൾ. സിസ്റ്റങ്ങൾക്കൊപ്പം നിങ്ങൾ മിക്കവാറും എല്ലാ ദിവസവും കൈകാര്യം ചെയ്യും (ദി
GNU ടൂൾചെയിൻ, മെർക്കുറിയൽ, ഒരു ടെക്സ്റ്റ് എഡിറ്റർ) നിങ്ങൾ ഒരു എണ്ണം ഉറപ്പാക്കേണ്ടതുണ്ട്
തുടരുന്നതിന് മുമ്പ് നിങ്ങളുടെ സിസ്റ്റത്തിൽ അധിക ലൈബ്രറികൾ ഉണ്ട്. ns-3 ഒരു വിക്കി നൽകുന്നു
ഉപയോഗപ്രദമായ നിരവധി സൂചനകളും നുറുങ്ങുകളും ഉള്ള പേജുകൾ ഉൾക്കൊള്ളുന്ന പേജ്. അത്തരത്തിലുള്ള ഒരു പേജാണ്
"ഇൻസ്റ്റലേഷൻ" പേജ്, http://www.nsnam.org/wiki/Installation.

ഈ വിക്കി താളിലെ "മുൻആവശ്യങ്ങൾ" എന്ന ഭാഗം ഏത് പാക്കേജുകളാണ് ആവശ്യമെന്ന് വിശദീകരിക്കുന്നു
പൊതുവായ പിന്തുണ ns-3 ഓപ്ഷനുകൾ, കൂടാതെ അവ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഉപയോഗിക്കുന്ന കമാൻഡുകളും നൽകുന്നു
സാധാരണ Linux വകഭേദങ്ങൾ. Cygwin ഉപയോക്താക്കൾക്ക് Cygwin ഇൻസ്റ്റാളർ ഉപയോഗിക്കേണ്ടി വരും (നിങ്ങളാണെങ്കിൽ a
Cygwin ഉപയോക്താവ്, Cygwin ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങൾ ഇത് ഉപയോഗിച്ചു).

പര്യവേക്ഷണം ചെയ്യാൻ നിങ്ങൾ ഈ അവസരം ഉപയോഗിക്കാൻ ആഗ്രഹിച്ചേക്കാം ns-3 ശരിക്കും ഉള്ളതിനാൽ വിക്കി അൽപ്പം
അവിടെയുള്ള വിവരങ്ങളുടെ ഒരു സമ്പത്ത്.

ഈ ഘട്ടം മുതൽ, വായനക്കാരൻ ലിനക്സിൽ അല്ലെങ്കിൽ എയിൽ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഞങ്ങൾ അനുമാനിക്കാൻ പോകുന്നു
ലിനക്സ് എമുലേഷൻ എൻവയോൺമെന്റ് (ലിനക്സ്, സിഗ്വിൻ മുതലായവ) കൂടാതെ ഗ്നു ടൂൾചെയിൻ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്.
മുകളിൽ സൂചിപ്പിച്ച മുൻവ്യവസ്ഥകൾക്കൊപ്പം പരിശോധിച്ചു. ഞങ്ങളും അത് അനുമാനിക്കാൻ പോകുന്നു
നിങ്ങൾ മെർക്കുറിയലും വാഫും ഇൻസ്റ്റാൾ ചെയ്യുകയും ടാർഗെറ്റ് സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുകയും ചെയ്തിട്ടുണ്ട്.

ദി ns-3 സെർവറിലെ മെർക്കുറിയൽ റിപ്പോസിറ്ററികളിൽ കോഡ് ലഭ്യമാണ് http://code.nsnam.org.
നിങ്ങൾക്ക് ഇവിടെ ഒരു ടാർബോൾ റിലീസ് ഡൗൺലോഡ് ചെയ്യാനും കഴിയും http://www.nsnam.org/release/, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ജോലി ചെയ്യാം
മെർക്കുറിയൽ ഉപയോഗിച്ച് റിപ്പോസിറ്ററികൾക്കൊപ്പം. മെർക്കുറിയൽ നല്ലതല്ലെങ്കിൽ ഉപയോഗിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു
അല്ല എന്നതിന്റെ കാരണം. ഒരു ടാർബോൾ എങ്ങനെ നേടാം എന്നതിനെക്കുറിച്ചുള്ള നിർദ്ദേശങ്ങൾക്കായി ഈ വിഭാഗത്തിന്റെ അവസാനം കാണുക
റിലീസ്.

മെർക്കുറിയൽ റിപ്പോസിറ്ററികൾ ഉപയോഗിച്ച് ആരംഭിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഉപയോഗിക്കുക എന്നതാണ് ns-3-അലിനോൺ
പരിസ്ഥിതി. ഡൗൺലോഡ് ചെയ്യുന്നതും നിർമ്മിക്കുന്നതും നിയന്ത്രിക്കുന്ന സ്ക്രിപ്റ്റുകളുടെ ഒരു കൂട്ടമാണിത്
വിവിധ ഉപസിസ്റ്റങ്ങൾ ns-3 നിനക്കായ്. നിങ്ങളുടേത് ആരംഭിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു ns-3 ഇതിൽ പ്രവർത്തിക്കുക
പരിസ്ഥിതി.

എന്ന പേരിൽ ഒരു ഡയറക്‌ടറി സൃഷ്‌ടിക്കുക എന്നതാണ് ഒരു രീതി വർക്ക്‌സ്‌പെയ്‌സ് ഒരാളുടെ ഹോം ഡയറക്‌ടറിയിൽ
ഒരാൾക്ക് പ്രാദേശിക മെർക്കുറിയൽ ശേഖരങ്ങൾ സൂക്ഷിക്കാൻ കഴിയും. ഏത് ഡയറക്ടറി നാമവും ചെയ്യും, പക്ഷേ ഞങ്ങൾ അനുമാനിക്കും
ആ വർക്ക്‌സ്‌പെയ്‌സ് ഇവിടെ ഉപയോഗിക്കുന്നത് (ശ്രദ്ധിക്കുക: ബാക്കി ചില ഡോക്യുമെന്റേഷനുകളിലും ഒരു ആയി ഉപയോഗിക്കാം
ഉദാഹരണ ഡയറക്ടറിയുടെ പേര്).

ഡൗൺലോഡുചെയ്യുന്നു ns-3 ഉപയോഗിക്കുന്നു a ടാർബോൾ
ഒന്നിലധികം ഫയലുകൾ ബണ്ടിൽ ചെയ്‌തിരിക്കുന്ന സോഫ്റ്റ്‌വെയർ ആർക്കൈവിന്റെ ഒരു പ്രത്യേക ഫോർമാറ്റാണ് ടാർബോൾ
ഒരുമിച്ച്, ആർക്കൈവ് കംപ്രസ് ചെയ്തിരിക്കാം. ns-3 സോഫ്‌റ്റ്‌വെയർ റിലീസുകൾ എ വഴിയാണ് നൽകുന്നത്
ഡൗൺലോഡ് ചെയ്യാവുന്ന ടാർബോൾ. ഡൗൺലോഡ് ചെയ്യുന്നതിനുള്ള നടപടിക്രമം ns-3 ടാർബോൾ വഴി ലളിതമാണ്; നിങ്ങൾ വെറുതെ
ഒരു റിലീസ് തിരഞ്ഞെടുത്ത് അത് ഡൗൺലോഡ് ചെയ്ത് ഡീകംപ്രസ് ചെയ്യണം.

ഒരു ഉപയോക്താവെന്ന നിലയിൽ നിങ്ങൾ നിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്നുവെന്ന് കരുതുക ns-3 എന്ന ഒരു പ്രാദേശിക ഡയറക്ടറിയിൽ
വർക്ക്‌സ്‌പെയ്‌സ്. നിങ്ങൾ ദത്തെടുക്കുകയാണെങ്കിൽ വർക്ക്‌സ്‌പെയ്‌സ് ഡയറക്ടറി സമീപനം, നിങ്ങൾക്ക് ഒരു റിലീസിന്റെ ഒരു പകർപ്പ് ലഭിക്കും
നിങ്ങളുടെ Linux ഷെല്ലിൽ ഇനിപ്പറയുന്നവ ടൈപ്പ് ചെയ്തുകൊണ്ട് (അനുയോജ്യമായ പതിപ്പ് നമ്പറുകൾ പകരം വയ്ക്കുക,
തീർച്ചയായും):

$ സിഡി
$ mkdir ജോലിസ്ഥലം
$ cd ജോലിസ്ഥലം
$ wget http://www.nsnam.org/release/ns-allinone-3.22.tar.bz2
$ tar xjf ns-allinone-3.22.tar.bz2

നിങ്ങൾ ഡയറക്ടറിയിലേക്ക് മാറുകയാണെങ്കിൽ എൻഎസ്-അല്ലിനോൺ-3.22 നിങ്ങൾ നിരവധി ഫയലുകൾ കാണണം:

s ls
ബേക്ക് കോൺസ്റ്റന്റ്സ്.py ns-3.22 README
build.py netanim-3.105 pybindgen-0.16.0.886 util.py

നിങ്ങൾ ഇപ്പോൾ അടിസ്ഥാനം നിർമ്മിക്കാൻ തയ്യാറാണ് ns-3 വിതരണ.

ഡൗൺലോഡുചെയ്യുന്നു ns-3 ഉപയോഗിക്കുന്നു ചുടേണം
വിതരണം ചെയ്ത സംയോജനത്തിനും നിർമ്മാണത്തിനുമുള്ള ഒരു ഉപകരണമാണ് ബേക്ക്, വികസിപ്പിച്ചെടുത്തത് ns-3 പ്രോജക്ട്.
ന്റെ വികസന പതിപ്പുകൾ ലഭ്യമാക്കാൻ ബേക്ക് ഉപയോഗിക്കാം ns-3 സോഫ്റ്റ്‌വെയർ, ഒപ്പം ഡൗൺലോഡ് ചെയ്യാനും
അടിത്തറയിലേക്ക് വിപുലീകരണങ്ങൾ നിർമ്മിക്കുക ns-3 ഡയറക്ട് കോഡ് എക്സിക്യൂഷൻ പോലുള്ള വിതരണം
പരിസ്ഥിതി, നെറ്റ്‌വർക്ക് സിമുലേഷൻ ക്രാഡിൽ, പുതിയ പൈത്തൺ ബൈൻഡിംഗുകൾ സൃഷ്ടിക്കാനുള്ള കഴിവ് എന്നിവയും മറ്റുള്ളവയും.

സമീപകാലത്ത് ns-3 റിലീസുകൾ, ബേക്ക് റിലീസ് ടാർബോളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. കോൺഫിഗറേഷൻ
റിലീസ് ചെയ്ത പതിപ്പിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഫയൽ, നിലവിലുള്ള ഏത് സോഫ്റ്റ്‌വെയറും ഡൗൺലോഡ് ചെയ്യാൻ ഒരാളെ അനുവദിക്കും
റിലീസ് സമയത്ത് നിലവിലുള്ളത്. അതായത്, ഉദാഹരണത്തിന്, ബേക്കിന്റെ പതിപ്പ്
കൂടെ വിതരണം ചെയ്തു ns-3.21 അതിനുള്ള ഘടകങ്ങൾ ലഭ്യമാക്കാൻ റിലീസ് ഉപയോഗിക്കാം ns-3 റിലീസ്
അല്ലെങ്കിൽ നേരത്തെ, എന്നാൽ പിന്നീടുള്ള റിലീസുകൾക്കായി ഘടകങ്ങൾ ലഭ്യമാക്കാൻ ഉപയോഗിക്കാനാവില്ല (അല്ലാതെ
bakeconf.xml ഫയൽ അപ്ഡേറ്റ് ചെയ്തു).

ഇതിന്റെ ഏറ്റവും പുതിയ പകർപ്പും നിങ്ങൾക്ക് ലഭിക്കും ചുടേണം ഇനിപ്പറയുന്നവ നിങ്ങളുടെ Linux-ൽ ടൈപ്പ് ചെയ്തുകൊണ്ട്
ഷെൽ (നിങ്ങൾ മെർക്കുറിയൽ ഇൻസ്റ്റാൾ ചെയ്തുവെന്ന് കരുതുക):

$ സിഡി
$ mkdir ജോലിസ്ഥലം
$ cd ജോലിസ്ഥലം
$ എച്ച്ജി ക്ലോൺ http://code.nsnam.org/bake

hg (Mercurial) കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ഇനിപ്പറയുന്നതുപോലുള്ള ഒന്ന് നിങ്ങൾ കാണും
പ്രദർശിപ്പിച്ചു,

...
ലക്ഷ്യസ്ഥാന ഡയറക്ടറി: ചുടേണം
എല്ലാ മാറ്റങ്ങളും അഭ്യർത്ഥിക്കുന്നു
മാറ്റങ്ങൾ ചേർക്കുന്നു
മാനിഫെസ്റ്റുകൾ ചേർക്കുന്നു
ഫയൽ മാറ്റങ്ങൾ ചേർക്കുന്നു
339 ഫയലുകളിലേക്ക് 796 മാറ്റങ്ങളോടെ 63 മാറ്റങ്ങൾ ചേർത്തു
ബ്രാഞ്ച് ഡിഫോൾട്ടിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുന്നു
45 ഫയലുകൾ അപ്‌ഡേറ്റുചെയ്‌തു, 0 ഫയലുകൾ ലയിപ്പിച്ചു, 0 ഫയലുകൾ നീക്കം ചെയ്‌തു, 0 ഫയലുകൾ പരിഹരിക്കപ്പെട്ടിട്ടില്ല

ക്ലോൺ കമാൻഡ് പൂർത്തിയായ ശേഷം, നിങ്ങൾക്ക് ഒരു ഡയറക്‌ടറി ഉണ്ടായിരിക്കണം ചുടേണം, ഉള്ളടക്കം
ഇവയിൽ ഇനിപ്പറയുന്നത് പോലെ ഒന്ന് കാണണം:

s ls
bakeconf.xml ഡോക് ജനറേറ്റ്-ബൈനറി.പി ടോഡോ ബേക്ക് ചെയ്യുക
bake.py ഉദാഹരണ പരിശോധന

നിങ്ങൾ ശരിക്കും ചില പൈത്തൺ സ്ക്രിപ്റ്റുകളും ഒരു പൈത്തൺ മൊഡ്യൂളും ഡൗൺലോഡ് ചെയ്‌തുവെന്ന് ശ്രദ്ധിക്കുക
ചുടേണം. ഡൗൺലോഡ് ചെയ്യാനും നിർമ്മിക്കാനും ആ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കുക എന്നതാണ് അടുത്ത ഘട്ടം ns-3
നിങ്ങൾക്ക് ഇഷ്ടമുള്ള വിതരണം.

കുറച്ച് കോൺഫിഗറേഷൻ ലക്ഷ്യങ്ങൾ ലഭ്യമാണ്:

1. ns-3.22: റിലീസിന് അനുയോജ്യമായ മൊഡ്യൂൾ; ഇത് സമാനമായ ഘടകങ്ങൾ ഡൗൺലോഡ് ചെയ്യും
റിലീസ് ടാർബോളിലേക്ക്.

2. ns-3-dev: സമാനമായ മൊഡ്യൂൾ എന്നാൽ ഡെവലപ്‌മെന്റ് കോഡ് ട്രീ ഉപയോഗിക്കുന്നു

3. എൻഎസ്-അല്ലിനോൺ-3.22: ക്ലിക്ക് പോലുള്ള മറ്റ് ഓപ്ഷണൽ ഫീച്ചറുകൾ ഉൾക്കൊള്ളുന്ന മൊഡ്യൂൾ
റൂട്ടിംഗ്, ഓപ്പൺഫ്ലോ ns-3, കൂടാതെ നെറ്റ്‌വർക്ക് സിമുലേഷൻ ക്രാഡിൽ

4. ns-3-അലിനോൺ: അല്ലിനോൺ മൊഡ്യൂളിന്റെ റിലീസ് പതിപ്പിന് സമാനമാണ്, പക്ഷേ
വികസന കോഡ്.

ന്റെ നിലവിലെ വികസന സ്നാപ്പ്ഷോട്ട് (റിലീസ് ചെയ്യാത്തത്). ns-3 എന്നതിൽ കണ്ടെത്താം
http://code.nsnam.org/ns-3-dev/. ഡെവലപ്പർമാർ ഈ ശേഖരം സൂക്ഷിക്കാൻ ശ്രമിക്കുന്നു
സ്ഥിരതയുള്ള, പ്രവർത്തിക്കുന്ന സംസ്ഥാനങ്ങൾ എന്നാൽ അവ പുറത്തിറക്കാത്ത കോഡുള്ള ഒരു വികസന മേഖലയിലാണ്
നിലവിൽ, അതിനാൽ നിങ്ങൾക്ക് ആവശ്യമില്ലെങ്കിൽ ഔദ്യോഗിക റിലീസിനൊപ്പം തുടരുന്നത് പരിഗണിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
പുതുതായി അവതരിപ്പിച്ച സവിശേഷതകൾ.

റിപ്പോസിറ്ററി ലിസ്റ്റിന്റെ പരിശോധനയിലൂടെ നിങ്ങൾക്ക് കോഡിന്റെ ഏറ്റവും പുതിയ പതിപ്പ് കണ്ടെത്താനാകും
അല്ലെങ്കിൽ പോകുന്നതിലൂടെ "ns-3 റിലീസ്" വെബ് പേജ്, ഏറ്റവും പുതിയ റിലീസ് ലിങ്കിൽ ക്ലിക്ക് ചെയ്യുക.
ഈ ട്യൂട്ടോറിയൽ ഉദാഹരണത്തിൽ ഞങ്ങൾ തുടരും ns-3.22.

ഞങ്ങൾ ഇപ്പോൾ ബേക്ക് ടൂൾ ഉപയോഗിച്ച് വിവിധ കഷണങ്ങൾ വലിച്ചെടുക്കാൻ പോകുന്നു ns-3 നിങ്ങളായിരിക്കും
ഉപയോഗിക്കുന്നത്. ആദ്യം, റണ്ണിംഗ് ബേക്കിനെക്കുറിച്ച് ഞങ്ങൾ ഒരു വാക്ക് പറയും.

ഒരു സോഴ്‌സ് ഡയറക്‌ടറിയിലേക്ക് സോഴ്‌സ് പാക്കേജുകൾ ഡൗൺലോഡ് ചെയ്‌ത് ഇൻസ്റ്റാളുചെയ്യുന്നതിലൂടെയാണ് ബേക്ക് പ്രവർത്തിക്കുന്നത്
ലൈബ്രറികൾ ഒരു ബിൽഡ് ഡയറക്ടറിയിലേക്ക്. ബൈനറി പരാമർശിച്ചുകൊണ്ട് ബേക്ക് പ്രവർത്തിപ്പിക്കാം, എന്നാൽ ഒന്നാണെങ്കിൽ
ഡൗൺലോഡ് ചെയ്‌ത ഡയറക്‌ടറിക്ക് പുറത്ത് നിന്ന് ബേക്ക് പ്രവർത്തിപ്പിക്കാൻ തിരഞ്ഞെടുക്കുന്നു, അത് അഭികാമ്യമാണ്
നിങ്ങളുടെ പാതയിലേക്ക് ചുടേണം, ഇനിപ്പറയുന്നത് പോലെ (ലിനക്സ് ബാഷ് ഷെൽ ഉദാഹരണം). ആദ്യം, മാറ്റുക
'ബേക്ക്' ഡയറക്‌ടറിയിലേക്ക്, തുടർന്ന് ഇനിപ്പറയുന്ന എൻവയോൺമെന്റ് വേരിയബിളുകൾ സജ്ജമാക്കുക

$ കയറ്റുമതി BAKE_HOME=`pwd`
$ കയറ്റുമതി PATH=$PATH:$BAKE_HOME:$BAKE_HOME/build/bin
$ കയറ്റുമതി PYTHONPATH=$PYTHONPATH:$BAKE_HOME:$BAKE_HOME/build/lib

ഇത് bake.py പ്രോഗ്രാമിനെ ഷെല്ലിന്റെ പാതയിലേക്ക് മാറ്റുകയും മറ്റ് പ്രോഗ്രാമുകളെ അനുവദിക്കുകയും ചെയ്യും
ബേക്ക് ഉപയോഗിച്ച് സൃഷ്ടിച്ച എക്സിക്യൂട്ടബിളുകളും ലൈബ്രറികളും കണ്ടെത്തുക. നിരവധി ബേക്ക് ഉപയോഗ കേസുകൾ ഇല്ലെങ്കിലും
പാത്തും പൈത്തോൺപാത്തും മുകളിൽ പറഞ്ഞതുപോലെ സജ്ജീകരിക്കേണ്ടതുണ്ട്, എൻഎസ്-3-അലിനോണിന്റെ പൂർണ്ണമായ ബിൽഡുകൾ (കൂടാതെ
ഓപ്ഷണൽ പാക്കേജുകൾ) സാധാരണ ചെയ്യാറുണ്ട്.

വർക്ക്‌സ്‌പെയ്‌സ് ഡയറക്‌ടറിയിൽ പ്രവേശിച്ച് നിങ്ങളുടെ ഷെല്ലിൽ ഇനിപ്പറയുന്നവ ടൈപ്പ് ചെയ്യുക:

$ ./bake.py കോൺഫിഗർ -e ns-3.22

അടുത്തതായി, വിവിധ ഘടകങ്ങൾ ഡൗൺലോഡ് ചെയ്യാൻ ആവശ്യമായ ടൂളുകൾ ഞങ്ങളുടെ പക്കലുണ്ടോ എന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ ബേക്കിനോട് ആവശ്യപ്പെടും.
തരം:

$ ./bake.py ചെക്ക്

ഇനിപ്പറയുന്നതുപോലുള്ള ഒന്ന് നിങ്ങൾ കാണണം,

> പൈത്തൺ - ശരി
> ഗ്നു സി++ കമ്പൈലർ - ശരി
> മെർക്കുറിയൽ - ശരി
> CVS - ശരി
> GIT - ശരി
> ബസാർ - ശരി
> ടാർ ടൂൾ - ശരി
> അൺസിപ്പ് ടൂൾ - ശരി
> Unrar ടൂൾ - കാണുന്നില്ല
> 7z ഡാറ്റ കംപ്രഷൻ യൂട്ടിലിറ്റി - ശരി
> XZ ഡാറ്റ കംപ്രഷൻ യൂട്ടിലിറ്റി - ശരി
> ഉണ്ടാക്കുക - ശരി
> cMake - ശരി
> പാച്ച് ടൂൾ - ശരി
> autoreconf ടൂൾ - ശരി

> ടൂളുകൾക്കായി പാത്ത് തിരഞ്ഞു: /usr/lib64/qt-3.3/bin /usr/lib64/ccache
/ usr / local / bin / ബിൻ / usr / bin / usr / local / sbin / usr / sbin / sbin
/home/tomh/bin bin

പ്രത്യേകിച്ചും, മെർക്കുറിയൽ, സിവിഎസ്, ജിഐടി, ബസാർ തുടങ്ങിയ ഡൗൺലോഡ് ടൂളുകളാണ് ഞങ്ങളുടെ പ്രധാനം
ഈ ഘട്ടത്തിൽ ആശങ്കകൾ, കാരണം അവർ കോഡ് ലഭ്യമാക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു. നഷ്‌ടമായി ഇൻസ്റ്റാൾ ചെയ്യുക
ഈ ഘട്ടത്തിലെ ഉപകരണങ്ങൾ, നിങ്ങളുടെ സിസ്റ്റത്തിനായുള്ള സാധാരണ രീതിയിൽ (നിങ്ങൾക്ക് കഴിയുമെങ്കിൽ) അല്ലെങ്കിൽ ബന്ധപ്പെടുക
ഈ ടൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങളുടെ സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർ ആവശ്യമാണ്.

അടുത്തതായി, സോഫ്റ്റ്വെയർ ഡൗൺലോഡ് ചെയ്യാൻ ശ്രമിക്കുക:

$ ./bake.py ഡൗൺലോഡ് ചെയ്യുക

ഇതുപോലുള്ള എന്തെങ്കിലും നൽകണം:

>> സിസ്റ്റം ഡിപൻഡൻസി pygoocanvas-നായി തിരയുന്നു - ശരി
>> സിസ്റ്റം ഡിപൻഡൻസി python-dev-നായി തിരയുന്നു - ശരി
>> സിസ്റ്റം ഡിപൻഡൻസി പൈഗ്രാഫ്വിസിനായി തിരയുന്നു - ശരി
>> pybindgen-0.16.0.886 ഡൗൺലോഡ് ചെയ്യുന്നു - ശരി
>> സിസ്റ്റം ഡിപൻഡൻസി g++ നായി തിരയുന്നു - ശരി
>> സിസ്റ്റം ഡിപൻഡൻസി qt4-നായി തിരയുന്നു - ശരി
>> netanim-3.105 ഡൗൺലോഡ് ചെയ്യുന്നു - ശരി
>> ns-3.22 ഡൗൺലോഡ് ചെയ്യുന്നു - ശരി

മൂന്ന് ഉറവിടങ്ങൾ ഡൗൺലോഡ് ചെയ്‌തതായി മുകളിൽ സൂചിപ്പിച്ചിരിക്കുന്നു. പരിശോധിക്കുക ഉറവിടം ഡയറക്ടറി
ഇപ്പോൾ ടൈപ്പ് ചെയ്യുക ls; ഒന്ന് കാണണം:

s ls
netanim-3.105 ns-3.22 pybindgen-0.16.0.886

നിങ്ങൾ ഇപ്പോൾ നിർമ്മിക്കാൻ തയ്യാറാണ് ns-3 വിതരണ.

കെട്ടിടം ns-3
കെട്ടിടം കൂടെ build.py
റിലീസ് ചെയ്ത ടാർബോളിൽ നിന്ന് പ്രവർത്തിക്കുമ്പോൾ, നിങ്ങൾ ആദ്യമായി നിർമ്മിക്കുന്നത് ns-3 നിങ്ങൾക്ക് കഴിയുന്ന പദ്ധതി
എന്നതിൽ കാണുന്ന ഒരു സൗകര്യപ്രദമായ പ്രോഗ്രാം ഉപയോഗിച്ച് നിർമ്മിക്കുക എല്ലാംകൂടി ഒന്നിൽ ഡയറക്ടറി. ഈ പ്രോഗ്രാമിനെ വിളിക്കുന്നു
build.py. ഈ പ്രോഗ്രാം നിങ്ങൾക്കായി ഏറ്റവും സാധാരണയായി കോൺഫിഗർ ചെയ്ത പ്രോജക്റ്റ് ലഭിക്കും
ഉപയോഗപ്രദമായ വഴി. എന്നിരുന്നാലും, കൂടുതൽ വിപുലമായ കോൺഫിഗറേഷനും പ്രവർത്തിക്കുന്നതും ശ്രദ്ധിക്കുക ns-3 ഉദ്ദേശിക്കുന്ന
സാധാരണഗതിയിൽ സ്വദേശി ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു ns-3 ബിൽഡ് സിസ്റ്റം, വാഫ്, ഇതിൽ പിന്നീട് അവതരിപ്പിക്കും
ട്യൂട്ടോറിയൽ.

നിങ്ങൾ ഒരു ടാർബോൾ ഉപയോഗിച്ചാണ് ഡൗൺലോഡ് ചെയ്‌തതെങ്കിൽ, നിങ്ങൾക്ക് ഇതുപോലൊരു ഡയറക്‌ടറി ഉണ്ടായിരിക്കണം
എൻഎസ്-അല്ലിനോൺ-3.22 നിങ്ങളുടെ കീഴിൽ ~/ജോലിസ്ഥലം ഡയറക്ടറി. ഇനിപ്പറയുന്നവ ടൈപ്പ് ചെയ്യുക:

$ ./build.py --enable-examples --enable-tests

ഈ ട്യൂട്ടോറിയലിൽ ഞങ്ങൾ ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും ഉപയോഗിച്ചാണ് പ്രവർത്തിക്കുന്നത്, അവ അല്ലാത്തതിനാൽ
സ്ഥിരസ്ഥിതിയായി നിർമ്മിച്ചത് ns-3, build.py എന്നതിനായുള്ള വാദങ്ങൾ നമുക്കായി അവ നിർമ്മിക്കാൻ പറയുന്നു. ദി
ലഭ്യമായ എല്ലാ മൊഡ്യൂളുകളും നിർമ്മിക്കുന്നതിലും പ്രോഗ്രാം ഡിഫോൾട്ടാണ്. പിന്നീട്, നിങ്ങൾക്ക് നിർമ്മിക്കാം ns-3
ഉദാഹരണങ്ങളും പരിശോധനകളും ഇല്ലാതെ, അല്ലെങ്കിൽ നിങ്ങളുടെ ജോലിക്ക് ആവശ്യമില്ലാത്ത മൊഡ്യൂളുകൾ ഇല്ലാതാക്കുക,
നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ.

ബിൽഡ് സ്‌ക്രിപ്റ്റ് ബിൽഡ് ചെയ്യുമ്പോൾ ധാരാളം സാധാരണ കംപൈലർ ഔട്ട്‌പുട്ട് സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കുന്നത് നിങ്ങൾ കാണും
നിങ്ങൾ ഡൗൺലോഡ് ചെയ്ത വിവിധ ഭാഗങ്ങൾ. ഒടുവിൽ നിങ്ങൾ ഇനിപ്പറയുന്നവ കാണണം:

വാഫ്: ഡയറക്ടറി വിടുന്നു `/path/to/workspace/ns-allinone-3.22/ns-3.22/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയാക്കി (6മി.25.032സെ)

മൊഡ്യൂളുകൾ നിർമ്മിച്ചിരിക്കുന്നത്:
ആന്റിന aodv ആപ്ലിക്കേഷനുകൾ
പാലം കെട്ടിടങ്ങൾ കോൺഫിഗറേഷൻ-സ്റ്റോർ
കോർ csma csma-ലേഔട്ട്
dsdv dsr ഊർജ്ജം
fd-net-device flow-monitor internet
lr-wpan lte മെഷ്
മൊബിലിറ്റി എംപിഐ നെറ്റാനിം (പൈത്തൺ ഇല്ല)
നെറ്റ്വർക്ക് നിക്സ്-വെക്റ്റർ-റൂട്ടിംഗ് ഒഎൽഎസ്ആർ
പോയിന്റ്-ടു-പോയിന്റ് പോയിന്റ്-ടു-പോയിന്റ്-ലേഔട്ട് പ്രചരണം
ആറ് ലോപാൻ സ്പെക്ട്രം സ്ഥിതിവിവരക്കണക്കുകൾ
ടാപ്പ്-ബ്രിഡ്ജ് ടെസ്റ്റ് (പൈത്തൺ ഇല്ല) ടോപ്പോളജി-വായന
uan വെർച്വൽ-നെറ്റ്-ഡിവൈസ് വേവ്
വൈഫൈ wimax

മൊഡ്യൂളുകൾ നിർമ്മിച്ചിട്ടില്ല (വിശദീകരണത്തിന് ns-3 ട്യൂട്ടോറിയൽ കാണുക):
brite ക്ലിക്ക് openflow
വിഷ്വലൈസർ

ഡയറക്‌ടറി വിടുന്നു `./ns-3.22'

നിർമ്മിക്കാത്ത മൊഡ്യൂളുകളെ കുറിച്ചുള്ള ഭാഗത്തെ സംബന്ധിച്ച്:

മൊഡ്യൂളുകൾ നിർമ്മിച്ചിട്ടില്ല (വിശദീകരണത്തിന് ns-3 ട്യൂട്ടോറിയൽ കാണുക):
brite ക്ലിക്ക് openflow
വിഷ്വലൈസർ

ഇതിനർത്ഥം ചിലത് എന്ന് മാത്രം ns-3 പുറത്തുള്ള ലൈബ്രറികളെ ആശ്രയിക്കുന്ന മൊഡ്യൂളുകൾ പാടില്ല
നിർമ്മിച്ചിട്ടുണ്ട്, അല്ലെങ്കിൽ കോൺഫിഗറേഷൻ അവ നിർമ്മിക്കരുതെന്ന് പ്രത്യേകം ആവശ്യപ്പെട്ടിട്ടുണ്ട്. അത് ചെയ്യുന്നു
സിമുലേറ്റർ വിജയകരമായി നിർമ്മിച്ചില്ല എന്നോ അത് തെറ്റായി നൽകുമെന്നോ അർത്ഥമാക്കുന്നില്ല
നിർമ്മിച്ചിരിക്കുന്നതായി ലിസ്റ്റുചെയ്തിരിക്കുന്ന മൊഡ്യൂളുകളുടെ ഫലങ്ങൾ.

കെട്ടിടം കൂടെ ചുടേണം
പ്രോജക്‌റ്റ് ശേഖരണങ്ങളിൽ നിന്ന് സോഴ്‌സ് കോഡ് ലഭിക്കാൻ നിങ്ങൾ മുകളിൽ ബേക്ക് ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് തുടരാം
അത് നിർമ്മിക്കാൻ ഉപയോഗിക്കുക ns-3. തരം

$ ./bake.py ബിൽഡ്

കൂടാതെ നിങ്ങൾ ഇതുപോലുള്ള ഒന്ന് കാണണം:

>> ബിൽഡിംഗ് pybindgen-0.16.0.886 - ശരി
>> ബിൽഡിംഗ് netanim-3.105 - ശരി
>> ബിൽഡിംഗ് ns-3.22 - ശരി

സൂചന: നിങ്ങളെ കഴിയും ഇതും നിർവഹിക്കുക രണ്ടും ഘട്ടങ്ങൾ, ഡൗൺലോഡ് ഒപ്പം പണിയുക by വിളിക്കുന്നു 'bake.py വിന്യസിക്കുക'.

ഒരു പരാജയം സംഭവിക്കുകയാണെങ്കിൽ, ഇനിപ്പറയുന്ന കമാൻഡ് എന്താണ് പറയുന്നതെന്ന് ദയവായി നോക്കുക
നിങ്ങൾ; നഷ്‌ടമായ ആശ്രിതത്വത്തെക്കുറിച്ച് ഇത് ഒരു സൂചന നൽകിയേക്കാം:

$ ./bake.py ഷോ

നിങ്ങൾ നിർമ്മിക്കാൻ ശ്രമിക്കുന്ന പാക്കേജുകളുടെ വിവിധ ഡിപൻഡൻസികൾ ഇത് ലിസ്റ്റ് ചെയ്യും.

കെട്ടിടം കൂടെ വഫ്
ഈ സമയം വരെ, ഞങ്ങൾ ഒന്നുകിൽ ഉപയോഗിച്ചു build.py സ്ക്രിപ്റ്റ്, അല്ലെങ്കിൽ ചുടേണം ഉപകരണം, ലഭിക്കാൻ
കെട്ടിടത്തിൽ തുടങ്ങി ns-3. ഈ ഉപകരണങ്ങൾ നിർമ്മാണത്തിന് ഉപയോഗപ്രദമാണ് ns-3 പിന്തുണയ്ക്കുകയും ചെയ്യുന്നു
ലൈബ്രറികൾ, അവർ അകത്തേക്ക് വിളിക്കുന്നു ns-3 വാഫ് ബിൽഡ് ടൂളിനെ വിളിക്കാനുള്ള ഡയറക്ടറി
യഥാർത്ഥ കെട്ടിടം. മിക്ക ഉപയോക്താക്കളും കോൺഫിഗർ ചെയ്യുന്നതിനായി നേരിട്ട് വാഫ് ഉപയോഗിക്കുന്നതിലേക്ക് വേഗത്തിൽ മാറുന്നു
പണിയുക ns-3. അതിനാൽ, തുടരുന്നതിന്, ദയവായി നിങ്ങളുടെ പ്രവർത്തന ഡയറക്ടറി എന്നതിലേക്ക് മാറ്റുക ns-3 ഡയറക്ടറി
നിങ്ങൾ ആദ്യം നിർമ്മിച്ചത്.

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

$ ./വാഫ് ക്ലീൻ
$ ./waf --build-profile=optimized --enable-examples --enable-tests configure

ഇത് ലോക്കൽ ഡയറക്‌ടറിയിൽ നിന്ന് Waf റൺ ചെയ്യുന്നു (ഇത് നിങ്ങൾക്ക് സൗകര്യമായി നൽകിയിരിക്കുന്നു).
മുമ്പത്തെ ബിൽഡ് വൃത്തിയാക്കുന്നതിനുള്ള ആദ്യ കമാൻഡ് സാധാരണയായി കർശനമായി ആവശ്യമില്ല
നല്ല പരിശീലനമാണ് (എന്നാൽ കാണുക പണിയുക പ്രൊഫൈലുകൾ, താഴെ); ഇത് മുമ്പ് നിർമ്മിച്ചവ നീക്കം ചെയ്യും
ഡയറക്ടറിയിൽ കാണുന്ന ലൈബ്രറികളും ഒബ്‌ജക്റ്റ് ഫയലുകളും നിർമ്മിക്കുക/. പദ്ധതി പുനഃക്രമീകരിക്കുമ്പോൾ
കൂടാതെ ബിൽഡ് സിസ്റ്റം വിവിധ ഡിപൻഡൻസികൾക്കായി പരിശോധിക്കുന്നു, നിങ്ങൾ കാണുന്ന ഔട്ട്പുട്ട് കാണും
ഇനിപ്പറയുന്നതിന് സമാനമാണ്:

മുകളിൽ സജ്ജീകരിക്കുന്നു : .
ഇതിനായി സജ്ജീകരിക്കുന്നു: നിർമ്മിക്കുക
'gcc' (c കംപൈലർ) പരിശോധിക്കുന്നു : /usr/bin/gcc
സിസി പതിപ്പ് പരിശോധിക്കുന്നു : 4.2.1
'g++' (c++ കമ്പൈലർ) : /usr/bin/g++ പരിശോധിക്കുന്നു
ബൂസ്റ്റ് പരിശോധിക്കുന്നത് ഉൾപ്പെടുന്നു : 1_46_1
ബൂസ്റ്റ് ലിബുകൾ പരിശോധിക്കുന്നു: ശരി
ബൂസ്റ്റ് ലിങ്കേജ് പരിശോധിക്കുന്നു: ശരി
ക്ലിക്ക് ലൊക്കേഷൻ പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
പ്രോഗ്രാമിനായി പരിശോധിക്കുന്നു pkg-config : /sw/bin/pkg-config
'gtk+-2.0' >= 2.12 പരിശോധിക്കുന്നു : അതെ
'libxml-2.0' >= 2.7 പരിശോധിക്കുന്നു : അതെ
uint128_t തരം പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
തരം __uint128_t പരിശോധിക്കുന്നു : അതെ
ഉയർന്ന കൃത്യതയുള്ള നടപ്പിലാക്കൽ പരിശോധിക്കുന്നു: 128-ബിറ്റ് പൂർണ്ണസംഖ്യ (സ്ഥിരസ്ഥിതി)
തലക്കെട്ട് stdint.h പരിശോധിക്കുന്നു : അതെ
inttypes.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : അതെ
sys/inttypes.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
sys/types.h എന്ന തലക്കെട്ട് പരിശോധിക്കുന്നു : അതെ
sys/stat.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : അതെ
dirent.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : അതെ
തലക്കെട്ട് stdlib.h പരിശോധിക്കുന്നു : അതെ
ഹെഡർ സിഗ്നൽ പരിശോധിക്കുന്നു.h : അതെ
തലക്കെട്ട് pthread.h പരിശോധിക്കുന്നു : അതെ
തലക്കെട്ട് stdint.h പരിശോധിക്കുന്നു : അതെ
inttypes.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : അതെ
sys/inttypes.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
ലൈബ്രറി RT പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
netpacket/packet.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
sys/ioctl.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : അതെ
net/if.h എന്ന തലക്കെട്ട് പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
net/ethernet.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : അതെ
തലക്കെട്ട് linux/if_tun.h പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
netpacket/packet.h എന്ന തലക്കെട്ടിനായി പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
NSC ലൊക്കേഷനായി പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
'mpic++' പരിശോധിക്കുന്നു : അതെ
'sqlite3' പരിശോധിക്കുന്നു: അതെ
തലക്കെട്ട് linux/if_tun.h പരിശോധിക്കുന്നു : കണ്ടെത്തിയില്ല
പ്രോഗ്രാം സുഡോയ്ക്കായി പരിശോധിക്കുന്നു: /usr/bin/sudo
പ്രോഗ്രാം valgrind പരിശോധിക്കുന്നു : /sw/bin/valgrind
'gsl' പരിശോധിക്കുന്നു: അതെ
കംപൈലേഷൻ ഫ്ലാഗിനായി പരിശോധിക്കുന്നു -Wno-error=deprecated-d... പിന്തുണ : ശരി
കംപൈലേഷൻ ഫ്ലാഗിനായി പരിശോധിക്കുന്നു -Wno-error=deprecated-d... പിന്തുണ : ശരി
കംപൈലേഷൻ ഫ്ലാഗ് പരിശോധിക്കുന്നു -fstrict-aliasing... പിന്തുണ : ശരി
കംപൈലേഷൻ ഫ്ലാഗ് പരിശോധിക്കുന്നു -fstrict-aliasing... പിന്തുണ : ശരി
കംപൈലേഷൻ ഫ്ലാഗിനായി പരിശോധിക്കുന്നു -Wstrict-aliasing... support : ok
കംപൈലേഷൻ ഫ്ലാഗിനായി പരിശോധിക്കുന്നു -Wstrict-aliasing... support : ok
പ്രോഗ്രാം doxygen പരിശോധിക്കുന്നു : /usr/local/bin/doxygen
---- ഓപ്ഷണൽ NS-3 സവിശേഷതകളുടെ സംഗ്രഹം:
പ്രൊഫൈൽ നിർമ്മിക്കുക: ഡീബഗ് ചെയ്യുക
ബിൽഡ് ഡയറക്ടറി: ബിൽഡ്
പൈത്തൺ ബൈൻഡിംഗുകൾ: പ്രവർത്തനക്ഷമമാക്കി
BRITE ഏകീകരണം: പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (BRITE പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (ഓപ്ഷൻ കാണുക --with-brite))
NS-3 ക്ലിക്ക് ഇന്റഗ്രേഷൻ : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (nsclick not enabled (ഓപ്ഷൻ കാണുക --with-nsclick))
GtkConfigStore : പ്രവർത്തനക്ഷമമാക്കി
XmlIo: പ്രവർത്തനക്ഷമമാക്കി
ത്രെഡിംഗ് പ്രിമിറ്റീവുകൾ : പ്രവർത്തനക്ഷമമാക്കി
റിയൽ ടൈം സിമുലേറ്റർ: പ്രവർത്തനക്ഷമമാക്കി (librt ലഭ്യമല്ല)
എമുലേറ്റഡ് നെറ്റ് ഉപകരണം: പ്രവർത്തനക്ഷമമാക്കി ( ഉൾപ്പെടുത്തിയിട്ടില്ല)
ഫയൽ ഡിസ്ക്രിപ്റ്റർ NetDevice : പ്രവർത്തനക്ഷമമാക്കി
FdNetDevice ടാപ്പ് ചെയ്യുക : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (linux/if_tun.h ആവശ്യമാണ്)
എമുലേഷൻ FdNetDevice : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (netpacket/packet.h ആവശ്യമാണ്)
PlanetLab FdNetDevice : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (PlanetLab ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കണ്ടെത്തിയില്ല (ഓപ്ഷൻ --force-planetlab കാണുക))
നെറ്റ്‌വർക്ക് സിമുലേഷൻ ക്രാഡിൽ: പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (NSC കണ്ടെത്തിയില്ല (ഓപ്ഷൻ --with-nsc കാണുക))
MPI പിന്തുണ: പ്രവർത്തനക്ഷമമാക്കി
NS-3 ഓപ്പൺഫ്ലോ ഇന്റഗ്രേഷൻ : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (ആവശ്യമായ ബൂസ്റ്റ് ലൈബ്രറികൾ കണ്ടെത്തിയില്ല, കാണുന്നില്ല: സിസ്റ്റം, സിഗ്നലുകൾ, ഫയൽസിസ്റ്റം)
SQlite സ്ഥിതിവിവരക്കണക്കുകളുടെ ഡാറ്റ ഔട്ട്പുട്ട്: പ്രവർത്തനക്ഷമമാക്കി
ടാപ്പ് ബ്രിഡ്ജ്: പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല ( ഉൾപ്പെടുത്തിയിട്ടില്ല)
PyViz വിഷ്വലൈസർ: പ്രവർത്തനക്ഷമമാക്കി
suid ബിറ്റ് സജ്ജമാക്കാൻ sudo ഉപയോഗിക്കുക : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (ഓപ്ഷൻ --enable-sudo തിരഞ്ഞെടുത്തിട്ടില്ല)
ബിൽഡ് ടെസ്റ്റുകൾ: പ്രവർത്തനക്ഷമമാക്കി
ബിൽഡ് ഉദാഹരണങ്ങൾ : പ്രവർത്തനക്ഷമമാക്കി
GNU സയന്റിഫിക് ലൈബ്രറി (GSL) : പ്രവർത്തനക്ഷമമാക്കി
'കോൺഫിഗർ' വിജയകരമായി പൂർത്തിയായി (1.944സെ)

മുകളിലുള്ള ഔട്ട്പുട്ടിന്റെ അവസാന ഭാഗം ശ്രദ്ധിക്കുക. ചിലത് ns-3 ഓപ്‌ഷനുകൾ സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല അല്ലെങ്കിൽ
ശരിയായി പ്രവർത്തിക്കുന്നതിന് അടിസ്ഥാന സിസ്റ്റത്തിൽ നിന്നുള്ള പിന്തുണ ആവശ്യമാണ്. ഉദാഹരണത്തിന്, പ്രവർത്തനക്ഷമമാക്കാൻ
XmlTo, ലൈബ്രറി libxml-2.0 സിസ്റ്റത്തിൽ കണ്ടെത്തണം. ഈ ലൈബ്രറി ഇല്ലായിരുന്നെങ്കിൽ
കണ്ടെത്തി, അനുബന്ധം ns-3 ഫീച്ചർ പ്രവർത്തനക്ഷമമാക്കില്ല, ഒരു സന്ദേശം ആയിരിക്കും
പ്രദർശിപ്പിച്ചിരിക്കുന്നു. പ്രോഗ്രാം ഉപയോഗിക്കുന്നതിന് ഒരു സവിശേഷത ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക സുഡോ suid സജ്ജമാക്കാൻ
ചില പ്രോഗ്രാമുകളുടെ ബിറ്റ്. ഇത് ഡിഫോൾട്ടായി പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല, അതിനാൽ ഈ സവിശേഷത റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നു
"പ്രാപ്തമാക്കിയിട്ടില്ല" എന്ന നിലയിൽ

ഇപ്പോൾ മുന്നോട്ട് പോയി ഉദാഹരണങ്ങളും പരിശോധനകളും ഉൾപ്പെടുന്ന ഡീബഗ് ബിൽഡിലേക്ക് മടങ്ങുക.

$ ./വാഫ് ക്ലീൻ
$ ./waf --build-profile=debug --enable-examples --enable-tests configure

ബിൽഡ് സിസ്റ്റം ഇപ്പോൾ കോൺഫിഗർ ചെയ്‌തു, നിങ്ങൾക്ക് ഇതിന്റെ ഡീബഗ് പതിപ്പുകൾ നിർമ്മിക്കാൻ കഴിയും ns-3
ലളിതമായി ടൈപ്പുചെയ്യുന്നതിലൂടെ പ്രോഗ്രാമുകൾ

$ ./waf

ശരി, ക്ഷമിക്കണം, ഞാൻ നിങ്ങളെ നിർമ്മിക്കാൻ പ്രേരിപ്പിച്ചു ns-3 രണ്ടുതവണ സിസ്റ്റത്തിന്റെ ഭാഗം, എന്നാൽ ഇപ്പോൾ നിങ്ങൾക്കറിയാം
കോൺഫിഗറേഷൻ മാറ്റി ഒപ്റ്റിമൈസ് ചെയ്ത കോഡ് നിർമ്മിക്കുക.

മുകളിൽ ചർച്ച ചെയ്ത build.py സ്ക്രിപ്റ്റ് പിന്തുണയ്ക്കുന്നു --പ്രവർത്തനക്ഷമമാക്കുക-ഉദാഹരണങ്ങൾ ഒപ്പം പ്രവർത്തനക്ഷമമാക്കുക-ടെസ്റ്റുകൾ
ആർഗ്യുമെന്റുകൾ, എന്നാൽ പൊതുവേ, മറ്റ് വാഫ് ഓപ്ഷനുകളെ നേരിട്ട് പിന്തുണയ്ക്കുന്നില്ല; ഉദാഹരണത്തിന്, ഇത്
പ്രവർത്തിക്കില്ല:

$ ./build.py --disable-python

കാരണമാകും

build.py: പിശക്: അത്തരം ഓപ്ഷനുകളൊന്നുമില്ല: --disable-python

എന്നിരുന്നാലും, പ്രത്യേക ഓപ്പറേറ്റർ -- waf-ലേക്ക് അധിക ഓപ്ഷനുകൾ കൈമാറാൻ ഉപയോഗിക്കാം, അങ്ങനെ
മുകളിൽ പറഞ്ഞതിനുപകരം, ഇനിപ്പറയുന്നവ പ്രവർത്തിക്കും:

$ ./build.py -- --disable-python

അത് അടിസ്ഥാനപരമായ കമാൻഡ് സൃഷ്ടിക്കുന്നതിനാൽ ./വാഫ് കോൺഫിഗർ --disable-python.

വാഫിനെ കുറിച്ചുള്ള ചില ആമുഖ നുറുങ്ങുകൾ ഇതാ.

സജ്ജമാക്കുന്നു വേഴ്സസ് പണിയുക
ചില വാഫ് കമാൻഡുകൾ കോൺഫിഗർ ഘട്ടത്തിൽ മാത്രമേ അർത്ഥവത്തായിട്ടുള്ളൂ, ചില കമാൻഡുകൾ അങ്ങനെയാണ്
നിർമ്മാണ ഘട്ടത്തിൽ സാധുവാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾ എമുലേഷൻ സവിശേഷതകൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ns-3, മുകളിൽ വിവരിച്ചതുപോലെ സുഡോ ഉപയോഗിച്ച് സ്യൂഡ് ബിറ്റ് സജ്ജീകരിക്കുന്നത് പ്രവർത്തനക്ഷമമാക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഈ
ഒരു കോൺഫിഗറേഷൻ-ടൈം കമാൻഡ് ആയി മാറുന്നു, അതിനാൽ നിങ്ങൾക്ക് ഇത് ഉപയോഗിച്ച് വീണ്ടും ക്രമീകരിക്കാം
ഇനിപ്പറയുന്ന കമാൻഡ് ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും ഉൾക്കൊള്ളുന്നു.

$ ./waf കോൺഫിഗർ ചെയ്യുക --enable-sudo --enable-examples --enable-tests

നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ, സോക്കറ്റ് ക്രിയേറ്റർ പ്രോഗ്രാമുകൾ മാറ്റാൻ Waf sudo പ്രവർത്തിപ്പിക്കും
റൂട്ടായി പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള എമുലേഷൻ കോഡ്.

Waf-ൽ മറ്റ് നിരവധി കോൺഫിഗർ, ബിൽഡ്-ടൈം ഓപ്ഷനുകൾ ലഭ്യമാണ്. ഇവ പര്യവേക്ഷണം ചെയ്യാൻ
ഓപ്ഷനുകൾ, തരം:

$ ./waf --സഹായം

അടുത്ത വിഭാഗത്തിൽ ഞങ്ങൾ ടെസ്റ്റിംഗുമായി ബന്ധപ്പെട്ട ചില കമാൻഡുകൾ ഉപയോഗിക്കും.

പണിയുക പ്രൊഫൈലുകൾ
നിങ്ങൾക്ക് എങ്ങനെ വാഫ് കോൺഫിഗർ ചെയ്യാമെന്ന് ഞങ്ങൾ ഇതിനകം കണ്ടു ഡീബഗ് or ഒപ്റ്റിമൈസ് ചെയ്തു നിർമ്മിക്കുന്നു:

$ ./waf --build-profile=debug

ഒരു ഇന്റർമീഡിയറ്റ് ബിൽഡ് പ്രൊഫൈലും ഉണ്ട്, റിലീസ്. -d എന്നതിന്റെ പര്യായപദമാണ്
--ബിൽഡ്-പ്രൊഫൈൽ.

സ്വതവേ, Waf ബിൽഡ് ആർട്ടിഫാക്‌റ്റുകൾ ഇതിൽ ഇടുന്നു പണിയുക ഡയറക്ടറി. നിങ്ങൾക്ക് എ വ്യക്തമാക്കാൻ കഴിയും
കൂടെ വ്യത്യസ്ത ഔട്ട്പുട്ട് ഡയറക്ടറി --പുറത്ത് ഓപ്ഷൻ, ഉദാ

$ ./waf കോൺഫിഗർ --out=foo

ബിൽഡ് പ്രൊഫൈലുകളുമായി ഇത് സംയോജിപ്പിക്കുന്നത് വ്യത്യസ്ത കംപൈൽ ഓപ്ഷനുകൾക്കിടയിൽ മാറാൻ നിങ്ങളെ അനുവദിക്കുന്നു
ശുദ്ധമായ രീതിയിൽ:

$ ./waf കോൺഫിഗർ ചെയ്യുക --build-profile=debug --out=build/debug
$ ./waf ബിൽഡ്
...
$ ./waf കോൺഫിഗർ ചെയ്യുക --build-profile=optimized --out=build/optimized
$ ./waf ബിൽഡ്
...

എല്ലായ്‌പ്പോഴും അവസാനത്തേത് തിരുത്തിയെഴുതുന്നതിനുപകരം ഒന്നിലധികം ബിൽഡുകളിൽ പ്രവർത്തിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു
പണിയുക. നിങ്ങൾ സ്വിച്ചുചെയ്യുമ്പോൾ, വീണ്ടും കംപൈൽ ചെയ്യുന്നതിനുപകരം വാഫ് ആവശ്യമുള്ളത് കംപൈൽ ചെയ്യും
എല്ലാം.

നിങ്ങൾ ഇതുപോലുള്ള ബിൽഡ് പ്രൊഫൈലുകൾ മാറുമ്പോൾ, അത് നൽകാൻ നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്
ഓരോ തവണയും കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ. ചില പരിസ്ഥിതി നിർവചിക്കുന്നത് സൗകര്യപ്രദമായിരിക്കും
തെറ്റുകൾ ഒഴിവാക്കാൻ നിങ്ങളെ സഹായിക്കുന്ന വേരിയബിളുകൾ:

$ എക്സ്പോർട്ട് NS3CONFIG="--enable-examples --enable-tests"
$ എക്സ്പോർട്ട് NS3DEBUG="--build-profile=debug --out=build/debug"
$ എക്സ്പോർട്ട് NS3OPT=="--build-profile=optimized --out=build/optimized"

$ ./waf $NS3CONFIG $NS3DEBUG കോൺഫിഗർ ചെയ്യുക
$ ./waf ബിൽഡ്
...
$ ./waf $NS3CONFIG $NS3OPT കോൺഫിഗർ ചെയ്യുക
$ ./waf ബിൽഡ്

കംപൈലറുകൾ
മുകളിലുള്ള ഉദാഹരണങ്ങളിൽ, Waf GCC C++ കമ്പൈലർ ഉപയോഗിക്കുന്നു, g ++, നിർമ്മാണത്തിനായി ns-3. എന്നിരുന്നാലും,
നിർവചിക്കുന്നതിലൂടെ Waf ഉപയോഗിക്കുന്ന C++ കമ്പൈലർ മാറ്റാൻ സാധിക്കും CXX പരിസ്ഥിതി
വേരിയബിൾ. ഉദാഹരണത്തിന്, Clang C++ കമ്പൈലർ ഉപയോഗിക്കുന്നതിന്, clang++,

$ CXX="clang++" ./waf കോൺഫിഗർ ചെയ്യുക
$ ./waf ബിൽഡ്

വിതരണം ചെയ്‌ത സമാഹാരം ചെയ്യാൻ ഒരാൾക്ക് വാഫ് സജ്ജീകരിക്കാനും കഴിയും distcc സമാനമായ രീതിയിൽ:

$ CXX="distcc g++" ./waf കോൺഫിഗർ ചെയ്യുക
$ ./waf ബിൽഡ്

കൂടുതൽ വിവരങ്ങൾ distcc വിതരണം ചെയ്ത സമാഹാരം അതിൽ കാണാം പദ്ധതി പേജ് കീഴെ
ഡോക്യുമെന്റേഷൻ വിഭാഗം.

ഇൻസ്റ്റോൾ
സിസ്റ്റത്തിൽ വിവിധ സ്ഥലങ്ങളിൽ ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ വാഫ് ഉപയോഗിക്കാം. സ്ഥിരസ്ഥിതി
ലൈബ്രറികളും എക്സിക്യൂട്ടബിളുകളും നിർമ്മിച്ചിരിക്കുന്ന സ്ഥലം പണിയുക ഡയറക്ടറി, കാരണം
ഈ ലൈബ്രറികളുടെയും എക്സിക്യൂട്ടബിളുകളുടെയും സ്ഥാനം വാഫിന് അറിയാം, അത് ഇൻസ്റ്റാൾ ചെയ്യേണ്ട ആവശ്യമില്ല
മറ്റിടങ്ങളിലെ ലൈബ്രറികൾ.

ബിൽഡ് ഡയറക്‌ടറിക്ക് പുറത്ത് കാര്യങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഉപയോക്താക്കൾ തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, ഉപയോക്താക്കൾ ഇത് നൽകിയേക്കാം
./വാഫ് ഇൻസ്റ്റാൾ ചെയ്യുക കമാൻഡ്. സ്ഥിരസ്ഥിതിയായി, ഇൻസ്റ്റലേഷനുള്ള പ്രിഫിക്സ് ആണ് / usr / local, അങ്ങനെ ./വാഫ്
ഇൻസ്റ്റാൾ ചെയ്യുക എന്നതിലേക്ക് പ്രോഗ്രാമുകൾ ഇൻസ്റ്റാൾ ചെയ്യും / usr / local / bin, ലൈബ്രറികൾ / usr / local / lib, ഒപ്പം
തലക്കെട്ടുകൾ /usr/local/ഉൾപ്പെടുത്തുക. ഇൻസ്റ്റാൾ ചെയ്യാൻ സൂപ്പർ യൂസർ പ്രത്യേകാവകാശങ്ങൾ ആവശ്യമാണ്
ഡിഫോൾട്ട് പ്രിഫിക്സ്, അതിനാൽ സാധാരണ കമാൻഡ് ആയിരിക്കും സുഡോ ./വാഫ് ഇൻസ്റ്റാൾ ചെയ്യുക. ഓടുമ്പോൾ
Waf ഉള്ള പ്രോഗ്രാമുകൾ, Waf ആദ്യം ബിൽഡ് ഡയറക്ടറിയിൽ പങ്കിട്ട ലൈബ്രറികൾ ഉപയോഗിക്കാൻ താൽപ്പര്യപ്പെടുന്നു,
തുടർന്ന് പ്രാദേശിക പരിതസ്ഥിതിയിൽ ക്രമീകരിച്ച ലൈബ്രറി പാതയിലെ ലൈബ്രറികൾക്കായി തിരയും. അങ്ങനെ
സിസ്റ്റത്തിലേക്ക് ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ, ഉദ്ദേശിക്കുന്നത് പരിശോധിക്കുന്നത് നല്ലതാണ്
ലൈബ്രറികൾ ഉപയോഗിക്കുന്നു.

ഉപയോക്താക്കൾക്ക് മറ്റൊരു പ്രിഫിക്സിലേക്ക് ഇൻസ്റ്റാൾ ചെയ്യാൻ തിരഞ്ഞെടുത്തേക്കാം --പ്രിഫിക്സ് ഓപ്ഷൻ
സമയം ക്രമീകരിക്കുക, ഉദാഹരണത്തിന്:

./waf കോൺഫിഗർ ചെയ്യുക --prefix=/opt/local

ബിൽഡിന് ശേഷം പിന്നീട് ഉപയോക്താവ് പ്രശ്നം നൽകുന്നു ./വാഫ് ഇൻസ്റ്റാൾ ചെയ്യുക കമാൻഡ്, പ്രിഫിക്സ് /ഓപ്റ്റ്/ലോക്കൽ
ഉപയോഗിക്കും.

ദി ./വാഫ് വെടിപ്പുള്ള Waf ആണെങ്കിൽ പ്രൊജക്റ്റ് പുനഃക്രമീകരിക്കുന്നതിന് മുമ്പ് കമാൻഡ് ഉപയോഗിക്കണം
മറ്റൊരു പ്രിഫിക്സിൽ കാര്യങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഉപയോഗിക്കുന്നു.

ചുരുക്കത്തിൽ, വിളിക്കേണ്ട ആവശ്യമില്ല ./വാഫ് ഇൻസ്റ്റാൾ ചെയ്യുക ഉപയോഗിക്കാൻ ns-3. മിക്ക ഉപയോക്താക്കളും അങ്ങനെ ചെയ്യില്ല
വാഫ് നിലവിലെ ലൈബ്രറികൾ എടുക്കുന്നതിനാൽ ഈ കമാൻഡ് ആവശ്യമാണ് പണിയുക ഡയറക്ടറി,
എന്നാൽ ചില ഉപയോക്താക്കൾ അവരുടെ ഉപയോഗ കേസിൽ പുറത്തുള്ള പ്രോഗ്രാമുകളിൽ പ്രവർത്തിക്കുന്നത് ഉൾപ്പെട്ടാൽ അത് ഉപയോഗപ്രദമാകും
എന്ന ns-3 ഡയറക്ടറി.

ഒന്ന് വഫ്
ഒരു വഫ് സ്ക്രിപ്റ്റ് മാത്രമേ ഉള്ളൂ, മുകളിലെ തലത്തിൽ ns-3 ഉറവിട വൃക്ഷം. നിങ്ങൾ ജോലി ചെയ്യുമ്പോൾ, നിങ്ങൾ
നിങ്ങൾ ധാരാളം സമയം ചെലവഴിക്കുന്നതായി കണ്ടെത്തിയേക്കാം പോറൽ/, അല്ലെങ്കിൽ ആഴത്തിൽ src/..., ഒപ്പം ആവശ്യമാണ്
വഫിനെ വിളിക്കുക. നിങ്ങൾ എവിടെയാണെന്ന് ഓർക്കുകയും വാഫിനെ ഇതുപോലെ വിളിക്കുകയും ചെയ്യാം:

$ ../../../waf ...

എന്നാൽ അത് മടുപ്പിക്കുന്നതും പിശക് സാധ്യതയുള്ളതുമാണ്, കൂടാതെ മികച്ച പരിഹാരങ്ങളുമുണ്ട്.

നിങ്ങൾക്ക് മുഴുവൻ ഉണ്ടെങ്കിൽ ns-3 ഈ ചെറിയ രത്നം ഒരു തുടക്കമാണ് ശേഖരം:

$ cd $(hg റൂട്ട്) && ./waf ...

ഇതിലും മികച്ചത് ഇതൊരു ഷെൽ ഫംഗ്‌ഷനായി നിർവ്വചിക്കുന്നതാണ്:

$ ഫംഗ്ഷൻ വാഫ് { cd $(hg റൂട്ട്) && ./waf $* ; }

$ വാഫ് ബിൽഡ്

നിങ്ങൾക്ക് ടാർബോൾ മാത്രമേ ഉള്ളൂവെങ്കിൽ, ഒരു പരിസ്ഥിതി വേരിയബിളിന് സഹായിക്കാനാകും:

$ എക്സ്പോർട്ട് NS3DIR="$PWD"
$ ഫംഗ്ഷൻ വാഫ് { cd $NS3DIR && ./waf $* ; }

$ cd സ്ക്രാച്ച്
$ വാഫ് ബിൽഡ്

ഒരു മൊഡ്യൂൾ ഡയറക്‌ടറിയിൽ നിസ്സാരമായത് ചേർക്കുന്നത് പ്രലോഭിപ്പിച്ചേക്കാം വാഫ് എന്ന വരികളിലൂടെ സ്ക്രിപ്റ്റ്
exec ../../waf. ദയവായി ചെയ്യരുത്. പുതുതായി വരുന്നവർക്ക് ഇത് ആശയക്കുഴപ്പമുണ്ടാക്കുന്നു, മോശമായി ചെയ്യുമ്പോൾ
സൂക്ഷ്മമായ ബിൽഡ് പിശകുകളിലേക്ക് നയിക്കുന്നു. മുകളിലുള്ള പരിഹാരങ്ങൾ പോകാനുള്ള വഴിയാണ്.

ടെസ്റ്റിംഗ് ns-3
യുടെ യൂണിറ്റ് ടെസ്റ്റുകൾ നിങ്ങൾക്ക് പ്രവർത്തിപ്പിക്കാൻ കഴിയും ns-3 പ്രവർത്തിപ്പിച്ച് വിതരണം ./test.py -c കോർ
സ്ക്രിപ്റ്റ്:

$ ./test.py -c കോർ

ഈ ടെസ്റ്റുകൾ വാഫ് സമാന്തരമായി നടത്തുന്നു. എന്ന് പറയുന്ന ഒരു റിപ്പോർട്ട് നിങ്ങൾ ഒടുവിൽ കാണണം

92 ടെസ്റ്റുകളിൽ 92 എണ്ണം വിജയിച്ചു (92 വിജയിച്ചു, 0 പരാജയപ്പെട്ടു, 0 ക്രാഷായി, 0 valgrind പിശകുകൾ)

ഇതാണ് പ്രധാന സന്ദേശം.

വാഫിൽ നിന്നുള്ള സംഗ്രഹ ഔട്ട്‌പുട്ടും ഓരോ ടെസ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്ന ടെസ്റ്റ് റണ്ണറും നിങ്ങൾ കാണും,
ഇത് യഥാർത്ഥത്തിൽ ഇതുപോലെ കാണപ്പെടും:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/path/to/workspace/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/path/to/workspace/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (1.799സെ)

മൊഡ്യൂളുകൾ നിർമ്മിച്ചിരിക്കുന്നത്:
aodv ആപ്ലിക്കേഷൻസ് ബ്രിഡ്ജ്
കോൺഫിഗർ-സ്റ്റോർ കോർ ക്ലിക്ക് ചെയ്യുക
csma csma-ലേഔട്ട് dsdv
എമു ഊർജ്ജ ഫ്ലോ മോണിറ്റർ
ഇന്റർനെറ്റ് എൽടിഇ മെഷ്
മൊബിലിറ്റി എംപി നെറ്റാനിം
നെറ്റ്വർക്ക് നിക്സ്-വെക്റ്റർ-റൂട്ടിംഗ് ns3tcp
ns3wifi olsr ഓപ്പൺഫ്ലോ
പോയിന്റ്-ടു-പോയിന്റ് പോയിന്റ്-ടു-പോയിന്റ്-ലേഔട്ട് പ്രചരണം
സ്പെക്ട്രം സ്ഥിതിവിവരക്കണക്കുകൾ ടാപ്പ്-ബ്രിഡ്ജ്
ടെംപ്ലേറ്റ് ടെസ്റ്റ് ടൂളുകൾ
ടോപ്പോളജി-റീഡ് uan virtual-net-device
വിഷ്വലൈസർ വൈഫൈ wimax

പാസ്: TestSuite ns3-വൈഫൈ-ഇടപെടൽ
പാസ്: ടെസ്റ്റ് സ്യൂട്ട് ഹിസ്റ്റോഗ്രാം

...

പാസ്: ടെസ്റ്റ് സ്യൂട്ട് ഒബ്‌ജക്റ്റ്
പാസ്: ടെസ്റ്റ് സ്യൂട്ട് റാൻഡം നമ്പർ ജനറേറ്ററുകൾ
92 ടെസ്റ്റുകളിൽ 92 എണ്ണം വിജയിച്ചു (92 വിജയിച്ചു, 0 പരാജയപ്പെട്ടു, 0 ക്രാഷായി, 0 valgrind പിശകുകൾ)

ഈ കമാൻഡ് സാധാരണഗതിയിൽ ഉപയോക്താക്കൾ അത് വേഗത്തിൽ പരിശോധിക്കുന്നതിനായി പ്രവർത്തിപ്പിക്കുന്നതാണ് ns-3 വിതരണം ഉണ്ട്
ശരിയായി നിർമ്മിച്ചത്. (ഇതിന്റെ ക്രമം ശ്രദ്ധിക്കുക പാസ്: ... വരികൾ വ്യത്യാസപ്പെടാം, അത് കുഴപ്പമില്ല. എന്താണ്
എല്ലാ ടെസ്റ്റുകളും വിജയിച്ചതിന്റെ അവസാന റിപ്പോർട്ടിലെ സംഗ്രഹ രേഖ പ്രധാനമാണ്; ഒന്നും പരാജയപ്പെട്ടില്ല അല്ലെങ്കിൽ
തകർന്നു.)

പ്രവർത്തിക്കുന്ന a സ്ക്രിപ്റ്റ്
ഞങ്ങൾ സാധാരണയായി വാഫിന്റെ നിയന്ത്രണത്തിലാണ് സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നത്. ഇത് ബിൽഡ് സിസ്റ്റം ഉറപ്പാക്കാൻ അനുവദിക്കുന്നു
പങ്കിട്ട ലൈബ്രറി പാതകൾ ശരിയായി സജ്ജീകരിച്ചിട്ടുണ്ടെന്നും ലൈബ്രറികൾ ലഭ്യമാണെന്നും
റൺ സമയം. ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന്, ലളിതമായി ഉപയോഗിക്കുക --ഓടുക വാഫിലെ ഓപ്ഷൻ. നമുക്ക് ഓടിക്കാം ns-3
ഇനിപ്പറയുന്നവ ടൈപ്പ് ചെയ്തുകൊണ്ട് സർവ്വവ്യാപിയായ ഹലോ വേൾഡ് പ്രോഗ്രാമിന് തുല്യമാണ്:

$ ./waf --റൺ ഹലോ-സിമുലേറ്റർ

പ്രോഗ്രാം ശരിയായി നിർമ്മിച്ചിട്ടുണ്ടോയെന്ന് ഉറപ്പാക്കാൻ വാഫ് ആദ്യം പരിശോധിക്കുകയും ഒരു ബിൽഡ് എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു
ആവശ്യമാണ്. വാഫ് പിന്നീട് പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുന്നു, അത് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കുന്നു.

ഹലോ സിമുലേറ്റർ

അഭിനന്ദനങ്ങൾ! നിങ്ങൾ ഇപ്പോൾ ഒരു ns-3 ഉപയോക്താവാണ്!

എന്ത് do I do if I ചെയ്യരുത് കാണുക The ഔട്ട്പുട്ട്?

നിർമ്മാണം വിജയകരമായി പൂർത്തിയാക്കിയതായി സൂചിപ്പിക്കുന്ന വാഫ് സന്ദേശങ്ങൾ നിങ്ങൾ കാണുകയാണെങ്കിൽ, പക്ഷേ ചെയ്യരുത്
"ഹലോ സിമുലേറ്റർ" ഔട്ട്‌പുട്ട് കാണുക, നിങ്ങളുടെ ബിൽഡ് മോഡിലേക്ക് നിങ്ങൾ മാറിയിരിക്കാൻ സാധ്യതയുണ്ട്
ഒപ്റ്റിമൈസ് ചെയ്തു ലെ കെട്ടിടം കൂടെ വഫ് വിഭാഗം, എന്നാൽ തിരികെ മാറ്റുന്നത് നഷ്‌ടമായി ഡീബഗ് മോഡ്.
ഈ ട്യൂട്ടോറിയലിൽ ഉപയോഗിച്ചിരിക്കുന്ന എല്ലാ കൺസോൾ ഔട്ട്പുട്ടും ഒരു പ്രത്യേകം ഉപയോഗിക്കുന്നു ns-3 ലോഗിംഗ് ഘടകം അത്
കൺസോളിലേക്ക് ഉപയോക്തൃ സന്ദേശങ്ങൾ അച്ചടിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്. ഈ ഘടകത്തിൽ നിന്നുള്ള ഔട്ട്പുട്ട് ആണ്
നിങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്ത കോഡ് കംപൈൽ ചെയ്യുമ്പോൾ യാന്ത്രികമായി അപ്രാപ്തമാക്കപ്പെടും -- അത് "ഒപ്റ്റിമൈസ് ഔട്ട്." നിങ്ങൾ എങ്കിൽ
"ഹലോ സിമുലേറ്റർ" ഔട്ട്പുട്ട് കാണരുത്, ഇനിപ്പറയുന്നവ ടൈപ്പ് ചെയ്യുക:

$ ./waf കോൺഫിഗർ ചെയ്യുക --build-profile=debug --enable-examples --enable-tests

യുടെ ഡീബഗ് പതിപ്പുകൾ നിർമ്മിക്കാൻ വാഫിനോട് പറയുക ns-3 ഉദാഹരണങ്ങൾ ഉൾക്കൊള്ളുന്ന പ്രോഗ്രാമുകൾ
ടെസ്റ്റുകളും. ടൈപ്പുചെയ്യുന്നതിലൂടെ നിങ്ങൾ ഇപ്പോഴും കോഡിന്റെ യഥാർത്ഥ ഡീബഗ് പതിപ്പ് നിർമ്മിക്കേണ്ടതുണ്ട്

$ ./waf

ഇപ്പോൾ, നിങ്ങൾ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ ഹലോ-സിമുലേറ്റർ പ്രോഗ്രാം, നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ട് കാണും.

പ്രോഗ്രാം വാദങ്ങൾ
ഒരു കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ നൽകുന്നതിന് ns-3 പ്രോഗ്രാം ഈ പാറ്റേൺ ഉപയോഗിക്കുന്നു:

$ ./waf --റൺ --command-template="%s "

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

ഒരു ടെസ്റ്റ് സ്യൂട്ട് സ്വയം പ്രവർത്തിപ്പിക്കുക എന്നതാണ് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമായ മറ്റൊരു ഉദാഹരണം. എ എന്ന് നമുക്ക് അനുമാനിക്കാം
mytest ടെസ്റ്റ് സ്യൂട്ട് നിലവിലുണ്ട് (അതല്ല). മുകളിൽ, ഞങ്ങൾ ഉപയോഗിച്ചു ./test.py മൊത്തത്തിൽ പ്രവർത്തിപ്പിക്കാനുള്ള സ്ക്രിപ്റ്റ്
യഥാർത്ഥ ടെസ്റ്റിംഗ് പ്രോഗ്രാം ആവർത്തിച്ച് അഭ്യർത്ഥിച്ചുകൊണ്ട് സമാന്തരമായി നിരവധി ടെസ്റ്റുകൾ, ടെസ്റ്റ് റണ്ണർ.
അഭ്യർത്ഥിക്കാൻ ടെസ്റ്റ് റണ്ണർ ഒരൊറ്റ ടെസ്റ്റിനായി നേരിട്ട്:

$ ./waf --run test-runner --command-template="%s --suite=mytest --verbose"

ഇത് വാദങ്ങൾ കൈമാറുന്നു ടെസ്റ്റ് റണ്ണർ പ്രോഗ്രാം. മുതലുള്ള mytest നിലവിലില്ല, ഒരു
പിശക് സന്ദേശം ജനറേറ്റ് ചെയ്യും. ലഭ്യമായവ അച്ചടിക്കാൻ ടെസ്റ്റ് റണ്ണർ ഓപ്ഷനുകൾ:

$ ./waf --run test-runner --command-template="%s --help"

ഡീബഗ്ഗിംഗ്
ഓടാൻ ns-3 ഒരു ഡീബഗ്ഗർ പോലെയുള്ള മറ്റൊരു യൂട്ടിലിറ്റിയുടെ നിയന്ത്രണത്തിലുള്ള പ്രോഗ്രാമുകൾ (ഉദാ ജിഡിബി)
അല്ലെങ്കിൽ മെമ്മറി ചെക്കർ (ഉദാ വാൽഗ്രിൻഡ്), നിങ്ങൾ സമാനമായ ഒന്ന് ഉപയോഗിക്കുന്നു --command-template="..." രൂപം.

ഉദാഹരണത്തിന്, നിങ്ങളുടെ പ്രവർത്തിപ്പിക്കാൻ ns-3 പ്രോഗ്രാം ഹലോ-സിമുലേറ്റർ വാദങ്ങൾക്കൊപ്പം കീഴെ
ജിഡിബി ഡീബഗ്ഗർ:

$ ./waf --run=hello-simulator --command-template="gdb %s --args "

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

ഡീബഗ്ഗറിന് കീഴിൽ ഒരു ടെസ്റ്റ് നടത്താൻ നമുക്ക് ഈ പാചകക്കുറിപ്പും മുമ്പത്തേതും സംയോജിപ്പിക്കാം:

$ ./waf --run test-runner --command-template="gdb %s --args --suite=mytest --verbose"

ജോലി ഡയറക്ടറി
വാഫ് അതിന്റെ മുകൾഭാഗത്ത് നിന്ന് ഓടേണ്ടതുണ്ട് ns-3 വൃക്ഷം. ഇത് പ്രവർത്തനമായി മാറുന്നു
ഔട്ട്പുട്ട് ഫയലുകൾ എഴുതുന്ന ഡയറക്ടറി. എന്നാൽ നിങ്ങൾക്ക് അവ സൂക്ഷിക്കണമെങ്കിൽ എന്തുചെയ്യും
The ns-3 ഉറവിട വൃക്ഷം? ഉപയോഗിക്കുക --cwd വാദം:

$ ./waf --cwd=...

നിങ്ങൾക്ക് ഔട്ട്പുട്ട് ആവശ്യമുള്ളിടത്ത് നിങ്ങളുടെ വർക്കിംഗ് ഡയറക്ടറിയിൽ ആരംഭിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും
ഫയലുകൾ, ഈ സാഹചര്യത്തിൽ ഒരു ചെറിയ പരോക്ഷ സഹായം സഹായിക്കും:

$ ഫംഗ്ഷൻ വാഫ് {
CWD="$PWD"
cd $NS3DIR >/dev/null
./waf --cwd="$CWD" $*
cd - >/dev/null
}

മുമ്പത്തെ പതിപ്പിന്റെ ഈ അലങ്കാരം നിലവിലെ പ്രവർത്തന ഡയറക്ടറി സംരക്ഷിക്കുന്നു, cdയുടെ
Waf ഡയറക്ടറി, തുടർന്ന് വർക്കിംഗ് ഡയറക്ടറി മാറ്റാൻ Waf-നോട് നിർദ്ദേശിക്കുന്നു തിരികെ രക്ഷിക്കപ്പെട്ടവരിലേക്ക്
പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് നിലവിലുള്ള വർക്കിംഗ് ഡയറക്ടറി.

ആശയപരമായ ചുരുക്കവിവരണത്തിനുള്ള

യഥാർത്ഥത്തിൽ നോക്കാനോ എഴുതാനോ തുടങ്ങുന്നതിനുമുമ്പ് നമ്മൾ ആദ്യം ചെയ്യേണ്ടത് ns-3 എന്നതാണ് കോഡ്
സിസ്റ്റത്തിലെ ചില അടിസ്ഥാന ആശയങ്ങളും അമൂർത്തങ്ങളും വിശദീകരിക്കുക. ഇതിൽ ഭൂരിഭാഗവും പ്രത്യക്ഷപ്പെടാം
ചിലർക്ക് സുതാര്യമായി വ്യക്തമാണ്, എന്നാൽ ഇതിലൂടെ വായിക്കാൻ സമയമെടുക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു
നിങ്ങൾ ഒരു ഉറച്ച അടിത്തറയിലാണ് ആരംഭിക്കുന്നതെന്ന് ഉറപ്പാക്കാൻ മാത്രം വിഭാഗം.

കീ സംഗ്രഹങ്ങൾ
ഈ വിഭാഗത്തിൽ, നെറ്റ്‌വർക്കിംഗിൽ സാധാരണയായി ഉപയോഗിക്കുന്ന ചില നിബന്ധനകൾ ഞങ്ങൾ അവലോകനം ചെയ്യും, എന്നാൽ എ
പ്രത്യേക അർത്ഥം ns-3.

നോഡ്
ഇന്റർനെറ്റ് പദപ്രയോഗത്തിൽ, ഒരു നെറ്റ്‌വർക്കുമായി ബന്ധിപ്പിക്കുന്ന ഒരു കമ്പ്യൂട്ടിംഗ് ഉപകരണത്തെ വിളിക്കുന്നു a ഹോസ്റ്റ് or
ചിലപ്പോൾ ഒരു അവസാനിക്കുന്നു സിസ്റ്റം. കാരണം ns-3 ഒരു ആണ് നെറ്റ്വർക്ക് സിമുലേറ്റർ, പ്രത്യേകിച്ച് ഒരു അല്ല
ഇന്റർനെറ്റ് സിമുലേറ്റർ, ഹോസ്റ്റ് എന്ന പദം ഞങ്ങൾ മനഃപൂർവ്വം ഉപയോഗിക്കുന്നില്ല, കാരണം അത് അടുത്താണ്
ഇന്റർനെറ്റുമായും അതിന്റെ പ്രോട്ടോക്കോളുകളുമായും ബന്ധപ്പെട്ടിരിക്കുന്നു. പകരം, ഞങ്ങൾ കൂടുതൽ പൊതുവായ ഒരു പദവും ഉപയോഗിക്കുന്നു
ഗ്രാഫ് തിയറിയിൽ നിന്ന് ഉത്ഭവിക്കുന്ന മറ്റ് സിമുലേറ്ററുകൾ ഉപയോഗിക്കുന്നു --- നോഡ്.

In ns-3 അടിസ്ഥാന കമ്പ്യൂട്ടിംഗ് ഉപകരണത്തിന്റെ അമൂർത്തീകരണത്തെ നോഡ് എന്ന് വിളിക്കുന്നു. ഈ അമൂർത്തീകരണം
ക്ലാസ് C++ ൽ പ്രതിനിധീകരിക്കുന്നു നോഡ്. ദി നോഡ് ക്ലാസ് കൈകാര്യം ചെയ്യുന്നതിനുള്ള രീതികൾ നൽകുന്നു
സിമുലേഷനുകളിൽ കമ്പ്യൂട്ടിംഗ് ഉപകരണങ്ങളുടെ പ്രതിനിധാനം.

നിങ്ങൾ ഒരു ചിന്തിക്കണം നോഡ് നിങ്ങൾ പ്രവർത്തനക്ഷമത ചേർക്കുന്ന ഒരു കമ്പ്യൂട്ടർ എന്ന നിലയിൽ. ഒരാൾ കൂട്ടിച്ചേർക്കുന്നു
ആപ്ലിക്കേഷനുകൾ, പ്രോട്ടോക്കോൾ സ്റ്റാക്കുകൾ, അനുബന്ധ കാർഡുകൾ എന്നിവ പോലെയുള്ള കാര്യങ്ങൾ
ഉപയോഗപ്രദമായ ജോലി ചെയ്യാൻ കമ്പ്യൂട്ടറിനെ പ്രവർത്തനക്ഷമമാക്കുന്നതിനുള്ള ഡ്രൈവറുകൾ. ഞങ്ങൾ ഒരേ അടിസ്ഥാന മോഡൽ ഉപയോഗിക്കുന്നു ns-3.

അപേക്ഷ
സാധാരണഗതിയിൽ, കമ്പ്യൂട്ടർ സോഫ്‌റ്റ്‌വെയറിനെ രണ്ട് വിശാലമായ ക്ലാസുകളായി തിരിച്ചിരിക്കുന്നു. സിസ്റ്റം സോഫ്റ്റ്വെയർ സംഘടിപ്പിക്കുന്നു
മെമ്മറി, പ്രോസസർ സൈക്കിളുകൾ, ഡിസ്ക്, നെറ്റ്‌വർക്ക് തുടങ്ങിയ വിവിധ കമ്പ്യൂട്ടർ ഉറവിടങ്ങൾ,
ചില കമ്പ്യൂട്ടിംഗ് മോഡൽ അനുസരിച്ച്. സിസ്റ്റം സോഫ്റ്റ്‌വെയർ സാധാരണയായി ആ ഉറവിടങ്ങൾ ഉപയോഗിക്കുന്നില്ല
ഒരു ഉപയോക്താവിന് നേരിട്ട് പ്രയോജനപ്പെടുന്ന ജോലികൾ പൂർത്തിയാക്കാൻ. ഒരു ഉപയോക്താവ് സാധാരണയായി ഒരു പ്രവർത്തിപ്പിക്കും അപേക്ഷ
അത് സിസ്റ്റം സോഫ്‌റ്റ്‌വെയർ നിയന്ത്രിത ഉറവിടങ്ങൾ നേടുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നു
ലക്ഷ്യം.

മിക്കപ്പോഴും, സിസ്റ്റവും ആപ്ലിക്കേഷൻ സോഫ്‌റ്റ്‌വെയറും തമ്മിലുള്ള വേർതിരിവിന്റെ രേഖ ഇവിടെയാണ് നിർമ്മിച്ചിരിക്കുന്നത്
ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ട്രാപ്പുകളിൽ സംഭവിക്കുന്ന പ്രിവിലേജ് ലെവൽ മാറ്റം. ഇൻ ns-3 യാഥാർത്ഥ്യമില്ല
ഓപ്പറേറ്റിംഗ് സിസ്റ്റം എന്ന ആശയം, പ്രത്യേകിച്ച് പ്രിവിലേജ് ലെവലുകളോ സിസ്റ്റം കോളുകളോ ഇല്ല.
എന്നിരുന്നാലും, ഒരു ആപ്ലിക്കേഷന്റെ ആശയം ഞങ്ങൾക്കുണ്ട്. സോഫ്റ്റ്‌വെയർ ആപ്ലിക്കേഷനുകൾ പ്രവർത്തിക്കുന്നത് പോലെ
"യഥാർത്ഥ ലോകത്ത്" ചുമതലകൾ നിർവഹിക്കാനുള്ള കമ്പ്യൂട്ടറുകൾ, ns-3 ആപ്ലിക്കേഷനുകൾ പ്രവർത്തിക്കുന്നു ns-3 നോഡുകൾ ലേക്ക്
സിമുലേറ്റഡ് ലോകത്ത് ഡ്രൈവ് സിമുലേഷനുകൾ.

In ns-3 ഒരു ഉപയോക്തൃ പ്രോഗ്രാമിന്റെ അടിസ്ഥാന സംഗ്രഹം ചില പ്രവർത്തനങ്ങൾ സൃഷ്ടിക്കുന്നു
സിമുലേറ്റഡ് ആണ് ആപ്ലിക്കേഷൻ. ഈ അമൂർത്തീകരണം C++ ൽ ക്ലാസ് പ്രതിനിധീകരിക്കുന്നു
അപേക്ഷ. ദി അപേക്ഷ യുടെ പ്രാതിനിധ്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള രീതികൾ ക്ലാസ് നൽകുന്നു
സിമുലേഷനുകളിലെ ഉപയോക്തൃ-തല ആപ്ലിക്കേഷനുകളുടെ ഞങ്ങളുടെ പതിപ്പ്. ഡെവലപ്പർമാർ പ്രതീക്ഷിക്കുന്നു
സ്പെഷ്യലൈസ് ചെയ്യുക അപേക്ഷ പുതിയത് സൃഷ്ടിക്കാൻ ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് അർത്ഥത്തിൽ ക്ലാസ്
അപേക്ഷകൾ. ഈ ട്യൂട്ടോറിയലിൽ, ഞങ്ങൾ ക്ലാസിന്റെ സ്പെഷ്യലൈസേഷനുകൾ ഉപയോഗിക്കും അപേക്ഷ വിളിച്ചു
UdpEchoClientApplication ഒപ്പം UdpEchoServerApplication. നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതുപോലെ, ഇവ
ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനും പ്രതിധ്വനിപ്പിക്കുന്നതിനും ഉപയോഗിക്കുന്ന ഒരു ക്ലയന്റ്/സെർവർ ആപ്ലിക്കേഷൻ സെറ്റ് രചിക്കുന്നു
നെറ്റ്വർക്ക് പാക്കറ്റുകൾ

ചാനൽ
യഥാർത്ഥ ലോകത്ത്, ഒരാൾക്ക് ഒരു കമ്പ്യൂട്ടറിനെ ഒരു നെറ്റ്‌വർക്കിലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിയും. പലപ്പോഴും ഏത് മാധ്യമങ്ങളും
ഈ നെറ്റ്‌വർക്കുകളിലെ ഡാറ്റ ഫ്ലോകളെ വിളിക്കുന്നു ചാനലുകൾ. നിങ്ങളുടെ ഇഥർനെറ്റ് കേബിൾ ബന്ധിപ്പിക്കുമ്പോൾ
ഭിത്തിയിലെ പ്ലഗ്, നിങ്ങൾ നിങ്ങളുടെ കമ്പ്യൂട്ടറിനെ ഒരു ഇഥർനെറ്റ് ആശയവിനിമയത്തിലേക്ക് ബന്ധിപ്പിക്കുകയാണ്
ചാനൽ. എന്ന സിമുലേറ്റഡ് ലോകത്ത് ns-3, ഒന്ന് ബന്ധിപ്പിക്കുന്നു a നോഡ് a പ്രതിനിധീകരിക്കുന്ന ഒരു വസ്തുവിലേക്ക്
ആശയവിനിമയ ചാനൽ. ഇവിടെ അടിസ്ഥാന ആശയവിനിമയ സബ്‌നെറ്റ്‌വർക്ക് അബ്‌സ്‌ട്രാക്ഷൻ എന്ന് വിളിക്കുന്നു
ചാനൽ, ക്ലാസ് C++ ൽ പ്രതിനിധീകരിക്കുന്നു ചാനൽ.

ദി ചാനൽ ആശയവിനിമയ സബ്‌നെറ്റ്‌വർക്ക് ഒബ്‌ജക്‌റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള രീതികൾ ക്ലാസ് നൽകുന്നു
അവയുമായി നോഡുകൾ ബന്ധിപ്പിക്കുന്നു. ചാനലുകൾ ഒബ്‌ജക്‌റ്റിലെ ഡെവലപ്പർമാർക്കും സ്പെഷ്യലൈസ് ചെയ്‌തേക്കാം
ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് സെൻസ്. എ ചാനൽ സ്പെഷ്യലൈസേഷൻ ഒരു പോലെ ലളിതമായ എന്തെങ്കിലും മാതൃകയാക്കാം
വയർ. സ്പെഷ്യലൈസ്ഡ് ചാനൽ ഒരു വലിയ ഇഥർനെറ്റ് പോലെ സങ്കീർണ്ണമായ കാര്യങ്ങൾ മാതൃകയാക്കാനും കഴിയും
സ്വിച്ച്, അല്ലെങ്കിൽ വയർലെസ് നെറ്റ്‌വർക്കുകളുടെ കാര്യത്തിൽ തടസ്സങ്ങൾ നിറഞ്ഞ ത്രിമാന ഇടം.

ഇതിന്റെ പ്രത്യേക പതിപ്പുകൾ ഞങ്ങൾ ഉപയോഗിക്കും ചാനൽ വിളിച്ചു CsmaChannel, PointToPointChannel
ഒപ്പം വൈഫൈചാനൽ ഈ ട്യൂട്ടോറിയലിൽ. ദി CsmaChannel, ഉദാഹരണത്തിന്, a യുടെ ഒരു പതിപ്പ് മോഡലുകൾ
എ നടപ്പിലാക്കുന്ന ആശയവിനിമയ സബ്‌നെറ്റ്‌വർക്ക് കാരിയർ അർത്ഥം ഒന്നിലധികം പ്രവേശനം വാര്ത്താവിനിമയം
ഇടത്തരം. ഇത് ഞങ്ങൾക്ക് ഇഥർനെറ്റ് പോലെയുള്ള പ്രവർത്തനക്ഷമത നൽകുന്നു.

നെറ്റ് ഉപകരണ
ഒരു കമ്പ്യൂട്ടറിനെ ഒരു നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റുചെയ്യണമെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യേണ്ടതായിരുന്നു
ഒരു പ്രത്യേക തരം നെറ്റ്‌വർക്ക് കേബിളും ഒരു ഹാർഡ്‌വെയർ ഉപകരണവും വാങ്ങുക (PC ടെർമിനോളജിയിൽ) a
പെരിഫറൽ കാർഡ് അത് നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതായിരുന്നു. പെരിഫറൽ കാർഡ് ആണെങ്കിൽ
ചില നെറ്റ്‌വർക്കിംഗ് ഫംഗ്‌ഷൻ നടപ്പിലാക്കി, അവയെ നെറ്റ്‌വർക്ക് ഇന്റർഫേസ് കാർഡുകൾ എന്ന് വിളിക്കുന്നു, അല്ലെങ്കിൽ എൻ‌ഐ‌സി.
ഇന്ന് മിക്ക കമ്പ്യൂട്ടറുകളും നെറ്റ്‌വർക്ക് ഇന്റർഫേസ് ഹാർഡ്‌വെയർ ബിൽറ്റ്-ഇൻ ഉപയോഗിച്ചാണ് വരുന്നത്, മാത്രമല്ല ഉപയോക്താക്കൾ കാണുന്നില്ല
ഈ നിർമ്മാണ ബ്ലോക്കുകൾ.

ഹാർഡ്‌വെയർ നിയന്ത്രിക്കാൻ ഒരു സോഫ്റ്റ്‌വെയർ ഡ്രൈവർ ഇല്ലാതെ ഒരു NIC പ്രവർത്തിക്കില്ല. Unix-ൽ (അല്ലെങ്കിൽ
Linux), പെരിഫറൽ ഹാർഡ്‌വെയറിന്റെ ഒരു ഭാഗത്തെ തരംതിരിച്ചിരിക്കുന്നു a ഉപകരണം. ഉപകരണങ്ങൾ നിയന്ത്രിക്കപ്പെടുന്നു
ഉപയോഗിച്ച് ഉപകരണം ഡ്രൈവറുകൾ, നെറ്റ്‌വർക്ക് ഉപകരണങ്ങൾ (NIC) എന്നിവ ഉപയോഗിച്ച് നിയന്ത്രിക്കപ്പെടുന്നു നെറ്റ്വർക്ക് ഉപകരണം
ഡ്രൈവറുകൾ മൊത്തത്തിൽ അറിയപ്പെടുന്നത് വല ഉപകരണങ്ങൾ. യുണിക്സിലും ലിനക്സിലും നിങ്ങൾ ഈ നെറ്റിനെ പരാമർശിക്കുന്നു
തുടങ്ങിയ പേരുകളുള്ള ഉപകരണങ്ങൾ eth0.

In ns-3 The വല ഉപകരണം അബ്‌സ്‌ട്രാക്ഷൻ സോഫ്റ്റ്‌വെയർ ഡ്രൈവർ, സിമുലേറ്റഡ് എന്നിവയെ ഉൾക്കൊള്ളുന്നു
ഹാർഡ്വെയർ. ഒരു നെറ്റ് ഉപകരണം "ഇൻസ്റ്റാൾ" ചെയ്തിരിക്കുന്നു a നോഡ് പ്രവർത്തനക്ഷമമാക്കുന്നതിന് നോഡ് ലേക്ക്
മറ്റുള്ളവരുമായി ആശയവിനിമയം നടത്തുക നോഡുകൾ വഴി സിമുലേഷനിൽ ചാനലുകൾ. ഒരു യഥാർത്ഥ കമ്പ്യൂട്ടറിലെന്നപോലെ,
a നോഡ് ഒന്നിൽ കൂടുതൽ ബന്ധിപ്പിച്ചിരിക്കാം ചാനൽ ഒന്നിലധികം വഴി നെറ്റ് ഡിവൈസുകൾ.

നെറ്റ് ഉപകരണത്തിന്റെ അമൂർത്തീകരണം C++ ൽ ക്ലാസ് പ്രതിനിധീകരിക്കുന്നു നെറ്റ് ഡിവൈസ്. ദി നെറ്റ് ഡിവൈസ്
ക്ലാസ് കണക്ഷനുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള രീതികൾ നൽകുന്നു നോഡ് ഒപ്പം ചാനൽ വസ്തുക്കൾ; ആയിരിക്കാം
ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് അർത്ഥത്തിൽ ഡെവലപ്പർമാർ പ്രത്യേകം തയ്യാറാക്കിയത്. ഞങ്ങൾ ഉപയോഗിക്കും
യുടെ നിരവധി പ്രത്യേക പതിപ്പുകൾ നെറ്റ് ഡിവൈസ് വിളിച്ചു CsmaNetDevice, PointToPointNetDevice,
ഒപ്പം WifiNetDevice ഈ ട്യൂട്ടോറിയലിൽ. ഒരു ഇഥർനെറ്റ് എൻഐസി ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് പോലെ
ഇഥർനെറ്റ് നെറ്റ്‌വർക്ക്, ദി CsmaNetDevice എയുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു CsmaChannel; The
PointToPointNetDevice എയുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു PointToPointChannel ഒരു WifiNetNevice
എയുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു വൈഫൈചാനൽ.

ടോപ്പോളജി സഹായികൾ
ഒരു യഥാർത്ഥ നെറ്റ്‌വർക്കിൽ, ചേർത്ത (അല്ലെങ്കിൽ അന്തർനിർമ്മിത) NIC-കൾ ഉള്ള ഹോസ്റ്റ് കമ്പ്യൂട്ടറുകൾ നിങ്ങൾ കണ്ടെത്തും. ഇൻ ns-3 we
കണ്ടെത്തും എന്ന് പറയും നോഡുകൾ അറ്റാച്ചുചെയ്‌തത് നെറ്റ് ഡിവൈസുകൾ. ഒരു വലിയ സിമുലേറ്റഡ് നെറ്റ്‌വർക്കിൽ
നിങ്ങൾ തമ്മിൽ നിരവധി കണക്ഷനുകൾ ക്രമീകരിക്കേണ്ടതുണ്ട് നോഡുകൾ, നെറ്റ് ഡിവൈസുകൾ ഒപ്പം ചാനലുകൾ.

ബന്ധിപ്പിക്കുന്നത് മുതൽ നെറ്റ് ഡിവൈസുകൾ ലേക്ക് നോഡുകൾ, നെറ്റ് ഡിവൈസുകൾ ലേക്ക് ചാനലുകൾ, IP വിലാസങ്ങൾ നൽകൽ,
മുതലായവ, ഇത്തരം പൊതുവായ ജോലികളാണ് ns-3, ഞങ്ങൾ വിളിക്കുന്നത് ഞങ്ങൾ നൽകുന്നു ടോപ്പോളജി സഹായികൾ ഇത് നിർമ്മിക്കാൻ
കഴിയുന്നത്ര എളുപ്പമാണ്. ഉദാഹരണത്തിന്, ഇതിന് നിരവധി വ്യത്യസ്തതകൾ എടുത്തേക്കാം ns-3 പ്രധാന പ്രവർത്തനങ്ങൾ
ഒരു NetDevice സൃഷ്ടിക്കുക, ഒരു MAC വിലാസം ചേർക്കുക, ആ നെറ്റ് ഉപകരണം a-യിൽ ഇൻസ്റ്റാൾ ചെയ്യുക നോഡ്, കോൺഫിഗർ ചെയ്യുക
നോഡിന്റെ പ്രോട്ടോക്കോൾ സ്റ്റാക്ക്, തുടർന്ന് ബന്ധിപ്പിക്കുക നെറ്റ് ഡിവൈസ് ഒരു ചാനൽ. കൂടുതൽ പ്രവർത്തനങ്ങൾ
മൾട്ടിപോയിന്റ് ചാനലുകളിലേക്ക് ഒന്നിലധികം ഉപകരണങ്ങൾ കണക്റ്റുചെയ്യാനും തുടർന്ന് കണക്റ്റുചെയ്യാനും ആവശ്യമായി വരും
വ്യക്തിഗത നെറ്റ്‌വർക്കുകൾ ഒരുമിച്ച് ഇന്റർനെറ്റ് വർക്കുകളിലേക്ക്. ഞങ്ങൾ ടോപ്പോളജി സഹായ വസ്തുക്കൾ നൽകുന്നു
നിങ്ങളുടെ സൗകര്യത്തിനായി ഉപയോഗിക്കാൻ എളുപ്പമുള്ള ഒരു മോഡലായി വ്യത്യസ്തമായ നിരവധി പ്രവർത്തനങ്ങളെ സംയോജിപ്പിക്കുക.

A ആദ്യം ns-3 സ്ക്രിപ്റ്റ്
മുകളിൽ നിർദ്ദേശിച്ച പ്രകാരം നിങ്ങൾ സിസ്റ്റം ഡൗൺലോഡ് ചെയ്‌താൽ, നിങ്ങൾക്ക് ഇതിന്റെ ഒരു റിലീസ് ഉണ്ടായിരിക്കും ns-3 എ
ഡയറക്ടറി വിളിച്ചു ബാക്കി നിങ്ങളുടെ ഹോം ഡയറക്ടറിക്ക് കീഴിൽ. ആ റിലീസ് ഡയറക്‌ടറിയിലേക്ക് മാറ്റുക, ഒപ്പം
ഇനിപ്പറയുന്നതുപോലുള്ള ഒരു ഡയറക്ടറി ഘടന നിങ്ങൾ കണ്ടെത്തണം:

എഴുത്തുകാരുടെ ഉദാഹരണങ്ങൾ സ്ക്രാച്ച് യൂട്ടിലുകൾ waf.bat*
ബൈൻഡിംഗ് ലൈസൻസ് src utils.py waf-tools
ns3 test.py* utils.pyc wscript നിർമ്മിക്കുക
CHANGES.html README testpy-output VERSION wutils.py
ഡോക് RELEASE_NOTES testpy.supp waf* wutils.pyc

എന്നതിലേക്ക് മാറ്റുക ഉദാഹരണങ്ങൾ / ട്യൂട്ടോറിയൽ ഡയറക്ടറി. എന്ന പേരിലുള്ള ഒരു ഫയൽ നിങ്ങൾ കാണണം ആദ്യം.cc സ്ഥിതി
അവിടെ. രണ്ട് നോഡുകൾക്കിടയിൽ ലളിതമായ ഒരു പോയിന്റ്-ടു-പോയിന്റ് ലിങ്ക് സൃഷ്ടിക്കുന്ന ഒരു സ്ക്രിപ്റ്റാണിത്
നോഡുകൾക്കിടയിൽ ഒരൊറ്റ പാക്കറ്റ് പ്രതിധ്വനിപ്പിക്കുകയും ചെയ്യുക. നമുക്ക് ആ സ്ക്രിപ്റ്റ് ലൈൻ വഴി നോക്കാം
ലൈൻ, അതിനാൽ മുന്നോട്ട് പോയി തുറക്കുക ആദ്യം.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ.

ബോയിലർപ്ലേറ്റ്
ഫയലിലെ ആദ്യ വരി ഒരു emacs മോഡ് ലൈൻ ആണ്. ഇത് ഫോർമാറ്റിംഗിനെക്കുറിച്ച് ഇമാക്സിനോട് പറയുന്നു
ഞങ്ങളുടെ സോഴ്സ് കോഡിൽ ഞങ്ങൾ ഉപയോഗിക്കുന്ന കൺവെൻഷനുകൾ (കോഡിംഗ് ശൈലി).

/* -*- മോഡ്:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

ഇത് എല്ലായ്‌പ്പോഴും അൽപ്പം വിവാദ വിഷയമാണ്, അതിനാൽ ഞങ്ങൾ അത് ഒഴിവാക്കുകയും ചെയ്യാം
ഉടനെ. ദി ns-3 പ്രോജക്റ്റ്, മിക്ക വലിയ പ്രോജക്റ്റുകളെയും പോലെ, ഒരു കോഡിംഗ് ശൈലി സ്വീകരിച്ചു
സംഭാവന ചെയ്ത എല്ലാ കോഡുകളും പാലിക്കേണ്ടതാണ്. ഇതിലേക്ക് നിങ്ങളുടെ കോഡ് സംഭാവന ചെയ്യണമെങ്കിൽ
പ്രോജക്റ്റ്, നിങ്ങൾ ഒടുവിൽ ഇത് പാലിക്കേണ്ടിവരും ns-3 വിവരിച്ചിരിക്കുന്നതുപോലെ കോഡിംഗ് സ്റ്റാൻഡേർഡ്
ഫയല് doc/codingstd.txt അല്ലെങ്കിൽ പ്രോജക്റ്റ് വെബ് പേജിൽ കാണിച്ചിരിക്കുന്നു ഇവിടെ.

നിങ്ങൾ രൂപവും ഭാവവും ഉപയോഗിക്കണമെന്ന് ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു ns-3 കോഡ് ചെയ്ത് സ്വീകരിക്കുക
നിങ്ങൾ ഞങ്ങളുടെ കോഡ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോഴെല്ലാം ഈ മാനദണ്ഡം. എല്ലാ വികസന ടീമും ഒപ്പം
വിവിധ അളവിലുള്ള പിറുപിറുക്കലുകളോടെയാണ് സംഭാവകർ അങ്ങനെ ചെയ്തത്. മുകളിലെ emacs മോഡ് ലൈൻ
നിങ്ങൾ emacs എഡിറ്റർ ഉപയോഗിക്കുകയാണെങ്കിൽ ഫോർമാറ്റിംഗ് ശരിയാക്കുന്നത് എളുപ്പമാക്കുന്നു.

ദി ns-3 ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ് ഉപയോഗിച്ചാണ് സിമുലേറ്ററിന് അനുമതി നൽകിയിരിക്കുന്നത്. നിങ്ങൾ കാണും
എല്ലാ ഫയലുകളുടെയും തലയിൽ ഉചിതമായ GNU നിയമങ്ങൾ ns-3 വിതരണ. പലപ്പോഴും നിങ്ങൾ
ഇതിൽ ഉൾപ്പെട്ടിരിക്കുന്ന സ്ഥാപനങ്ങളിലൊന്നിന്റെ പകർപ്പവകാശ അറിയിപ്പ് കാണും ns-3 മുകളിലുള്ള പദ്ധതി
GPL ടെക്‌സ്‌റ്റും ഒരു രചയിതാവും ചുവടെ ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്നു.

/*
* ഈ പ്രോഗ്രാം ഒരു സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ആണ്; നിങ്ങൾക്ക് ഇത് പുനർവിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കാനും കഴിയും
* ഇത് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ് പതിപ്പ് 2-ന്റെ നിബന്ധനകൾക്ക് കീഴിലാണ്
* സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ പ്രസിദ്ധീകരിച്ചത്;
*
* ഈ പ്രോഗ്രാം ഉപയോഗപ്രദമാകുമെന്ന പ്രതീക്ഷയിലാണ് വിതരണം ചെയ്യുന്നത്,
* എന്നാൽ യാതൊരു വാറന്റിയും ഇല്ലാതെ; യുടെ സൂചിപ്പിച്ച വാറന്റി പോലുമില്ലാതെ
* ഒരു പ്രത്യേക ഉദ്ദേശ്യത്തിനായുള്ള വ്യാപാരം അല്ലെങ്കിൽ ഫിറ്റ്നസ്. കാണുക
* കൂടുതൽ വിവരങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ്.
*
* നിങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസിന്റെ ഒരു പകർപ്പ് ലഭിച്ചിരിക്കണം
* ഈ പ്രോഗ്രാമിനൊപ്പം; ഇല്ലെങ്കിൽ, സ്വതന്ത്ര സോഫ്റ്റ്‌വെയറിലേക്ക് എഴുതുക
* ഫൗണ്ടേഷൻ, Inc., 59 ടെംപിൾ പ്ലേസ്, സ്യൂട്ട് 330, ബോസ്റ്റൺ, MA 02111-1307 USA
*/

മൊഡ്യൂൾ ഉൾപ്പെടുന്നു
ശരിയായ കോഡ് ആരംഭിക്കുന്നത് നിരവധി ഉൾപ്പെടുത്തിയ പ്രസ്താവനകളിൽ നിന്നാണ്.

#ഉൾപ്പെടുത്തുക "ns3/core-module.h"
#ഉൾപ്പെടുത്തുക "ns3/network-module.h"
#ഉൾപ്പെടുത്തുക "ns3/internet-module.h"
#ഉൾപ്പെടുത്തുക "ns3/point-to-point-module.h"
#ഉൾപ്പെടുത്തുക "ns3/applications-module.h"

ഞങ്ങളുടെ ഉയർന്ന തലത്തിലുള്ള സ്‌ക്രിപ്റ്റ് ഉപയോക്താക്കളെ ഉൾപ്പെടുത്തിയിട്ടുള്ള ഫയലുകളുടെ വലിയ എണ്ണം കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്നതിന്
സിസ്റ്റം, താരതമ്യേന വലിയ മൊഡ്യൂളുകൾ അനുസരിച്ച് ഞങ്ങൾ ഗ്രൂപ്പിൽ ഉൾപ്പെടുന്നു. ഞങ്ങൾ ഒറ്റത്തവണ നൽകുന്നു
ഓരോ മൊഡ്യൂളിലും ഉപയോഗിക്കുന്ന എല്ലാ ഉൾപ്പെടുത്തിയ ഫയലുകളും ആവർത്തിച്ച് ലോഡ് ചെയ്യുന്ന ഫയൽ ഉൾപ്പെടുത്തുക.
നിങ്ങൾക്ക് ആവശ്യമുള്ള തലക്കെട്ട് കൃത്യമായി നോക്കുന്നതിന് പകരം, ഒരുപക്ഷേ ഒരു നേടേണ്ടതുണ്ട്
ഡിപൻഡൻസികളുടെ എണ്ണം ശരിയാണ്, ഒരു കൂട്ടം ഫയലുകൾ വലിയ അളവിൽ ലോഡ് ചെയ്യാനുള്ള കഴിവ് ഞങ്ങൾ നിങ്ങൾക്ക് നൽകുന്നു
ഗ്രാനുലാരിറ്റി. ഇത് ഏറ്റവും കാര്യക്ഷമമായ സമീപനമല്ല, പക്ഷേ ഇത് തീർച്ചയായും എഴുതുന്നു
സ്ക്രിപ്റ്റുകൾ വളരെ എളുപ്പമാണ്.

ഓരോ ns-3 ഉൾക്കൊള്ളുന്ന ഫയലുകൾ എന്ന ഡയറക്‌ടറിയിൽ സ്ഥാപിച്ചിരിക്കുന്നു ns3 (നിർമ്മാണത്തിന് കീഴിൽ
ഡയറക്‌ടറി) ബിൽഡ് പ്രോസസ്സിനിടെ ഫയൽ നെയിം കൂട്ടിയിടികൾ ഒഴിവാക്കാൻ സഹായിക്കും. ദി
ns3/core-module.h ഡയറക്‌ടറിയിൽ നിങ്ങൾ കണ്ടെത്തുന്ന ns-3 മൊഡ്യൂളുമായി ഫയൽ യോജിക്കുന്നു
src/core നിങ്ങളുടെ ഡൗൺലോഡ് ചെയ്ത റിലീസ് വിതരണത്തിൽ. നിങ്ങൾ ഈ ഡയറക്‌ടറി ലിസ്റ്റുചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യും
ധാരാളം ഹെഡ്ഡർ ഫയലുകൾ കണ്ടെത്തുക. നിങ്ങൾ ഒരു ബിൽഡ് ചെയ്യുമ്പോൾ, വാഫ് പൊതു തലക്കെട്ട് സ്ഥാപിക്കും
ഒരു ഫയലുകൾ ns3 ഉചിതമായ കീഴിലുള്ള ഡയറക്ടറി നിർമ്മിക്കുക/ഡീബഗ് ചെയ്യുക or ബിൽഡ്/ഒപ്റ്റിമൈസ്ഡ് ഡയറക്ടറി
നിങ്ങളുടെ കോൺഫിഗറേഷൻ അനുസരിച്ച്. ഉൾപ്പെടുന്ന ഒരു മൊഡ്യൂളും വാഫ് സ്വയമേവ സൃഷ്ടിക്കും
എല്ലാ പബ്ലിക് ഹെഡർ ഫയലുകളും ലോഡ് ചെയ്യാനുള്ള ഫയൽ.

തീർച്ചയായും, നിങ്ങൾ ഈ ട്യൂട്ടോറിയൽ മതപരമായി പിന്തുടരുന്നതിനാൽ, നിങ്ങൾ ഇതിനകം ചെയ്തുകഴിഞ്ഞിരിക്കും
a

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

ഉദാഹരണങ്ങളും പരിശോധനകളും ഉൾപ്പെടുന്ന ഡീബഗ് ബിൽഡുകൾ നടത്താൻ പ്രോജക്റ്റ് കോൺഫിഗർ ചെയ്യുന്നതിനായി.
നിങ്ങളും ചെയ്തിരിക്കും

$ ./waf

പദ്ധതി നിർമ്മിക്കാൻ. ഇപ്പോൾ നിങ്ങൾ ഡയറക്ടറിയിൽ നോക്കിയാൽ ../../build/debug/ns3 നിങ്ങൾ ഇത് ചെയ്യും
മുകളിൽ കാണിച്ചിരിക്കുന്ന ഫയലുകൾ ഉൾപ്പെടുന്ന നാല് മൊഡ്യൂളുകൾ കണ്ടെത്തുക. നിങ്ങൾക്ക് ഉള്ളടക്കം പരിശോധിക്കാം
ഈ ഫയലുകൾ അവയിൽ പൊതുവിലുള്ള എല്ലാ ഫയലുകളും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്
ബന്ധപ്പെട്ട മൊഡ്യൂളുകൾ.

Ns3 നെയിംസ്പെയ്സ്
ലെ അടുത്ത വരി ആദ്യം.cc സ്ക്രിപ്റ്റ് ഒരു നെയിംസ്പേസ് ഡിക്ലറേഷൻ ആണ്.

നെയിംസ്പേസ് ns3 ഉപയോഗിക്കുന്നു;

ദി ns-3 ഒരു C++ നെയിംസ്പേസിലാണ് പദ്ധതി നടപ്പിലാക്കുന്നത് ns3. ഇത് എല്ലാ ഗ്രൂപ്പുകളും
ns-3ആഗോള നെയിംസ്‌പെയ്‌സിന് പുറത്തുള്ള ഒരു പരിധിയിലുള്ള അനുബന്ധ പ്രഖ്യാപനങ്ങൾ, അത് സഹായിക്കുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു
മറ്റ് കോഡുകളുമായുള്ള സംയോജനത്തോടെ. C++ ഉപയോഗിച്ച് പ്രസ്താവന അവതരിപ്പിക്കുന്നു ns-3 നെയിംസ്പേസ്
നിലവിലെ (ആഗോള) പ്രഖ്യാപന മേഖലയിലേക്ക്. ഇത് പിന്നീട് പറയാനുള്ള ഒരു ഫാൻസി രീതിയാണ്
ഈ പ്രഖ്യാപനം, നിങ്ങൾ ടൈപ്പ് ചെയ്യേണ്ടതില്ല ns3:: എല്ലാത്തിനും മുമ്പായി സ്കോപ്പ് റെസലൂഷൻ ഓപ്പറേറ്റർ
The ns-3 അത് ഉപയോഗിക്കുന്നതിന് കോഡ്. നിങ്ങൾക്ക് നെയിംസ്‌പെയ്‌സുകൾ പരിചയമില്ലെങ്കിൽ, ദയവായി പരിശോധിക്കുക
മിക്കവാറും എല്ലാ C++ ട്യൂട്ടോറിയലും താരതമ്യം ചെയ്യുക ns3 ഇവിടെ നെയിംസ്പേസും ഉപയോഗവും ഉദാഹരണങ്ങൾക്കൊപ്പം
ക്ലാസ് നെയിംസ്പേസും ഉപയോഗിച്ച് നെയിംസ്പേസ് എസ്ടിഡി; ചർച്ചകളിൽ നിങ്ങൾ പലപ്പോഴും കണ്ടെത്തുന്ന പ്രസ്താവനകൾ
of വില അരുവികളും.

ലോഗ് ചെയ്യുന്നു
സ്ക്രിപ്റ്റിന്റെ അടുത്ത വരി ഇനിപ്പറയുന്നതാണ്,

NS_LOG_COMPONENT_DEFINE ("ആദ്യ സ്ക്രിപ്റ്റ് ഉദാഹരണം");

ഞങ്ങളുടെ ഡോക്‌സിജൻ ഡോക്യുമെന്റേഷനെ കുറിച്ച് സംസാരിക്കാനുള്ള സൗകര്യപ്രദമായ സ്ഥലമായി ഞങ്ങൾ ഈ പ്രസ്താവന ഉപയോഗിക്കും
സിസ്റ്റം. പദ്ധതിയുടെ വെബ്‌സൈറ്റ് നോക്കിയാൽ, ns-3 പദ്ധതി, എന്നതിലേക്കുള്ള ഒരു ലിങ്ക് നിങ്ങൾ കണ്ടെത്തും
നാവിഗേഷൻ ബാറിലെ "ഡോക്യുമെന്റേഷൻ". നിങ്ങൾ ഈ ലിങ്ക് തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, നിങ്ങളെ ഞങ്ങളിലേക്ക് കൊണ്ടുപോകും
ഡോക്യുമെന്റേഷൻ പേജ്. "ഏറ്റവും പുതിയ റിലീസ്" എന്നതിലേക്ക് നിങ്ങളെ കൊണ്ടുപോകുന്ന ഒരു ലിങ്ക് ഉണ്ട്
ഏറ്റവും പുതിയ സ്ഥിരതയുള്ള റിലീസിനുള്ള ഡോക്യുമെന്റേഷൻ ns-3. നിങ്ങൾ "API തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ
ഡോക്യുമെന്റേഷൻ" ലിങ്ക്, നിങ്ങളെ ഇതിലേക്ക് കൊണ്ടുപോകും ns-3 API ഡോക്യുമെന്റേഷൻ പേജ്.

ഇടതുവശത്ത്, ഘടനയുടെ ഒരു ഗ്രാഫിക്കൽ പ്രാതിനിധ്യം നിങ്ങൾ കണ്ടെത്തും
പ്രമാണീകരണം. ആരംഭിക്കാനുള്ള ഒരു നല്ല സ്ഥലമാണ് NS-3 മൊഡ്യൂളുകൾ "പുസ്തകം" എന്നതിൽ ns-3 വഴികാട്ടി
വൃക്ഷം. നിങ്ങൾ വികസിപ്പിക്കുകയാണെങ്കിൽ മൊഡ്യൂളുകൾ നിങ്ങൾ ഒരു ലിസ്റ്റ് കാണും ns-3 മൊഡ്യൂൾ ഡോക്യുമെന്റേഷൻ. ദി
മൊഡ്യൂളിന്റെ ആശയം ഇവിടെ നേരിട്ട് മൊഡ്യൂളുമായി ബന്ധിപ്പിക്കുന്നു, മുകളിൽ ചർച്ച ചെയ്ത ഫയലുകൾ ഉൾപ്പെടുന്നു. ദി
ns-3 ലോഗിംഗ് സബ്സിസ്റ്റം എന്നതിൽ ചർച്ചചെയ്യുന്നു സി ++ നിർമ്മിക്കുന്നു ഉപയോഗിച്ച by എല്ലാം മൊഡ്യൂളുകൾ വിഭാഗം, അങ്ങനെ
മുന്നോട്ട് പോയി ആ ​​ഡോക്യുമെന്റേഷൻ നോഡ് വികസിപ്പിക്കുക. ഇപ്പോൾ, വികസിപ്പിക്കുക ഡീബഗ്ഗിംഗ് പുസ്തകം പിന്നെ
തിരഞ്ഞെടുക്കുക ലോഗ് ചെയ്യുന്നു പേജ്.

നിങ്ങൾ ഇപ്പോൾ ലോഗിംഗ് മൊഡ്യൂളിനായുള്ള ഡോക്‌സിജൻ ഡോക്യുമെന്റേഷനാണ് നോക്കുന്നത്. ൽ
ലിസ്റ്റ് # നിർവചിക്കുകപേജിന്റെ മുകളിൽ നിങ്ങൾ എൻട്രി കാണും
NS_LOG_COMPONENT_DEFINE. ചാടുന്നതിന് മുമ്പ്, അത് അന്വേഷിക്കുന്നത് നല്ലതായിരിക്കും
മൊത്തത്തിലുള്ള പ്രവർത്തനത്തിന്റെ അനുഭവം ലഭിക്കുന്നതിന് ലോഗിംഗ് മൊഡ്യൂളിന്റെ "വിശദമായ വിവരണം". നിങ്ങൾ
ഒന്നുകിൽ താഴേക്ക് സ്ക്രോൾ ചെയ്യാം അല്ലെങ്കിൽ ചെയ്യാൻ സഹകരണ ഡയഗ്രാമിന് താഴെയുള്ള "കൂടുതൽ..." ലിങ്ക് തിരഞ്ഞെടുക്കുക
ഈ.

എന്താണ് സംഭവിക്കുന്നതെന്ന് നിങ്ങൾക്ക് പൊതുവായ ഒരു ധാരണ ലഭിച്ചുകഴിഞ്ഞാൽ, മുന്നോട്ട് പോയി നിർദ്ദിഷ്ടമായി നോക്കുക
NS_LOG_COMPONENT_DEFINE പ്രമാണീകരണം. ഞാൻ ഇവിടെ ഡോക്യുമെന്റേഷൻ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യില്ല, പക്ഷേ
സംഗ്രഹിക്കുക, ഈ വരി ഒരു ലോഗിംഗ് ഘടകം പ്രഖ്യാപിക്കുന്നു ഫസ്റ്റ്സ്ക്രിപ്റ്റ് ഉദാഹരണം അത് അനുവദിക്കും
പേര് റഫറൻസ് വഴി കൺസോൾ സന്ദേശ ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുകയും പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുക.

മെയിൻ ഫംഗ്ഷൻ
സ്ക്രിപ്റ്റിന്റെ അടുത്ത വരികൾ നിങ്ങൾ കണ്ടെത്തും,

int
പ്രധാനം (int argc, char *argv[])
{

ഇത് നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ (സ്ക്രിപ്റ്റ്) പ്രധാന പ്രവർത്തനത്തിന്റെ പ്രഖ്യാപനം മാത്രമാണ്. ഉള്ളതുപോലെ തന്നെ
ഏതെങ്കിലും C++ പ്രോഗ്രാം, നിങ്ങൾ ഒരു പ്രധാന ഫംഗ്ഷൻ നിർവചിക്കേണ്ടതുണ്ട്, അത് ആദ്യ ഫംഗ്ഷൻ റൺ ആയിരിക്കും.
ഇവിടെ പ്രത്യേകിച്ചൊന്നും ഇല്ല. നിങ്ങളുടെ ns-3 സ്ക്രിപ്റ്റ് ഒരു C++ പ്രോഗ്രാം മാത്രമാണ്.

അടുത്ത വരി സമയ മിഴിവ് ഒരു നാനോ സെക്കൻഡായി സജ്ജമാക്കുന്നു, അത് സ്ഥിരസ്ഥിതിയായി മാറുന്നു
മൂല്യം:

സമയം :: സെറ്റ് റെസല്യൂഷൻ (സമയം :: NS);

പ്രതിനിധീകരിക്കാൻ കഴിയുന്ന ഏറ്റവും ചെറിയ സമയ മൂല്യമാണ് റെസല്യൂഷൻ (അതുപോലെ തന്നെ ഏറ്റവും ചെറുത്
രണ്ട് സമയ മൂല്യങ്ങൾ തമ്മിലുള്ള പ്രതിനിധീകരിക്കാവുന്ന വ്യത്യാസം). നിങ്ങൾക്ക് റെസല്യൂഷൻ കൃത്യമായി മാറ്റാൻ കഴിയും
ഒരിക്കല്. ഈ ഫ്ലെക്സിബിലിറ്റി പ്രവർത്തനക്ഷമമാക്കുന്ന സംവിധാനം ഒരു പരിധിവരെ മെമ്മറി ഹംഗറിയാണ്, അതിനാൽ ഒരിക്കൽ
റെസല്യൂഷൻ വ്യക്തമായി സജ്ജീകരിച്ചിരിക്കുന്നു, ഞങ്ങൾ മെമ്മറി റിലീസ് ചെയ്യുന്നു, കൂടുതൽ അപ്‌ഡേറ്റുകൾ തടയുന്നു.
(നിങ്ങൾ റെസല്യൂഷൻ വ്യക്തമായി സജ്ജീകരിച്ചില്ലെങ്കിൽ, അത് ഒരു നാനോ സെക്കൻഡ് സ്ഥിരസ്ഥിതിയാകും, കൂടാതെ
സിമുലേഷൻ ആരംഭിക്കുമ്പോൾ മെമ്മറി റിലീസ് ചെയ്യും.)

സ്ക്രിപ്റ്റിന്റെ അടുത്ത രണ്ട് വരികൾ നിർമ്മിച്ചിരിക്കുന്ന രണ്ട് ലോഗിംഗ് ഘടകങ്ങൾ പ്രവർത്തനക്ഷമമാക്കാൻ ഉപയോഗിക്കുന്നു
എക്കോ ക്ലയന്റ്, എക്കോ സെർവർ ആപ്ലിക്കേഷനുകളിലേക്ക്:

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

നിങ്ങൾ ലോഗിംഗ് ഘടക ഡോക്യുമെന്റേഷൻ വായിച്ചിട്ടുണ്ടെങ്കിൽ അത് അവിടെ കാണും
ഓരോ ഘടകത്തിലും നിങ്ങൾക്ക് പ്രവർത്തനക്ഷമമാക്കാൻ കഴിയുന്ന ലോഗിംഗ് വെർബോസിറ്റി/വിശദാംശത്തിന്റെ നിരവധി ലെവലുകളാണ്.
ഈ രണ്ട് കോഡുകളും എക്കോ ക്ലയന്റുകൾക്ക് INFO ലെവലിൽ ഡീബഗ് ലോഗിംഗ് പ്രാപ്തമാക്കുന്നു
സെർവറുകൾ. പാക്കറ്റുകൾ അയയ്‌ക്കുമ്പോൾ സന്ദേശങ്ങൾ ആപ്ലിക്കേഷൻ പ്രിന്റുചെയ്യുന്നതിന് ഇത് കാരണമാകും
സിമുലേഷൻ സമയത്ത് ലഭിച്ചു.

ഇപ്പോൾ നമുക്ക് ഒരു ടോപ്പോളജി സൃഷ്ടിക്കുന്നതിനും ഒരു സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള ബിസിനസ്സിലേക്ക് നേരിട്ട് പോകാം.
ഈ ജോലി കഴിയുന്നത്ര എളുപ്പമാക്കാൻ ഞങ്ങൾ ടോപ്പോളജി സഹായ വസ്തുക്കൾ ഉപയോഗിക്കുന്നു.

ടോപ്പോളജി സഹായികൾ
നോഡ് കണ്ടെയ്നർ
ഞങ്ങളുടെ സ്ക്രിപ്റ്റിലെ അടുത്ത രണ്ട് വരി കോഡ് യഥാർത്ഥത്തിൽ സൃഷ്ടിക്കും ns-3 നോഡ് വസ്തുക്കൾ
സിമുലേഷനിലെ കമ്പ്യൂട്ടറുകളെ പ്രതിനിധീകരിക്കും.

നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
നോഡുകൾ.സൃഷ്ടിക്കുക (2);

അതിനുള്ള ഡോക്യുമെന്റേഷൻ കണ്ടെത്താം നോഡ് കണ്ടെയ്നർ ഞങ്ങൾ തുടരുന്നതിന് മുമ്പ് ക്ലാസ്. മറ്റൊരു വഴി
തന്നിരിക്കുന്ന ക്ലാസിലെ ഡോക്യുമെന്റേഷനിൽ പ്രവേശിക്കുന്നത് ഇതുവഴിയാണ് ക്ലാസുകൾ ഡോക്‌സിജനിലെ ടാബ്
പേജുകൾ. നിങ്ങൾക്ക് ഇപ്പോഴും Doxygen ഹാൻഡിലുണ്ടെങ്കിൽ, പേജിന്റെ മുകളിലേക്ക് സ്ക്രോൾ ചെയ്യുക
തിരഞ്ഞെടുക്കുക ക്ലാസുകൾ ടാബ്. ഒരു പുതിയ ടാബുകൾ ദൃശ്യമാകുന്നത് നിങ്ങൾ കാണും, അതിലൊന്നാണ് ക്ലാസ്
പട്ടിക. ആ ടാബിന് കീഴിൽ നിങ്ങൾ എല്ലാറ്റിന്റെയും ഒരു ലിസ്റ്റ് കാണും 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 "5Mbps" (സെക്കൻഡിൽ അഞ്ച് മെഗാബിറ്റ്) എന്ന മൂല്യം ഉപയോഗിക്കുന്നതിന് ഒബ്ജക്റ്റ്
"DataRate" സൃഷ്ടിക്കുമ്പോൾ a PointToPointNetDevice വസ്തു

കൂടുതൽ വിശദമായ വീക്ഷണകോണിൽ, "DataRate" എന്ന സ്ട്രിംഗ് നമ്മൾ വിളിക്കുന്നവയുമായി യോജിക്കുന്നു
ഗുണങ്ങളെ എന്ന PointToPointNetDevice. ക്ലാസിനുള്ള ഡോക്സിജൻ നോക്കിയാൽ
ns3::PointToPointNetDevice അതിനുള്ള ഡോക്യുമെന്റേഷൻ കണ്ടെത്തുക GetTypeId രീതി, നിങ്ങൾ ചെയ്യും
ഒരു ലിസ്റ്റ് കണ്ടെത്തുക ഗുണവിശേഷങ്ങൾ ഉപകരണത്തിനായി നിർവ്വചിച്ചിരിക്കുന്നു. ഇവയിൽ "ഡാറ്റ റേറ്റ്" ഉൾപ്പെടുന്നു
ഗുണങ്ങളെ. ഏറ്റവും കൂടുതൽ ഉപയോക്താക്കൾക്ക് ദൃശ്യമാണ് ns-3 ഒബ്‌ജക്‌റ്റുകൾക്ക് സമാനമായ ലിസ്റ്റുകളുണ്ട് ഗുണവിശേഷങ്ങൾ. ഞങ്ങൾ ഇത് ഉപയോഗിക്കുന്നു
നിങ്ങൾ എയിൽ കാണുന്നത് പോലെ വീണ്ടും കംപൈൽ ചെയ്യാതെ സിമുലേഷനുകൾ എളുപ്പത്തിൽ ക്രമീകരിക്കാനുള്ള സംവിധാനം
ഇനിപ്പറയുന്ന വിഭാഗം.

എന്നതിലെ "ഡാറ്ററേറ്റിന്" സമാനമാണ് PointToPointNetDevice നിങ്ങൾ ഒരു "കാലതാമസം" കണ്ടെത്തും ഗുണങ്ങളെ
ഇതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു PointToPointChannel. അവസാന വരി,

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

പറയുന്നു PointToPointHelper മൂല്യമായി "2ms" (രണ്ട് മില്ലിസെക്കൻഡ്) മൂല്യം ഉപയോഗിക്കുന്നതിന്
ഓരോ പോയിന്റ് ടു പോയിന്റ് ചാനലിന്റെയും ട്രാൻസ്മിഷൻ കാലതാമസം അത് പിന്നീട് സൃഷ്ടിക്കുന്നു.

NetDeviceContainer
സ്ക്രിപ്റ്റിലെ ഈ ഘട്ടത്തിൽ, നമുക്ക് എ നോഡ് കണ്ടെയ്നർ അതിൽ രണ്ട് നോഡുകൾ അടങ്ങിയിരിക്കുന്നു. ഞങ്ങൾക്ക് എ
PointToPointHelper അത് പ്രൈം ചെയ്ത് ഉണ്ടാക്കാൻ തയ്യാറാണ് PointToPointNetDevices വയർ
PointToPointChannel അവയ്ക്കിടയിലുള്ള വസ്തുക്കൾ. ഞങ്ങൾ ഉപയോഗിച്ചതുപോലെ നോഡ് കണ്ടെയ്നർ ടോപ്പോളജി
സൃഷ്ടിക്കാൻ സഹായിക്കുന്ന ഒബ്ജക്റ്റ് നോഡുകൾ ഞങ്ങളുടെ സിമുലേഷനായി, ഞങ്ങൾ ചോദിക്കും PointToPointHelper
ഞങ്ങൾക്കായി ഞങ്ങളുടെ ഉപകരണങ്ങൾ സൃഷ്‌ടിക്കുന്നതിലും കോൺഫിഗർ ചെയ്യുന്നതിലും ഇൻസ്റ്റാൾ ചെയ്യുന്നതിലും ഉൾപ്പെട്ടിരിക്കുന്ന ജോലി ചെയ്യാൻ. ഞങ്ങൾ
സൃഷ്ടിക്കപ്പെട്ട എല്ലാ NetDevice ഒബ്‌ജക്‌റ്റുകളുടെയും ഒരു ലിസ്റ്റ് ഉണ്ടായിരിക്കണം, അതിനാൽ ഞങ്ങൾ a ഉപയോഗിക്കുന്നു
ഞങ്ങൾ നോഡുകൾ പിടിക്കാൻ ഒരു NodeContainer ഉപയോഗിക്കുന്നതുപോലെ അവയെ പിടിക്കാൻ NetDeviceContainer
സൃഷ്ടിച്ചു. കോഡിന്റെ ഇനിപ്പറയുന്ന രണ്ട് വരികൾ,

NetDeviceContainer ഉപകരണങ്ങൾ;
ഉപകരണങ്ങൾ = pointToPoint.Install (നോഡുകൾ);

ഉപകരണങ്ങളും ചാനലും കോൺഫിഗർ ചെയ്യുന്നത് പൂർത്തിയാക്കും. ആദ്യ വരി ഉപകരണം പ്രഖ്യാപിക്കുന്നു
മുകളിൽ സൂചിപ്പിച്ച കണ്ടെയ്നർ, രണ്ടാമത്തേത് ഹെവി ലിഫ്റ്റിംഗ് ചെയ്യുന്നു. ദി ഇൻസ്റ്റോൾ രീതി
The PointToPointHelper ഒരു എ നോഡ് കണ്ടെയ്നർ ഒരു പരാമീറ്ററായി. ആന്തരികമായി, എ
NetDeviceContainer സൃഷ്ടിക്കപ്പെടുന്നു. ലെ ഓരോ നോഡിനും നോഡ് കണ്ടെയ്നർ (കൃത്യമായി ഉണ്ടായിരിക്കണം
പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന് രണ്ട്) a PointToPointNetDevice ഉപകരണത്തിൽ സൃഷ്ടിക്കുകയും സംരക്ഷിക്കുകയും ചെയ്യുന്നു
കണ്ടെയ്നർ. എ PointToPointChannel സൃഷ്ടിക്കപ്പെട്ടതും രണ്ടും PointToPointNetDevices ആകുന്നു
ഘടിപ്പിച്ചിരിക്കുന്നു. വസ്തുക്കൾ സൃഷ്ടിക്കുമ്പോൾ PointToPointHelper, ഗുണവിശേഷങ്ങൾ മുമ്പ്
ഹെൽപ്പറിൽ സജ്ജീകരിച്ചത് അനുബന്ധം ആരംഭിക്കാൻ ഉപയോഗിക്കുന്നു ഗുണവിശേഷങ്ങൾ സൃഷ്ടിച്ചതിൽ
വസ്തുക്കൾ.

നടപ്പിലാക്കിയ ശേഷം pointToPoint.ഇൻസ്റ്റാൾ ചെയ്യുക (നോഡുകൾ) വിളിക്കുക നമുക്ക് രണ്ട് നോഡുകൾ ഉണ്ടാകും, ഓരോന്നിനും ഒന്ന്
പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണവും അവയ്ക്കിടയിൽ ഒരൊറ്റ പോയിന്റ്-ടു-പോയിന്റ് ചാനലും ഇൻസ്റ്റാൾ ചെയ്തു.
രണ്ട് ഉപകരണങ്ങളും സെക്കൻഡിൽ അഞ്ച് മെഗാബിറ്റ് വേഗതയിൽ ഡാറ്റ കൈമാറാൻ കോൺഫിഗർ ചെയ്യപ്പെടും
രണ്ട് മില്ലിസെക്കൻഡ് ട്രാൻസ്മിഷൻ കാലതാമസമുള്ള ചാനൽ.

InternetStackHelper
ഞങ്ങൾക്ക് ഇപ്പോൾ നോഡുകളും ഉപകരണങ്ങളും കോൺഫിഗർ ചെയ്‌തിട്ടുണ്ട്, പക്ഷേ ഞങ്ങൾക്ക് പ്രോട്ടോക്കോൾ സ്റ്റാക്കുകളൊന്നും ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല
ഞങ്ങളുടെ നോഡുകളിൽ. കോഡിന്റെ അടുത്ത രണ്ട് വരികൾ അത് ശ്രദ്ധിക്കും.

InternetStackHelper സ്റ്റാക്ക്;
സ്റ്റാക്ക്.ഇൻസ്റ്റാൾ (നോഡുകൾ);

ദി InternetStackHelper ഇൻറർനെറ്റ് സ്റ്റാക്ക് ചെയ്യുന്ന ഒരു ടോപ്പോളജി സഹായിയാണ്
PointToPointHelper പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണങ്ങൾ ആണ്. ദി ഇൻസ്റ്റോൾ രീതി a എടുക്കുന്നു
നോഡ് കണ്ടെയ്നർ ഒരു പരാമീറ്ററായി. ഇത് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അത് ഒരു ഇന്റർനെറ്റ് സ്റ്റാക്ക് ഇൻസ്റ്റാൾ ചെയ്യും
(TCP, UDP, IP, മുതലായവ) നോഡ് കണ്ടെയ്നറിലെ ഓരോ നോഡിലും.

Ipv4 വിലാസം സഹായി
അടുത്തതായി നമ്മുടെ നോഡുകളിലെ ഉപകരണങ്ങളെ IP വിലാസങ്ങളുമായി ബന്ധപ്പെടുത്തേണ്ടതുണ്ട്. ഞങ്ങൾ എ നൽകുന്നു
ഐപി വിലാസങ്ങളുടെ അലോക്കേഷൻ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ടോപ്പോളജി സഹായി. ഉപയോക്താക്കൾക്ക് കാണാവുന്ന ഒരേയൊരു API ആണ്
യഥാർത്ഥ വിലാസം നിർവ്വഹിക്കുമ്പോൾ ഉപയോഗിക്കുന്നതിന് അടിസ്ഥാന IP വിലാസവും നെറ്റ്‌വർക്ക് മാസ്കും സജ്ജമാക്കുക
അലോക്കേഷൻ (ഇത് സഹായിയുടെ ഉള്ളിൽ താഴ്ന്ന തലത്തിലാണ് ചെയ്യുന്നത്).

ഞങ്ങളുടെ ഉദാഹരണ സ്ക്രിപ്റ്റിലെ കോഡിന്റെ അടുത്ത രണ്ട് വരികൾ, ആദ്യം.cc,

Ipv4Addressസഹായ വിലാസം;
വിലാസം.സെറ്റ്ബേസ് ("10.1.1.0", "255.255.255.0");

ഒരു അഡ്രസ് ഹെൽപ്പർ ഒബ്‌ജക്റ്റ് പ്രഖ്യാപിക്കുകയും അത് IP വിലാസങ്ങൾ അനുവദിക്കാൻ തുടങ്ങണമെന്ന് പറയുകയും ചെയ്യുക
നെറ്റ്‌വർക്ക് 10.1.1.0-ൽ നിന്ന് 255.255.255.0 മാസ്ക് ഉപയോഗിച്ച് അലോക്കേറ്റബിൾ ബിറ്റുകൾ നിർവചിക്കുക. എഴുതിയത്
സ്ഥിരസ്ഥിതിയായി അനുവദിച്ച വിലാസങ്ങൾ ഒന്നിൽ ആരംഭിക്കുകയും ഏകതാനമായി വർദ്ധിക്കുകയും ചെയ്യും, അതിനാൽ ആദ്യത്തേത്
ഈ ബേസിൽ നിന്ന് അനുവദിച്ച വിലാസം 10.1.1.1 ആയിരിക്കും, തുടർന്ന് 10.1.1.2, മുതലായവ
ലെവൽ ns-3 അനുവദിച്ചിട്ടുള്ള എല്ലാ IP വിലാസങ്ങളും സിസ്റ്റം യഥാർത്ഥത്തിൽ ഓർക്കുന്നു, അത് സൃഷ്ടിക്കും
നിങ്ങൾ അബദ്ധവശാൽ ഒരേ വിലാസം രണ്ടുതവണ ജനറേറ്റുചെയ്യാൻ ഇടയാക്കിയാൽ മാരകമായ പിശക് (അത് a
പിശക് ഡീബഗ് ചെയ്യാൻ വളരെ ബുദ്ധിമുട്ടാണ്, വഴി).

കോഡിന്റെ അടുത്ത വരി,

Ipv4InterfaceContainer ഇന്റർഫേസുകൾ = വിലാസം.അസൈൻ (ഉപകരണങ്ങൾ);

യഥാർത്ഥ വിലാസ അസൈൻമെന്റ് നിർവഹിക്കുന്നു. ഇൻ ns-3 ഞങ്ങൾ ഒരു IP തമ്മിലുള്ള ബന്ധം ഉണ്ടാക്കുന്നു
വിലാസവും ഒരു ഉപയോഗിക്കുന്ന ഉപകരണവും Ipv4 ഇന്റർഫേസ് വസ്തു. നമുക്ക് ചിലപ്പോൾ ഒരു ലിസ്റ്റ് ആവശ്യമായി വരുന്നതുപോലെ
ഭാവി റഫറൻസിനായി ഒരു സഹായി സൃഷ്ടിച്ച നെറ്റ് ഉപകരണങ്ങൾ നമുക്ക് ചിലപ്പോൾ ഒരു ലിസ്റ്റ് ആവശ്യമാണ്
Ipv4 ഇന്റർഫേസ് വസ്തുക്കൾ. ദി Ipv4InterfaceContainer ഈ പ്രവർത്തനം നൽകുന്നു.

ഇപ്പോൾ നമുക്ക് ഒരു പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ്‌വർക്ക് നിർമ്മിച്ചിട്ടുണ്ട്, സ്റ്റാക്കുകളും IP വിലാസങ്ങളും ഇൻസ്റ്റാൾ ചെയ്തു
ചുമതലപ്പെടുത്തി. ഈ ഘട്ടത്തിൽ നമുക്ക് വേണ്ടത് ട്രാഫിക് സൃഷ്ടിക്കുന്നതിനുള്ള ആപ്ലിക്കേഷനുകളാണ്.

അപ്ലിക്കേഷനുകൾ
ns-3 സിസ്റ്റത്തിന്റെ മറ്റൊരു പ്രധാന സംഗ്രഹമാണ് അപേക്ഷ. ഇതിൽ
സ്ക്രിപ്റ്റ് ഞങ്ങൾ കോറിന്റെ രണ്ട് സ്പെഷ്യലൈസേഷനുകൾ ഉപയോഗിക്കുന്നു ns-3 ക്ലാസ് അപേക്ഷ വിളിച്ചു
UdpEchoServerApplication ഒപ്പം UdpEchoClientApplication. ഞങ്ങളുടെ മുമ്പത്തെപ്പോലെ തന്നെ
വിശദീകരണങ്ങൾ, അടിസ്ഥാന ഒബ്‌ജക്‌റ്റുകൾ ക്രമീകരിക്കാനും നിയന്ത്രിക്കാനും സഹായിക്കുന്നതിന് ഞങ്ങൾ സഹായ ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിക്കുന്നു.
ഇവിടെ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു UdpEchoServerHelper ഒപ്പം UdpEchoClientHelper നമ്മുടെ ജീവിതം എളുപ്പമാക്കാനുള്ള വസ്തുക്കൾ.

UdpEchoServerHelper
ഞങ്ങളുടെ ഉദാഹരണ സ്ക്രിപ്റ്റിലെ കോഡിന്റെ ഇനിപ്പറയുന്ന വരികൾ, ആദ്യം.cc, ഒരു UDP എക്കോ സജ്ജീകരിക്കാൻ ഉപയോഗിക്കുന്നു
ഞങ്ങൾ മുമ്പ് സൃഷ്ടിച്ച നോഡുകളിലൊന്നിലെ സെർവർ ആപ്ലിക്കേഷൻ.

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
serverApps.Start (സെക്കൻഡ് (1.0));
serverApps.Stop (സെക്കൻഡ് (10.0));

മുകളിലെ സ്‌നിപ്പെറ്റിലെ ആദ്യ വരി കോഡ് പ്രഖ്യാപിക്കുന്നു UdpEchoServerHelper. സാധാരണത്തേത് പോലെ,
ഇത് ആപ്ലിക്കേഷൻ തന്നെയല്ല, യഥാർത്ഥമായത് സൃഷ്ടിക്കാൻ ഞങ്ങളെ സഹായിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു വസ്തുവാണ് ഇത്
അപേക്ഷകൾ. സ്ഥാപിക്കുക എന്നതാണ് ഞങ്ങളുടെ കൺവെൻഷനുകളിലൊന്ന് ആവശ്യമാണ് ഗുണവിശേഷങ്ങൾ സഹായിയിൽ
കൺസ്ട്രക്റ്റർ. ഈ സാഹചര്യത്തിൽ, സഹായി നൽകിയിട്ടില്ലെങ്കിൽ ഉപകാരപ്രദമായ ഒന്നും ചെയ്യാൻ കഴിയില്ല
ക്ലയന്റിനും അറിയാവുന്ന ഒരു പോർട്ട് നമ്പർ. ഒരെണ്ണം തിരഞ്ഞെടുത്ത് പ്രതീക്ഷിക്കുന്നതിനുപകരം
എല്ലാം പ്രവർത്തിക്കുന്നു, കൺസ്ട്രക്റ്ററിന് ഒരു പാരാമീറ്ററായി ഞങ്ങൾക്ക് പോർട്ട് നമ്പർ ആവശ്യമാണ്. ദി
കൺസ്ട്രക്റ്റർ, അതാകട്ടെ, ലളിതമായി ഒരു ചെയ്യുന്നു സെറ്റ് ആട്രിബ്യൂട്ട് പാസ്സായ മൂല്യത്തോടൊപ്പം. നിങ്ങൾക്ക് വേണമെങ്കിൽ, നിങ്ങൾ
"പോർട്ട്" സജ്ജമാക്കാൻ കഴിയും ഗുണങ്ങളെ പിന്നീട് ഉപയോഗിക്കുന്ന മറ്റൊരു മൂല്യത്തിലേക്ക് സെറ്റ് ആട്രിബ്യൂട്ട്.

മറ്റ് പല സഹായ വസ്തുക്കളും പോലെ, ദി UdpEchoServerHelper വസ്തുവിന് ഒരു ഉണ്ട് ഇൻസ്റ്റോൾ
രീതി. ഈ രീതിയുടെ നിർവ്വഹണമാണ് യഥാർത്ഥത്തിൽ അന്തർലീനമായ പ്രതിധ്വനി ഉണ്ടാക്കുന്നത്
സെർവർ ആപ്ലിക്കേഷൻ തൽക്ഷണം ചെയ്ത് ഒരു നോഡിൽ ഘടിപ്പിക്കണം. രസകരമെന്നു പറയട്ടെ, ദി ഇൻസ്റ്റോൾ
രീതി a എടുക്കുന്നു നോഡ് കണ്ടെയ്‌നർ മറ്റൊന്ന് പോലെ ഒരു പരാമീറ്ററായി ഇൻസ്റ്റോൾ നമുക്കുള്ള രീതികൾ
കണ്ടു. കാണുന്നില്ലെങ്കിലും യഥാർത്ഥത്തിൽ ഇത് രീതിയിലേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു
ഈ കാര്യം. ഒരു C++ ഉണ്ട് അബോധാവസ്ഥ പരിവർത്തനം ഇവിടെ ജോലി ചെയ്യുമ്പോൾ അത് ഫലം എടുക്കുന്നു
നോഡുകൾ.നേടുക (1) (ഇത് ഒരു നോഡ് ഒബ്‌ജക്റ്റിലേക്ക് ഒരു സ്മാർട്ട് പോയിന്റർ തിരികെ നൽകുന്നു --- Ptr) കൂടാതെ അത് ഉപയോഗിക്കുന്നു
പേരില്ലാത്ത ഒരു കൺസ്ട്രക്‌ടറിൽ നോഡ് കണ്ടെയ്നർ അത് പിന്നീട് കൈമാറുന്നു ഇൻസ്റ്റോൾ. നിങ്ങളാണെങ്കിൽ
കംപൈൽ ചെയ്യുകയും റൺ ചെയ്യുകയും ചെയ്യുന്ന C++ കോഡിൽ ഒരു പ്രത്യേക മെത്തേഡ് സിഗ്നേച്ചർ കണ്ടെത്തുന്നത് എപ്പോഴെങ്കിലും നഷ്ടത്തിലാണ്
കൊള്ളാം, ഇത്തരം പരോക്ഷമായ പരിവർത്തനങ്ങൾക്കായി നോക്കുക.

അത് നമ്മൾ ഇപ്പോൾ കാണുന്നു echoServer.Install എ ഇൻസ്റ്റാൾ ചെയ്യാൻ പോകുന്നു UdpEchoServerApplication ന്
സൂചികയുടെ ഒന്നാം നമ്പറിൽ നോഡ് കണ്ടെത്തി നോഡ് കണ്ടെയ്നർ ഞങ്ങൾ ഞങ്ങളുടെ നോഡുകൾ കൈകാര്യം ചെയ്യാറുണ്ടായിരുന്നു. ഇൻസ്റ്റോൾ
എല്ലാ ആപ്ലിക്കേഷനുകളിലേക്കും പോയിന്ററുകൾ സൂക്ഷിക്കുന്ന ഒരു കണ്ടെയ്നർ തിരികെ നൽകും (ഈ സാഹചര്യത്തിൽ ഒന്ന്
ഞങ്ങൾ എ പാസ്സായതിനാൽ നോഡ് കണ്ടെയ്നർ ഒരു നോഡ് അടങ്ങിയിരിക്കുന്നു) സഹായി സൃഷ്ടിച്ചത്.

ട്രാഫിക്ക് സൃഷ്‌ടിക്കുന്നത് "ആരംഭിക്കാൻ" അപ്ലിക്കേഷനുകൾക്ക് ഒരു സമയം ആവശ്യമാണ്, അതിന് ഒരു ഓപ്‌ഷണൽ സമയമെടുത്തേക്കാം
"നിർത്തുക". ഞങ്ങൾ രണ്ടും നൽകുന്നു. ഉപയോഗിച്ചാണ് ഈ സമയങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നത് ആപ്ലിക്കേഷൻ കണ്ടെയ്നർ രീതികൾ
ആരംഭിക്കുക ഒപ്പം നിർത്തുക. ഈ രീതികൾ എടുക്കുന്നു കാലം പരാമീറ്ററുകൾ. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഒരു ഉപയോഗിക്കുന്നു സ്പഷ്ടമായത് സി ++
C++ ഇരട്ട 1.0 എടുത്ത് ഒരു ആക്കി മാറ്റുന്നതിനുള്ള പരിവർത്തന ക്രമം ns-3 കാലം ഉപയോഗിക്കുന്ന വസ്തു
a സെക്കൻഡ് കാസ്റ്റ്. പരിവർത്തന നിയമങ്ങൾ മോഡൽ രചയിതാവിനാൽ നിയന്ത്രിക്കപ്പെടാമെന്ന കാര്യം ശ്രദ്ധിക്കുക,
കൂടാതെ C++ നും അതിന്റേതായ നിയമങ്ങളുണ്ട്, അതിനാൽ പാരാമീറ്ററുകൾ സന്തോഷകരമാകുമെന്ന് നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഊഹിക്കാനാവില്ല
നിങ്ങൾക്കായി പരിവർത്തനം ചെയ്തു. രണ്ട് വരികൾ,

serverApps.Start (സെക്കൻഡ് (1.0));
serverApps.Stop (സെക്കൻഡ് (10.0));

എക്കോ സെർവർ ആപ്ലിക്കേഷന് കാരണമാകും ആരംഭിക്കുക (സ്വയം പ്രാപ്തമാക്കുക) ഒരു സെക്കൻഡിൽ
സിമുലേഷൻ ആൻഡ് ടു നിർത്തുക സിമുലേഷനിൽ പത്ത് സെക്കൻഡിൽ (സ്വയം പ്രവർത്തനരഹിതമാക്കുക). ബലത്തില്
ഞങ്ങൾ ഒരു സിമുലേഷൻ ഇവന്റ് (അപ്ലിക്കേഷൻ സ്റ്റോപ്പ് ഇവന്റ്) പ്രഖ്യാപിച്ചിട്ടുണ്ട്
പത്ത് സെക്കൻഡിൽ നിർവ്വഹിച്ചാൽ, സിമുലേഷൻ നീണ്ടുനിൽക്കും at കുറഞ്ഞത് പത്ത് സെക്കൻഡ്.

UdpEchoClientHelper
എക്കോ ക്ലയന്റ് ആപ്ലിക്കേഷൻ സജ്ജീകരിച്ചിരിക്കുന്നത് അതിന് സമാനമായ ഒരു രീതിയിലാണ്
സെർവർ. ഒരു അടിയൊഴുക്കുണ്ട് UdpEchoClientApplication അത് നിയന്ത്രിക്കുന്നത് ഒരു ആണ്
UdpEchoClientHelper.

UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("ഇന്റർവെൽ", ടൈംവാല്യൂ (സെക്കൻഡ് (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
clientApps.Start (സെക്കൻഡ് (2.0));
clientApps.Stop (സെക്കൻഡ് (10.0));

എക്കോ ക്ലയന്റിനായി, ഞങ്ങൾ അഞ്ച് വ്യത്യസ്തമായി സജ്ജീകരിക്കേണ്ടതുണ്ട് ഗുണവിശേഷങ്ങൾ. ആദ്യ രണ്ട്
ഗുണവിശേഷങ്ങൾ നിർമ്മാണ സമയത്ത് സജ്ജീകരിച്ചിരിക്കുന്നു UdpEchoClientHelper. ഞങ്ങൾ പാരാമീറ്ററുകൾ കൈമാറുന്നു
"റിമോട്ട് അഡ്രസ്", "റിമോട്ട് പോർട്ട്" എന്നിവ സജ്ജീകരിക്കാൻ (ആന്തരികമായി സഹായിക്ക്) ഉപയോഗിക്കുന്നു
ഗുണവിശേഷങ്ങൾ ഞങ്ങളുടെ കൺവെൻഷൻ അനുസരിച്ച് ആവശ്യപ്പെടുക ഗുണവിശേഷങ്ങൾ ലെ പാരാമീറ്ററുകൾ
സഹായ നിർമ്മാതാക്കൾ.

ഞങ്ങൾ ഉപയോഗിച്ചത് ഓർക്കുക Ipv4InterfaceContainer ഞങ്ങൾ IP വിലാസങ്ങളുടെ ട്രാക്ക് സൂക്ഷിക്കാൻ
ഞങ്ങളുടെ ഉപകരണങ്ങളിലേക്ക് അസൈൻ ചെയ്‌തിരിക്കുന്നു. ലെ സീറോത്ത് ഇന്റർഫേസ് ഇന്റർഫേസുകൾ കണ്ടെയ്നർ പോകുന്നു
ലെ സീറോത്ത് നോഡിന്റെ IP വിലാസവുമായി പൊരുത്തപ്പെടുന്നു നോഡുകൾ കണ്ടെയ്നർ. ആദ്യത്തേത്
ഇൻ ഇന്റർഫേസ് ഇന്റർഫേസുകൾ കണ്ടെയ്നർ ആദ്യത്തെ നോഡിന്റെ IP വിലാസവുമായി പൊരുത്തപ്പെടുന്നു
The നോഡുകൾ കണ്ടെയ്നർ. അതിനാൽ, കോഡിന്റെ ആദ്യ വരിയിൽ (മുകളിൽ നിന്ന്), ഞങ്ങൾ സൃഷ്ടിക്കുന്നു
സഹായി, അത് പറയുക, അതിനാൽ ക്ലയന്റിന്റെ റിമോട്ട് വിലാസം ഐപി വിലാസമായി സജ്ജമാക്കുക
സെർവർ താമസിക്കുന്ന നോഡിലേക്ക് അസൈൻ ചെയ്‌തിരിക്കുന്നു. അയക്കാൻ ഏർപ്പാടാക്കാനും ഞങ്ങൾ പറയുന്നു
ഒൻപത് പോർട്ടിലേക്കുള്ള പാക്കറ്റുകൾ.

"മാക്സ്പാക്കറ്റുകൾ" ഗുണങ്ങളെ ഞങ്ങൾ അനുവദിക്കുന്ന പരമാവധി പാക്കറ്റുകളുടെ എണ്ണം ക്ലയന്റിനോട് പറയുന്നു
സിമുലേഷൻ സമയത്ത് അയയ്ക്കുക. "ഇടവേള" ഗുണങ്ങളെ എത്ര സമയം കാത്തിരിക്കണമെന്ന് ക്ലയന്റിനോട് പറയുന്നു
പാക്കറ്റുകൾക്കും "പാക്കറ്റ് വലുപ്പത്തിനും" ഇടയിൽ ഗുണങ്ങളെ അതിന്റെ പാക്കറ്റ് എത്ര വലുതാണെന്ന് ക്ലയന്റിനോട് പറയുന്നു
പേലോഡുകൾ ആയിരിക്കണം. ഈ പ്രത്യേക കോമ്പിനേഷൻ ഉപയോഗിച്ച് ഗുണവിശേഷങ്ങൾ, ഞങ്ങൾ പറയുന്നത്
ഒരു 1024-ബൈറ്റ് പാക്കറ്റ് അയയ്ക്കാൻ ക്ലയന്റ്.

എക്കോ സെർവറിന്റെ കാര്യത്തിലെന്നപോലെ, ഞങ്ങൾ എക്കോ ക്ലയന്റിനോട് പറയുന്നു ആരംഭിക്കുക ഒപ്പം നിർത്തുക, പക്ഷേ
സെർവർ പ്രവർത്തനക്ഷമമാക്കിയതിന് ശേഷം ഒരു സെക്കൻഡ് കഴിഞ്ഞ് ഞങ്ങൾ ക്ലയന്റ് ആരംഭിക്കുന്നു (രണ്ട് സെക്കൻഡിൽ
സിമുലേഷൻ).

സിമുലേറ്റർ
ഈ ഘട്ടത്തിൽ നമ്മൾ ചെയ്യേണ്ടത് യഥാർത്ഥത്തിൽ സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുക എന്നതാണ്. ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്
ആഗോള പ്രവർത്തനം സിമുലേറ്റർ:: റൺ.

സിമുലേറ്റർ:: റൺ ();

ഞങ്ങൾ മുമ്പ് രീതികൾ വിളിച്ചപ്പോൾ,

serverApps.Start (സെക്കൻഡ് (1.0));
serverApps.Stop (സെക്കൻഡ് (10.0));
...
clientApps.Start (സെക്കൻഡ് (2.0));
clientApps.Stop (സെക്കൻഡ് (10.0));

ഞങ്ങൾ യഥാർത്ഥത്തിൽ സിമുലേറ്ററിൽ ഇവന്റുകൾ 1.0 സെക്കൻഡ്, 2.0 സെക്കൻഡ്, രണ്ട് ഇവന്റുകൾ എന്നിവയിൽ ഷെഡ്യൂൾ ചെയ്തു
10.0 സെക്കൻഡിൽ. എപ്പോൾ സിമുലേറ്റർ:: റൺ എന്ന് വിളിക്കപ്പെടുന്നു, സിസ്റ്റം അതിലൂടെ നോക്കാൻ തുടങ്ങും
ഷെഡ്യൂൾ ചെയ്ത ഇവന്റുകളുടെ പട്ടികയും അവ നടപ്പിലാക്കലും. ആദ്യം അത് 1.0 സെക്കൻഡിൽ ഇവന്റ് പ്രവർത്തിപ്പിക്കും,
ഇത് എക്കോ സെർവർ ആപ്ലിക്കേഷൻ പ്രവർത്തനക്ഷമമാക്കും (ഈ ഇവന്റ് പലതും ഷെഡ്യൂൾ ചെയ്തേക്കാം
മറ്റ് ഇവന്റുകൾ). തുടർന്ന് അത് ആരംഭിക്കുന്ന t=2.0 സെക്കൻഡ് സമയത്തേക്ക് ഷെഡ്യൂൾ ചെയ്ത ഇവന്റ് പ്രവർത്തിപ്പിക്കും
എക്കോ ക്ലയന്റ് ആപ്ലിക്കേഷൻ. വീണ്ടും, ഈ ഇവന്റ് നിരവധി ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്തേക്കാം. തുടക്കം
എക്കോ ക്ലയന്റ് ആപ്ലിക്കേഷനിൽ ഇവന്റ് നടപ്പിലാക്കുന്നത് ഡാറ്റാ ട്രാൻസ്ഫർ ഘട്ടം ആരംഭിക്കും
സെർവറിലേക്ക് ഒരു പാക്കറ്റ് അയച്ചുകൊണ്ട് അനുകരണം.

സെർവറിലേക്ക് പാക്കറ്റ് അയയ്‌ക്കുന്ന പ്രവർത്തനം, സംഭവങ്ങളുടെ ഒരു ശൃംഖലയെ ട്രിഗർ ചെയ്യും
തിരശ്ശീലയ്ക്ക് പിന്നിൽ യാന്ത്രികമായി ഷെഡ്യൂൾ ചെയ്‌തു, അത് മെക്കാനിക്‌സ് നിർവഹിക്കും
ഞങ്ങൾ സ്ക്രിപ്റ്റിൽ സജ്ജീകരിച്ചിരിക്കുന്ന വിവിധ സമയ പാരാമീറ്ററുകൾ അനുസരിച്ച് പാക്കറ്റ് എക്കോ.

ഒടുവിൽ, ഞങ്ങൾ ഒരു പാക്കറ്റ് മാത്രമേ അയയ്‌ക്കൂ (ഓർക്കുക മാക്സ്പാക്കറ്റുകൾ ഗുണങ്ങളെ ആയി നിശ്ചയിച്ചിരുന്നു
ഒന്ന്), ആ ഒരൊറ്റ ക്ലയന്റ് പ്രതിധ്വനി അഭ്യർത്ഥന ട്രിഗർ ചെയ്ത സംഭവങ്ങളുടെ ശൃംഖല കുറയും
സിമുലേഷൻ നിഷ്‌ക്രിയമാകും. ഇത് സംഭവിച്ചുകഴിഞ്ഞാൽ, ശേഷിക്കുന്ന ഇവന്റുകൾ ആയിരിക്കും നിർത്തുക
സെർവറിനും ക്ലയന്റിനുമുള്ള ഇവന്റുകൾ. ഈ സംഭവങ്ങൾ നടപ്പിലാക്കുമ്പോൾ, ഇല്ല
പ്രോസസ്സ് ചെയ്യാനുള്ള കൂടുതൽ ഇവന്റുകൾ കൂടാതെ സിമുലേറ്റർ:: റൺ മടങ്ങുന്നു. അപ്പോൾ സിമുലേഷൻ പൂർത്തിയായി.

ശുചീകരണം മാത്രമാണ് ബാക്കിയുള്ളത്. ഗ്ലോബൽ ഫംഗ്‌ഷൻ എന്ന് വിളിച്ചാണ് ഇത് ചെയ്യുന്നത്
സിമുലേറ്റർ:: നശിപ്പിക്കുക. സഹായി പ്രവർത്തിക്കുമ്പോൾ (അല്ലെങ്കിൽ താഴ്ന്ന നില ns-3 കോഡ്) നടപ്പിലാക്കി, അവർ
എല്ലാ വസ്തുക്കളെയും നശിപ്പിക്കാൻ സിമുലേറ്ററിൽ കൊളുത്തുകൾ ഘടിപ്പിച്ച് അത് ക്രമീകരിച്ചു
സൃഷ്ടിക്കപ്പെട്ടവ. ഈ ഒബ്‌ജക്‌റ്റുകളിലൊന്നും നിങ്ങൾ സ്വയം ട്രാക്ക് ചെയ്യേണ്ടതില്ല ---
വിളിച്ചാൽ മതിയായിരുന്നു സിമുലേറ്റർ:: നശിപ്പിക്കുക പുറത്തുകടക്കുക. ദി ns-3 സിസ്റ്റം ശ്രദ്ധിച്ചു
നിങ്ങൾക്ക് ബുദ്ധിമുട്ടുള്ള ഭാഗം. ഞങ്ങളുടെ ആദ്യ വരികൾ അവശേഷിക്കുന്നു ns-3 സ്ക്രിപ്റ്റ്, ആദ്യം.cc, വെറുതെ ചെയ്യുക
അത്:

സിമുലേറ്റർ:: നശിപ്പിക്കുക ();
തിരികെ വരുക;
}

എപ്പോൾ The സിമുലേറ്റർ ഉദ്ദേശിക്കുന്ന നിർത്തുക?
ns-3 ഒരു ഡിസ്‌ക്രീറ്റ് ഇവന്റ് (DE) സിമുലേറ്ററാണ്. അത്തരമൊരു സിമുലേറ്ററിൽ, ഓരോ ഇവന്റും ബന്ധപ്പെട്ടിരിക്കുന്നു
അതിന്റെ നിർവ്വഹണ സമയത്തോടൊപ്പം, താൽക്കാലിക സംഭവങ്ങൾ നടപ്പിലാക്കിക്കൊണ്ട് അനുകരണം തുടരുന്നു
സിമുലേഷൻ സമയ ക്രമം. ഇവന്റുകൾ ഭാവി ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യാൻ കാരണമായേക്കാം (ഉദാഹരണത്തിന്, എ
അടുത്ത ഇടവേളയിൽ കാലഹരണപ്പെടാൻ ടൈമർ സ്വയം വീണ്ടും ഷെഡ്യൂൾ ചെയ്തേക്കാം).

പ്രാരംഭ ഇവന്റുകൾ സാധാരണയായി ഓരോ ഒബ്ജക്റ്റിലും ട്രിഗർ ചെയ്യപ്പെടുന്നു, ഉദാ, IPv6 റൂട്ടർ ഷെഡ്യൂൾ ചെയ്യും
പരസ്യങ്ങൾ, അയൽക്കാരുടെ അഭ്യർത്ഥനകൾ മുതലായവ, ഒരു ആപ്ലിക്കേഷൻ ഷെഡ്യൂൾ ആദ്യ പാക്കറ്റ്
ഇവന്റ് അയയ്ക്കൽ മുതലായവ.

ഒരു ഇവന്റ് പ്രോസസ്സ് ചെയ്യുമ്പോൾ, അത് പൂജ്യമോ ഒന്നോ അതിലധികമോ ഇവന്റുകൾ സൃഷ്ടിച്ചേക്കാം. ഒരു സിമുലേഷൻ എന്ന നിലയിൽ
നിർവ്വഹിക്കുന്നു, ഇവന്റുകൾ ഉപഭോഗം ചെയ്യുന്നു, എന്നാൽ കൂടുതൽ ഇവന്റുകൾ സൃഷ്ടിക്കപ്പെട്ടേക്കാം (അല്ലെങ്കിൽ ഇല്ലായിരിക്കാം). ദി
കൂടുതൽ ഇവന്റുകളൊന്നും ഇവന്റ് ക്യൂവിൽ ഇല്ലെങ്കിൽ, അല്ലെങ്കിൽ എപ്പോൾ സിമുലേഷൻ സ്വയമേവ നിർത്തും
ഒരു പ്രത്യേക സ്റ്റോപ്പ് ഇവന്റ് കണ്ടെത്തി. എന്നതിലൂടെയാണ് സ്റ്റോപ്പ് ഇവന്റ് സൃഷ്ടിക്കുന്നത് സിമുലേറ്റർ:: നിർത്തുക
(സ്റ്റോപ്പ് ടൈം); പ്രവർത്തനം.

അവിടെ ഒരു സാധാരണ കേസ് ഉണ്ട് സിമുലേറ്റർ:: നിർത്തുക നിർത്താൻ അത്യന്താപേക്ഷിതമാണ്
അനുകരണം: സ്വയം നിലനിൽക്കുന്ന ഒരു സംഭവം ഉണ്ടാകുമ്പോൾ. സ്വയം നിലനിൽക്കുന്ന (അല്ലെങ്കിൽ ആവർത്തിച്ചുള്ള) ഇവന്റുകൾ
എല്ലായ്‌പ്പോഴും സ്വയം ഷെഡ്യൂൾ ചെയ്യുന്ന സംഭവങ്ങളാണ്. തൽഫലമായി, അവർ എല്ലായ്പ്പോഴും ഇവന്റ് നിലനിർത്തുന്നു
ക്യൂ ശൂന്യമല്ല.

ആവർത്തിച്ചുള്ള ഇവന്റുകൾ അടങ്ങുന്ന നിരവധി പ്രോട്ടോക്കോളുകളും മൊഡ്യൂളുകളും ഉണ്ട്, ഉദാ:

· FlowMonitor - നഷ്ടപ്പെട്ട പാക്കറ്റുകൾക്കായി ആനുകാലിക പരിശോധന

RIPng - റൂട്ടിംഗ് ടേബിളുകളുടെ ആനുകാലിക പ്രക്ഷേപണം

· തുടങ്ങിയവ.

ഇത്തരം സന്ദർഭങ്ങളിൽ, സിമുലേറ്റർ:: നിർത്തുക സിമുലേഷൻ ഭംഗിയായി നിർത്താൻ ഇത് ആവശ്യമാണ്. ഇൻ
കൂടാതെ, എപ്പോൾ ns-3 എമുലേഷൻ മോഡിൽ ആണ് റിയൽടൈം സിമുലേറ്റർ സൂക്ഷിക്കാൻ ഉപയോഗിക്കുന്നു
മെഷീൻ ക്ലോക്കുമായി വിന്യസിച്ചിരിക്കുന്ന സിമുലേഷൻ ക്ലോക്ക്, കൂടാതെ സിമുലേറ്റർ:: നിർത്തുക നിർത്താൻ അത്യാവശ്യമാണ്
പ്രക്രിയ.

ട്യൂട്ടോറിയലിലെ പല സിമുലേഷൻ പ്രോഗ്രാമുകളും വ്യക്തമായി വിളിക്കുന്നില്ല സിമുലേറ്റർ:: നിർത്തുക,
ഇവന്റ് ക്യൂ സ്വയമേവ ഇവന്റുകൾ തീർന്നുപോകുമെന്നതിനാൽ. എന്നിരുന്നാലും, ഈ പ്രോഗ്രാമുകൾ ചെയ്യും
എന്നതിലേക്കുള്ള ഒരു കോളും സ്വീകരിക്കുക സിമുലേറ്റർ:: നിർത്തുക. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന അധിക പ്രസ്താവന
ആദ്യ ഉദാഹരണ പ്രോഗ്രാം 11 സെക്കൻഡിൽ ഒരു വ്യക്തമായ സ്റ്റോപ്പ് ഷെഡ്യൂൾ ചെയ്യും:

+ സിമുലേറ്റർ:: നിർത്തുക (സെക്കൻഡ് (11.0));
സിമുലേറ്റർ:: റൺ ();
സിമുലേറ്റർ:: നശിപ്പിക്കുക ();
തിരികെ വരുക;
}

മുകളിൽ പറഞ്ഞവ യഥാർത്ഥത്തിൽ ഈ പ്രോഗ്രാമിന്റെ സ്വഭാവത്തെ മാറ്റില്ല, കാരണം ഇത് പ്രത്യേകമാണ്
സിമുലേഷൻ 10 സെക്കൻഡിന് ശേഷം സ്വാഭാവികമായും അവസാനിക്കുന്നു. എന്നാൽ നിങ്ങൾ സ്റ്റോപ്പ് സമയം മാറ്റുകയാണെങ്കിൽ
മുകളിലുള്ള പ്രസ്താവന 11 സെക്കൻഡ് മുതൽ 1 സെക്കൻഡ് വരെ, സിമുലേഷൻ നിങ്ങൾ ശ്രദ്ധിക്കും
ഏതെങ്കിലും ഔട്ട്‌പുട്ട് സ്‌ക്രീനിലേക്ക് പ്രിന്റ് ചെയ്യപ്പെടുന്നതിന് മുമ്പ് നിർത്തുന്നു (ഔട്ട്‌പുട്ട് സമയം 2-നടുത്ത് സംഭവിക്കുന്നതിനാൽ
സിമുലേഷൻ സമയത്തിന്റെ സെക്കൻഡുകൾ).

വിളിക്കേണ്ടത് പ്രധാനമാണ് സിമുലേറ്റർ:: നിർത്തുക മുമ്പ് വിളിക്കുന്നു സിമുലേറ്റർ:: റൺ; അല്ലാത്തപക്ഷം,
സിമുലേറ്റർ:: റൺ സ്റ്റോപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള പ്രധാന പ്രോഗ്രാമിലേക്ക് നിയന്ത്രണം ഒരിക്കലും തിരികെ നൽകില്ല!

കെട്ടിടം നിങ്ങളുടെ സ്ക്രിപ്റ്റ്
നിങ്ങളുടെ ലളിതമായ സ്ക്രിപ്റ്റുകൾ നിർമ്മിക്കുന്നത് ഞങ്ങൾ നിസ്സാരമാക്കിയിരിക്കുന്നു. നിങ്ങൾ ചെയ്യേണ്ടത് നിങ്ങളുടെ ഉപേക്ഷിക്കുക എന്നതാണ്
സ്‌ക്രാച്ച് ഡയറക്‌ടറിയിലേക്ക് സ്‌ക്രിപ്റ്റ് ചെയ്യുക, നിങ്ങൾ Waf പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ അത് സ്വയമേവ നിർമ്മിക്കപ്പെടും.
ശ്രമിക്കാം. പകർത്തുക ഉദാഹരണങ്ങൾ/tutorial/first.cc കടന്നു സ്ക്രാച്ച് മാറ്റിയതിനുശേഷം ഡയറക്ടറി
ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിലേക്ക് മടങ്ങുക.

$cd../..
$ cp ഉദാഹരണങ്ങൾ/tutorial/first.cc സ്ക്രാച്ച്/myfirst.cc

ഇപ്പോൾ waf ഉപയോഗിച്ച് നിങ്ങളുടെ ആദ്യ ഉദാഹരണ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുക:

$ ./waf

നിങ്ങളുടേതെന്ന് റിപ്പോർട്ടുചെയ്യുന്ന സന്ദേശങ്ങൾ നിങ്ങൾ കാണും എന്റെ ആദ്യത്തെ ഉദാഹരണം വിജയകരമായി നിർമ്മിച്ചു.

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/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
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (2.357സെ)

നിങ്ങൾക്ക് ഇപ്പോൾ ഉദാഹരണം പ്രവർത്തിപ്പിക്കാൻ കഴിയും (സ്ക്രാച്ച് ഡയറക്ടറിയിൽ നിങ്ങളുടെ പ്രോഗ്രാം നിർമ്മിക്കുകയാണെങ്കിൽ ശ്രദ്ധിക്കുക
സ്ക്രാച്ച് ഡയറക്‌ടറിയിൽ നിന്ന് നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിക്കണം):

$ ./waf --റൺ സ്ക്രാച്ച്/മൈഫസ്റ്റ്

നിങ്ങൾ കുറച്ച് ഔട്ട്പുട്ട് കാണണം:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.418സെ)
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു

ഫയൽ ബിൽഡ് ആണോ എന്ന് ഉറപ്പുവരുത്താൻ ബിൽഡ് സിസ്റ്റം പരിശോധിക്കുന്നത് ഇവിടെ കാണാം
എന്നിട്ട് അത് പ്രവർത്തിപ്പിക്കുന്നു. എക്കോ ക്ലയന്റിലുള്ള ലോഗിംഗ് ഘടകം അത് അയച്ചതായി സൂചിപ്പിക്കുന്നത് നിങ്ങൾ കാണുന്നു
ഒരു 1024 ബൈറ്റ് പാക്കറ്റ് 10.1.1.2-ൽ എക്കോ സെർവറിലേക്ക്. ലോഗിംഗ് ഘടകവും നിങ്ങൾ കാണുന്നു
എക്കോ സെർവറിൽ 1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചുവെന്ന് പറയുന്നു. എക്കോ സെർവർ
നിശബ്ദമായി പാക്കറ്റ് പ്രതിധ്വനിക്കുന്നു, അതിന്റെ പാക്കറ്റ് ലഭിച്ചതായി എക്കോ ക്ലയന്റ് ലോഗ് നിങ്ങൾ കാണുന്നു
സെർവറിൽ നിന്ന് തിരികെ.

Ns-3 ഉറവിടം കോഡ്
ഇപ്പോൾ നിങ്ങൾ ചിലത് ഉപയോഗിച്ചു ns-3 സഹായികളിൽ ചിലത് നിങ്ങൾ കാണാൻ ആഗ്രഹിച്ചേക്കാം
ആ പ്രവർത്തനം നടപ്പിലാക്കുന്ന സോഴ്സ് കോഡ്. ഏറ്റവും പുതിയ കോഡ് ബ്രൗസ് ചെയ്യാൻ കഴിയും
ഇനിപ്പറയുന്ന ലിങ്കിൽ ഞങ്ങളുടെ വെബ് സെർവർ: http://code.nsnam.org/ns-3-dev. അവിടെ, നിങ്ങൾ കാണും
ഞങ്ങളുടെ മെർക്കുറിയൽ സംഗ്രഹ പേജ് ns-3 വികസന വൃക്ഷം.

പേജിന്റെ മുകളിൽ, നിങ്ങൾ നിരവധി ലിങ്കുകൾ കാണും,

സംഗ്രഹം | ഷോർട്ട്ലോഗ് | ചേഞ്ച്ലോഗ് | ഗ്രാഫ് | ടാഗുകൾ | ഫയലുകൾ

മുന്നോട്ട് പോയി തിരഞ്ഞെടുക്കുക ഫയലുകൾ ലിങ്ക്. ഇതാണ് നമ്മുടെ മിക്കവരുടെയും ഉയർന്ന തലം
റിപ്പോസിറ്ററികൾ നോക്കാം:

drwxr-xr-x [മുകളിലേക്ക്]
drwxr-xr-x ബൈൻഡിംഗ് പൈത്തൺ ഫയലുകൾ
drwxr-xr-x ഡോക് ഫയലുകൾ
drwxr-xr-x ഉദാഹരണ ഫയലുകൾ
drwxr-xr-x ns3 ഫയലുകൾ
drwxr-xr-x സ്ക്രാച്ച് ഫയലുകൾ
drwxr-xr-x src ഫയലുകൾ
drwxr-xr-x utils ഫയലുകൾ
-rw-r--r-- 2009-07-01 12:47 +0200 560 .hgignore ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 1886 .hgtags ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 1276 AUTHORS ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 30961 CHANGES.html ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 17987 ലൈസൻസ് ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 3742 README ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 16171 RELEASE_NOTES ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 6 VERSION ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rwxr-xr-x 2009-07-01 12:47 +0200 88110 waf ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rwxr-xr-x 2009-07-01 12:47 +0200 28 waf.bat ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 35395 wscript ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക
-rw-r--r-- 2009-07-01 12:47 +0200 7673 wutils.py ഫയൽ | തിരുത്തലുകൾ | വ്യാഖ്യാനിക്കുക

ഞങ്ങളുടെ ഉദാഹരണ സ്ക്രിപ്റ്റുകൾ ഇതിൽ ഉണ്ട് ഉദാഹരണങ്ങൾ ഡയറക്ടറി. നിങ്ങൾ ക്ലിക്ക് ചെയ്താൽ ഉദാഹരണങ്ങൾ നിങ്ങൾ കാണും
ഉപഡയറക്‌ടറികളുടെ ഒരു ലിസ്റ്റ്. ഫയലുകളിൽ ഒന്ന് ട്യൂട്ടോറിയൽ ഉപഡയറക്‌ടറി ആണ് ആദ്യം.cc. നിങ്ങൾ എങ്കിൽ
ക്ലിക്ക് ചെയ്യുക ആദ്യം.cc നിങ്ങൾ ഇപ്പോൾ നടന്ന കോഡ് നിങ്ങൾ കണ്ടെത്തും.

സോഴ്സ് കോഡ് പ്രധാനമായും ഉള്ളത് ഉറവിട ഡയറക്ടറി. ഒന്നുകിൽ നിങ്ങൾക്ക് സോഴ്സ് കോഡ് കാണാൻ കഴിയും
ഡയറക്‌ടറിയുടെ പേരിൽ ക്ലിക്ക് ചെയ്യുക അല്ലെങ്കിൽ ക്ലിക്ക് ചെയ്യുക ഫയലുകൾ യുടെ വലതുവശത്തുള്ള ലിങ്ക്
ഡയറക്ടറിയുടെ പേര്. എന്നതിൽ ക്ലിക്ക് ചെയ്താൽ ഉറവിട ഡയറക്ടറി, നിങ്ങളെ ലിസ്റ്റിംഗിലേക്ക് കൊണ്ടുപോകും
The ഉറവിട ഉപഡയറക്‌ടറികൾ. എങ്കിൽ ക്ലിക്ക് ചെയ്യുക കോർ ഉപഡയറക്‌ടറി, നിങ്ങൾ ഒരു ലിസ്റ്റ് കണ്ടെത്തും
ഫയലുകൾ. നിങ്ങൾ കണ്ടെത്തുന്ന ആദ്യത്തെ ഫയൽ (ഈ എഴുത്ത് പോലെ) ആണ് abort.h. എന്നതിൽ ക്ലിക്ക് ചെയ്താൽ
abort.h ലിങ്ക്, നിങ്ങളെ സോഴ്സ് ഫയലിലേക്ക് അയയ്ക്കും abort.h ഉപയോഗപ്രദമായ മാക്രോകൾ അടങ്ങിയിരിക്കുന്നു
അസാധാരണമായ അവസ്ഥകൾ കണ്ടെത്തിയാൽ സ്ക്രിപ്റ്റിൽ നിന്ന് പുറത്തുകടക്കുന്നതിന്.

ഈ അധ്യായത്തിൽ ഞങ്ങൾ ഉപയോഗിച്ച സഹായികൾക്കുള്ള സോഴ്സ് കോഡ് ഇതിൽ കാണാം
എസ്ആർസി/അപ്ലിക്കേഷൻസ്/ഹെൽപ്പർ ഡയറക്ടറി. ലഭിക്കാൻ ഡയറക്ടറി ട്രീയിൽ കുത്താൻ മടിക്കേണ്ടതില്ല
ഉള്ളതിനെക്കുറിച്ചും ശൈലിയെക്കുറിച്ചും ഒരു തോന്നൽ ns-3 പ്രോഗ്രാമുകൾ.

ട്വീക്കിംഗ്

ഉപയോഗിക്കുന്നു The ലോഗ് ചെയ്യുന്നു മൊഡ്യൂൾ
ഞങ്ങൾ ഇതിനകം ഒരു ഹ്രസ്വ അവലോകനം നടത്തിയിട്ടുണ്ട് ns-3 കടന്നുപോകുമ്പോൾ ലോഗിംഗ് മൊഡ്യൂൾ
ആദ്യം.cc സ്ക്രിപ്റ്റ്. നമ്മൾ ഇപ്പോൾ സൂക്ഷ്മമായി നോക്കുകയും ഏത് തരത്തിലുള്ള ഉപയോഗ-കേസുകൾ നോക്കുകയും ചെയ്യും
ലോഗിംഗ് സബ്സിസ്റ്റം കവർ ചെയ്യുന്നതിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു.

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

ns-3 ഈ വെർബോസിറ്റി ലെവലുകളെല്ലാം ഉപയോഗപ്രദമാണെന്ന് വീക്ഷണം എടുക്കുന്നു, ഞങ്ങൾ എ നൽകുന്നു
മെസേജ് ലോഗിംഗിനുള്ള തിരഞ്ഞെടുക്കാവുന്ന, മൾട്ടി-ലെവൽ സമീപനം. ലോഗിംഗ് പൂർണ്ണമായും പ്രവർത്തനരഹിതമാക്കാം,
ഘടകം-ബൈ-ഘടകത്തിന്റെ അടിസ്ഥാനത്തിൽ പ്രവർത്തനക്ഷമമാക്കി, അല്ലെങ്കിൽ ആഗോളതലത്തിൽ പ്രവർത്തനക്ഷമമാക്കി; അത് തിരഞ്ഞെടുക്കാവുന്നതും നൽകുന്നു
verbosity ലെവലുകൾ. ദി ns-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_LEVEL_INFO പ്രവർത്തനക്ഷമമാക്കുന്നത് NS_LOG_DEBUG, NS_LOG_WARN നൽകുന്ന സന്ദേശങ്ങളും പ്രാപ്തമാക്കും
കൂടാതെ NS_LOG_ERROR മാക്രോകളും.

ഞങ്ങൾ ഒരു നിരുപാധിക ലോഗിംഗ് മാക്രോയും നൽകുന്നു, അത് പരിഗണിക്കാതെ തന്നെ എപ്പോഴും പ്രദർശിപ്പിക്കും
ലോഗിംഗ് ലെവലുകൾ അല്ലെങ്കിൽ ഘടകങ്ങൾ തിരഞ്ഞെടുക്കൽ.

· NS_LOG_UNCOND -- ബന്ധപ്പെട്ട സന്ദേശം നിരുപാധികമായി ലോഗ് ചെയ്യുക (അനുബന്ധ ലോഗ് ലെവൽ ഇല്ല).

ഓരോ ലെവലും ഒറ്റയായോ സഞ്ചിതമായോ അഭ്യർത്ഥിക്കാം; കൂടാതെ ലോഗിംഗ് ഒരു ഉപയോഗിച്ച് സജ്ജീകരിക്കാവുന്നതാണ്
ഷെൽ എൻവയോൺമെന്റ് വേരിയബിൾ (NS_LOG) അല്ലെങ്കിൽ സിസ്റ്റം ഫംഗ്‌ഷൻ കോൾ ലോഗ് ചെയ്യുന്നതിലൂടെ. കണ്ടതുപോലെ
നേരത്തെ ട്യൂട്ടോറിയലിൽ, ലോഗിംഗ് സിസ്റ്റത്തിന് ഡോക്‌സിജൻ ഡോക്യുമെന്റേഷൻ ഉണ്ട്, ഇപ്പോൾ എ
നിങ്ങൾ അങ്ങനെ ചെയ്തിട്ടില്ലെങ്കിൽ ലോഗിംഗ് മൊഡ്യൂൾ ഡോക്യുമെന്റേഷൻ പരിശോധിക്കാൻ നല്ല സമയം.

ഇപ്പോൾ നിങ്ങൾ ഡോക്യുമെന്റേഷൻ വളരെ വിശദമായി വായിച്ചുകഴിഞ്ഞാൽ, നമുക്ക് ആ അറിവിൽ ചിലത് ഉപയോഗിക്കാം
അതിൽ നിന്ന് രസകരമായ ചില വിവരങ്ങൾ ലഭിക്കാൻ സ്ക്രാച്ച്/myfirst.cc നിങ്ങളുടെ പക്കലുള്ള ഉദാഹരണ സ്ക്രിപ്റ്റ്
ഇതിനകം നിർമ്മിച്ചത്.

പ്രാപ്തമാക്കുന്നു ലോഗ് ചെയ്യുന്നു
കുറച്ചുകൂടി ലോഗിംഗ് ഓണാക്കാൻ നമുക്ക് NS_LOG എൻവയോൺമെന്റ് വേരിയബിൾ ഉപയോഗിക്കാം, എന്നാൽ ആദ്യം,
ഞങ്ങളുടെ ബെയറിംഗുകൾ നേടുക, മുന്നോട്ട് പോയി നിങ്ങൾ മുമ്പ് ചെയ്തതുപോലെ അവസാന സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക,

$ ./waf --റൺ സ്ക്രാച്ച്/മൈഫസ്റ്റ്

ആദ്യത്തേതിന്റെ ഇപ്പോൾ പരിചിതമായ ഔട്ട്പുട്ട് നിങ്ങൾ കാണണം ns-3 ഉദാഹരണം പ്രോഗ്രാം

$ വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.413സെ)
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു

നിങ്ങൾ മുകളിൽ കാണുന്ന "അയച്ച", "സ്വീകരിച്ച" സന്ദേശങ്ങൾ യഥാർത്ഥത്തിൽ ലോഗിംഗ് ചെയ്യുന്നതായി മാറുന്നു
എന്നതിൽ നിന്നുള്ള സന്ദേശങ്ങൾ UdpEchoClientApplication ഒപ്പം UdpEchoServerApplication. നമുക്ക് ചോദിക്കാം
ക്ലയന്റ് ആപ്ലിക്കേഷൻ, ഉദാഹരണത്തിന്, അതിന്റെ ലോഗിംഗ് ലെവൽ സജ്ജീകരിച്ച് കൂടുതൽ വിവരങ്ങൾ പ്രിന്റ് ചെയ്യാൻ
NS_LOG എൻവയോൺമെന്റ് വേരിയബിൾ വഴി.

നിങ്ങൾ ഉപയോഗിക്കുന്ന ഒരു sh പോലുള്ള ഷെല്ലാണ് നിങ്ങൾ ഉപയോഗിക്കുന്നതെന്ന് ഞാൻ ഇവിടെ നിന്ന് അനുമാനിക്കാൻ പോകുന്നു
"VARIABLE=value" വാക്യഘടന. നിങ്ങൾ csh പോലുള്ള ഷെല്ലാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യേണ്ടിവരും
ആ ഷെല്ലുകൾക്ക് ആവശ്യമായ "setenv VARIABLE മൂല്യം" വാക്യഘടനയിലേക്ക് എന്റെ ഉദാഹരണങ്ങൾ പരിവർത്തനം ചെയ്യുക.

ഇപ്പോൾ, 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 എൻവയോൺമെന്റ് വേരിയബിൾ ഇതുപോലെ ക്രമീകരിക്കുന്നു:

$ കയറ്റുമതി NS_LOG=UdpEchoClientApplication=level_all

ഇത് ഷെൽ എൻവയോൺമെന്റ് വേരിയബിളിനെ സജ്ജമാക്കുന്നു NS_LOG സ്ട്രിംഗിലേക്ക്,

UdpEchoClientApplication=level_all

അസൈൻമെന്റിന്റെ ഇടത് വശം നമ്മൾ സജ്ജീകരിക്കാൻ ആഗ്രഹിക്കുന്ന ലോഗിംഗ് ഘടകത്തിന്റെ പേരാണ്,
വലത് വശമാണ് നമ്മൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന പതാക. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഓണാക്കാൻ പോകുന്നു
ആപ്ലിക്കേഷന്റെ എല്ലാ ഡീബഗ്ഗിംഗ് ലെവലുകളും. നിങ്ങൾ NS_LOG സെറ്റ് ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ
ഈ വഴി, ദി ns-3 ലോഗിംഗ് സിസ്റ്റം മാറ്റം എടുക്കും, നിങ്ങൾ ഇനിപ്പറയുന്നവ കാണും
ഔട്ട്പുട്ട്:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.404സെ)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:സെറ്റ് ഡാറ്റാസൈസ്(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

ആപ്ലിക്കേഷൻ നൽകുന്ന അധിക ഡീബഗ് വിവരങ്ങൾ NS_LOG_FUNCTION-ൽ നിന്നുള്ളതാണ്
നില. സ്ക്രിപ്റ്റ് സമയത്ത് ആപ്ലിക്കേഷനിൽ ഒരു ഫംഗ്ഷൻ വിളിക്കപ്പെടുന്ന ഓരോ തവണയും ഇത് കാണിക്കുന്നു
വധശിക്ഷ. സാധാരണയായി, അംഗങ്ങളുടെ പ്രവർത്തനങ്ങളിൽ (കുറഞ്ഞത്) NS_LOG_FUNCTION (ഇത്) ഉപയോഗിക്കുന്നത്
മുൻഗണന. സ്റ്റാറ്റിക് ഫംഗ്ഷനുകളിൽ മാത്രം NS_LOG_FUNCTION_NOARGS() ഉപയോഗിക്കുക. എന്നിരുന്നാലും, അത് ശ്രദ്ധിക്കുക
ൽ ആവശ്യകതകളൊന്നുമില്ല ns-3 മോഡലുകൾ ഏതെങ്കിലും പ്രത്യേക പിന്തുണ നൽകേണ്ട സംവിധാനം
ലോഗിംഗ് പ്രവർത്തനം. എത്ര വിവരങ്ങൾ ലോഗിൻ ചെയ്തിട്ടുണ്ടെന്നത് സംബന്ധിച്ച് തീരുമാനം എടുക്കും
വ്യക്തിഗത മോഡൽ ഡെവലപ്പർ. എക്കോ ആപ്ലിക്കേഷനുകളുടെ കാര്യത്തിൽ, ഒരു നല്ല ലോഗ്
ഔട്ട്പുട്ട് ലഭ്യമാണ്.

ആപ്ലിക്കേഷനിലേക്ക് നടത്തിയ ഫംഗ്‌ഷൻ കോളുകളുടെ ഒരു ലോഗ് നിങ്ങൾക്ക് ഇപ്പോൾ കാണാൻ കഴിയും. നിങ്ങൾ എങ്കിൽ
സൂക്ഷിച്ചുനോക്കിയാൽ, സ്ട്രിങ്ങിനിടയിൽ ഒരൊറ്റ കോളൻ കാണാം UdpEchoClientApplication
നിങ്ങൾ ഒരു C++ സ്കോപ്പ് ഓപ്പറേറ്റർ പ്രതീക്ഷിച്ചിരിക്കാവുന്ന രീതി നാമവും (::). ഇതാണ്
മനഃപൂർവം.

പേര് യഥാർത്ഥത്തിൽ ഒരു ക്ലാസ് നാമമല്ല, ഇത് ഒരു ലോഗിംഗ് ഘടക നാമമാണ്. ഉള്ളപ്പോൾ എ
ഒരു സോഴ്‌സ് ഫയലും ക്ലാസും തമ്മിലുള്ള വൺ-ടു-വൺ കത്തിടപാടുകൾ, ഇത് സാധാരണയായി ഇതായിരിക്കും
ക്ലാസ് നാമം എന്നാൽ അത് യഥാർത്ഥത്തിൽ ഒരു ക്ലാസ് നാമമല്ലെന്ന് നിങ്ങൾ മനസ്സിലാക്കണം, കൂടാതെ a ഉണ്ട്
താരതമ്യേന സൂക്ഷ്മമായ രീതിയിൽ നിങ്ങളെ ഓർമ്മിപ്പിക്കുന്നതിന് ഇരട്ട കോളണിന് പകരം ഒറ്റ കോളൻ
ലോഗിംഗ് ഘടകത്തിന്റെ പേര് ക്ലാസ് നാമത്തിൽ നിന്ന് ആശയപരമായി വേർതിരിക്കുക.

ചില സന്ദർഭങ്ങളിൽ, യഥാർത്ഥത്തിൽ ഏത് രീതിയാണെന്ന് നിർണ്ണയിക്കാൻ ബുദ്ധിമുട്ടാണ്
ഒരു ലോഗ് സന്ദേശം സൃഷ്ടിക്കുന്നു. മുകളിലെ വാചകം നോക്കുകയാണെങ്കിൽ, സ്ട്രിംഗ് എവിടെയാണെന്ന് നിങ്ങൾ ചിന്തിച്ചേക്കാം
"ലഭിച്ചു 1024 ബൈറ്റുകൾ നിന്ന് 10.1.1.2" നിന്ന് വരുന്നു. നിങ്ങൾക്ക് ഇത് പരിഹരിക്കാൻ കഴിയും
പ്രിഫിക്സ്_ഫങ്ക് ലെവലിലേക്ക് NS_LOG പരിസ്ഥിതി വേരിയബിൾ. ഇനിപ്പറയുന്നവ ചെയ്യാൻ ശ്രമിക്കുക,

$ കയറ്റുമതി 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func'

ഒരു OR സൂചിപ്പിക്കാൻ ഞങ്ങൾ ഉപയോഗിക്കുന്ന ലംബ ബാർ മുതൽ ഉദ്ധരണികൾ ആവശ്യമാണെന്ന് ശ്രദ്ധിക്കുക
പ്രവർത്തനം ഒരു Unix പൈപ്പ് കണക്ടർ കൂടിയാണ്.

ഇപ്പോൾ, നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, ലോഗിംഗ് സിസ്റ്റം ഓരോന്നും ഉറപ്പാക്കുന്നത് നിങ്ങൾ കാണും
നൽകിയിരിക്കുന്ന ലോഗ് ഘടകത്തിൽ നിന്നുള്ള സന്ദേശം ഘടകത്തിന്റെ പേരിനൊപ്പം പ്രിഫിക്‌സ് ചെയ്‌തിരിക്കുന്നു.

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.417സെ)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:സെറ്റ് ഡാറ്റാസൈസ്(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): 1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
UdpEchoClientApplication:HandleRead(): 1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

UDP എക്കോ ക്ലയന്റ് ആപ്ലിക്കേഷനിൽ നിന്ന് വരുന്ന എല്ലാ സന്ദേശങ്ങളും ഇപ്പോൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും
അത്തരത്തിൽ തിരിച്ചറിഞ്ഞു. "1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു" എന്ന സന്ദേശം ഇപ്പോൾ വ്യക്തമാണ്
എക്കോ ക്ലയന്റ് ആപ്ലിക്കേഷനിൽ നിന്നാണ് വരുന്നതെന്ന് തിരിച്ചറിഞ്ഞു. ബാക്കിയുള്ള സന്ദേശം ഇതായിരിക്കണം
UDP എക്കോ സെർവർ ആപ്ലിക്കേഷനിൽ നിന്നാണ് വരുന്നത്. a എന്ന് നൽകി നമുക്ക് ആ ഘടകം പ്രവർത്തനക്ഷമമാക്കാം
NS_LOG എൻവയോൺമെന്റ് വേരിയബിളിലെ ഘടകങ്ങളുടെ കോളൻ വേർതിരിച്ച ലിസ്റ്റ്.

$ കയറ്റുമതി 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func:
UdpEchoServerApplication=level_all|prefix_func'

മുന്നറിയിപ്പ്: ഇതിന് ശേഷം നിങ്ങൾ പുതിയ ലൈൻ നീക്കം ചെയ്യേണ്ടതുണ്ട് : മുകളിലുള്ള ഉദാഹരണ വാചകത്തിൽ
ഡോക്യുമെന്റ് ഫോർമാറ്റിംഗ് ആവശ്യങ്ങൾക്കായി മാത്രമേ ഉള്ളൂ.

ഇപ്പോൾ, നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, രണ്ട് എക്കോ ക്ലയന്റുകളിൽ നിന്നുമുള്ള എല്ലാ ലോഗ് സന്ദേശങ്ങളും നിങ്ങൾ കാണും
കൂടാതെ സെർവർ ആപ്ലിക്കേഷനുകളും. ഡീബഗ്ഗിംഗ് പ്രശ്നങ്ങൾക്ക് ഇത് വളരെ ഉപയോഗപ്രദമാകുമെന്ന് നിങ്ങൾ കണ്ടേക്കാം.

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.406സെ)
UdpEchoServerApplication:UdpEchoServer()
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:സെറ്റ് ഡാറ്റാസൈസ്(1024)
UdpEchoServerApplication:StartApplication()
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): 1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
UdpEchoServerApplication:HandleRead(): 1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
UdpEchoServerApplication:HandleRead(): പാക്കറ്റ് എക്കോയിംഗ്
UdpEchoClientApplication:HandleRead(0x624920, 0x625160)
UdpEchoClientApplication:HandleRead(): 1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
UdpEchoServerApplication:StopApplication()
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

ഒരു ലോഗ് സന്ദേശം വരുന്ന സിമുലേഷൻ സമയം കാണാൻ കഴിയുന്നതും ചിലപ്പോൾ ഉപയോഗപ്രദമാണ്
സൃഷ്ടിക്കപ്പെടുന്നു. പ്രിഫിക്‌സ്_ടൈം ബിറ്റിൽ OR ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും.

$ കയറ്റുമതി 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func|prefix_time:
UdpEchoServerApplication=level_all|prefix_func|prefix_time'

വീണ്ടും, മുകളിലുള്ള പുതിയ ലൈൻ നിങ്ങൾ നീക്കം ചെയ്യേണ്ടിവരും. നിങ്ങൾ ഇപ്പോൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ചെയ്യണം
ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് കാണുക:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.418സെ)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:സെറ്റ് ഡാറ്റാസൈസ്(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): 1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
2.00369s UdpEchoServerApplication:HandleRead(): 1024-ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
2.00369s UdpEchoServerApplication:HandleRead(): എക്കോയിംഗ് പാക്കറ്റ്
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): 1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

UdpEchoServer-നുള്ള കൺസ്ട്രക്റ്റർ ഒരു സിമുലേഷൻ സമയത്ത് വിളിച്ചതായി നിങ്ങൾക്ക് കാണാൻ കഴിയും
0 സെക്കൻഡ്. സിമുലേഷൻ ആരംഭിക്കുന്നതിന് മുമ്പാണ് ഇത് യഥാർത്ഥത്തിൽ സംഭവിക്കുന്നത്, പക്ഷേ സമയമാണ്
പൂജ്യം സെക്കന്റുകളായി പ്രദർശിപ്പിച്ചിരിക്കുന്നു. UdpEchoClient കൺസ്ട്രക്റ്റർ സന്ദേശത്തിനും ഇത് ബാധകമാണ്.

അത് ഓർക്കുക സ്ക്രാച്ച്/first.cc സ്ക്രിപ്റ്റ് ഒരു സെക്കൻഡിൽ എക്കോ സെർവർ ആപ്ലിക്കേഷൻ ആരംഭിച്ചു
സിമുലേഷനിലേക്ക്. അത് ഇപ്പോൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും ആപ്ലിക്കേഷൻ ആരംഭിക്കുക സെർവറിന്റെ രീതി,
വാസ്തവത്തിൽ, ഒരു സെക്കൻഡിൽ വിളിച്ചു. എക്കോ ക്ലയന്റ് ആപ്ലിക്കേഷൻ ആണെന്നും നിങ്ങൾക്ക് കാണാൻ കഴിയും
സ്‌ക്രിപ്റ്റിൽ ഞങ്ങൾ ആവശ്യപ്പെട്ടതുപോലെ രണ്ട് സെക്കൻഡിന്റെ സിമുലേഷൻ സമയത്ത് ആരംഭിച്ചു.

എന്നതിൽ നിന്നുള്ള സിമുലേഷന്റെ പുരോഗതി നിങ്ങൾക്ക് ഇപ്പോൾ പിന്തുടരാനാകും ഷെഡ്യൂൾ ട്രാൻസ്മിറ്റ് വിളിക്കുക
വിളിക്കുന്ന ക്ലയന്റ് അയയ്ക്കുക ലേക്ക് ഹാൻഡിൽ റീഡ് എക്കോ സെർവർ ആപ്ലിക്കേഷനിൽ കോൾബാക്ക്. കുറിപ്പ്
പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിലൂടെ പാക്കറ്റ് അയയ്‌ക്കുന്നതിനുള്ള കഴിഞ്ഞ സമയം 3.69 ആണ്
മില്ലിസെക്കൻഡ്. എക്കോ സെർവർ അത് പ്രതിധ്വനിച്ചതായി നിങ്ങളോട് പറയുന്ന ഒരു സന്ദേശം ലോഗ് ചെയ്യുന്നത് നിങ്ങൾ കാണുന്നു
പാക്കറ്റ്, തുടർന്ന്, മറ്റൊരു ചാനൽ കാലതാമസത്തിന് ശേഷം, എക്കോ ക്ലയന്റ് സ്വീകരിക്കുന്നത് നിങ്ങൾ കാണുന്നു
അതിലെ പാക്കറ്റ് പ്രതിധ്വനിച്ചു ഹാൻഡിൽ റീഡ് രീതി.

ഈ സിമുലേഷനിൽ നിങ്ങൾ അല്ലാത്ത പലതും മറച്ചുവെച്ച് നടക്കുന്നുണ്ട്
അതുപോലെ കാണുന്നു. എല്ലാം ഓണാക്കി നിങ്ങൾക്ക് മുഴുവൻ പ്രക്രിയയും വളരെ എളുപ്പത്തിൽ പിന്തുടരാനാകും
സിസ്റ്റത്തിലെ ലോഗിംഗ് ഘടകങ്ങൾ. സജ്ജമാക്കാൻ ശ്രമിക്കുക NS_LOG ഇനിപ്പറയുന്നവയിലേക്ക് വേരിയബിൾ,

$ കയറ്റുമതി 'NS_LOG=*=level_all|prefix_func|prefix_time'

മുകളിലെ നക്ഷത്രചിഹ്നം ലോഗിംഗ് ഘടകം വൈൽഡ്കാർഡാണ്. ഇത് എല്ലാം ഓണാക്കും
സിമുലേഷനിൽ ഉപയോഗിക്കുന്ന എല്ലാ ഘടകങ്ങളും ലോഗിൻ ചെയ്യുന്നു. ഞാൻ ഔട്ട്പുട്ട് പുനർനിർമ്മിക്കില്ല
ഇവിടെ (ഇത് എഴുതുന്നത് പോലെ സിംഗിൾ പാക്കറ്റ് എക്കോയ്‌ക്കായി 1265 ലൈനുകൾ ഔട്ട്‌പുട്ട് ഉത്പാദിപ്പിക്കുന്നു)
നിങ്ങൾക്ക് ഈ വിവരങ്ങൾ ഒരു ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യാനും നിങ്ങളുടെ പ്രിയപ്പെട്ടവ ഉപയോഗിച്ച് അത് നോക്കാനും കഴിയും
നിങ്ങൾക്ക് ഇഷ്ടമാണെങ്കിൽ എഡിറ്റർ,

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

ഞാൻ അവതരിപ്പിക്കുമ്പോൾ ലോഗിംഗിന്റെ വളരെ വാചാലമായ ഈ പതിപ്പ് ഞാൻ വ്യക്തിപരമായി ഉപയോഗിക്കുന്നു
പ്രശ്‌നം കൂടാതെ കാര്യങ്ങൾ എവിടെയാണ് തെറ്റായി പോകുന്നതെന്ന് എനിക്കറിയില്ല. യുടെ പുരോഗതി എനിക്ക് പിന്തുടരാനാകും
ഒരു ഡീബഗ്ഗറിൽ ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിക്കാതെ വളരെ എളുപ്പത്തിൽ കോഡ് ചെയ്യുക.
എനിക്ക് എന്റെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ ഔട്ട്പുട്ട് എഡിറ്റ് ചെയ്യാനും ഞാൻ പ്രതീക്ഷിക്കുന്ന കാര്യങ്ങൾക്കായി തിരയാനും കഴിയും,
ഞാൻ പ്രതീക്ഷിക്കാത്ത കാര്യങ്ങൾ സംഭവിക്കുന്നത് കാണുക. എന്താണെന്നതിനെക്കുറിച്ച് എനിക്ക് പൊതുവായ ഒരു ആശയം ഉള്ളപ്പോൾ
തെറ്റായി പോകുന്നു, പ്രശ്നത്തിന്റെ സൂക്ഷ്മമായ പരിശോധനയ്ക്കായി ഞാൻ ഒരു ഡീബഗ്ഗറിലേക്ക് മാറുന്നു.
നിങ്ങളുടെ സ്ക്രിപ്റ്റ് എന്തെങ്കിലും പൂർണ്ണമായി ചെയ്യുമ്പോൾ ഇത്തരത്തിലുള്ള ഔട്ട്പുട്ട് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും
അപ്രതീക്ഷിതമായ. നിങ്ങൾ ഒരു ഡീബഗ്ഗർ ഉപയോഗിച്ചാണ് ചുവടുവെക്കുന്നതെങ്കിൽ നിങ്ങൾക്ക് അപ്രതീക്ഷിതമായ ഒരു ഉല്ലാസയാത്ര നഷ്‌ടമായേക്കാം
പൂർണ്ണമായും. ഉല്ലാസയാത്ര ലോഗിൻ ചെയ്യുന്നത് അത് വേഗത്തിൽ ദൃശ്യമാക്കുന്നു.

ചേർക്കുന്നു ലോഗ് ചെയ്യുന്നു ലേക്ക് നിങ്ങളുടെ കോഡ്
ലോഗ് ഘടകത്തിലേക്ക് കോളുകൾ വഴി നിങ്ങളുടെ സിമുലേഷനുകളിലേക്ക് പുതിയ ലോഗിംഗ് ചേർക്കാൻ കഴിയും
നിരവധി മാക്രോകൾ. നമുക്ക് അങ്ങനെ ചെയ്യാം myfirst.cc സ്ക്രിപ്റ്റ് ഞങ്ങളുടെ പക്കലുണ്ട് സ്ക്രാച്ച് ഡയറക്ടറി.

ആ സ്ക്രിപ്റ്റിൽ ഞങ്ങൾ ഒരു ലോഗിംഗ് ഘടകം നിർവചിച്ചിരിക്കുന്നത് ഓർക്കുക:

NS_LOG_COMPONENT_DEFINE ("ആദ്യ സ്ക്രിപ്റ്റ് ഉദാഹരണം");

സജ്ജീകരിക്കുന്നതിലൂടെ ഈ ഘടകത്തിനായുള്ള എല്ലാ ലോഗിംഗും നിങ്ങൾക്ക് പ്രവർത്തനക്ഷമമാക്കാൻ കഴിയുമെന്ന് ഇപ്പോൾ നിങ്ങൾക്കറിയാം
NS_LOG വിവിധ തലങ്ങളിലേക്കുള്ള പരിസ്ഥിതി വേരിയബിൾ. നമുക്ക് മുന്നോട്ട് പോയി കുറച്ച് ലോഗിംഗ് ചേർക്കാം
തിരക്കഥ. ഒരു ഇൻഫർമേഷൻ ലെവൽ ലോഗ് സന്ദേശം ചേർക്കാൻ ഉപയോഗിക്കുന്ന മാക്രോ ആണ് NS_LOG_INFO. പോകൂ
മുന്നോട്ട്, സ്ക്രിപ്റ്റ് എന്ന് നിങ്ങളോട് പറയുന്ന ഒന്ന് (ഞങ്ങൾ നോഡുകൾ സൃഷ്ടിക്കാൻ തുടങ്ങുന്നതിന് തൊട്ടുമുമ്പ്) ചേർക്കുക
"ടോപോളജി സൃഷ്ടിക്കുന്നു." ഈ കോഡ് സ്‌നിപ്പറ്റിലെ പോലെയാണ് ഇത് ചെയ്യുന്നത്,

തുറക്കുക സ്ക്രാച്ച്/myfirst.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ വരി ചേർക്കുക,

NS_LOG_INFO ("ടോപ്പോളജി സൃഷ്ടിക്കുന്നു");

വരികൾക്ക് തൊട്ടുമുമ്പ്,

നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
നോഡുകൾ.സൃഷ്ടിക്കുക (2);

ഇപ്പോൾ waf ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് നിർമ്മിച്ച് ക്ലിയർ ചെയ്യുക NS_LOG എന്ന ടോറന്റ് ഓഫ് ചെയ്യാനുള്ള വേരിയബിൾ
ഞങ്ങൾ മുമ്പ് പ്രവർത്തനക്ഷമമാക്കിയ ലോഗിംഗ്:

$ ./waf
$ കയറ്റുമതി NS_LOG=

ഇപ്പോൾ, നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ,

$ ./waf --റൺ സ്ക്രാച്ച്/മൈഫസ്റ്റ്

നിങ്ങൾ ഇത് ചെയ്യും അല്ല ബന്ധപ്പെട്ട ലോഗിംഗ് ഘടകം മുതൽ നിങ്ങളുടെ പുതിയ സന്ദേശം കാണുക
(ഫസ്റ്റ്സ്ക്രിപ്റ്റ് ഉദാഹരണം) പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല. നിങ്ങളുടെ സന്ദേശം കാണുന്നതിന് നിങ്ങൾ ചെയ്യേണ്ടി വരും
പ്രാപ്തമാക്കുക ഫസ്റ്റ്സ്ക്രിപ്റ്റ് ഉദാഹരണം അതിലും വലുതോ തുല്യമോ ആയ ലെവലുള്ള ലോഗിംഗ് ഘടകം
NS_LOG_INFO. ഈ പ്രത്യേക ലെവൽ ലോഗിംഗ് കാണാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്കത് പ്രവർത്തനക്ഷമമാക്കാം
പ്രകാരം,

$ കയറ്റുമതി NS_LOG=FirstScriptExample=info

നിങ്ങൾ ഇപ്പോൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ പുതിയ "ടോപ്പോളജി സൃഷ്ടിക്കുന്നു" എന്ന ലോഗ് സന്ദേശം നിങ്ങൾ കാണും,

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.404സെ)
ടോപ്പോളജി സൃഷ്ടിക്കുന്നു
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു

ഉപയോഗിക്കുന്നു കമാൻഡ് വര വാദങ്ങൾ
അസാധ്യം സ്വതേ ഗുണവിശേഷങ്ങൾ
മറ്റൊരു വഴി നിങ്ങൾക്ക് എങ്ങനെ മാറ്റാം ns-3 സ്ക്രിപ്റ്റുകൾ എഡിറ്റ് ചെയ്യാതെ പ്രവർത്തിക്കുന്നു, നിർമ്മാണം വഴിയാണ്
കമാൻഡ് വര വാദങ്ങൾ. കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ പാഴ്‌സ് ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനം ഞങ്ങൾ നൽകുന്നു
ആ ആർഗ്യുമെന്റുകളെ അടിസ്ഥാനമാക്കി പ്രാദേശികവും ആഗോളവുമായ വേരിയബിളുകൾ സ്വയമേവ സജ്ജീകരിക്കുന്നു.

കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് സിസ്റ്റം ഉപയോഗിക്കുന്നതിനുള്ള ആദ്യപടി കമാൻഡ് ലൈൻ പ്രഖ്യാപിക്കുക എന്നതാണ്
പാഴ്സർ. ഇനിപ്പറയുന്ന കോഡിലെന്നപോലെ ഇത് വളരെ ലളിതമായി (നിങ്ങളുടെ പ്രധാന പ്രോഗ്രാമിൽ) ചെയ്യുന്നു,

int
പ്രധാനം (int argc, char *argv[])
{
...

കമാൻഡ് ലൈൻ cmd;
cmd.Parse (argc, argv);

...
}

ഈ ലളിതമായ രണ്ട് വരി സ്നിപ്പെറ്റ് യഥാർത്ഥത്തിൽ വളരെ ഉപയോഗപ്രദമാണ്. അതിലേക്കുള്ള വാതിൽ തുറക്കുന്നു
ns-3 ആഗോള വേരിയബിൾ ഒപ്പം ഗുണങ്ങളെ സംവിധാനങ്ങൾ. മുന്നോട്ട് പോയി കോഡിന്റെ രണ്ട് വരികൾ ചേർക്കുക
The സ്ക്രാച്ച്/myfirst.cc തുടക്കത്തിൽ സ്ക്രിപ്റ്റ് പ്രധാന. മുന്നോട്ട് പോയി സ്ക്രിപ്റ്റ് നിർമ്മിച്ച് ഓടുക
അത്, എന്നാൽ ഇനിപ്പറയുന്ന രീതിയിൽ സഹായത്തിനായി സ്ക്രിപ്റ്റിനോട് ആവശ്യപ്പെടുക,

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ് --പ്രിന്റ് ഹെൽപ്പ്"

ഇത് പ്രവർത്തിപ്പിക്കാൻ വാഫിനോട് ആവശ്യപ്പെടും സ്ക്രാച്ച്/മൈഫസ്റ്റ് സ്ക്രിപ്റ്റ് ചെയ്ത് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് പാസ്സ് ചെയ്യുക
--PrintHelp തിരക്കഥയിലേക്ക്. ഏത് പ്രോഗ്രാമാണ് ലഭിക്കുന്നതെന്ന് അടുക്കാൻ ഉദ്ധരണികൾ ആവശ്യമാണ്
വാദം. കമാൻഡ് ലൈൻ പാർസർ ഇപ്പോൾ കാണും --PrintHelp വാദിക്കുകയും പ്രതികരിക്കുകയും ചെയ്യുക,

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.413സെ)
TcpL4Protocol:TcpStateMachine()
CommandLine:HandleArgument(): Handle arg name=PrintHelp value=
--PrintHelp: ഈ സഹായ സന്ദേശം അച്ചടിക്കുക.
--PrintGroups: ഗ്രൂപ്പുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.
--PrintTypeIds: എല്ലാ ടൈപ്പ് ഐഡുകളും പ്രിന്റ് ചെയ്യുക.
--PrintGroup=[group]: ഗ്രൂപ്പിന്റെ എല്ലാ TypeId-കളും പ്രിന്റ് ചെയ്യുക.
--PrintAttributes=[typeid]: ടൈപ്പിഡിന്റെ എല്ലാ ആട്രിബ്യൂട്ടുകളും പ്രിന്റ് ചെയ്യുക.
--PrintGlobals: ഗ്ലോബലുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.

എന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം --PrintAtributes ഓപ്ഷൻ. ഞങ്ങൾ ഇതിനകം സൂചിപ്പിച്ചു ns-3 ഗുണങ്ങളെ
വഴി നടക്കുമ്പോൾ സിസ്റ്റം ആദ്യം.cc സ്ക്രിപ്റ്റ്. എന്നതിന്റെ ഇനിപ്പറയുന്ന വരികൾ ഞങ്ങൾ നോക്കി
കോഡ്,

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

അത് പരാമർശിച്ചു വിവര നിരക്ക് യഥാർത്ഥത്തിൽ ഒരു ആയിരുന്നു ഗുണങ്ങളെ എന്ന PointToPointNetDevice. ചെയ്യാനും അനുവദിക്കുന്നു
കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് പാഴ്സർ ഉപയോഗിച്ച് നോക്കുക ഗുണവിശേഷങ്ങൾ എന്ന
PointToPointNetDevice. ഹെൽപ്പ് ലിസ്‌റ്റിംഗ് പറയുന്നത് ഞങ്ങൾ എ നൽകണം എന്നാണ് ടൈപ്പ് ഐഡി. ഈ
ഏത് ക്ലാസിന്റെ ക്ലാസിന്റെ പേരുമായി പൊരുത്തപ്പെടുന്നു ഗുണവിശേഷങ്ങൾ പെടുന്നു. ഈ സാഹചര്യത്തിൽ
ഇത് ഇങ്ങനെയായിരിക്കും ns3::PointToPointNetDevice. നമുക്ക് മുന്നോട്ട് പോയി ടൈപ്പ് ചെയ്യാം,

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ് --PrintAttributes=ns3::PointToPointNetDevice"

സിസ്റ്റം എല്ലാം പ്രിന്റ് ഔട്ട് ചെയ്യും ഗുണവിശേഷങ്ങൾ ഇത്തരത്തിലുള്ള നെറ്റ് ഉപകരണത്തിന്റെ. കൂട്ടത്തിൽ
ഗുണവിശേഷങ്ങൾ പട്ടികപ്പെടുത്തിയിരിക്കുന്നത് നിങ്ങൾ കാണും,

--ns3::PointToPointNetDevice::DataRate=[32768bps]:
പോയിന്റ് ടു പോയിന്റ് ലിങ്കുകൾക്കുള്ള ഡിഫോൾട്ട് ഡാറ്റ നിരക്ക്

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

നിങ്ങളുടെ സ്ക്രിപ്റ്റ് ഇപ്പോൾ പ്രഖ്യാപിക്കണം PointToPointHelper ഒന്നും ചെയ്യരുത് ഗണം പ്രവർത്തനങ്ങൾ
ഇനിപ്പറയുന്ന ഉദാഹരണത്തിലെന്നപോലെ,

...

നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
നോഡുകൾ.സൃഷ്ടിക്കുക (2);

PointToPointHelper pointToPoint;

NetDeviceContainer ഉപകരണങ്ങൾ;
ഉപകരണങ്ങൾ = pointToPoint.Install (നോഡുകൾ);

...

മുന്നോട്ട് പോയി വാഫ് ഉപയോഗിച്ച് പുതിയ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുക (./വാഫ്) നമുക്ക് തിരികെ പോയി ചിലത് പ്രവർത്തനക്ഷമമാക്കാം
UDP എക്കോ സെർവർ ആപ്ലിക്കേഷനിൽ നിന്ന് ലോഗിംഗ് ചെയ്ത് സമയ പ്രിഫിക്‌സ് ഓണാക്കുക.

$ കയറ്റുമതി 'NS_LOG=UdpEchoServerApplication=level_all|prefix_time'

നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഇപ്പോൾ ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് കാണും,

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.405സെ)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
2.25732s 1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
2.25732s എക്കോയിംഗ് പാക്കറ്റ്
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

അവസാനമായി ഞങ്ങൾ പാക്കറ്റ് ഏത് സിമുലേഷൻ സമയത്താണ് നോക്കിയതെന്ന് ഓർക്കുക
എക്കോ സെർവർ സ്വീകരിച്ചു, അത് 2.00369 സെക്കൻഡിൽ ആയിരുന്നു.

2.00369s UdpEchoServerApplication:HandleRead(): 1024-ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു

ഇപ്പോൾ അത് 2.25732 സെക്കൻഡിൽ പാക്കറ്റ് സ്വീകരിക്കുന്നു. ഇത് ഞങ്ങൾ ഉപേക്ഷിച്ചതാണ് കാരണം
യുടെ ഡാറ്റ നിരക്ക് PointToPointNetDevice മുതൽ സെക്കൻഡിൽ 32768 ബിറ്റുകൾ എന്നതിന്റെ ഡിഫോൾട്ടിലേക്ക്
സെക്കൻഡിൽ അഞ്ച് മെഗാബൈറ്റ്.

ഞങ്ങൾ പുതിയത് നൽകുകയാണെങ്കിൽ വിവര നിരക്ക് കമാൻഡ് ലൈൻ ഉപയോഗിച്ച്, നമുക്ക് നമ്മുടെ സിമുലേഷൻ വേഗത്തിലാക്കാം
വീണ്ടും മുകളിലേക്ക്. സഹായം സൂചിപ്പിക്കുന്ന ഫോർമുല അനുസരിച്ച് ഞങ്ങൾ ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യുന്നു
ഇനം:

$ ./waf --run "സ്ക്രാച്ച്/മൈഫസ്റ്റ് --ns3::PointToPointNetDevice::DataRate=5Mbps"

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

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ് --PrintAttributes=ns3::PointToPointChannel"

ഞങ്ങൾ കണ്ടെത്തുന്നു കാലതാമസം ഗുണങ്ങളെ ചാനൽ ഇനിപ്പറയുന്ന രീതിയിൽ സജ്ജീകരിച്ചിരിക്കുന്നു:

--ns3::PointToPointChannel::Delay=[0ns]:
ചാനലിലൂടെ സംപ്രേഷണം വൈകുന്നു

കമാൻഡ് ലൈൻ സിസ്റ്റം വഴി നമുക്ക് ഈ രണ്ട് സ്ഥിര മൂല്യങ്ങളും സജ്ജമാക്കാൻ കഴിയും,

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ്
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms"

ഈ സാഹചര്യത്തിൽ ഞങ്ങൾ വ്യക്തമായി സജ്ജീകരിക്കുമ്പോൾ ഉണ്ടായിരുന്ന സമയം വീണ്ടെടുക്കുന്നു വിവര നിരക്ക് ഒപ്പം കാലതാമസം
സ്ക്രിപ്റ്റിൽ:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.417സെ)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
2.00369s 1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
2.00369s എക്കോയിംഗ് പാക്കറ്റ്
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

2.00369 സെക്കൻഡിൽ പാക്കറ്റ് വീണ്ടും സെർവറിന് ലഭിക്കുന്നത് ശ്രദ്ധിക്കുക. ഞങ്ങൾക്ക് കഴിഞ്ഞു
യഥാർത്ഥത്തിൽ ഏതെങ്കിലും സജ്ജമാക്കുക ഗുണവിശേഷങ്ങൾ ഈ രീതിയിൽ സ്ക്രിപ്റ്റിൽ ഉപയോഗിച്ചു. പ്രത്യേകിച്ചും നമുക്ക് കഴിയുമായിരുന്നു
സജ്ജമാക്കുക UdpEchoClient ഗുണങ്ങളെ മാക്സ്പാക്കറ്റുകൾ ഒന്നല്ലാതെ മറ്റെന്തെങ്കിലും മൂല്യത്തിലേക്ക്.

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

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ്
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms
--ns3::UdpEchoClient::MaxPackets=2"

ഹുക്കിംഗ് നിങ്ങളുടെ സ്വന്തം മൂല്യങ്ങൾ
കമാൻഡ് ലൈൻ സിസ്റ്റത്തിലേക്ക് നിങ്ങളുടെ സ്വന്തം ഹുക്കുകൾ ചേർക്കാനും കഴിയും. ഇത് വളരെ ലളിതമായി ചെയ്തു
ഉപയോഗിച്ച് ആഡ് വാല്യൂ കമാൻഡ് ലൈൻ പാർസറിലേക്കുള്ള രീതി.

തികച്ചും വ്യത്യസ്തമായ രീതിയിൽ പ്രതിധ്വനിക്കുന്ന പാക്കറ്റുകളുടെ എണ്ണം വ്യക്തമാക്കാൻ ഈ സൗകര്യം ഉപയോഗിക്കാം
വഴി. എന്ന് വിളിക്കുന്ന ഒരു ലോക്കൽ വേരിയബിൾ ചേർക്കാം nപാക്കറ്റുകൾ ലേക്ക് പ്രധാന പ്രവർത്തനം. ഞങ്ങൾ സമാരംഭിക്കും
ഞങ്ങളുടെ മുമ്പത്തെ ഡിഫോൾട്ട് സ്വഭാവവുമായി പൊരുത്തപ്പെടുന്നതിന് ഇത് ഒന്നിലേക്ക്. കമാൻഡ് ലൈൻ പാഴ്‌സർ അനുവദിക്കുന്നതിന്
ഈ മൂല്യം മാറ്റുക, നമുക്ക് മൂല്യം പാർസറിലേക്ക് ഹുക്ക് ചെയ്യേണ്ടതുണ്ട്. ഒരു കോൾ ചേർത്താണ് ഞങ്ങൾ ഇത് ചെയ്യുന്നത്
ലേക്ക് ആഡ് വാല്യൂ. മുന്നോട്ട് പോയി മാറ്റുക സ്ക്രാച്ച്/myfirst.cc ആരംഭിക്കുന്നതിനുള്ള സ്ക്രിപ്റ്റ്
ഇനിപ്പറയുന്ന കോഡ്,

int
പ്രധാനം (int argc, char *argv[])
{
uint32_t nPackets = 1;

കമാൻഡ് ലൈൻ cmd;
cmd.AddValue("nPackets", "echo ചെയ്യാനുള്ള പാക്കറ്റുകളുടെ എണ്ണം", nPackets);
cmd.Parse (argc, argv);

...

സ്‌ക്രിപ്റ്റിലെ പോയിന്റിലേക്ക് സ്‌ക്രോൾ ചെയ്യുക, അവിടെ ഞങ്ങൾ സെറ്റ് ചെയ്യുന്നു മാക്സ്പാക്കറ്റുകൾ ഗുണങ്ങളെ അത് മാറ്റുക
അങ്ങനെ അത് വേരിയബിളിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു nപാക്കറ്റുകൾ സ്ഥിരത്തിന് പകരം 1 താഴെ കാണിച്ചിരിക്കുന്നത് പോലെ.

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

ഇപ്പോൾ നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിച്ച് നൽകുകയാണെങ്കിൽ --PrintHelp വാദം, നിങ്ങളുടെ പുതിയത് നിങ്ങൾ കാണണം
ഉപയോക്താവ് ആര്ഗ്യുമെന്റ് സഹായ ഡിസ്പ്ലേയിൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്നു.

ശ്രമിക്കുക,

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ് --പ്രിന്റ് ഹെൽപ്പ്"

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.403സെ)
--PrintHelp: ഈ സഹായ സന്ദേശം അച്ചടിക്കുക.
--PrintGroups: ഗ്രൂപ്പുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.
--PrintTypeIds: എല്ലാ ടൈപ്പ് ഐഡുകളും പ്രിന്റ് ചെയ്യുക.
--PrintGroup=[group]: ഗ്രൂപ്പിന്റെ എല്ലാ TypeId-കളും പ്രിന്റ് ചെയ്യുക.
--PrintAttributes=[typeid]: ടൈപ്പിഡിന്റെ എല്ലാ ആട്രിബ്യൂട്ടുകളും പ്രിന്റ് ചെയ്യുക.
--PrintGlobals: ഗ്ലോബലുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.
ഉപയോക്തൃ വാദങ്ങൾ:
--nപാക്കറ്റുകൾ: പ്രതിധ്വനിക്കുന്ന പാക്കറ്റുകളുടെ എണ്ണം

പ്രതിധ്വനിക്കുന്ന പാക്കറ്റുകളുടെ എണ്ണം വ്യക്തമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, സജ്ജീകരിച്ചുകൊണ്ട് നിങ്ങൾക്കത് ചെയ്യാൻ കഴിയും
--nപാക്കറ്റുകൾ കമാൻഡ് ലൈനിലെ വാദം,

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈഫസ്റ്റ് --nPackets=2"

നിങ്ങൾ ഇപ്പോൾ കാണണം

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.404സെ)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
2.25732s 1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
2.25732s എക്കോയിംഗ് പാക്കറ്റ്
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
1024 ലേക്ക് 10.1.1.2 ബൈറ്റുകൾ അയച്ചു
3.25732s 1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
3.25732s എക്കോയിംഗ് പാക്കറ്റ്
1024 ൽ നിന്ന് 10.1.1.2 ബൈറ്റുകൾ ലഭിച്ചു
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

നിങ്ങൾ ഇപ്പോൾ രണ്ട് പാക്കറ്റുകൾ പ്രതിധ്വനിച്ചു. വളരെ എളുപ്പമാണ്, അല്ലേ?

നിങ്ങൾ ആണെങ്കിൽ നിങ്ങൾക്ക് അത് കാണാൻ കഴിയും ns-3 ഉപയോക്താവ്, നിങ്ങൾക്ക് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് സിസ്റ്റം ഉപയോഗിക്കാം
ആഗോള മൂല്യങ്ങളെ നിയന്ത്രിക്കുകയും ഗുണവിശേഷങ്ങൾ. നിങ്ങൾ ഒരു മാതൃകാ രചയിതാവാണെങ്കിൽ, നിങ്ങൾക്ക് പുതിയത് ചേർക്കാം
ഗുണവിശേഷങ്ങൾ നിങ്ങളുടെ വസ്തുക്കൾ നിങ്ങളുടെ ക്രമീകരണത്തിനായി അവ സ്വയമേവ ലഭ്യമാകും
കമാൻഡ് ലൈൻ സിസ്റ്റം വഴിയുള്ള ഉപയോക്താക്കൾ. നിങ്ങൾ ഒരു സ്ക്രിപ്റ്റ് രചയിതാവാണെങ്കിൽ, നിങ്ങൾക്ക് പുതിയത് ചേർക്കാം
നിങ്ങളുടെ സ്ക്രിപ്റ്റുകളിലേക്കുള്ള വേരിയബിളുകൾ കമാൻഡ് ലൈൻ സിസ്റ്റത്തിലേക്ക് വളരെ വേദനയില്ലാതെ ഹുക്ക് ചെയ്യുക.

ഉപയോഗിക്കുന്നു The പിന്തുടരുന്നു സിസ്റ്റം
സിമുലേഷന്റെ മുഴുവൻ പോയിന്റും തുടർ പഠനത്തിനായി ഔട്ട്പുട്ട് സൃഷ്ടിക്കുക എന്നതാണ്, കൂടാതെ ns-3
ട്രേസിംഗ് സിസ്റ്റം ഇതിനുള്ള ഒരു പ്രാഥമിക സംവിധാനമാണ്. മുതലുള്ള ns-3 ഒരു C++ പ്രോഗ്രാമാണ്, സ്റ്റാൻഡേർഡ്
C++ പ്രോഗ്രാമുകളിൽ നിന്ന് ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നതിനുള്ള സൗകര്യങ്ങൾ ഉപയോഗിക്കാം:

#ഉൾപ്പെടുന്നു
...
int മെയിൻ ()
{
...
std::cout << "x ന്റെ മൂല്യം " << x << std::endl;
...
}

നിങ്ങളുടെ പരിഹാരത്തിലേക്ക് ഒരു ചെറിയ ഘടന ചേർക്കാൻ നിങ്ങൾക്ക് ലോഗിംഗ് മൊഡ്യൂൾ ഉപയോഗിക്കാം. അവിടെ
അത്തരം സമീപനങ്ങളാൽ സൃഷ്ടിക്കപ്പെട്ട നിരവധി അറിയപ്പെടുന്ന പ്രശ്നങ്ങൾ, അതിനാൽ ഞങ്ങൾ എ
പ്രധാനമെന്ന് ഞങ്ങൾ കരുതുന്ന പ്രശ്‌നങ്ങൾ പരിഹരിക്കുന്നതിന് ജനറിക് ഇവന്റ് ട്രെയ്‌സിംഗ് സബ്‌സിസ്റ്റം.

യുടെ അടിസ്ഥാന ലക്ഷ്യങ്ങൾ ns-3 ട്രേസിംഗ് സിസ്റ്റം ഇവയാണ്:

അടിസ്ഥാന ജോലികൾക്കായി, ട്രെയ്‌സിംഗ് സിസ്റ്റം സ്റ്റാൻഡേർഡ് ട്രെയ്‌സിംഗ് സൃഷ്‌ടിക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കണം
ജനപ്രിയമായ ട്രെയ്‌സിംഗ് സ്രോതസ്സുകൾക്കും ട്രെയ്‌സിംഗ് സൃഷ്‌ടിക്കുന്ന ഒബ്‌ജക്‌റ്റുകൾ ഇഷ്‌ടാനുസൃതമാക്കുന്നതിനും;

· ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് പരിഷ്‌ക്കരിക്കുന്നതിന് ഇന്റർമീഡിയറ്റ് ഉപയോക്താക്കൾക്ക് ട്രെയ്‌സിംഗ് സിസ്റ്റം വിപുലീകരിക്കാൻ കഴിയണം
സൃഷ്ടിച്ചത്, അല്ലെങ്കിൽ പുതിയ ട്രെയ്‌സിംഗ് സ്രോതസ്സുകൾ തിരുകാൻ, കോർ പരിഷ്‌ക്കരിക്കാതെ
സിമുലേറ്റർ;

· നൂതന ഉപയോക്താക്കൾക്ക് പുതിയ ട്രെയ്സിംഗ് ഉറവിടങ്ങളും സിങ്കുകളും ചേർക്കുന്നതിന് സിമുലേറ്റർ കോർ പരിഷ്കരിക്കാനാകും.

ദി ns-3 ട്രെയ്‌സിംഗ് സിസ്റ്റം സ്വതന്ത്ര ട്രേസിംഗ് സ്രോതസ്സുകളുടെ ആശയങ്ങളെ അടിസ്ഥാനമാക്കിയാണ് നിർമ്മിച്ചിരിക്കുന്നത്
ട്രെയ്‌സിംഗ് സിങ്കുകൾ, സിങ്കുകളിലേക്ക് ഉറവിടങ്ങളെ ബന്ധിപ്പിക്കുന്നതിനുള്ള ഏകീകൃത സംവിധാനം. ട്രെയ്സ് ഉറവിടങ്ങളാണ്
ഒരു സിമുലേഷനിൽ സംഭവിക്കുന്ന ഇവന്റുകൾ സൂചിപ്പിക്കുകയും ആക്സസ് നൽകുകയും ചെയ്യുന്ന എന്റിറ്റികൾ
രസകരമായ അടിസ്ഥാന ഡാറ്റ. ഉദാഹരണത്തിന്, ഒരു പാക്കറ്റ് എപ്പോഴാണെന്ന് ഒരു ട്രെയ്സ് ഉറവിടം സൂചിപ്പിക്കാം
ഒരു നെറ്റ് ഉപകരണം വഴി സ്വീകരിക്കുകയും താൽപ്പര്യമുള്ള കണ്ടെത്തലിനായി പാക്കറ്റ് ഉള്ളടക്കങ്ങളിലേക്ക് പ്രവേശനം നൽകുകയും ചെയ്യുന്നു
മുങ്ങുന്നു.

ട്രെയ്സ് ഉറവിടങ്ങൾ സ്വയം ഉപയോഗപ്രദമല്ല, അവ മറ്റ് ഭാഗങ്ങളുമായി "ബന്ധിപ്പിച്ചിരിക്കണം"
സിങ്ക് നൽകുന്ന വിവരങ്ങൾ ഉപയോഗിച്ച് യഥാർത്ഥത്തിൽ ഉപയോഗപ്രദമായ എന്തെങ്കിലും ചെയ്യുന്ന കോഡ്. ട്രെയ്സ്
ട്രെയ്സ് ഉറവിടങ്ങൾ നൽകുന്ന ഇവന്റുകളുടെയും ഡാറ്റയുടെയും ഉപഭോക്താക്കളാണ് സിങ്കുകൾ. ഉദാഹരണത്തിന്,
ഒരാൾക്ക് ഒരു ട്രെയ്‌സ് സിങ്ക് സൃഷ്‌ടിക്കാനാകും, അത് (ട്രേസ് സോഴ്‌സുമായി ബന്ധിപ്പിക്കുമ്പോൾ
മുമ്പത്തെ ഉദാഹരണം) ലഭിച്ച പാക്കറ്റിന്റെ രസകരമായ ഭാഗങ്ങൾ പ്രിന്റ് ഔട്ട് ചെയ്യുക.

പുതിയ തരം സിങ്കുകൾ അറ്റാച്ചുചെയ്യാൻ ഉപയോക്താക്കളെ അനുവദിക്കുക എന്നതാണ് ഈ വ്യക്തമായ വിഭജനത്തിന്റെ യുക്തി
കാമ്പിന്റെ എഡിറ്റിംഗും പുനഃസംയോജനവും ആവശ്യമില്ലാതെ നിലവിലുള്ള ട്രേസിംഗ് ഉറവിടങ്ങൾ
സിമുലേറ്റർ. അതിനാൽ, മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഒരു ഉപയോക്താവിന് അവളിൽ ഒരു പുതിയ ട്രെയ്സിംഗ് സിങ്ക് നിർവചിക്കാനാകും
സ്ക്രിപ്റ്റ് ചെയ്ത് സിമുലേഷൻ കോറിൽ നിർവചിച്ചിരിക്കുന്ന നിലവിലുള്ള ഒരു ട്രെയ്സിംഗ് ഉറവിടത്തിലേക്ക് അറ്റാച്ചുചെയ്യുക
ഉപയോക്തൃ സ്ക്രിപ്റ്റ് മാത്രം എഡിറ്റുചെയ്യുന്നു.

ഈ ട്യൂട്ടോറിയലിൽ, ഞങ്ങൾ മുൻകൂട്ടി നിർവചിച്ച ചില ഉറവിടങ്ങളിലൂടെയും സിങ്കുകളിലൂടെയും നടന്ന് എങ്ങനെയെന്ന് കാണിക്കും
കുറച്ച് ഉപയോക്തൃ പ്രയത്നത്തിലൂടെ അവ ഇഷ്ടാനുസൃതമാക്കാം. ns-3 മാനുവൽ അല്ലെങ്കിൽ എങ്ങനെ-ടു എന്ന വിഭാഗങ്ങൾ കാണുക
ട്രെയ്‌സിംഗ് വിപുലീകരിക്കുന്നത് ഉൾപ്പെടെയുള്ള വിപുലമായ ട്രെയ്‌സിംഗ് കോൺഫിഗറേഷനെക്കുറിച്ചുള്ള വിവരങ്ങൾക്ക്
നെയിംസ്പേസ്, പുതിയ ട്രെയ്സിംഗ് ഉറവിടങ്ങൾ സൃഷ്ടിക്കൽ.

ASCII പിന്തുടരുന്നു
ns-3 നിങ്ങളെ സഹായിക്കാൻ ലോ-ലെവൽ ട്രെയ്‌സിംഗ് സിസ്റ്റം പൊതിയുന്ന സഹായ പ്രവർത്തനം നൽകുന്നു
എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്ന ചില പാക്കറ്റ് ട്രെയ്‌സുകൾ കോൺഫിഗർ ചെയ്യുന്നതിൽ ഉൾപ്പെട്ടിരിക്കുന്ന വിശദാംശങ്ങൾക്കൊപ്പം. നിങ്ങൾ എങ്കിൽ
ഈ പ്രവർത്തനം പ്രാപ്തമാക്കുക, നിങ്ങൾ ഒരു ASCII ഫയലുകളിൽ ഔട്ട്പുട്ട് കാണും --- അങ്ങനെ പേര്. വേണ്ടി
പരിചയമുള്ളവർ ns-2 ഔട്ട്പുട്ട്, ഈ തരത്തിലുള്ള ട്രെയ്സ് സമാനമാണ് പുറത്ത്.tr സൃഷ്ടിച്ചു
പല സ്ക്രിപ്റ്റുകളാൽ.

നമുക്ക് നേരെ കുതിച്ച് കുറച്ച് ASCII ട്രെയ്‌സിംഗ് ഔട്ട്‌പുട്ടിലേക്ക് ചേർക്കാം സ്ക്രാച്ച്/myfirst.cc
സ്ക്രിപ്റ്റ്. വിളിക്കുന്നതിന് തൊട്ടുമുമ്പ് സിമുലേറ്റർ:: റൺ (), കോഡിന്റെ ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക:

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

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

പുറത്തേക്കുള്ള വിളി, ലേയ്ക്ക് പ്രവർത്തനക്ഷമമാക്കുകAsciiAll(), നിങ്ങൾക്ക് ASCII പ്രവർത്തനക്ഷമമാക്കണമെന്ന് സഹായിയോട് പറയുന്നു
നിങ്ങളുടെ സിമുലേഷനിലെ എല്ലാ പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണങ്ങളിലും കണ്ടെത്തൽ; നിങ്ങൾക്ക് (നൽകിയത്) വേണം
ASCII ഫോർമാറ്റിൽ പാക്കറ്റ് ചലനത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ എഴുതാൻ സിങ്കുകൾ കണ്ടെത്തുക.

പരിചയമുള്ളവർക്ക് ns-2, കണ്ടെത്തിയ ഇവന്റുകൾ ജനപ്രിയ ട്രെയ്സ് പോയിന്റുകൾക്ക് തുല്യമാണ്
ആ ലോഗ് "+", "-", "d", "r" ഇവന്റുകൾ.

നിങ്ങൾക്ക് ഇപ്പോൾ സ്ക്രിപ്റ്റ് നിർമ്മിക്കാനും കമാൻഡ് ലൈനിൽ നിന്ന് പ്രവർത്തിപ്പിക്കാനും കഴിയും:

$ ./waf --റൺ സ്ക്രാച്ച്/മൈഫസ്റ്റ്

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

അത് പ്രവർത്തിക്കുമ്പോൾ, പ്രോഗ്രാം എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിച്ചിരിക്കും myfirst.tr. വഴി കാരണം
വാഫ് പ്രവർത്തിക്കുന്നു, ഫയൽ ലോക്കൽ ഡയറക്ടറിയിൽ സൃഷ്‌ടിച്ചതല്ല, അത് സൃഷ്‌ടിച്ചിരിക്കുന്നത്
ഡിഫോൾട്ടായി റിപ്പോസിറ്ററിയുടെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറി. ട്രെയ്‌സ് എവിടെയാണെന്ന് നിങ്ങൾക്ക് നിയന്ത്രിക്കണമെങ്കിൽ
നിങ്ങൾക്ക് ഉപയോഗിക്കാൻ കഴിയുന്ന സംരക്ഷിച്ചിരിക്കുന്നു --cwd ഇത് വ്യക്തമാക്കാൻ Waf എന്ന ഓപ്ഷൻ. ഞങ്ങൾ അങ്ങനെ ചെയ്തിട്ടില്ല, അങ്ങനെ
ഞങ്ങളുടെ റിപ്പോയുടെ ടോപ്പ് ലെവൽ ഡയറക്‌ടറിയിലേക്ക് മാറുകയും ASCII നോക്കുകയും വേണം
ട്രെയ്സ് ഫയൽ myfirst.tr നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ.

പാഴ്‌സിംഗ് അസ്സി തെളിവുകൾ
വളരെ സാന്ദ്രമായ രൂപത്തിൽ ധാരാളം വിവരങ്ങൾ അവിടെയുണ്ട്, എന്നാൽ ആദ്യം ശ്രദ്ധിക്കേണ്ട കാര്യം
ഈ ഫയലിൽ നിരവധി വ്യത്യസ്ത വരികൾ ഉണ്ട് എന്നതാണ്. ഇത് കാണാൻ ബുദ്ധിമുട്ടായിരിക്കാം
നിങ്ങളുടെ വിൻഡോ ഗണ്യമായി വിശാലമാക്കിയില്ലെങ്കിൽ ഇത് വ്യക്തമാണ്.

ഫയലിലെ ഓരോ വരിയും a എന്നതിനോട് യോജിക്കുന്നു പിന്തുടരുക സംഭവം. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഇവന്റുകൾ പിന്തുടരുകയാണ്
The സംപ്രേഷണം ചെയ്യുക വരി സിമുലേഷനിലെ എല്ലാ പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണത്തിലും ഉണ്ട്. ദി
ഓരോ പാക്കറ്റും ഒരു പോയിന്റ്-ടു-പോയിന്റ് ചാനലിനായി ഉദ്ദേശിച്ചിട്ടുള്ള ഒരു ക്യൂ ആണ് ട്രാൻസ്മിറ്റ് ക്യൂ
കടന്നുപോകണം. ട്രെയ്‌സ് ഫയലിലെ ഓരോ വരിയും ആരംഭിക്കുന്നത് ഒരു ഏകാന്ത പ്രതീകത്തിലാണ് (എ
അതിനു ശേഷം സ്ഥലം). ഈ പ്രതീകത്തിന് ഇനിപ്പറയുന്ന അർത്ഥമുണ്ടാകും:

· +: ഉപകരണ ക്യൂവിൽ ഒരു എൻക്യൂ പ്രവർത്തനം സംഭവിച്ചു;

· -: ഉപകരണ ക്യൂവിൽ ഒരു ഡീക്യൂ പ്രവർത്തനം സംഭവിച്ചു;

· d: ക്യൂ നിറഞ്ഞതിനാൽ ഒരു പാക്കറ്റ് ഉപേക്ഷിച്ചു;

· r: നെറ്റ് ഉപകരണത്തിൽ ഒരു പാക്കറ്റ് ലഭിച്ചു.

ട്രേസ് ഫയലിലെ ആദ്യ വരിയുടെ കൂടുതൽ വിശദമായ കാഴ്ച നമുക്ക് നോക്കാം. ഞാൻ അത് തകർക്കും
ഇടത് വശത്ത് ഒരു റഫറൻസ് നമ്പർ ഉള്ള വിഭാഗങ്ങളായി (വ്യക്തതയ്ക്കായി ഇൻഡന്റ് ചെയ്‌തിരിക്കുന്നു):

+
2
/NodeList/0/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Enqueue
ns3::PppHeader (
പോയിന്റ്-ടു-പോയിന്റ് പ്രോട്ടോക്കോൾ: IP (0x0021))
ns3::Ipv4ഹെഡർ (
tos 0x0 ttl 64 id 0 പ്രോട്ടോക്കോൾ 17 ഓഫ്‌സെറ്റ് 0 ഫ്ലാഗുകൾ [ഒന്നുമില്ല]
ദൈർഘ്യം: 1052 10.1.1.1 > 10.1.1.2)
ns3::UdpHeader (
ദൈർഘ്യം: 1032 49153 > 9)
പേലോഡ് (വലിപ്പം=1024)

ഈ വിപുലീകരിച്ച ട്രെയ്സ് ഇവന്റിന്റെ ആദ്യ വിഭാഗം (റഫറൻസ് നമ്പർ 0) പ്രവർത്തനമാണ്. ഞങ്ങൾ
ഒരു ഉണ്ട് + പ്രതീകം, അതിനാൽ ഇത് a എന്നതിനോട് യോജിക്കുന്നു ഇൻ ലൈൻ ട്രാൻസ്മിറ്റ് ക്യൂവിൽ പ്രവർത്തനം.
സെക്കൻഡിൽ പ്രകടിപ്പിക്കുന്ന സിമുലേഷൻ സമയമാണ് രണ്ടാമത്തെ വിഭാഗം (റഫറൻസ് 1). ഒരുപക്ഷേ നിങ്ങൾ
ഞങ്ങൾ ചോദിച്ചത് ഓർക്കുക UdpEchoClientApplication രണ്ട് സെക്കൻഡിൽ പാക്കറ്റുകൾ അയച്ചു തുടങ്ങാൻ.
ഇത് തീർച്ചയായും സംഭവിക്കുന്നു എന്നതിന്റെ സ്ഥിരീകരണം ഇവിടെ കാണാം.

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

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

ട്രെയ്‌സിലെ ശേഷിക്കുന്ന ഭാഗങ്ങൾ തികച്ചും അവബോധജന്യമായിരിക്കണം. 3-4 റഫറൻസുകൾ സൂചിപ്പിക്കുന്നു
പോയിന്റ്-ടു-പോയിന്റ് പ്രോട്ടോക്കോളിൽ പാക്കറ്റ് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. 5-7 റഫറൻസുകൾ അത് കാണിക്കുന്നു
പാക്കറ്റിന് ഒരു IP പതിപ്പ് നാല് തലക്കെട്ടുണ്ട് കൂടാതെ 10.1.1.1 എന്ന ഐപി വിലാസത്തിൽ നിന്നും ഉത്ഭവിച്ചതാണ്
10.1.1.2 ന് ഉദ്ദേശിച്ചുള്ളതാണ്. റഫറൻസ് 8-9 ഈ പാക്കറ്റിന് ഒരു UDP തലക്കെട്ടുണ്ടെന്നും,
ഒടുവിൽ, റഫറൻസ് 10 കാണിക്കുന്നത് പേലോഡ് പ്രതീക്ഷിക്കുന്ന 1024 ബൈറ്റുകളാണ്.

ട്രേസ് ഫയലിലെ അടുത്ത വരി, ട്രാൻസ്മിറ്റിൽ നിന്ന് അതേ പാക്കറ്റ് ഡീക്യൂ ചെയ്തതായി കാണിക്കുന്നു
ഒരേ നോഡിൽ ക്യൂ.

ട്രേസ് ഫയലിലെ മൂന്നാമത്തെ വരി, നെറ്റ് ഉപകരണത്തിൽ പാക്കറ്റ് സ്വീകരിക്കുന്നതായി കാണിക്കുന്നു
എക്കോ സെർവർ ഉള്ള നോഡ്. ആ സംഭവം ഞാൻ താഴെ പുനർനിർമ്മിച്ചിട്ടുണ്ട്.

r
2.25732
/NodeList/1/DeviceList/0/$ns3::PointToPointNetDevice/MacRx
ns3::Ipv4ഹെഡർ (
tos 0x0 ttl 64 id 0 പ്രോട്ടോക്കോൾ 17 ഓഫ്‌സെറ്റ് 0 ഫ്ലാഗുകൾ [ഒന്നുമില്ല]
ദൈർഘ്യം: 1052 10.1.1.1 > 10.1.1.2)
ns3::UdpHeader (
ദൈർഘ്യം: 1032 49153 > 9)
പേലോഡ് (വലിപ്പം=1024)

ട്രെയ്‌സ് ഓപ്പറേഷൻ ഇപ്പോഴാണെന്ന് ശ്രദ്ധിക്കുക r സിമുലേഷൻ സമയം 2.25732 ആയി വർദ്ധിച്ചു
സെക്കന്റുകൾ. നിങ്ങൾ ട്യൂട്ടോറിയൽ ഘട്ടങ്ങൾ കൃത്യമായി പിന്തുടരുകയാണെങ്കിൽ ഇതിനർത്ഥം നിങ്ങൾക്കുണ്ട് എന്നാണ്
വിട്ടു വിവര നിരക്ക് നെറ്റ് ഉപകരണങ്ങളുടെയും ചാനലിന്റെയും കാലതാമസം അവയുടെ സ്ഥിര മൂല്യങ്ങളിലേക്ക് സജ്ജമാക്കുക.
മുമ്പത്തെ ഒരു വിഭാഗത്തിൽ നിങ്ങൾ മുമ്പ് കണ്ടതുപോലെ ഈ സമയം പരിചിതമായിരിക്കണം.

ട്രെയ്സ് സോഴ്സ് നെയിംസ്പേസ് എൻട്രി (റഫറൻസ് 02) ഈ ഇവന്റ് ആണെന്ന് പ്രതിഫലിപ്പിക്കാൻ മാറ്റി
നോഡ് 1 ൽ നിന്ന് വരുന്നു (/നോഡ് ലിസ്റ്റ്/1) കൂടാതെ പാക്കറ്റ് റിസപ്ഷൻ ട്രെയ്സ് ഉറവിടം (/MacRx). അത്
ടോപ്പോളജി വഴി പാക്കറ്റിന്റെ പുരോഗതി പിന്തുടരാൻ നിങ്ങൾക്ക് വളരെ എളുപ്പമായിരിക്കണം
ഫയലിലെ ബാക്കി ട്രെയ്‌സുകൾ നോക്കുന്നു.

പിസിഎപി പിന്തുടരുന്നു
ദി ns-3 എന്നതിൽ ട്രേസ് ഫയലുകൾ സൃഷ്‌ടിക്കാൻ ഉപകരണ സഹായികളെയും ഉപയോഗിക്കാം .pcap ഫോർമാറ്റ്. ദി
pcap എന്ന ചുരുക്കെഴുത്ത് (സാധാരണയായി ചെറിയ അക്ഷരത്തിൽ എഴുതുന്നു) എന്നത് പാക്കറ്റ് ക്യാപ്‌ചറിനെ സൂചിപ്പിക്കുന്നു, ഇത് യഥാർത്ഥത്തിൽ a
a യുടെ നിർവചനം ഉൾപ്പെടുന്ന API .pcap ഫയൽ ഫോർമാറ്റ്. ഏറ്റവും ജനപ്രിയമായ പ്രോഗ്രാം
ഈ ഫോർമാറ്റ് വായിക്കാനും പ്രദർശിപ്പിക്കാനും കഴിയും Wireshark (മുമ്പ് Ethereal എന്ന് വിളിച്ചിരുന്നു). എന്നിരുന്നാലും, അവിടെ
ഈ പാക്കറ്റ് ഫോർമാറ്റ് ഉപയോഗിക്കുന്ന നിരവധി ട്രാഫിക് ട്രെയ്സ് അനലൈസറുകൾ. ഞങ്ങൾ ഉപയോക്താക്കളെ പ്രോത്സാഹിപ്പിക്കുന്നു
pcap ട്രെയ്‌സുകൾ വിശകലനം ചെയ്യുന്നതിനായി ലഭ്യമായ നിരവധി ടൂളുകൾ പ്രയോജനപ്പെടുത്തുക. ഈ ട്യൂട്ടോറിയലിൽ, ഞങ്ങൾ
tcpdump ഉപയോഗിച്ച് pcap ട്രെയ്‌സുകൾ കാണുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുക.

pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാൻ ഉപയോഗിക്കുന്ന കോഡ് ഒരു വൺ-ലൈനർ ആണ്.

pointToPoint.EnablePcapAll ("myfirst");

മുന്നോട്ട് പോയി ഞങ്ങൾ ഇപ്പോൾ ചേർത്ത ASCII ട്രെയ്‌സിംഗ് കോഡിന് ശേഷം ഈ കോഡിന്റെ വരി ചേർക്കുക
സ്ക്രാച്ച്/myfirst.cc. "myfirst" എന്ന സ്ട്രിംഗ് മാത്രമേ ഞങ്ങൾ പാസ്സാക്കിയിട്ടുള്ളൂ എന്നതും ശ്രദ്ധിക്കുക
"myfirst.pcap" അല്ലെങ്കിൽ സമാനമായ എന്തെങ്കിലും. കാരണം, പരാമീറ്റർ ഒരു പ്രിഫിക്സാണ്, a അല്ല
പൂർണ്ണമായ ഫയലിന്റെ പേര്. ഓരോ പോയിന്റ്-ടു-പോയിന്റിനും സഹായി യഥാർത്ഥത്തിൽ ഒരു ട്രേസ് ഫയൽ സൃഷ്ടിക്കും
സിമുലേഷനിലെ ഉപകരണം. പ്രിഫിക്‌സ്, നോഡ് നമ്പർ, ഉപയോഗിച്ചാണ് ഫയലിന്റെ പേരുകൾ നിർമ്മിക്കുന്നത്.
ഉപകരണ നമ്പറും ഒരു ".pcap" പ്രത്യയവും.

ഞങ്ങളുടെ ഉദാഹരണ സ്ക്രിപ്റ്റിൽ, "myfirst-0-0.pcap" എന്ന പേരിലുള്ള ഫയലുകൾ ഞങ്ങൾ ഒടുവിൽ കാണും.
"myfirst-1-0.pcap" നോഡ് 0-ഡിവൈസ് 0, നോഡ് 1-ഡിവൈസ് 0 എന്നിവയ്ക്കുള്ള pcap ട്രെയ്‌സുകളാണ്,
യഥാക്രമം.

pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാൻ നിങ്ങൾ കോഡിന്റെ ലൈൻ ചേർത്തുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും
സാധാരണ വഴി:

$ ./waf --റൺ സ്ക്രാച്ച്/മൈഫസ്റ്റ്

നിങ്ങളുടെ വിതരണത്തിന്റെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറി നിങ്ങൾ നോക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഇപ്പോൾ മൂന്ന് ലോഗ് കാണും
ഫയലുകൾ: myfirst.tr ഞങ്ങൾ മുമ്പ് പരിശോധിച്ച ASCII ട്രേസ് ഫയൽ ആണ്. myfirst-0-0.pcap
ഒപ്പം myfirst-1-0.pcap ഞങ്ങൾ ഇപ്പോൾ സൃഷ്ടിച്ച പുതിയ pcap ഫയലുകളാണ്.

വായന ഔട്ട്പുട്ട് കൂടെ tcpdump
ഈ ഘട്ടത്തിൽ ചെയ്യാൻ ഏറ്റവും എളുപ്പമുള്ള കാര്യം ഉപയോഗിക്കുക എന്നതാണ് tcpdump നോക്കാൻ pcap ഫയലുകൾ.

$ tcpdump -nn -tt -r myfirst-0-0.pcap
myfist-0-0.pcap എന്ന ഫയലിൽ നിന്നുള്ള വായന, ലിങ്ക്-ടൈപ്പ് PPP (PPP)
2.000000 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, ദൈർഘ്യം 1024
2.514648 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

tcpdump -nn -tt -r myfirst-1-0.pcap
myfist-1-0.pcap എന്ന ഫയലിൽ നിന്നുള്ള വായന, ലിങ്ക്-ടൈപ്പ് PPP (PPP)
2.257324 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, ദൈർഘ്യം 1024
2.257324 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

കുപ്പത്തൊട്ടിയിൽ കാണാം myfirst-0-0.pcap (ക്ലയന്റ് ഉപകരണം) എക്കോ പാക്കറ്റ് ആണ്
സിമുലേഷനിലേക്ക് 2 സെക്കൻഡിൽ അയച്ചു. നിങ്ങൾ രണ്ടാമത്തെ കുപ്പത്തൊട്ടിയിൽ നോക്കിയാൽ (myfirst-1-0.pcap)
2.257324 സെക്കൻഡിൽ ആ പാക്കറ്റ് ലഭിക്കുന്നത് നിങ്ങൾക്ക് കാണാം. പാക്കറ്റ് ഉണ്ടെന്ന് നിങ്ങൾ കാണുന്നു
രണ്ടാമത്തെ ഡമ്പിൽ 2.257324 സെക്കൻഡിൽ പ്രതിധ്വനിച്ചു, ഒടുവിൽ, പാക്കറ്റ് ആണെന്ന് നിങ്ങൾ കാണുന്നു
2.514648 സെക്കൻഡിൽ ആദ്യ ഡംപിൽ ക്ലയന്റിലേക്ക് തിരികെ ലഭിച്ചു.

വായന ഔട്ട്പുട്ട് കൂടെ വയറുകൾഷാർക്ക്
Wireshark-നെ കുറിച്ച് നിങ്ങൾക്ക് പരിചയമില്ലെങ്കിൽ, നിങ്ങൾക്ക് കഴിയുന്ന ഒരു വെബ് സൈറ്റ് ലഭ്യമാണ്
പ്രോഗ്രാമുകളും ഡോക്യുമെന്റേഷനും ഡൗൺലോഡ് ചെയ്യുക: http://www.wireshark.org/.

ഈ ട്രെയ്സ് പ്രദർശിപ്പിക്കാൻ ഉപയോഗിക്കാവുന്ന ഒരു ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസാണ് വയർഷാർക്ക്
ഫയലുകൾ. നിങ്ങൾക്ക് Wireshark ലഭ്യമാണെങ്കിൽ, നിങ്ങൾക്ക് ഓരോ ട്രേസ് ഫയലുകളും തുറന്ന് പ്രദർശിപ്പിക്കാൻ കഴിയും
എ ഉപയോഗിച്ച് പാക്കറ്റുകൾ പിടിച്ചെടുത്തത് പോലെയുള്ള ഉള്ളടക്കം പാക്കറ്റ് സ്നിഫർ.

ബിൽഡിംഗ് ടോപ്പോളജികൾ

കെട്ടിടം a ബസ് നെറ്റ്വർക്ക് ടോപ്പോളജി
ഈ വിഭാഗത്തിൽ ഞങ്ങൾ ഞങ്ങളുടെ പാണ്ഡിത്യം വിപുലീകരിക്കാൻ പോകുന്നു ns-3 നെറ്റ്‌വർക്ക് ഉപകരണങ്ങളും ചാനലുകളും
ഒരു ബസ് ശൃംഖലയുടെ ഒരു ഉദാഹരണം ഉൾക്കൊള്ളുന്നു. ns-3 ഞങ്ങൾ CSMA എന്ന് വിളിക്കുന്ന ഒരു നെറ്റ് ഉപകരണവും ചാനലും നൽകുന്നു
(കാരിയർ സെൻസ് മൾട്ടിപ്പിൾ ആക്സസ്).

ദി ns-3 CSMA ഉപകരണം ഇഥർനെറ്റിന്റെ സ്പിരിറ്റിൽ ഒരു ലളിതമായ നെറ്റ്‌വർക്ക് മാതൃകയാക്കുന്നു. ഒരു യഥാർത്ഥ ഇഥർനെറ്റ്
CSMA/CD (Carrier Sense Multiple Access with Collision Detection) സ്കീം ഉപയോഗിക്കുന്നു
പങ്കിട്ട ട്രാൻസ്മിഷൻ മീഡിയത്തിന് വേണ്ടി പോരാടുന്നതിന് ബാക്ക്ഓഫ് ഗണ്യമായി വർദ്ധിപ്പിക്കുന്നു. ദി ns-3
CSMA ഉപകരണവും ചാനൽ മോഡലുകളും ഇതിന്റെ ഒരു ഉപവിഭാഗം മാത്രമാണ്.

നിർമ്മിക്കുമ്പോൾ പോയിന്റ്-ടു-പോയിന്റ് ടോപ്പോളജി സഹായ വസ്തുക്കൾ നമ്മൾ കണ്ടതുപോലെ
പോയിന്റ്-ടു-പോയിന്റ് ടോപ്പോളജികൾ, ഈ വിഭാഗത്തിൽ തത്തുല്യമായ CSMA ടോപ്പോളജി സഹായികളെ നമുക്ക് കാണാം.
ഈ സഹായികളുടെ രൂപവും പ്രവർത്തനവും നിങ്ങൾക്ക് പരിചിതമായിരിക്കണം.

ഞങ്ങളുടെ ഉദാഹരണങ്ങൾ/ട്യൂട്ടോറിയൽ} ഡയറക്ടറിയിൽ ഞങ്ങൾ ഒരു ഉദാഹരണ സ്ക്രിപ്റ്റ് നൽകുന്നു. ഈ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു
The ആദ്യം.cc സ്ക്രിപ്റ്റ് ഞങ്ങൾ ഇതിനകം ചെയ്ത പോയിന്റ്-ടു-പോയിന്റ് സിമുലേഷനിലേക്ക് ഒരു CSMA നെറ്റ്‌വർക്ക് ചേർക്കുന്നു
പരിഗണിച്ചു. മുന്നോട്ട് പോയി തുറക്കുക ഉദാഹരണങ്ങൾ/tutorial/second.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ. നിങ്ങൾ
വേണ്ടത്ര കണ്ടിട്ടുണ്ടാകും ns-3 ഇതിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ കോഡ്
ഉദാഹരണം, എന്നാൽ ഞങ്ങൾ മുഴുവൻ സ്ക്രിപ്റ്റിലും പോയി ചില ഔട്ട്പുട്ടുകൾ പരിശോധിക്കും.

ലെ പോലെ തന്നെ ആദ്യം.cc ഉദാഹരണം (എല്ലാ ns-3 ഉദാഹരണങ്ങളിലും) ഫയൽ ആരംഭിക്കുന്നത് ഒരു emacs ഉപയോഗിച്ചാണ്
മോഡ് ലൈനും ചില ജിപിഎൽ ബോയിലർ പ്ലേറ്റും.

യഥാർത്ഥ കോഡ് ആരംഭിക്കുന്നത് മൊഡ്യൂളിൽ ചെയ്തതുപോലെ ഫയലുകൾ ഉൾപ്പെടുത്തി ലോഡ് ചെയ്യുന്നതിലൂടെയാണ് ആദ്യം.cc
ഉദാഹരണം.

#ഉൾപ്പെടുത്തുക "ns3/core-module.h"
#ഉൾപ്പെടുത്തുക "ns3/network-module.h"
#ഉൾപ്പെടുത്തുക "ns3/csma-module.h"
#ഉൾപ്പെടുത്തുക "ns3/internet-module.h"
#ഉൾപ്പെടുത്തുക "ns3/point-to-point-module.h"
#ഉൾപ്പെടുത്തുക "ns3/applications-module.h"
#ഉൾപ്പെടുത്തുക "ns3/ipv4-global-routing-helper.h"

ഒരു കാർട്ടൂൺ കാണിക്കുന്ന ASCII കലയുടെ ഒരു ചെറിയ ഭാഗമാണ് അതിശയകരമാംവിധം ഉപയോഗപ്രദമായ ഒരു കാര്യം.
ഉദാഹരണത്തിൽ നിർമ്മിച്ച നെറ്റ്‌വർക്ക് ടോപ്പോളജി. നിങ്ങൾ സമാനമായ ഒരു "ഡ്രോയിംഗ്" കണ്ടെത്തും
ഞങ്ങളുടെ മിക്ക ഉദാഹരണങ്ങളും.

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ പോയിന്റ്-ടു-പോയിന്റ് ഉദാഹരണം (ലിങ്ക്) നീട്ടാൻ പോകുന്നത് നിങ്ങൾക്ക് കാണാൻ കഴിയും
താഴെയുള്ള n0, n1 എന്നീ നോഡുകൾക്കിടയിൽ) വലതുവശത്ത് നിന്ന് ഒരു ബസ് ശൃംഖല തൂക്കിയിടുക. ശ്രദ്ധിക്കുക
ഇത് സ്ഥിരസ്ഥിതി നെറ്റ്‌വർക്ക് ടോപ്പോളജിയാണ്, കാരണം നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ നോഡുകളുടെ എണ്ണം വ്യത്യാസപ്പെടാം
LAN-ൽ സൃഷ്ടിച്ചു. നിങ്ങൾ nCsma ഒന്നായി സജ്ജീകരിക്കുകയാണെങ്കിൽ, അതിൽ ആകെ രണ്ട് നോഡുകൾ ഉണ്ടാകും
LAN (CSMA ചാനൽ) --- ആവശ്യമായ ഒരു നോഡും ഒരു "അധിക" നോഡും. സ്ഥിരസ്ഥിതിയായി മൂന്ന് ഉണ്ട്
താഴെ കാണുന്നത് പോലെ "അധിക" നോഡുകൾ:

// ഡിഫോൾട്ട് നെറ്റ്‌വർക്ക് ടോപ്പോളജി
//
// 10.1.1.0
// n0 ------------- n1 n2 n3 n4
// പോയിന്റ്-ടു-പോയിന്റ് | | | |
// ================
// ലാൻ 10.1.2.0

അപ്പോൾ ns-3 നെയിംസ്പേസ് ആണ് ഉപയോഗിച്ച ഒപ്പം ഒരു ലോഗിംഗ് ഘടകം നിർവചിച്ചിരിക്കുന്നു. ഇതെല്ലാം അതുപോലെ തന്നെ
അതിൽ ഉണ്ടായിരുന്നു ആദ്യം.cc, അതിനാൽ ഇതുവരെ പുതിയതായി ഒന്നുമില്ല.

നെയിംസ്പേസ് ns3 ഉപയോഗിക്കുന്നു;

NS_LOG_COMPONENT_DEFINE ("സെക്കൻഡ് സ്ക്രിപ്റ്റ് ഉദാഹരണം");

പ്രധാന പരിപാടി അല്പം വ്യത്യസ്തമായ ട്വിസ്റ്റിൽ തുടങ്ങുന്നു. ഞങ്ങൾ ഒരു വെർബോസ് ഫ്ലാഗ് ഉപയോഗിക്കുന്നു
വേണോ വേണ്ടയോ എന്ന് നിർണ്ണയിക്കുക UdpEchoClientApplication ഒപ്പം UdpEchoServerApplication ലോഗിംഗ്
ഘടകങ്ങൾ പ്രവർത്തനക്ഷമമാക്കി. ഈ ഫ്ലാഗ് ശരിയിലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു (ലോഗിംഗ് ഘടകങ്ങൾ പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു)
എന്നാൽ ഈ ഉദാഹരണത്തിന്റെ റിഗ്രഷൻ ടെസ്റ്റിംഗ് സമയത്ത് ലോഗിംഗ് ഓഫ് ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു.

ഉപകരണത്തിലെ ഉപകരണങ്ങളുടെ എണ്ണം മാറ്റാൻ നിങ്ങളെ അനുവദിക്കുന്ന പരിചിതമായ ചില കോഡ് നിങ്ങൾ കാണും
കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് വഴിയുള്ള CSMA നെറ്റ്‌വർക്ക്. ഞങ്ങൾ അനുവദിച്ചപ്പോൾ സമാനമായ എന്തെങ്കിലും ചെയ്തു
കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകളിലെ വിഭാഗത്തിൽ മാറ്റാൻ അയച്ച പാക്കറ്റുകളുടെ എണ്ണം. അവസാനത്തെ
നിങ്ങൾക്ക് കുറഞ്ഞത് ഒരു "അധിക" നോഡെങ്കിലും ഉണ്ടെന്ന് ലൈൻ ഉറപ്പാക്കുന്നു.

കോഡിൽ മുമ്പ് കവർ ചെയ്ത API യുടെ വ്യതിയാനങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അതിനാൽ നിങ്ങൾ പൂർണ്ണമായും ആയിരിക്കണം
ട്യൂട്ടോറിയലിലെ ഈ ഘട്ടത്തിൽ ഇനിപ്പറയുന്ന കോഡ് സൗകര്യപ്രദമാണ്.

bool verbose = true;
uint32_t nCsma = 3;

കമാൻഡ് ലൈൻ cmd;
cmd.AddValue ("nCsma", "\"അധിക\" CSMA നോഡുകൾ/ഉപകരണങ്ങളുടെ എണ്ണം", nCsma);
cmd.AddValue ("വെർബോസ്", "ശരി ആണെങ്കിൽ ലോഗ് ചെയ്യാൻ എക്കോ ആപ്ലിക്കേഷനുകളോട് പറയുക", വെർബോസ്);

cmd.Parse (argc, argv);

എങ്കിൽ (വാക്കുകൾ)
{
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
}

nCsma = nCsma == 0 ? 1 : nCsma;

പോയിന്റ്-ടു-പോയിന്റ് ലിങ്ക് വഴി ഞങ്ങൾ ബന്ധിപ്പിക്കുന്ന രണ്ട് നോഡുകൾ സൃഷ്ടിക്കുക എന്നതാണ് അടുത്ത ഘട്ടം.
ദി നോഡ് കണ്ടെയ്നർ ൽ ചെയ്തതുപോലെ ഇത് ചെയ്യാൻ ഉപയോഗിക്കുന്നു ആദ്യം.cc.

NodeContainer p2pNodes;
p2pNodes.ക്രിയേറ്റ് (2);

അടുത്തതായി, ഞങ്ങൾ മറ്റൊന്ന് പ്രഖ്യാപിക്കുന്നു നോഡ് കണ്ടെയ്നർ ബസിന്റെ ഭാഗമായ നോഡുകൾ പിടിക്കാൻ
(CSMA) നെറ്റ്‌വർക്ക്. ആദ്യം, ഞങ്ങൾ കണ്ടെയ്നർ ഒബ്ജക്റ്റ് തന്നെ തൽക്ഷണം ചെയ്യുന്നു.

നോഡ് കണ്ടെയ്നർ csmaNodes;
csmaNodes.Add (p2pNodes.Get (1));
csmaNodes.ക്രിയേറ്റ് (nCsma);

കോഡിന്റെ അടുത്ത വരി ലഭിക്കുന്നു ആദ്യ നോഡ് (ഒന്നിന്റെ സൂചിക ഉള്ളത് പോലെ).
പോയിന്റ്-ടു-പോയിന്റ് നോഡ് കണ്ടെയ്‌നർ, CSMA ലഭിക്കുന്ന നോഡുകളുടെ കണ്ടെയ്‌നറിലേക്ക് ഇത് ചേർക്കുന്നു
ഉപകരണങ്ങൾ. ചോദ്യം ചെയ്യപ്പെടുന്ന നോഡ് ഒരു പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണത്തിൽ അവസാനിക്കാൻ പോകുന്നു ഒപ്പം ഒരു CSMA
ഉപകരണം. CSMA യുടെ ബാക്കിയുള്ളവ രചിക്കുന്ന നിരവധി "അധിക" നോഡുകൾ ഞങ്ങൾ സൃഷ്ടിക്കുന്നു
നെറ്റ്വർക്ക്. CSMA നെറ്റ്‌വർക്കിൽ ഞങ്ങൾക്ക് ഇതിനകം ഒരു നോഡ് ഉള്ളതിനാൽ -- ഉണ്ടായിരിക്കുന്ന ഒന്ന്
ഒരു പോയിന്റ്-ടു-പോയിന്റ്, CSMA നെറ്റ് ഡിവൈസ് എന്നിവയിൽ, "അധിക" നോഡുകളുടെ എണ്ണം അർത്ഥമാക്കുന്നത് നമ്പർ എന്നാണ്
CSMA വിഭാഗത്തിൽ നിങ്ങൾ ആഗ്രഹിക്കുന്ന നോഡുകൾ മൈനസ് ഒന്ന്.

കോഡിന്റെ അടുത്ത ബിറ്റ് ഇപ്പോൾ പരിചിതമായിരിക്കണം. ഞങ്ങൾ തൽക്ഷണം എ PointToPointHelper
ബന്ധപ്പെട്ട ഡിഫോൾട്ട് സജ്ജമാക്കുക ഗുണവിശേഷങ്ങൾ അങ്ങനെ നമ്മൾ സെക്കൻഡിൽ അഞ്ച് മെഗാബിറ്റ് സൃഷ്ടിക്കുന്നു
സഹായി ഉപയോഗിച്ച് സൃഷ്‌ടിച്ച ഉപകരണങ്ങളിലെ ട്രാൻസ്മിറ്ററും ചാനലുകളിൽ രണ്ട് മില്ലിസെക്കൻഡ് കാലതാമസവും
സഹായി സൃഷ്ടിച്ചത്.

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

NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);

അപ്പോൾ ഞങ്ങൾ a NetDeviceContainer പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണങ്ങളുടെ ട്രാക്ക് സൂക്ഷിക്കാൻ
പിന്നെ നമ്മളും ഇൻസ്റ്റോൾ പോയിന്റ്-ടു-പോയിന്റ് നോഡുകളിലെ ഉപകരണങ്ങൾ.

CSMA ഉപകരണങ്ങൾക്കും ചാനലുകൾക്കുമായി നിങ്ങൾ ഒരു സഹായിയെ കാണാൻ പോകുകയാണെന്ന് ഞങ്ങൾ മുകളിൽ സൂചിപ്പിച്ചു
അടുത്ത വരികൾ അവരെ പരിചയപ്പെടുത്തുന്നു. ദി CsmaHelper ഒരു പോലെ പ്രവർത്തിക്കുന്നു PointToPointHelper, പക്ഷേ
ഇത് CSMA ഉപകരണങ്ങളും ചാനലുകളും സൃഷ്ടിക്കുകയും ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു. ഒരു CSMA ഉപകരണത്തിന്റെ കാര്യത്തിൽ ഒപ്പം
ചാനൽ ജോടി, ഡാറ്റ നിരക്ക് a വഴി വ്യക്തമാക്കിയിരിക്കുന്നത് ശ്രദ്ധിക്കുക ചാനൽ ഗുണങ്ങളെ പകരം a
ഉപകരണം ഗുണങ്ങളെ. കാരണം, ഒരു യഥാർത്ഥ CSMA നെറ്റ്‌വർക്ക് ഒരാളെ മിക്സ് ചെയ്യാൻ അനുവദിക്കുന്നില്ല
ഉദാഹരണത്തിന്, തന്നിരിക്കുന്ന ചാനലിലെ 10Base-T, 100Base-T ഉപകരണങ്ങൾ. ഞങ്ങൾ ആദ്യം ഡാറ്റ നിരക്ക് സജ്ജമാക്കി
സെക്കൻഡിൽ 100 ​​മെഗാബൈറ്റ്, തുടർന്ന് ചാനലിന്റെ പ്രകാശത്തിന്റെ വേഗത 6560 ആയി സജ്ജീകരിക്കുക
നാനോ-സെക്കൻഡ് (1 മീറ്റർ സെഗ്‌മെന്റിൽ ഒരടിക്ക് 100 നാനോ സെക്കൻഡ് എന്ന നിലയിൽ ഏകപക്ഷീയമായി തിരഞ്ഞെടുത്തു).
നിങ്ങൾക്ക് ഒരു സെറ്റ് ചെയ്യാൻ കഴിയുമെന്ന് ശ്രദ്ധിക്കുക ഗുണങ്ങളെ അതിന്റെ നേറ്റീവ് ഡാറ്റ തരം ഉപയോഗിച്ച്.

CsmaHelper csma;
csma.SetChannelAttribute ("DataRate", StringValue ("100Mbps"));
csma.SetChannelAttribute ("Delay", TimeValue (NanoSeconds (6560)));

NetDeviceContainer csmaDevices;
csmaDevices = csma.Install (csmaNodes);

ഞങ്ങൾ സൃഷ്ടിച്ചതുപോലെ തന്നെ NetDeviceContainer സൃഷ്ടിച്ച ഉപകരണങ്ങൾ ഹോൾഡ് ചെയ്യാൻ
PointToPointHelper ഞങ്ങൾ ഒരു സൃഷ്ടിക്കുന്നു NetDeviceContainer ഞങ്ങൾ സൃഷ്ടിച്ച ഉപകരണങ്ങൾ കൈവശം വയ്ക്കാൻ
CsmaHelper. ഞങ്ങൾ വിളിക്കുന്നു ഇൻസ്റ്റോൾ രീതി CsmaHelper ഉപകരണങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ
നോഡുകൾ csmaNodes നോഡ് കണ്ടെയ്നർ.

ഞങ്ങൾക്ക് ഇപ്പോൾ ഞങ്ങളുടെ നോഡുകളും ഉപകരണങ്ങളും ചാനലുകളും സൃഷ്‌ടിച്ചിട്ടുണ്ട്, പക്ഷേ ഞങ്ങൾക്ക് പ്രോട്ടോക്കോൾ സ്റ്റാക്കുകളൊന്നുമില്ല
വർത്തമാന. ലെ പോലെ തന്നെ ആദ്യം.cc സ്ക്രിപ്റ്റ്, ഞങ്ങൾ ഉപയോഗിക്കും InternetStackHelper ഇൻസ്റ്റാൾ ചെയ്യാൻ
ഈ സ്റ്റാക്കുകൾ.

InternetStackHelper സ്റ്റാക്ക്;
stack.Install (p2pNodes.Get (0));
stack.Install (csmaNodes);

എന്നതിൽ നിന്ന് ഞങ്ങൾ നോഡുകളിലൊന്ന് എടുത്തതായി ഓർക്കുക p2p നോഡുകൾ കണ്ടെയ്നർ അത് ചേർത്തു
csmaNodes കണ്ടെയ്നർ. അതിനാൽ, ബാക്കിയുള്ളവയിൽ മാത്രമേ നമുക്ക് സ്റ്റാക്കുകൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുള്ളൂ p2p നോഡുകൾ
നോഡ്, കൂടാതെ ഇതിലെ എല്ലാ നോഡുകളും csmaNodes ലെ എല്ലാ നോഡുകളും മറയ്ക്കാൻ കണ്ടെയ്നർ
സിമുലേഷൻ.

ലെ പോലെ തന്നെ ആദ്യം.cc ഉദാഹരണ സ്ക്രിപ്റ്റ്, ഞങ്ങൾ ഉപയോഗിക്കാൻ പോകുന്നു Ipv4 വിലാസം സഹായി ലേക്ക്
ഞങ്ങളുടെ ഉപകരണ ഇന്റർഫേസുകളിലേക്ക് IP വിലാസങ്ങൾ നൽകുക. ആദ്യം നമ്മൾ നെറ്റ്‌വർക്ക് 10.1.1.0 സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു
ഞങ്ങളുടെ രണ്ട് പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണങ്ങൾക്ക് ആവശ്യമായ രണ്ട് വിലാസങ്ങൾ.

Ipv4Addressസഹായ വിലാസം;
വിലാസം.സെറ്റ്ബേസ് ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = വിലാസം.അസൈൻ (p2pDevices);

പുറത്തെടുക്കുന്നത് എളുപ്പമാക്കുന്നതിന് ഞങ്ങൾ സൃഷ്ടിച്ച ഇന്റർഫേസുകൾ ഒരു കണ്ടെയ്‌നറിൽ സംരക്ഷിക്കുന്നത് ഓർക്കുക
ആപ്ലിക്കേഷനുകൾ സജ്ജീകരിക്കുന്നതിനുള്ള ഉപയോഗത്തിനായി വിവരങ്ങൾ പിന്നീട് അഭിസംബോധന ചെയ്യുന്നു.

ഞങ്ങളുടെ CSMA ഉപകരണ ഇന്റർഫേസുകളിലേക്ക് ഇപ്പോൾ IP വിലാസങ്ങൾ നൽകേണ്ടതുണ്ട്. ഓപ്പറേഷൻ പ്രവർത്തിക്കുന്നു
പോയിന്റ്-ടു-പോയിന്റ് കേസിൽ ചെയ്തതുപോലെ, ഞങ്ങൾ ഇപ്പോൾ ഓപ്പറേഷൻ നടത്തുന്നു എന്നതൊഴിച്ചാൽ
CSMA ഉപകരണങ്ങളുടെ വേരിയബിൾ സംഖ്യയുള്ള ഒരു കണ്ടെയ്‌നർ --- ഞങ്ങൾ നിർമ്മിച്ചത് ഓർക്കുക
കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് വഴി മാറ്റാവുന്ന CSMA ഉപകരണങ്ങൾ. CSMA ഉപകരണങ്ങൾ ബന്ധപ്പെടുത്തും
ഈ സാഹചര്യത്തിൽ നെറ്റ്‌വർക്ക് നമ്പർ 10.1.2.0-ൽ നിന്നുള്ള IP വിലാസങ്ങൾക്കൊപ്പം, താഴെ കാണുന്നത് പോലെ.

വിലാസം.സെറ്റ്ബേസ് ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = വിലാസം.അസൈൻ (csmaDevices);

ഇപ്പോൾ നമുക്ക് ഒരു ടോപ്പോളജി നിർമ്മിച്ചിട്ടുണ്ട്, പക്ഷേ ഞങ്ങൾക്ക് ആപ്ലിക്കേഷനുകൾ ആവശ്യമാണ്. ഈ വിഭാഗം ആയിരിക്കും
എന്ന ആപ്ലിക്കേഷനുകളുടെ വിഭാഗത്തിന് അടിസ്ഥാനപരമായി സമാനമാണ് ആദ്യം.cc എന്നാൽ ഞങ്ങൾ പോകുന്നു
ഒരു CSMA ഉപകരണവും ക്ലയന്റും ഉള്ള നോഡുകളിലൊന്നിൽ സെർവറിനെ തൽക്ഷണം ചെയ്യുക
ഒരു പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണം മാത്രമുള്ള നോഡിന്.

ആദ്യം, ഞങ്ങൾ എക്കോ സെർവർ സജ്ജീകരിച്ചു. ഞങ്ങൾ എ സൃഷ്ടിക്കുന്നു UdpEchoServerHelper ആവശ്യമുള്ളത് നൽകുകയും ചെയ്യുക
ഗുണങ്ങളെ സെർവർ പോർട്ട് നമ്പറായ കൺസ്ട്രക്‌ടറിലേക്കുള്ള മൂല്യം. ഈ തുറമുഖം ഓർക്കുക
ഉപയോഗിച്ച് പിന്നീട് മാറ്റാവുന്നതാണ് സെറ്റ് ആട്രിബ്യൂട്ട് വേണമെങ്കിൽ രീതി, പക്ഷേ ഞങ്ങൾ അത് ആവശ്യപ്പെടുന്നു
കൺസ്ട്രക്റ്റർക്ക് നൽകി.

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (csmaNodes.Get (nCsma));
serverApps.Start (സെക്കൻഡ് (1.0));
serverApps.Stop (സെക്കൻഡ് (10.0));

അത് ഓർക്കുക csmaNodes നോഡ് കണ്ടെയ്നർ ഇതിനായി സൃഷ്ടിച്ച നോഡുകളിലൊന്ന് അടങ്ങിയിരിക്കുന്നു
പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ്‌വർക്ക് കൂടാതെ nCsma "അധിക" നോഡുകൾ. നമുക്ക് ലഭിക്കാൻ ആഗ്രഹിക്കുന്നത് അവസാനത്തേതാണ്
"അധിക" നോഡുകൾ. യുടെ പൂജ്യം പ്രവേശനം csmaNodes കണ്ടെയ്നർ പോയിന്റ്-ടു-പോയിന്റ് ആയിരിക്കും
നോഡ്. ഇതിനെക്കുറിച്ച് ചിന്തിക്കാനുള്ള എളുപ്പവഴി, നമ്മൾ ഒരു "അധിക" CSMA നോഡ് സൃഷ്ടിക്കുകയാണെങ്കിൽ, അത്
എന്ന സൂചികയിലായിരിക്കും csmaNodes കണ്ടെയ്നർ. ഇൻഡക്ഷൻ വഴി, നമ്മൾ സൃഷ്ടിക്കുകയാണെങ്കിൽ nCsma "അധിക"
നോഡുകൾ അവസാനത്തേത് സൂചികയിലായിരിക്കും nCsma. ൽ ഇത് പ്രദർശിപ്പിച്ചിരിക്കുന്നത് നിങ്ങൾ കാണുന്നു നേടുക ആദ്യത്തെ
കോഡിന്റെ വരി.

ഞങ്ങൾ ചെയ്തതുപോലെ ക്ലയന്റ് ആപ്ലിക്കേഷൻ സജ്ജീകരിച്ചിരിക്കുന്നു ആദ്യം.cc ഉദാഹരണ സ്ക്രിപ്റ്റ്. വീണ്ടും,
ഞങ്ങൾ ആവശ്യമുള്ളത് നൽകുന്നു ഗുണവിശേഷങ്ങൾ ലേക്ക് UdpEchoClientHelper കൺസ്ട്രക്റ്ററിൽ (ഈ സാഹചര്യത്തിൽ
വിദൂര വിലാസവും പോർട്ടും). സെർവറിലേക്ക് പാക്കറ്റുകൾ അയയ്ക്കാൻ ഞങ്ങൾ ക്ലയന്റിനോട് പറയുന്നു
"അധിക" CSMA നോഡുകളുടെ അവസാനത്തിൽ ഇൻസ്റ്റാൾ ചെയ്തു. ഞങ്ങൾ ക്ലയന്റ് ഇടതുവശത്ത് ഇൻസ്റ്റാൾ ചെയ്യുന്നു
ടോപ്പോളജി ചിത്രീകരണത്തിൽ കാണുന്ന പോയിന്റ്-ടു-പോയിന്റ് നോഡ്.

UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("ഇന്റർവെൽ", ടൈംവാല്യൂ (സെക്കൻഡ് (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps = echoClient.Install (p2pNodes.Get (0));
clientApps.Start (സെക്കൻഡ് (2.0));
clientApps.Stop (സെക്കൻഡ് (10.0));

ഞങ്ങൾ യഥാർത്ഥത്തിൽ ഇവിടെ ഒരു ഇന്റർനെറ്റ് വർക്ക് നിർമ്മിച്ചതിനാൽ, ഞങ്ങൾക്ക് ചില തരത്തിലുള്ള ഇന്റർനെറ്റ് വർക്ക് ആവശ്യമാണ്
റൂട്ടിംഗ്. ns-3 നിങ്ങളെ സഹായിക്കാൻ ഞങ്ങൾ ആഗോള റൂട്ടിംഗ് എന്ന് വിളിക്കുന്നത് നൽകുന്നു. ആഗോള റൂട്ടിംഗ് എടുക്കുന്നു
മുഴുവൻ ഇന്റർനെറ്റ് വർക്കുകളും സിമുലേഷനിലും ആക്‌സസ് ചെയ്യാമെന്നതിന്റെ പ്രയോജനം
സിമുലേഷനായി സൃഷ്ടിച്ച എല്ലാ നോഡുകളിലൂടെയും പ്രവർത്തിക്കുന്നു --- ഇത് കഠിനാധ്വാനം ചെയ്യുന്നു
റൂട്ടറുകൾ കോൺഫിഗർ ചെയ്യാതെ തന്നെ നിങ്ങൾക്കായി റൂട്ടിംഗ് സജ്ജീകരിക്കുന്നു.

അടിസ്ഥാനപരമായി, സംഭവിക്കുന്നത് ഓരോ നോഡും ഒരു OSPF റൂട്ടർ പോലെ പ്രവർത്തിക്കുന്നു എന്നതാണ്
തിരശ്ശീലയ്ക്ക് പിന്നിലുള്ള മറ്റെല്ലാ റൂട്ടറുകളുമായും തൽക്ഷണമായും മാന്ത്രികമായും ആശയവിനിമയം നടത്തുന്നു. ഓരോ നോഡും
ലിങ്ക് പരസ്യങ്ങൾ സൃഷ്ടിക്കുകയും ഒരു ആഗോള റൂട്ട് മാനേജറുമായി നേരിട്ട് ആശയവിനിമയം നടത്തുകയും ചെയ്യുന്നു
ഓരോ നോഡിനും റൂട്ടിംഗ് ടേബിളുകൾ നിർമ്മിക്കാൻ ഈ ആഗോള വിവരങ്ങൾ ഉപയോഗിക്കുന്നു. ക്രമീകരണം
ഈ രീതിയിലുള്ള റൂട്ടിംഗ് ഒരു ഒറ്റ ലൈനറാണ്:

Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

അടുത്തതായി നമ്മൾ pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നു. pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നതിനുള്ള കോഡിന്റെ ആദ്യ വരി
പോയിന്റ്-ടു-പോയിന്റ് സഹായി ഇപ്പോൾ നിങ്ങൾക്ക് പരിചിതനായിരിക്കണം. രണ്ടാമത്തെ വരി pcap പ്രവർത്തനക്ഷമമാക്കുന്നു
CSMA സഹായിയിൽ കണ്ടെത്തുന്നു, നിങ്ങൾ ഇതുവരെ കണ്ടിട്ടില്ലാത്ത ഒരു അധിക പാരാമീറ്ററുണ്ട്.

pointToPoint.EnablePcapAll ("രണ്ടാം");
csma.EnablePcap ("രണ്ടാം", csmaDevices.Get (1), true);

CSMA നെറ്റ്‌വർക്ക് ഒരു മൾട്ടി-പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ്‌വർക്കാണ്. ഇതിനർത്ഥം ഉണ്ട് (അതിലും ഉണ്ട്
ഈ കേസ്) പങ്കിട്ട മാധ്യമത്തിൽ ഒന്നിലധികം എൻഡ് പോയിന്റുകൾ. ഈ അവസാന പോയിന്റുകളിൽ ഓരോന്നിനും ഒരു വലയുണ്ട്
അതുമായി ബന്ധപ്പെട്ട ഉപകരണം. ട്രേസ് ശേഖരിക്കുന്നതിന് രണ്ട് അടിസ്ഥാന ബദലുകൾ ഉണ്ട്
അത്തരം ഒരു നെറ്റ്‌വർക്കിൽ നിന്നുള്ള വിവരങ്ങൾ. ഓരോ നെറ്റ് ഡിവൈസിനും ഒരു ട്രെയ്സ് ഫയൽ സൃഷ്ടിക്കുക എന്നതാണ് ഒരു വഴി
കൂടാതെ ആ നെറ്റ് ഉപകരണം പുറത്തുവിടുന്നതോ ഉപഭോഗം ചെയ്യുന്നതോ ആയ പാക്കറ്റുകൾ മാത്രം സംഭരിക്കുക. മറ്റൊരു വഴി
ഉപകരണങ്ങളിൽ ഒന്ന് തിരഞ്ഞെടുത്ത് അത് പ്രോമിസ്ക്യൂസ് മോഡിൽ സ്ഥാപിക്കുക എന്നതാണ്. അപ്പോൾ ആ ഒരൊറ്റ ഉപകരണം
എല്ലാ പാക്കറ്റുകൾക്കുമായി നെറ്റ്‌വർക്ക് "സ്നിഫ്" ചെയ്യുകയും അവയെ ഒരൊറ്റ pcap ഫയലിൽ സംഭരിക്കുകയും ചെയ്യുന്നു. ഇങ്ങനെയാണ്
tcpdump, ഉദാഹരണത്തിന്, പ്രവർത്തിക്കുന്നു. ആ അന്തിമ പാരാമീറ്റർ CSMA സഹായിയോട് വേണോ വേണ്ടയോ എന്ന് പറയുന്നു
പ്രോമിസ്‌ക്യൂസ് മോഡിൽ പാക്കറ്റുകൾ ക്യാപ്‌ചർ ചെയ്യാൻ ക്രമീകരിക്കുക.

ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ CSMA നെറ്റ്‌വർക്കിലെ ഉപകരണങ്ങളിൽ ഒന്ന് തിരഞ്ഞെടുത്ത് അത് ചോദിക്കാൻ പോകുന്നു
ശൃംഖലയുടെ ഒരു അശ്ലീല സ്നിഫ് നടത്താൻ, അതുവഴി എന്ത് അനുകരിക്കുന്നു tcpdump ചെയ്യും.
നിങ്ങൾ ഒരു ലിനക്സ് മെഷീനിൽ ആയിരുന്നെങ്കിൽ നിങ്ങൾക്ക് ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാം tcpdump -i eth0 ലഭിക്കാൻ
ട്രെയ്സ്. ഈ സാഹചര്യത്തിൽ, ഉപയോഗിക്കുന്ന ഉപകരണം ഞങ്ങൾ വ്യക്തമാക്കുന്നു csmaDevices.Get(1), ഏത് തിരഞ്ഞെടുക്കുന്നു
കണ്ടെയ്നറിലെ ആദ്യ ഉപകരണം. അന്തിമ പാരാമീറ്റർ ശരി എന്നതിലേക്ക് സജ്ജീകരിക്കുന്നത് അശ്ലീലത്തെ പ്രാപ്തമാക്കുന്നു
പിടിച്ചെടുക്കുന്നു.

കോഡിന്റെ അവസാന ഭാഗം ഇതുപോലെ തന്നെ സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുകയും വൃത്തിയാക്കുകയും ചെയ്യുന്നു ആദ്യം.cc
ഉദാഹരണം.

സിമുലേറ്റർ:: റൺ ();
സിമുലേറ്റർ:: നശിപ്പിക്കുക ();
തിരികെ വരുക;
}

ഈ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന്, പകർത്തുക second.cc സ്ക്രാച്ച് ഡയറക്ടറിയിലേക്ക് ഉദാഹരണ സ്ക്രിപ്റ്റ്
നിങ്ങൾ നിർമ്മിച്ചത് പോലെ നിർമ്മിക്കാൻ waf ഉപയോഗിക്കുക ആദ്യം.cc ഉദാഹരണം. നിങ്ങൾ ഉള്ളിലാണെങ്കിൽ
നിങ്ങൾ ഇപ്പോൾ ടൈപ്പ് ചെയ്യുന്ന ശേഖരണത്തിന്റെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറി,

$ cp ഉദാഹരണങ്ങൾ/tutorial/second.cc സ്ക്രാച്ച്/mysecond.cc
$ ./waf

മുന്നറിയിപ്പ്: ഞങ്ങൾ ഫയൽ ഉപയോഗിക്കുന്നു second.cc ഇത് പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാനുള്ള ഞങ്ങളുടെ റിഗ്രഷൻ ടെസ്റ്റുകളിലൊന്നായി
നിങ്ങളുടെ ട്യൂട്ടോറിയൽ അനുഭവം പോസിറ്റീവ് ആക്കുന്നതിന് ഞങ്ങൾ കരുതുന്നത് പോലെ തന്നെ.
ഇതിനർത്ഥം ഒരു എക്സിക്യൂട്ടബിൾ എന്ന പേര് എന്നാണ് സെക്കന്റ് പദ്ധതിയിൽ ഇതിനകം നിലവിലുണ്ട്. ഏതെങ്കിലും ഒഴിവാക്കാൻ
നിങ്ങൾ എന്തുചെയ്യുന്നു എന്നതിനെക്കുറിച്ചുള്ള ആശയക്കുഴപ്പം, ദയവായി പുനർനാമകരണം ചെയ്യുക mysecond.cc നിർദ്ദേശിച്ചു
മുകളിൽ.

നിങ്ങൾ മതപരമായി ട്യൂട്ടോറിയൽ പിന്തുടരുകയാണെങ്കിൽ (നിങ്ങൾ, നിങ്ങളല്ലേ) നിങ്ങൾക്ക് ഇപ്പോഴും ഉണ്ടായിരിക്കും
NS_LOG വേരിയബിൾ സെറ്റ്, അതിനാൽ മുന്നോട്ട് പോയി ആ ​​വേരിയബിൾ മായ്‌ച്ച് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക.

$ കയറ്റുമതി NS_LOG=
$ ./waf --റൺ സ്ക്രാച്ച്/മൈസെക്കൻഡ്

ഞങ്ങൾ ലോഗിൻ ചെയ്‌തതുപോലെ തന്നെ യുഡിപി എക്കോ ആപ്ലിക്കേഷനുകൾ സജ്ജീകരിച്ചതിനാൽ ആദ്യം.cc, നിങ്ങൾ ഇത് ചെയ്യും
നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ സമാനമായ ഔട്ട്പുട്ട് കാണുക.

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.415സെ)
1024 ലേക്ക് 10.1.2.4 ബൈറ്റുകൾ അയച്ചു
1024 ൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു
1024 ൽ നിന്ന് 10.1.2.4 ബൈറ്റുകൾ ലഭിച്ചു

ആദ്യത്തെ സന്ദേശം ഓർക്കുക, "അയച്ചു 1024 ബൈറ്റുകൾ ലേക്ക് 10.1.2.4," ആണ് UDP എക്കോ ക്ലയന്റ്
സെർവറിലേക്ക് ഒരു പാക്കറ്റ് അയയ്ക്കുന്നു. ഈ സാഹചര്യത്തിൽ, സെർവർ മറ്റൊരു നെറ്റ്‌വർക്കിലാണ്
(10.1.2.0). രണ്ടാമത്തെ സന്ദേശം, "ലഭിച്ചു 1024 ബൈറ്റുകൾ നിന്ന് 10.1.1.1," യുഡിപി പ്രതിധ്വനിയിൽ നിന്നുള്ളതാണ്
സെർവർ, എക്കോ പാക്കറ്റ് ലഭിക്കുമ്പോൾ ജനറേറ്റ് ചെയ്യുന്നു. അവസാന സന്ദേശം, "ലഭിച്ചു 1024
ബൈറ്റുകൾ നിന്ന് 10.1.2.4," എക്കോ ക്ലയന്റിൽ നിന്നുള്ളതാണ്, അതിന്റെ പ്രതിധ്വനി ലഭിച്ചതായി സൂചിപ്പിക്കുന്നു
സെർവറിൽ നിന്ന് തിരികെ.

നിങ്ങൾ ഇപ്പോൾ പോയി ടോപ്പ് ലെവൽ ഡയറക്‌ടറിയിൽ നോക്കിയാൽ, നിങ്ങൾക്ക് മൂന്ന് ട്രേസ് ഫയലുകൾ കാണാം:

second-0-0.pcap second-1-0.pcap second-2-0.pcap

ഈ ഫയലുകളുടെ പേരുകൾ നോക്കാൻ നമുക്ക് ഒരു നിമിഷം നോക്കാം. അവയ്‌ക്കെല്ലാം ഒരേ രൂപമുണ്ട്,
- - .pcap. ഉദാഹരണത്തിന്, ലിസ്റ്റിംഗിലെ ആദ്യ ഫയൽ
രണ്ടാം-0-0.pcap നോഡ് സീറോയിൽ നിന്നുള്ള pcap ട്രെയ്സ് ആണ്, ഡിവൈസ് സീറോ. ഇതാണ്
നോഡ് പൂജ്യത്തിൽ പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണം. ഫയല് രണ്ടാം-1-0.pcap എന്നതിനായുള്ള pcap ട്രെയ്സ് ആണ്
നോഡ് ഒന്നിൽ ഉപകരണം പൂജ്യം, ഒരു പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണവും; ഫയലും രണ്ടാം-2-0.pcap is
നോഡ് രണ്ടിലെ ഉപകരണ പൂജ്യത്തിനായുള്ള pcap ട്രെയ്സ്.

വിഭാഗത്തിന്റെ തുടക്കത്തിലെ ടോപ്പോളജി ചിത്രീകരണത്തിലേക്ക് നിങ്ങൾ വീണ്ടും പരാമർശിക്കുകയാണെങ്കിൽ, നിങ്ങൾ കാണും
ആ നോഡ് പൂജ്യം പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന്റെ ഇടതുവശത്തുള്ള നോഡാണ്, നോഡ് ഒന്ന് നോഡാണ്
അതിന് ഒരു പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണവും CSMA ഉപകരണവും ഉണ്ട്. നോഡ് രണ്ട് ആണെന്ന് നിങ്ങൾ കാണും
CSMA നെറ്റ്‌വർക്കിലെ ആദ്യത്തെ "അധിക" നോഡും അതിന്റെ ഉപകരണ പൂജ്യവും ഉപകരണമായി തിരഞ്ഞെടുത്തു
പ്രോമിസ്ക്യൂസ്-മോഡ് ട്രെയ്സ് പിടിച്ചെടുക്കാൻ.

ഇപ്പോൾ, നമുക്ക് ഇന്റർനെറ്റ് വർക്കിലൂടെ എക്കോ പാക്കറ്റ് പിന്തുടരാം. ആദ്യം, ഒരു tcpdump ചെയ്യുക
ഇടതുവശത്തുള്ള പോയിന്റ്-ടു-പോയിന്റ് നോഡിനുള്ള ഫയൽ കണ്ടെത്തുക --- നോഡ് പൂജ്യം.

$ tcpdump -nn -tt -r second-0-0.pcap

പ്രദർശിപ്പിച്ചിരിക്കുന്ന pcap ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ നിങ്ങൾ കാണും:

ഫയൽ second-0-0.pcap, ലിങ്ക്-ടൈപ്പ് PPP (PPP) ൽ നിന്ന് വായിക്കുന്നു
2.000000 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.017607 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

ലിങ്ക് തരം PPP (പോയിന്റ്-ടു-പോയിന്റ്) ആണെന്ന് ഡമ്പിന്റെ ആദ്യ വരി സൂചിപ്പിക്കുന്നു
പ്രതീക്ഷിക്കുക. ഐപിയുമായി ബന്ധപ്പെട്ട ഉപകരണം വഴി നോഡ് പൂജ്യം വിടുന്ന എക്കോ പാക്കറ്റ് നിങ്ങൾ കാണും
വിലാസം 10.1.1.1 IP വിലാസം 10.1.2.4 (വലതുവശത്തുള്ള CSMA നോഡ്) ലേക്ക് നയിക്കുന്നു. ഈ പാക്കറ്റ്
പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന് മുകളിലൂടെ നീങ്ങുകയും പോയിന്റ്-ടു-പോയിന്റ് നെറ്റ് ഉപകരണത്തിൽ അത് സ്വീകരിക്കുകയും ചെയ്യും
നോഡ് ഒന്ന്. നമുക്കൊന്ന് നോക്കാം:

$ tcpdump -nn -tt -r second-1-0.pcap

പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന്റെ മറുവശത്തുള്ള pcap ട്രെയ്സ് ഔട്ട്പുട്ട് നിങ്ങൾ ഇപ്പോൾ കാണും:

ഫയൽ second-1-0.pcap, ലിങ്ക്-ടൈപ്പ് PPP (PPP) ൽ നിന്ന് വായിക്കുന്നു
2.003686 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

നമ്മൾ പ്രതീക്ഷിക്കുന്നത് പോലെ ലിങ്ക് തരവും PPP ആണെന്ന് ഇവിടെ കാണാം. ഐപിയിൽ നിന്നുള്ള പാക്കറ്റ് നിങ്ങൾ കാണുന്നു
വിലാസം 10.1.1.1 (അത് 2.000000 സെക്കൻഡിൽ അയച്ചത്) IP വിലാസം 10.1.2.4 ലേക്ക് പോകുന്നു
ഈ ഇന്റർഫേസിൽ ദൃശ്യമാകും. ഇപ്പോൾ, ആന്തരികമായി ഈ നോഡിലേക്ക്, പാക്കറ്റ് ഫോർവേഡ് ചെയ്യും
CSMA ഇന്റർഫേസ്, അതിന്റെ ആത്യന്തികതയിലേക്ക് പോകുന്ന ആ ഉപകരണത്തിൽ അത് പോപ്പ് ഔട്ട് ചെയ്യുന്നത് നമ്മൾ കാണണം
ലക്ഷ്യസ്ഥാനം.

CSMA നെറ്റ്‌വർക്കിനായുള്ള പ്രോമിസ്‌ക്യൂസ് സ്‌നിഫർ നോഡായി ഞങ്ങൾ നോഡ് 2 തിരഞ്ഞെടുത്തുവെന്നത് ഓർക്കുക
നമുക്ക് second-2-0.pcap നോക്കാം, അത് ഉണ്ടോ എന്ന് നോക്കാം.

$ tcpdump -nn -tt -r second-2-0.pcap

നിങ്ങൾ ഇപ്പോൾ നോഡ് രണ്ടിന്റെ പ്രോമിസ്ക്യൂസ് ഡംപ് കാണും, ഉപകരണം പൂജ്യം:

ഫയൽ second-2-0.pcap, ലിങ്ക്-ടൈപ്പ് EN10MB (ഇഥർനെറ്റ്) ൽ നിന്നുള്ള വായന
2.007698 ARP, 10.1.2.4 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.1-നോട് പറയുക, ദൈർഘ്യം 50
2.007710 ARP, മറുപടി 10.1.2.4 is- at 00:00:00:00:00:06, ദൈർഘ്യം 50
2.007803 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.013815 ARP, 10.1.2.1 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.4-നോട് പറയുക, ദൈർഘ്യം 50
2.013828 ARP, മറുപടി 10.1.2.1 is- at 00:00:00:00:00:03, ദൈർഘ്യം 50
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ലിങ്ക് തരം ഇപ്പോൾ "ഇഥർനെറ്റ്" ആണ്. എന്നിരുന്നാലും, പുതിയ എന്തെങ്കിലും പ്രത്യക്ഷപ്പെട്ടു. ദി
ബസ് ശൃംഖല ആവശ്യമാണ് arp, അഡ്രസ് റെസല്യൂഷൻ പ്രോട്ടോക്കോൾ. അയയ്‌ക്കേണ്ടതുണ്ടെന്ന് ഒരാൾക്ക് അറിയാവുന്ന നോഡ്
IP വിലാസം 10.1.2.4-ലേക്കുള്ള പാക്കറ്റ്, എന്നാൽ അതിന് MAC വിലാസം അറിയില്ല.
അനുബന്ധ നോഡ്. ഇത് ആവശ്യപ്പെട്ട് CSMA നെറ്റ്‌വർക്കിൽ (ff:ff:ff:ff:ff:ff) പ്രക്ഷേപണം ചെയ്യുന്നു
IP വിലാസം 10.1.2.4 ഉള്ള ഉപകരണം. ഈ സാഹചര്യത്തിൽ, വലതുവശത്തുള്ള നോഡ് അത് പറഞ്ഞുകൊണ്ട് മറുപടി നൽകുന്നു
MAC വിലാസത്തിലാണ് 00:00:00:00:00:06. നോഡ് രണ്ട് ഇതിൽ നേരിട്ട് ഉൾപ്പെട്ടിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക
എക്സ്ചേഞ്ച്, പക്ഷേ നെറ്റ്‌വർക്ക് സ്നിഫ് ചെയ്യുകയും അത് കാണുന്ന എല്ലാ ട്രാഫിക്കും റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു.

ഈ കൈമാറ്റം ഇനിപ്പറയുന്ന വരികളിൽ കാണാം,

2.007698 ARP, 10.1.2.4 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.1-നോട് പറയുക, ദൈർഘ്യം 50
2.007710 ARP, മറുപടി 10.1.2.4 is- at 00:00:00:00:00:06, ദൈർഘ്യം 50

തുടർന്ന് നോഡ് ഒന്ന്, ഉപകരണം ഒന്ന് മുന്നോട്ട് പോയി എക്കോ പാക്കറ്റ് UDP എക്കോ സെർവറിലേക്ക് അയയ്ക്കുന്നു
IP വിലാസം 10.1.2.4.

2.007803 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024

സെർവർ പ്രതിധ്വനി അഭ്യർത്ഥന സ്വീകരിക്കുകയും പാക്കറ്റ് തിരികെ അയയ്ക്കാൻ ശ്രമിക്കുകയും ചെയ്യുന്നു
ഉറവിടം. ഈ വിലാസം അത് വഴി എത്തുന്ന മറ്റൊരു നെറ്റ്‌വർക്കിലാണെന്ന് സെർവറിന് അറിയാം
IP വിലാസം 10.1.2.1. ഞങ്ങൾ ആഗോള റൂട്ടിംഗ് ആരംഭിച്ചതിനാലാണിത്
ഇതിൽ നിന്ന് ഞങ്ങൾക്കായി. പക്ഷേ, എക്കോ സെർവർ നോഡിന് ആദ്യത്തേതിന്റെ MAC വിലാസം അറിയില്ല
CSMA നോഡ്, അതിനാൽ ആദ്യത്തെ CSMA നോഡ് ചെയ്യേണ്ടത് പോലെ ഇതിന് ARP ചെയ്യണം.

2.013815 ARP, 10.1.2.1 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.4-നോട് പറയുക, ദൈർഘ്യം 50
2.013828 ARP, മറുപടി 10.1.2.1 is- at 00:00:00:00:00:03, ദൈർഘ്യം 50

സെർവർ പിന്നീട് ഫോർവേഡിംഗ് നോഡിലേക്ക് എക്കോ തിരികെ അയയ്ക്കുന്നു.

2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന്റെ വലതുവശത്തുള്ള നോഡിലേക്ക് തിരിഞ്ഞുനോക്കുമ്പോൾ,

$ tcpdump -nn -tt -r second-1-0.pcap

പ്രതിധ്വനിച്ച പാക്കറ്റ് അവസാനമായി പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിലേക്ക് തിരികെ വരുന്നത് നിങ്ങൾക്ക് ഇപ്പോൾ കാണാൻ കഴിയും
ട്രേസ് ഡമ്പിന്റെ ലൈൻ.

ഫയൽ second-1-0.pcap, ലിങ്ക്-ടൈപ്പ് PPP (PPP) ൽ നിന്ന് വായിക്കുന്നു
2.003686 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

അവസാനമായി, പ്രതിധ്വനി സൃഷ്ടിച്ച നോഡിലേക്ക് നിങ്ങൾക്ക് തിരിഞ്ഞുനോക്കാം

$ tcpdump -nn -tt -r second-0-0.pcap

പ്രതിധ്വനിച്ച പാക്കറ്റ് 2.007602 സെക്കൻഡിൽ ഉറവിടത്തിലേക്ക് തിരികെയെത്തുന്നത് കാണുക,

ഫയൽ second-0-0.pcap, ലിങ്ക്-ടൈപ്പ് PPP (PPP) ൽ നിന്ന് വായിക്കുന്നു
2.000000 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.017607 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

അവസാനമായി, CSMA ഉപകരണങ്ങളുടെ എണ്ണം നിയന്ത്രിക്കാനുള്ള കഴിവ് ഞങ്ങൾ ചേർത്തുവെന്നത് ഓർക്കുക
കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് വഴിയുള്ള അനുകരണം. എപ്പോൾ പോലെ തന്നെ നിങ്ങൾക്ക് ഈ വാദം മാറ്റാം
പ്രതിധ്വനിക്കുന്ന പാക്കറ്റുകളുടെ എണ്ണം മാറ്റുന്നത് ഞങ്ങൾ നോക്കി ആദ്യം.cc ഉദാഹരണം. ഓടാൻ ശ്രമിക്കുക
"അധിക" ഉപകരണങ്ങളുടെ എണ്ണം നാലായി സജ്ജീകരിച്ചിരിക്കുന്ന പ്രോഗ്രാം:

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈസെക്കൻഡ് --nCsma=4"

നിങ്ങൾ ഇപ്പോൾ കാണണം,

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.405സെ)
സമയത്ത് 2s ക്ലയന്റ് 1024 പോർട്ട് 10.1.2.5 ലേക്ക് 9 ബൈറ്റുകൾ അയച്ചു
2.0118s സെർവറിന് 1024 പോർട്ടിൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു 49153
സമയം 2.0118s സെർവർ 1024 പോർട്ട് 10.1.1.1 ലേക്ക് 49153 ബൈറ്റുകൾ അയച്ചു
സമയത്ത് 2.02461s ക്ലയന്റിന് 1024 പോർട്ട് 10.1.2.5 ൽ നിന്ന് 9 ബൈറ്റുകൾ ലഭിച്ചു

എക്കോ സെർവർ ഇപ്പോൾ CSMA നോഡുകളിൽ അവസാനത്തേതിലേക്ക് മാറ്റി, അത്
സ്ഥിരസ്ഥിതി കേസിന് പകരം 10.1.2.5, 10.1.2.4.

ഒരു ബൈസ്റ്റാൻഡർ സൃഷ്‌ടിച്ച ഒരു ട്രെയ്സ് ഫയലിൽ നിങ്ങൾ തൃപ്തരാകാതിരിക്കാൻ സാധ്യതയുണ്ട്
CSMA നെറ്റ്‌വർക്ക്. ഒരൊറ്റ ഉപകരണത്തിൽ നിന്ന് ഒരു ട്രെയ്സ് ലഭിക്കാൻ നിങ്ങൾ ശരിക്കും ആഗ്രഹിച്ചേക്കാം, നിങ്ങൾ അങ്ങനെ ചെയ്തേക്കില്ല
നെറ്റ്‌വർക്കിലെ മറ്റേതെങ്കിലും ട്രാഫിക്കിൽ താൽപ്പര്യമുള്ളവരായിരിക്കുക. നിങ്ങൾക്ക് ഇത് വളരെ എളുപ്പത്തിൽ ചെയ്യാൻ കഴിയും.

നമുക്ക് നോക്കാം സ്ക്രാച്ച്/mysecond.cc കൂടുതൽ ആകാൻ ഞങ്ങളെ പ്രാപ്തരാക്കുന്ന ആ കോഡ് ചേർക്കുക
നിർദ്ദിഷ്ടം. ns-3 സഹായികൾ ഒരു നോഡ് നമ്പറും ഉപകരണ നമ്പറും എടുക്കുന്ന രീതികൾ നൽകുന്നു
പരാമീറ്ററുകൾ. മുന്നോട്ട് പോയി മാറ്റിസ്ഥാപിക്കുക EnablePcap താഴെയുള്ള കോളുകൾക്കൊപ്പം കോളുകൾ.

pointToPoint.EnablePcap ("രണ്ടാം", p2pNodes.Get (0)->GetId (), 0);
csma.EnablePcap ("രണ്ടാം", csmaNodes.Get (nCsma)->GetId (), 0, false);
csma.EnablePcap ("രണ്ടാം", csmaNodes.Get (nCsma-1)->GetId (), 0, false);

"സെക്കൻഡ്" എന്ന അടിസ്ഥാന നാമത്തിൽ ഒരു pcap ഫയൽ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് ഞങ്ങൾക്കറിയാം, ഞങ്ങൾക്കും അറിയാം
രണ്ട് സാഹചര്യങ്ങളിലും താൽപ്പര്യമുള്ള ഉപകരണം പൂജ്യമായിരിക്കും, അതിനാൽ ആ പാരാമീറ്ററുകൾ അങ്ങനെയല്ല
ശരിക്കും രസകരമാണ്.

നോഡ് നമ്പർ ലഭിക്കുന്നതിന്, നിങ്ങൾക്ക് രണ്ട് ചോയ്‌സുകളുണ്ട്: ആദ്യം, നോഡുകൾ a എന്നതിൽ അക്കമിട്ടിരിക്കുന്നു
നിങ്ങൾ സൃഷ്ടിച്ച ക്രമത്തിൽ പൂജ്യത്തിൽ നിന്ന് ആരംഭിക്കുന്ന ഫാഷൻ ഏകതാനമായി വർദ്ധിക്കുന്നു
അവരെ. ഒരു നോഡ് നമ്പർ ലഭിക്കുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഈ നമ്പർ "മാനുവലായി" കണ്ടുപിടിക്കുക എന്നതാണ്
നോഡ് സൃഷ്ടിയുടെ ക്രമം ആലോചിക്കുന്നു. നിങ്ങൾ നെറ്റ്‌വർക്ക് ടോപ്പോളജി പരിശോധിച്ചാൽ
ഫയലിന്റെ തുടക്കത്തിൽ ചിത്രീകരണം, ഞങ്ങൾ നിങ്ങൾക്കായി ഇത് ചെയ്തു, അത് നിങ്ങൾക്ക് കാണാൻ കഴിയും
അവസാന CSMA നോഡ് നോഡ് നമ്പറായിരിക്കും nCsma + 1. ഈ സമീപനം അരോചകമായി മാറിയേക്കാം
വലിയ സിമുലേഷനുകളിൽ ബുദ്ധിമുട്ടാണ്.

ഞങ്ങൾ ഇവിടെ ഉപയോഗിക്കുന്ന ഒരു ഇതര മാർഗം, അത് തിരിച്ചറിയുക എന്നതാണ് നോഡ് കണ്ടെയ്നറുകൾ അടങ്ങിയിട്ടുണ്ട്
ചൂണ്ടിക്കാണിക്കുന്നു ns-3 നോഡ് വസ്തുക്കൾ. ദി നോഡ് വസ്തുവിന് എന്നൊരു രീതിയുണ്ട് GetId അത് ചെയ്യും
ആ നോഡിന്റെ ഐഡി തിരികെ നൽകുക, അത് നമ്മൾ അന്വേഷിക്കുന്ന നോഡ് നമ്പറാണ്. നമുക്ക് ഒന്ന് പോയി നോക്കാം
ഇതിനായി ഡോക്സിജൻ നോഡ് ആ രീതി കണ്ടെത്തുക, അത് കൂടുതൽ താഴെയാണ് ns-3 കോർ കോഡ്
നമ്മൾ ഇതുവരെ കണ്ടതിനേക്കാൾ; എന്നാൽ ചിലപ്പോൾ ഉപയോഗപ്രദമായ കാര്യങ്ങൾക്കായി നിങ്ങൾ ഉത്സാഹത്തോടെ തിരയേണ്ടി വരും.

നിങ്ങളുടെ റിലീസിനായി ഡോക്‌സിജൻ ഡോക്യുമെന്റേഷനിലേക്ക് പോകുക (നിങ്ങൾക്ക് ഇത് കണ്ടെത്താനാകുമെന്ന് ഓർക്കുക
പ്രോജക്റ്റ് വെബ് സൈറ്റ്). നിങ്ങൾക്ക് എത്തിച്ചേരാം നോഡ് പരിശോധിച്ചുകൊണ്ട് ഡോക്യുമെന്റേഷൻ
"ക്ലാസ്സുകൾ" ടാബ്, നിങ്ങൾ കണ്ടെത്തുന്നത് വരെ "ക്ലാസ് ലിസ്റ്റ്" താഴേക്ക് സ്ക്രോൾ ചെയ്യുക ns3::നോഡ്. തിരഞ്ഞെടുക്കുക
ns3::നോഡ് എന്നതിനായുള്ള ഡോക്യുമെന്റേഷനിലേക്ക് നിങ്ങളെ കൊണ്ടുപോകും നോഡ് ക്ലാസ്. നിങ്ങൾ ഇപ്പോൾ എങ്കിൽ
എന്നതിലേക്ക് താഴേക്ക് സ്ക്രോൾ ചെയ്യുക GetId രീതി തിരഞ്ഞെടുത്ത് അത് തിരഞ്ഞെടുക്കുക, നിങ്ങളെ വിശദമായി എടുക്കും
രീതിയുടെ ഡോക്യുമെന്റേഷൻ. ഉപയോഗിച്ച് GetId നോഡ് നമ്പറുകൾ നിർണ്ണയിക്കാൻ ഈ രീതിക്ക് കഴിയും
സങ്കീർണ്ണമായ ടോപ്പോളജികളിൽ വളരെ എളുപ്പമാണ്.

ആശയക്കുഴപ്പം ഒഴിവാക്കുന്നതിന് ടോപ്പ് ലെവൽ ഡയറക്ടറിയിൽ നിന്ന് പഴയ ട്രെയ്സ് ഫയലുകൾ മായ്‌ക്കാം
എന്താണ് സംഭവിക്കുന്നത്,

$ rm *.pcap
$ rm *.tr

നിങ്ങൾ പുതിയ സ്ക്രിപ്റ്റ് നിർമ്മിച്ച് സിമുലേഷൻ ക്രമീകരണം പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ nCsma മുതൽ 100 വരെ,

$ ./waf --റൺ "സ്ക്രാച്ച്/മൈസെക്കൻഡ് --nCsma=100"

നിങ്ങൾ ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് കാണും:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.407സെ)
സമയത്ത് 2s ക്ലയന്റ് 1024 പോർട്ട് 10.1.2.101 ലേക്ക് 9 ബൈറ്റുകൾ അയച്ചു
2.0068s സെർവറിന് 1024 പോർട്ടിൽ നിന്ന് 10.1.1.1 ബൈറ്റുകൾ ലഭിച്ചു 49153
സമയം 2.0068s സെർവർ 1024 പോർട്ട് 10.1.1.1 ലേക്ക് 49153 ബൈറ്റുകൾ അയച്ചു
സമയത്ത് 2.01761s ക്ലയന്റിന് 1024 പോർട്ട് 10.1.2.101 ൽ നിന്ന് 9 ബൈറ്റുകൾ ലഭിച്ചു

എക്കോ സെർവർ ഇപ്പോൾ 10.1.2.101-ൽ സ്ഥിതിചെയ്യുന്നുവെന്നത് ശ്രദ്ധിക്കുക.
അവസാനത്തേതിൽ എക്കോ സെർവറുള്ള "അധിക" CSMA നോഡുകൾ. നിങ്ങൾ pcap ഫയലുകൾ ലിസ്റ്റുചെയ്യുകയാണെങ്കിൽ
ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറി നിങ്ങൾ കാണും,

second-0-0.pcap second-100-0.pcap second-101-0.pcap

ട്രേസ് ഫയൽ രണ്ടാം-0-0.pcap "ഇടത്തെ" പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണമാണ് എക്കോ
പാക്കറ്റ് ഉറവിടം. ഫയല് രണ്ടാം-101-0.pcap ഏറ്റവും വലതുവശത്തുള്ള CSMA ഉപകരണവുമായി പൊരുത്തപ്പെടുന്നു
എക്കോ സെർവർ എവിടെയാണ് താമസിക്കുന്നത്. എന്നതിലെ അവസാന പാരാമീറ്റർ നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം
എക്കോ സെർവർ നോഡിൽ pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാനുള്ള കോൾ തെറ്റായിരുന്നു. ഇതിനർത്ഥം ട്രെയ്സ് എന്നാണ്
ആ നോഡിൽ ശേഖരിച്ചത് നോൺ-പ്രോമിസ്ക്യൂസ് മോഡിൽ ആയിരുന്നു.

വേശ്യാവൃത്തിയില്ലാത്തതും അല്ലാത്തതുമായ ട്രെയ്‌സുകൾ തമ്മിലുള്ള വ്യത്യാസം ചിത്രീകരിക്കാൻ, ഞങ്ങളും
അടുത്ത-അവസാന നോഡിനായി ഒരു നോൺ-പ്രോമിസ്ക്യൂസ് ട്രെയ്സ് അഭ്യർത്ഥിച്ചു. മുന്നോട്ട് പോയി നോക്കൂ
The tcpdump വേണ്ടി രണ്ടാം-100-0.pcap.

$ tcpdump -nn -tt -r second-100-0.pcap

എക്കോ എക്സ്ചേഞ്ചിലെ നോഡ് 100 ശരിക്കും ഒരു കാഴ്ചക്കാരനാണെന്ന് നിങ്ങൾക്ക് ഇപ്പോൾ കാണാൻ കഴിയും. ഒരേയൊരു
മുഴുവൻ CSMA-യിലേക്കും പ്രക്ഷേപണം ചെയ്യുന്ന ARP അഭ്യർത്ഥനകളാണ് ഇതിന് ലഭിക്കുന്ന പാക്കറ്റുകൾ
നെറ്റ്വർക്ക്.

ഫയൽ second-100-0.pcap, ലിങ്ക്-ടൈപ്പ് EN10MB (ഇഥർനെറ്റ്) ൽ നിന്നുള്ള വായന
2.006698 ARP, 10.1.2.101 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.1-നോട് പറയുക, ദൈർഘ്യം 50
2.013815 ARP, 10.1.2.1 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.101-നോട് പറയുക, ദൈർഘ്യം 50

ഇപ്പോൾ ഒന്നു നോക്കൂ tcpdump വേണ്ടി രണ്ടാം-101-0.pcap.

$ tcpdump -nn -tt -r second-101-0.pcap

നോഡ് 101 ശരിക്കും എക്കോ എക്സ്ചേഞ്ചിലെ പങ്കാളിയാണെന്ന് നിങ്ങൾക്ക് ഇപ്പോൾ കാണാൻ കഴിയും.

ഫയൽ second-101-0.pcap, ലിങ്ക്-ടൈപ്പ് EN10MB (ഇഥർനെറ്റ്) ൽ നിന്നുള്ള വായന
2.006698 ARP, 10.1.2.101 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.1-നോട് പറയുക, ദൈർഘ്യം 50
2.006698 ARP, മറുപടി 10.1.2.101 is- at 00:00:00:00:00:67, ദൈർഘ്യം 50
2.006803 IP 10.1.1.1.49153 > 10.1.2.101.9: UDP, ദൈർഘ്യം 1024
2.013803 ARP, 10.1.2.1 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.101-നോട് പറയുക, ദൈർഘ്യം 50
2.013828 ARP, മറുപടി 10.1.2.1 is- at 00:00:00:00:00:03, ദൈർഘ്യം 50
2.013828 IP 10.1.2.101.9 > 10.1.1.1.49153: UDP, ദൈർഘ്യം 1024

മോഡലുകൾ, ഗുണവിശേഷങ്ങൾ ഒപ്പം റിയാലിറ്റി
ഒരു ചെറിയ ഉല്ലാസയാത്ര നടത്താനും പ്രധാനപ്പെട്ട ഒരു കാര്യം പറയാനും പറ്റിയ സ്ഥലമാണിത്. അത് ഒരുപക്ഷെ
അല്ലെങ്കിൽ നിങ്ങൾക്ക് വ്യക്തമാകണമെന്നില്ല, എന്നാൽ ഒരാൾ ഒരു സിമുലേഷൻ ഉപയോഗിക്കുമ്പോഴെല്ലാം അത് പ്രധാനമാണ്
എന്താണ് മോഡൽ ചെയ്യുന്നതെന്നും അല്ലാത്തത് എന്താണെന്നും കൃത്യമായി മനസ്സിലാക്കുക. ഇത് പ്രലോഭിപ്പിക്കുന്നതാണ്, ഉദാഹരണത്തിന്, ചെയ്യാൻ
മുമ്പത്തെ വിഭാഗത്തിൽ ഉപയോഗിച്ച CSMA ഉപകരണങ്ങളും ചാനലുകളും യഥാർത്ഥമാണെന്ന് കരുതുക
ഇഥർനെറ്റ് ഉപകരണങ്ങൾ; എന്ത് സംഭവിക്കുമെന്ന് നേരിട്ട് പ്രതിഫലിപ്പിക്കുന്ന ഒരു സിമുലേഷൻ ഫലം പ്രതീക്ഷിക്കുക
ഒരു യഥാർത്ഥ ഇഥർനെറ്റിൽ. ഇത് അങ്ങനെയല്ല.

ഒരു മാതൃക, നിർവചനം അനുസരിച്ച്, യാഥാർത്ഥ്യത്തിന്റെ അമൂർത്തമാണ്. അത് ആത്യന്തികമായി ഉത്തരവാദിത്തമാണ്
സിമുലേഷൻ സ്ക്രിപ്റ്റ് രചയിതാവിന്റെ "കൃത്യതയുടെ പരിധി", "ഡൊമെയ്ൻ" എന്ന് വിളിക്കപ്പെടുന്നവ നിർണ്ണയിക്കാൻ
മൊത്തത്തിൽ സിമുലേഷന്റെ പ്രയോഗക്ഷമതയും അതിനാൽ അതിന്റെ ഘടകഭാഗങ്ങളും.

ചില സന്ദർഭങ്ങളിൽ, പോലെ Csma, എന്താണെന്ന് നിർണ്ണയിക്കുന്നത് വളരെ എളുപ്പമായിരിക്കും അല്ല മാതൃകയാക്കിയത്. എഴുതിയത്
മാതൃകാ വിവരണം വായിക്കുന്നു (csma.h) കൂട്ടിയിടി കണ്ടെത്തൽ ഇല്ലെന്ന് നിങ്ങൾക്ക് കണ്ടെത്താനാകും
CSMA മോഡലിൽ അതിന്റെ ഉപയോഗം നിങ്ങളുടെ സിമുലേഷനിൽ എത്രത്തോളം ബാധകമാണ് അല്ലെങ്കിൽ എന്താണെന്ന് തീരുമാനിക്കുക
നിങ്ങളുടെ ഫലങ്ങളിൽ ഉൾപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാവുന്ന മുന്നറിയിപ്പ്. മറ്റ് സന്ദർഭങ്ങളിൽ, ഇത് വളരെ എളുപ്പമായിരിക്കും
ഒരു യാഥാർത്ഥ്യത്തോടും യോജിക്കാത്ത സ്വഭാവരീതികൾ കോൺഫിഗർ ചെയ്യാൻ നിങ്ങൾക്ക് പുറത്ത് പോയി വാങ്ങാം. അത്
അത്തരത്തിലുള്ള ചില സംഭവങ്ങൾ അന്വേഷിക്കാൻ കുറച്ച് സമയം ചെലവഴിക്കുന്നത് മൂല്യവത്താണെന്ന് തെളിയിക്കും, എങ്ങനെ
നിങ്ങളുടെ സിമുലേഷനുകളിൽ യാഥാർത്ഥ്യത്തിന്റെ അതിരുകൾക്കപ്പുറത്തേക്ക് എളുപ്പത്തിൽ നീങ്ങാൻ കഴിയും.

നിങ്ങൾ കണ്ടതുപോലെ, ns-3 നൽകുന്നു ഗുണവിശേഷങ്ങൾ മോഡൽ മാറ്റാൻ ഒരു ഉപയോക്താവിന് എളുപ്പത്തിൽ സജ്ജമാക്കാൻ കഴിയും
പെരുമാറ്റം. അവയിൽ രണ്ടെണ്ണം പരിഗണിക്കുക ഗുണവിശേഷങ്ങൾ എന്ന CsmaNetDevice: Mtu ഒപ്പം
എൻക്യാപ്സുലേഷൻ മോഡ്. ദി Mtu ആട്രിബ്യൂട്ട് പരമാവധി ട്രാൻസ്മിഷൻ യൂണിറ്റിനെ സൂചിപ്പിക്കുന്നു
ഉപകരണം. ഉപകരണത്തിന് കഴിയുന്ന ഏറ്റവും വലിയ പ്രോട്ടോക്കോൾ ഡാറ്റ യൂണിറ്റിന്റെ (PDU) വലുപ്പമാണിത്
അയക്കുക.

MTU സ്ഥിരസ്ഥിതിയായി 1500 ബൈറ്റുകളായി CsmaNetDevice. ഈ ഡിഫോൾട്ട് ഒരു സംഖ്യയുമായി പൊരുത്തപ്പെടുന്നു
RFC 894-ൽ കണ്ടെത്തി, "ഇഥർനെറ്റിലൂടെ IP ഡാറ്റാഗ്രാമുകൾ സംപ്രേഷണം ചെയ്യുന്നതിനുള്ള ഒരു മാനദണ്ഡം
നെറ്റ്‌വർക്കുകൾ." 10Base5-നുള്ള പരമാവധി പാക്കറ്റ് വലുപ്പത്തിൽ നിന്നാണ് യഥാർത്ഥത്തിൽ ഈ നമ്പർ ഉരുത്തിരിഞ്ഞത്
(ഫുൾ-സ്പെക് ഇഥർനെറ്റ്) നെറ്റ്‌വർക്കുകൾ -- 1518 ബൈറ്റുകൾ. നിങ്ങൾ DIX എൻക്യാപ്സുലേഷൻ കുറയ്ക്കുകയാണെങ്കിൽ
ഇഥർനെറ്റ് പാക്കറ്റുകളുടെ ഓവർഹെഡ് (18 ബൈറ്റുകൾ) നിങ്ങൾക്ക് സാധ്യമായ പരമാവധി ഡാറ്റ വലുപ്പം ലഭിക്കും
(MTU) 1500 ബൈറ്റുകൾ. എന്ന് ഒരാൾക്ക് കണ്ടെത്താനും കഴിയും എം.ടി.യു IEEE 802.3 നെറ്റ്‌വർക്കുകൾക്ക് 1492 ആണ്
ബൈറ്റുകൾ. കാരണം, LLC/SNAP എൻക്യാപ്‌സുലേഷൻ അധികമായി എട്ട് ബൈറ്റുകൾ ഓവർഹെഡിലേക്ക് ചേർക്കുന്നു
പാക്കറ്റ്. രണ്ട് സാഹചര്യങ്ങളിലും, അടിസ്ഥാന ഹാർഡ്‌വെയറിന് 1518 ബൈറ്റുകൾ മാത്രമേ അയയ്ക്കാൻ കഴിയൂ, പക്ഷേ ഡാറ്റ
വലിപ്പം വ്യത്യസ്തമാണ്.

എൻക്യാപ്സുലേഷൻ മോഡ് സജ്ജീകരിക്കുന്നതിന്, ദി CsmaNetDevice ഒരു വാര്ത്ത നല്കുന്നു ഗുണങ്ങളെ വിളിച്ചു
എൻക്യാപ്സുലേഷൻ മോഡ് മൂല്യങ്ങൾ ഏറ്റെടുക്കാൻ കഴിയുന്ന പത്ത് or LLC. ഇവ ഇഥർനെറ്റുമായി യോജിക്കുന്നു
കൂടാതെ യഥാക്രമം LLC/SNAP ഫ്രെയിമിംഗ്.

ഒരാൾ ഉപേക്ഷിച്ചാൽ Mtu 1500 ബൈറ്റുകളിൽ എൻക്യാപ്സുലേഷൻ മോഡ് മാറ്റുന്നു LLC, ഫലം
LLC/SNAP ഫ്രെയിമിംഗിനൊപ്പം 1500 ബൈറ്റ് PDU-കൾ ഉൾക്കൊള്ളുന്ന ഒരു നെറ്റ്‌വർക്ക് ആയിരിക്കും
1526 ബൈറ്റുകളുടെ പാക്കറ്റുകൾ, അവ പല നെറ്റ്‌വർക്കുകളിലും നിയമവിരുദ്ധമായിരിക്കും, കാരണം അവയ്ക്ക് കൈമാറാൻ കഴിയും
ഒരു പാക്കറ്റിന് പരമാവധി 1518 ബൈറ്റുകൾ. ഇത് മിക്കവാറും ഒരു സിമുലേഷനിൽ കലാശിക്കും
നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന യാഥാർത്ഥ്യത്തെ വളരെ സൂക്ഷ്മമായി പ്രതിഫലിപ്പിക്കുന്നില്ല.

ചിത്രം സങ്കീർണ്ണമാക്കാൻ, ജംബോ ഫ്രെയിമുകൾ നിലവിലുണ്ട് (1500 < MTU <= 9000 ബൈറ്റുകൾ) കൂടാതെ
സൂപ്പർ-ജംബോ (MTU > 9000 ബൈറ്റുകൾ) ഫ്രെയിമുകൾ IEEE ഔദ്യോഗികമായി അനുവദിച്ചിട്ടില്ലെങ്കിലും
ചില ഹൈ-സ്പീഡ് (ഗിഗാബൈറ്റ്) നെറ്റ്‌വർക്കുകളിലും NIC-കളിലും ലഭ്യമാണ്. ഒരാൾക്ക് ഉപേക്ഷിക്കാമായിരുന്നു
എൻക്യാപ്സുലേഷൻ മോഡ് സജ്ജമാക്കി പത്ത്, എന്നിവ സജ്ജമാക്കുക Mtu ഗുണങ്ങളെ ന് ഒരു CsmaNetDevice 64000 ബൈറ്റുകൾ വരെ
-- ബന്ധപ്പെട്ടതാണെങ്കിലും CsmaChannel വിവര നിരക്ക് സെക്കൻഡിൽ 10 മെഗാബൈറ്റ് ആയി സജ്ജീകരിച്ചു. ഈ
വാമ്പയർ-ടാപ്പ് ചെയ്ത 1980-കളിലെ ശൈലിയിലുള്ള 10Base5 ഉപയോഗിച്ച് നിർമ്മിച്ച ഒരു ഇഥർനെറ്റ് സ്വിച്ച് അടിസ്ഥാനപരമായി മാതൃകയാക്കും.
സൂപ്പർ-ജംബോ ഡാറ്റാഗ്രാമുകളെ പിന്തുണയ്ക്കുന്ന നെറ്റ്‌വർക്കുകൾ. ഇത് തീർച്ചയായും ഉണ്ടായിരുന്ന ഒന്നല്ല
എപ്പോഴെങ്കിലും നിർമ്മിച്ചതാണ്, അല്ലെങ്കിൽ ഒരിക്കലും നിർമ്മിക്കപ്പെടാൻ സാധ്യതയില്ല, എന്നാൽ നിങ്ങൾക്ക് കോൺഫിഗർ ചെയ്യാൻ വളരെ എളുപ്പമാണ്.

മുമ്പത്തെ ഉദാഹരണത്തിൽ, 100 ഉള്ള ഒരു സിമുലേഷൻ സൃഷ്ടിക്കാൻ നിങ്ങൾ കമാൻഡ് ലൈൻ ഉപയോഗിച്ചു
Csma നോഡുകൾ. 500 നോഡുകളുള്ള ഒരു സിമുലേഷൻ നിങ്ങൾക്ക് എളുപ്പത്തിൽ സൃഷ്ടിക്കാമായിരുന്നു. നിങ്ങൾ എങ്കിൽ
യഥാർത്ഥത്തിൽ 10Base5 വാമ്പയർ-ടാപ്പ് നെറ്റ്‌വർക്ക് മോഡലിംഗ് ആയിരുന്നു, ഒരു ഫുൾ-സ്പെക്കിന്റെ പരമാവധി ദൈർഘ്യം
ഇഥർനെറ്റ് കേബിൾ 500 മീറ്ററാണ്, കുറഞ്ഞത് 2.5 മീറ്ററാണ് ടാപ്പ് സ്പേസിംഗ്. അതിനർത്ഥം അവിടെ എന്നാണ്
ഒരു യഥാർത്ഥ നെറ്റ്‌വർക്കിൽ 200 ടാപ്പുകൾ മാത്രമേ സാധ്യമാകൂ. നിങ്ങൾക്ക് വളരെ എളുപ്പത്തിൽ നിയമവിരുദ്ധമായി നിർമ്മിക്കാമായിരുന്നു
ആ വഴിയിലും നെറ്റ്‌വർക്ക്. ഇത് അർത്ഥവത്തായ ഒരു സിമുലേഷനിൽ കലാശിച്ചേക്കാം അല്ലെങ്കിൽ ഉണ്ടാകില്ല
നിങ്ങൾ മാതൃകയാക്കാൻ ശ്രമിക്കുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.

സമാനമായ സാഹചര്യങ്ങൾ പല സ്ഥലങ്ങളിലും ഉണ്ടാകാം ns-3 കൂടാതെ ഏതെങ്കിലും സിമുലേറ്ററിലും. ഉദാഹരണത്തിന്,
നോഡുകൾ ഒരേ ഇടം ഉൾക്കൊള്ളുന്ന തരത്തിൽ നിങ്ങൾക്ക് അവ സ്ഥാപിക്കാൻ കഴിഞ്ഞേക്കും
അതേ സമയം, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ആംപ്ലിഫയറുകളോ ശബ്‌ദ നിലകളോ ക്രമീകരിക്കാൻ കഴിഞ്ഞേക്കും
ഭൗതികശാസ്ത്രത്തിന്റെ അടിസ്ഥാന നിയമങ്ങൾ.

ns-3 സാധാരണയായി വഴക്കത്തെ അനുകൂലിക്കുന്നു, കൂടാതെ പല മോഡലുകളും സ്വതന്ത്രമായി സജ്ജീകരിക്കാൻ അനുവദിക്കും ഗുണവിശേഷങ്ങൾ
ഏതെങ്കിലും അനിയന്ത്രിതമായ സ്ഥിരതയോ അല്ലെങ്കിൽ പ്രത്യേകമായ അന്തർലീനമായ സവിശേഷതയോ നടപ്പിലാക്കാൻ ശ്രമിക്കാതെ.

ഇതിൽ നിന്ന് വീട്ടിലേക്ക് കൊണ്ടുപോകേണ്ട കാര്യം ഇതാണ് ns-3 ഒരു സൂപ്പർ-ഫ്ലെക്സിബിൾ അടിത്തറ നൽകാൻ പോകുന്നു
നിങ്ങൾക്ക് പരീക്ഷണത്തിനായി. നിങ്ങൾ സിസ്റ്റത്തോട് എന്താണ് ചോദിക്കുന്നതെന്ന് മനസിലാക്കേണ്ടത് നിങ്ങളാണ്
നിങ്ങൾ സൃഷ്‌ടിക്കുന്ന സിമുലേഷനുകൾക്ക് ചില അർഥങ്ങളും ചിലത് ഉണ്ടെന്ന് ഉറപ്പുവരുത്താനും
നിങ്ങൾ നിർവചിച്ച യാഥാർത്ഥ്യവുമായുള്ള ബന്ധം.

കെട്ടിടം a വയർലെസ് നെറ്റ്വർക്ക് ടോപ്പോളജി
ഈ വിഭാഗത്തിൽ ഞങ്ങൾ ഞങ്ങളുടെ അറിവ് കൂടുതൽ വികസിപ്പിക്കാൻ പോകുന്നു ns-3 നെറ്റ്‌വർക്ക് ഉപകരണങ്ങളും
വയർലെസ് നെറ്റ്‌വർക്കിന്റെ ഒരു ഉദാഹരണം ഉൾക്കൊള്ളുന്ന ചാനലുകൾ. ns-3 802.11 മോഡലുകളുടെ ഒരു കൂട്ടം നൽകുന്നു
802.11 സ്പെസിഫിക്കേഷന്റെ കൃത്യമായ MAC-ലെവൽ ഇംപ്ലിമേഷൻ നൽകാനുള്ള ശ്രമം
കൂടാതെ 802.11a സ്പെസിഫിക്കേഷന്റെ "അത്ര മന്ദഗതിയിലല്ല" PHY-ലെവൽ മോഡലും.

പോയിന്റ്-ടു-പോയിന്റ്, CSMA ടോപ്പോളജി സഹായ വസ്തുക്കൾ എന്നിവ ഞങ്ങൾ കണ്ടതുപോലെ
പോയിന്റ്-ടു-പോയിന്റ് ടോപ്പോളജികൾ നിർമ്മിക്കുമ്പോൾ, നമുക്ക് തുല്യമായത് കാണാം വൈഫൈ ടോപ്പോളജി സഹായികൾ
ഈ വിഭാഗം. ഈ സഹായികളുടെ രൂപവും പ്രവർത്തനവും തികച്ചും പരിചിതമായിരിക്കണം
നീ.

ഞങ്ങളിൽ ഞങ്ങൾ ഒരു ഉദാഹരണ സ്ക്രിപ്റ്റ് നൽകുന്നു ഉദാഹരണങ്ങൾ / ട്യൂട്ടോറിയൽ ഡയറക്ടറി. ഈ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു
The second.cc സ്ക്രിപ്റ്റ് ചെയ്യുകയും ഒരു വൈഫൈ നെറ്റ്‌വർക്ക് ചേർക്കുകയും ചെയ്യുന്നു. മുന്നോട്ട് പോയി തുറക്കുക
ഉദാഹരണങ്ങൾ/tutorial/third.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ. നിങ്ങൾ ഇതിനകം വേണ്ടത്ര കണ്ടിരിക്കും
ns-3 ഈ ഉദാഹരണത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ കോഡ്, എന്നാൽ കുറച്ച് പുതിയവയുണ്ട്
കാര്യങ്ങൾ, അതിനാൽ ഞങ്ങൾ മുഴുവൻ സ്ക്രിപ്റ്റിലേക്കും പോയി കുറച്ച് ഔട്ട്പുട്ട് പരിശോധിക്കും.

ലെ പോലെ തന്നെ second.cc ഉദാഹരണം (എല്ലാത്തിലും ns-3 ഉദാഹരണങ്ങൾ) ഫയൽ ആരംഭിക്കുന്നത് ഒരു emacs ഉപയോഗിച്ചാണ്
മോഡ് ലൈനും ചില ജിപിഎൽ ബോയിലർ പ്ലേറ്റും.

ഡിഫോൾട്ട് നെറ്റ്‌വർക്ക് ടോപ്പോളജി കാണിക്കുന്ന ASCII ആർട്ട് (ചുവടെ പുനർനിർമ്മിച്ചിരിക്കുന്നത്) നോക്കുക
ഉദാഹരണത്തിൽ നിർമ്മിച്ചത്. ഞങ്ങളുടെ ഉദാഹരണം ഞങ്ങൾ കൂടുതൽ വിപുലീകരിക്കാൻ പോകുന്നുവെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും
ഇടതുവശത്ത് വയർലെസ് നെറ്റ്‌വർക്ക് തൂക്കിയിടുന്നതിലൂടെ. ഇതൊരു ഡിഫോൾട്ട് നെറ്റ്‌വർക്ക് ആണെന്ന് ശ്രദ്ധിക്കുക
വയർ, വയർലെസ് എന്നിവയിൽ സൃഷ്ടിച്ച നോഡുകളുടെ എണ്ണം നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ വ്യത്യാസപ്പെടുത്താൻ കഴിയുമെന്നതിനാൽ ടോപ്പോളജി
നെറ്റ്വർക്കുകൾ. ലെ പോലെ തന്നെ second.cc സ്ക്രിപ്റ്റ് കേസ്, നിങ്ങൾ മാറ്റുകയാണെങ്കിൽ nCsma, അത് നിങ്ങൾക്ക് ഒരു തരും
"അധിക" CSMA നോഡുകളുടെ എണ്ണം. അതുപോലെ, നിങ്ങൾക്ക് സജ്ജമാക്കാൻ കഴിയും nWifi എത്രയെണ്ണം നിയന്ത്രിക്കാൻ എസ്
(സ്റ്റേഷൻ) നോഡുകൾ സിമുലേഷനിൽ സൃഷ്ടിക്കപ്പെടുന്നു. എപ്പോഴും ഒന്ന് ഉണ്ടാകും AP (ആക്സസ് പോയിന്റ്)
വയർലെസ് നെറ്റ്‌വർക്കിലെ നോഡ്. സ്ഥിരസ്ഥിതിയായി മൂന്ന് "അധിക" CSMA നോഡുകളും മൂന്ന് ഉണ്ട്
വയർലെസ് എസ് നോഡുകൾ.

മൊഡ്യൂളിൽ ചെയ്തതുപോലെ ഫയലുകൾ ഉൾപ്പെടുത്തി ലോഡുചെയ്യുന്നതിലൂടെയാണ് കോഡ് ആരംഭിക്കുന്നത് second.cc ഉദാഹരണം.
വൈഫൈ മൊഡ്യൂളിനും മൊബിലിറ്റിക്കും അനുസൃതമായി രണ്ട് പുതിയവ ഉൾപ്പെടുന്നു
ഞങ്ങൾ താഴെ ചർച്ച ചെയ്യുന്ന മൊഡ്യൂൾ.

#ഉൾപ്പെടുത്തുക "ns3/core-module.h"
#ഉൾപ്പെടുത്തുക "ns3/point-to-point-module.h"
#ഉൾപ്പെടുത്തുക "ns3/network-module.h"
#ഉൾപ്പെടുത്തുക "ns3/applications-module.h"
#ഉൾപ്പെടുത്തുക "ns3/wifi-module.h"
#ഉൾപ്പെടുത്തുക "ns3/mobility-module.h"
#ഉൾപ്പെടുത്തുക "ns3/csma-module.h"
#ഉൾപ്പെടുത്തുക "ns3/internet-module.h"

നെറ്റ്‌വർക്ക് ടോപ്പോളജി ചിത്രീകരണം ഇപ്രകാരമാണ്:

// ഡിഫോൾട്ട് നെറ്റ്‌വർക്ക് ടോപ്പോളജി
//
// വൈഫൈ 10.1.3.0
// എ.പി
// * * * *
// | | | | 10.1.1.0
// n5 n6 n7 n0 ------------- n1 n2 n3 n4
// പോയിന്റ്-ടു-പോയിന്റ് | | | |
// ================
// ലാൻ 10.1.2.0

ന്റെ ഇടതുവശത്തുള്ള നോഡിലേക്ക് ഞങ്ങൾ ഒരു പുതിയ നെറ്റ്‌വർക്ക് ഉപകരണം ചേർക്കുന്നത് നിങ്ങൾക്ക് കാണാം
വയർലെസ് നെറ്റ്‌വർക്കിന്റെ ആക്‌സസ് പോയിന്റായി മാറുന്ന പോയിന്റ്-ടു-പോയിന്റ് ലിങ്ക്. ഒരു കൂട്ടം
ഇടതുവശത്ത് കാണിച്ചിരിക്കുന്നതുപോലെ പുതിയ 10.1.3.0 നെറ്റ്‌വർക്ക് പൂരിപ്പിക്കുന്നതിന് വയർലെസ് STA നോഡുകൾ സൃഷ്‌ടിച്ചിരിക്കുന്നു
ചിത്രീകരണത്തിന്റെ വശം.

ചിത്രീകരണത്തിന് ശേഷം, ദി ns-3 നെയിംസ്പേസ് ആണ് ഉപയോഗിച്ച ഒപ്പം ഒരു ലോഗിംഗ് ഘടകം നിർവചിച്ചിരിക്കുന്നു.
ഇതെല്ലാം ഇപ്പോൾ പരിചിതമായിരിക്കണം.

നെയിംസ്പേസ് ns3 ഉപയോഗിക്കുന്നു;

NS_LOG_COMPONENT_DEFINE ("മൂന്നാം സ്ക്രിപ്റ്റ് ഉദാഹരണം");

പ്രധാന പരിപാടി ഇതുപോലെ ആരംഭിക്കുന്നു second.cc എന്നതിനായുള്ള ചില കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ ചേർത്തുകൊണ്ട്
ലോഗിംഗ് ഘടകങ്ങൾ പ്രവർത്തനക്ഷമമാക്കുകയോ പ്രവർത്തനരഹിതമാക്കുകയോ ചെയ്യുന്നതിനും സൃഷ്ടിച്ച ഉപകരണങ്ങളുടെ എണ്ണം മാറ്റുന്നതിനും.

bool verbose = true;
uint32_t nCsma = 3;
uint32_t nWifi = 3;

കമാൻഡ് ലൈൻ cmd;
cmd.AddValue ("nCsma", "\"അധിക\" CSMA നോഡുകൾ/ഉപകരണങ്ങളുടെ എണ്ണം", nCsma);
cmd.AddValue ("nWifi", "wifi STA ഉപകരണങ്ങളുടെ എണ്ണം", nWifi);
cmd.AddValue ("വെർബോസ്", "ശരി ആണെങ്കിൽ ലോഗ് ചെയ്യാൻ എക്കോ ആപ്ലിക്കേഷനുകളോട് പറയുക", വെർബോസ്);

cmd.Parse (argc,argv);

എങ്കിൽ (വാക്കുകൾ)
{
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
}

മുമ്പത്തെ എല്ലാ ഉദാഹരണങ്ങളിലെയും പോലെ, അടുത്ത ഘട്ടം രണ്ട് നോഡുകൾ സൃഷ്ടിക്കുക എന്നതാണ്
പോയിന്റ്-ടു-പോയിന്റ് ലിങ്ക് വഴി ബന്ധിപ്പിക്കുക.

NodeContainer p2pNodes;
p2pNodes.ക്രിയേറ്റ് (2);

അടുത്തതായി, ഞങ്ങൾ ഒരു പഴയ സുഹൃത്തിനെ കാണുന്നു. ഞങ്ങൾ തൽക്ഷണം എ PointToPointHelper അനുബന്ധമായി സജ്ജമാക്കുക
സ്ഥിരസ്ഥിതി ഗുണവിശേഷങ്ങൾ അങ്ങനെ ഞങ്ങൾ ഉപകരണങ്ങളിൽ സെക്കൻഡിൽ അഞ്ച് മെഗാബിറ്റ് ട്രാൻസ്മിറ്റർ സൃഷ്ടിക്കുന്നു
സഹായിയെ ഉപയോഗിച്ച് സൃഷ്‌ടിച്ചതും സഹായി സൃഷ്‌ടിച്ച ചാനലുകളിൽ രണ്ട് മില്ലിസെക്കൻഡ് കാലതാമസവും.
ഞങ്ങൾ അപ്പോൾ അകത്ത് നോഡുകളിലെ ഉപകരണങ്ങളും അവയ്ക്കിടയിലുള്ള ചാനലും.

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

NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);

അടുത്തതായി, ഞങ്ങൾ മറ്റൊന്ന് പ്രഖ്യാപിക്കുന്നു നോഡ് കണ്ടെയ്നർ ബസിന്റെ ഭാഗമായ നോഡുകൾ പിടിക്കാൻ
(CSMA) നെറ്റ്‌വർക്ക്.

നോഡ് കണ്ടെയ്നർ csmaNodes;
csmaNodes.Add (p2pNodes.Get (1));
csmaNodes.ക്രിയേറ്റ് (nCsma);

കോഡിന്റെ അടുത്ത വരി ലഭിക്കുന്നു ആദ്യ നോഡ് (ഒന്നിന്റെ സൂചിക ഉള്ളത് പോലെ).
പോയിന്റ്-ടു-പോയിന്റ് നോഡ് കണ്ടെയ്‌നർ, CSMA ലഭിക്കുന്ന നോഡുകളുടെ കണ്ടെയ്‌നറിലേക്ക് ഇത് ചേർക്കുന്നു
ഉപകരണങ്ങൾ. സംശയാസ്‌പദമായ നോഡ് ഒരു പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണവും ഒരു CSMA-യുമായി അവസാനിക്കും
ഉപകരണം. CSMA യുടെ ബാക്കിയുള്ളവ രചിക്കുന്ന നിരവധി "അധിക" നോഡുകൾ ഞങ്ങൾ സൃഷ്ടിക്കുന്നു
നെറ്റ്വർക്ക്.

അപ്പോൾ ഞങ്ങൾ a CsmaHelper അത് സജ്ജമാക്കുക ഗുണവിശേഷങ്ങൾ മുമ്പത്തെ ഉദാഹരണത്തിൽ ഞങ്ങൾ ചെയ്തതുപോലെ.
ഞങ്ങൾ ഒരു സൃഷ്ടിക്കുന്നു NetDeviceContainer സൃഷ്ടിച്ച CSMA നെറ്റ് ഉപകരണങ്ങളുടെ ട്രാക്ക് സൂക്ഷിക്കാൻ, തുടർന്ന് ഞങ്ങൾ
ഇൻസ്റ്റോൾ തിരഞ്ഞെടുത്ത നോഡുകളിലെ CSMA ഉപകരണങ്ങൾ.

CsmaHelper csma;
csma.SetChannelAttribute ("DataRate", StringValue ("100Mbps"));
csma.SetChannelAttribute ("Delay", TimeValue (NanoSeconds (6560)));

NetDeviceContainer csmaDevices;
csmaDevices = csma.Install (csmaNodes);

അടുത്തതായി, വൈഫൈ നെറ്റ്‌വർക്കിന്റെ ഭാഗമായ നോഡുകൾ ഞങ്ങൾ സൃഷ്ടിക്കാൻ പോകുന്നു. ഞങ്ങൾ
കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് വ്യക്തമാക്കിയിട്ടുള്ള നിരവധി "സ്റ്റേഷൻ" നോഡുകൾ സൃഷ്ടിക്കാൻ പോകുന്നു, കൂടാതെ
ഞങ്ങൾ പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന്റെ "ഇടത്തെ" നോഡ് നോഡായി ഉപയോഗിക്കാൻ പോകുന്നു
ആക്സസ് പോയിന്റ്.

നോഡ് കണ്ടെയ്നർ wifiStaNodes;
wifiStaNodes.Create (nWifi);
NodeContainer wifiApNode = p2pNodes.Get (0);

അടുത്ത ബിറ്റ് കോഡ് വൈഫൈ ഉപകരണങ്ങളും അവയ്‌ക്കിടയിലുള്ള ഇന്റർകണക്ഷൻ ചാനലും നിർമ്മിക്കുന്നു
ഈ വൈഫൈ നോഡുകൾ. ആദ്യം, ഞങ്ങൾ PHY, ചാനൽ സഹായികളെ കോൺഫിഗർ ചെയ്യുന്നു:

YansWifiChannelHelper ചാനൽ = YansWifiChannelHelper::Default ();
YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

ലാളിത്യത്തിനായി, ഈ കോഡ് ഡിഫോൾട്ട് PHY ലെയർ കോൺഫിഗറേഷനും ചാനൽ മോഡലുകളും ഉപയോഗിക്കുന്നു
ഇതിനായി API ഡോക്‌സിജൻ ഡോക്യുമെന്റേഷനിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്
YansWifiChannelHelper::Default ഒപ്പം YansWifiPhyHelper::Default രീതികൾ. ഒരിക്കൽ ഈ വസ്തുക്കൾ
സൃഷ്‌ടിക്കപ്പെട്ടവയാണ്, ഞങ്ങൾ ഒരു ചാനൽ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുകയും അതിനെ ഞങ്ങളുടെ PHY ലെയർ ഒബ്‌ജക്റ്റ് മാനേജറുമായി ബന്ധപ്പെടുത്തുകയും ചെയ്യുന്നു
എല്ലാ PHY ലെയർ ഒബ്‌ജക്‌റ്റുകളും സൃഷ്‌ടിച്ചതാണെന്ന് ഉറപ്പാക്കാൻ YansWifiPhyHelper പങ്കുവെക്കുക
അതേ അടിസ്ഥാന ചാനൽ, അതായത്, അവർ ഒരേ വയർലെസ് മീഡിയം പങ്കിടുന്നു
ആശയവിനിമയവും ഇടപെടലും:

phy.SetChannel (channel.Create ());

PHY സഹായി കോൺഫിഗർ ചെയ്തുകഴിഞ്ഞാൽ, നമുക്ക് MAC ലെയറിൽ ഫോക്കസ് ചെയ്യാം. ഇവിടെ ഞങ്ങൾ ജോലി തിരഞ്ഞെടുക്കുന്നു
നോൺ-ക്വോസ് MAC-കൾക്കൊപ്പം, MAC പാരാമീറ്ററുകൾ സജ്ജീകരിക്കാൻ ഞങ്ങൾ ഒരു NqosWifiMacHelper ഒബ്‌ജക്റ്റ് ഉപയോഗിക്കുന്നു.

WifiHelper wifi = WifiHelper ::Default ();
wifi.SetRemoteStationManager ("ns3::AarfWifiManager");

NqosWifiMacHelper mac = NqosWifiMacHelper::Default ();

ദി SetRemoteStationManager രീതി സഹായിയോട് നിരക്ക് നിയന്ത്രണ അൽഗോരിതം തരം പറയുന്നു
ഉപയോഗിക്കുക. ഇവിടെ, AARF അൽഗോരിതം ഉപയോഗിക്കാൻ ഇത് സഹായിയോട് ആവശ്യപ്പെടുന്നു --- വിശദാംശങ്ങൾ തീർച്ചയായും,
ഡോക്‌സിജനിൽ ലഭ്യമാണ്.

അടുത്തതായി, ഞങ്ങൾ ആഗ്രഹിക്കുന്ന MAC തരം, ഇൻഫ്രാസ്ട്രക്ചർ നെറ്റ്‌വർക്കിന്റെ SSID, ഞങ്ങൾ കോൺഫിഗർ ചെയ്യുന്നു
സജ്ജീകരിക്കുകയും ഞങ്ങളുടെ സ്റ്റേഷനുകൾ സജീവമായ അന്വേഷണം നടത്തുന്നില്ലെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുക:

Ssid ssid = Ssid ("ns-3-ssid");
mac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (തെറ്റായ));

ഈ കോഡ് ആദ്യം ഒരു 802.11 സർവീസ് സെറ്റ് ഐഡന്റിഫയർ (SSID) ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു, അത് ഉപയോഗിക്കും
"Ssid" ന്റെ മൂല്യം സജ്ജമാക്കാൻ ഗുണങ്ങളെ MAC ലെയർ നടപ്പിലാക്കൽ. പ്രത്യേകം
സഹായി സൃഷ്ടിക്കുന്ന തരത്തിലുള്ള MAC ലെയർ വ്യക്തമാക്കുന്നത് ഗുണങ്ങളെ എന്ന നിലയിൽ
"ns3::StaWifiMac" തരം. ഉപയോഗം NqosWifiMacHelper എന്ന് ഉറപ്പാക്കും
"QosSupported" ഗുണങ്ങളെ സൃഷ്ടിച്ച MAC ഒബ്‌ജക്‌റ്റുകൾക്ക് തെറ്റായി സജ്ജീകരിച്ചിരിക്കുന്നു. ഇവയുടെ സംയോജനം
രണ്ട് കോൺഫിഗറേഷനുകൾ അർത്ഥമാക്കുന്നത്, അടുത്തതായി സൃഷ്‌ടിച്ച MAC ഇൻസ്‌റ്റൻസ് ഒരു QoS ഇതര നോൺ-എപി ആയിരിക്കും എന്നാണ്
ഒരു ഇൻഫ്രാസ്ട്രക്ചർ BSS ലെ സ്റ്റേഷൻ (STA) (അതായത്, AP ഉള്ള ഒരു BSS). ഒടുവിൽ, ദി
"ആക്റ്റീവ് പ്രോബിംഗ്" ഗുണങ്ങളെ തെറ്റായി സജ്ജീകരിച്ചിരിക്കുന്നു. അന്വേഷണ അഭ്യർത്ഥനകൾ ഉണ്ടാകില്ല എന്നാണ് ഇതിനർത്ഥം
ഈ സഹായി സൃഷ്ടിച്ച MAC-കൾ അയച്ചത്.

MAC, PHY എന്നിവയിൽ എല്ലാ സ്റ്റേഷൻ-നിർദ്ദിഷ്ട പാരാമീറ്ററുകളും പൂർണ്ണമായി കോൺഫിഗർ ചെയ്തുകഴിഞ്ഞാൽ
ലെയറുകൾ, നമുക്ക് ഇപ്പോൾ പരിചിതമായവയെ വിളിക്കാം ഇൻസ്റ്റോൾ ഇവയുടെ വൈഫൈ ഉപകരണങ്ങൾ സൃഷ്ടിക്കുന്നതിനുള്ള രീതി
സ്റ്റേഷനുകൾ:

NetDeviceContainer staDevices;
staDevices = wifi.Install (phy, mac, wifiStaNodes);

ഞങ്ങളുടെ എല്ലാ STA നോഡുകൾക്കുമായി ഞങ്ങൾ വൈഫൈ കോൺഫിഗർ ചെയ്‌തു, ഇപ്പോൾ ഞങ്ങൾ AP കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്
(ആക്സസ് പോയിന്റ്) നോഡ്. സ്ഥിരസ്ഥിതി മാറ്റിക്കൊണ്ട് ഞങ്ങൾ ഈ പ്രക്രിയ ആരംഭിക്കുന്നു ഗുണവിശേഷങ്ങൾ എന്ന
NqosWifiMacHelper AP യുടെ ആവശ്യകതകൾ പ്രതിഫലിപ്പിക്കുന്നതിന്.

mac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));

ഈ സാഹചര്യത്തിൽ, ദി NqosWifiMacHelper "ns3::ApWifiMac"-ന്റെ MAC പാളികൾ സൃഷ്ടിക്കാൻ പോകുന്നു,
ഒരു AP ആയി കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന ഒരു MAC ഇൻസ്‌റ്റൻസ് സൃഷ്‌ടിക്കണമെന്ന് രണ്ടാമത്തേത് വ്യക്തമാക്കുന്നു.
സഹായി തരം സൂചിപ്പിക്കുന്നത് "QosSupported" ഗുണങ്ങളെ തെറ്റായി സജ്ജമാക്കണം - പ്രവർത്തനരഹിതമാക്കുന്നു
സൃഷ്ടിച്ച AP-കളിൽ 802.11e/WMM-ശൈലി QoS പിന്തുണ.

അടുത്ത വരികൾ ഒരേ PHY-ലെവൽ പങ്കിടുന്ന സിംഗിൾ AP സൃഷ്ടിക്കുന്നു ഗുണവിശേഷങ്ങൾ (ഒപ്പം
ചാനൽ) സ്റ്റേഷനുകളായി:

NetDeviceContainer apDevices;
apDevices = wifi.Install (phy, mac, wifiApNode);

ഇപ്പോൾ, ഞങ്ങൾ മൊബിലിറ്റി മോഡലുകൾ ചേർക്കാൻ പോകുന്നു. STA നോഡുകൾ മൊബൈൽ ആയിരിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
ഒരു ബൗണ്ടിംഗ് ബോക്‌സിനുള്ളിൽ ചുറ്റും, AP നോഡ് നിശ്ചലമാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഞങ്ങൾ ഉപയോഗിക്കുന്നു
മൊബിലിറ്റി ഹെൽപ്പർ ഇത് ഞങ്ങൾക്ക് എളുപ്പമാക്കാൻ. ആദ്യം, ഞങ്ങൾ a മൊബിലിറ്റി ഹെൽപ്പർ വസ്തു
കുറച്ച് വെച്ചു ഗുണവിശേഷങ്ങൾ "പൊസിഷൻ അലോക്കേറ്റർ" പ്രവർത്തനം നിയന്ത്രിക്കുന്നു.

മൊബിലിറ്റി ഹെൽപ്പർ മൊബിലിറ്റി;

mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (0.0),
"MinY", ഇരട്ടമൂല്യം (0.0),
"DeltaX", DoubleValue (5.0),
"DeltaY", DoubleValue (10.0),
"ഗ്രിഡ് വിഡ്ത്ത്", UintegerValue (3),
"ലേഔട്ട് ടൈപ്പ്", സ്ട്രിംഗ്വാല്യൂ ("റോഫസ്റ്റ്"));

ഈ കോഡ് മൊബിലിറ്റി ഹെൽപ്പറോട് ആദ്യം സ്ഥാപിക്കാൻ ദ്വിമാന ഗ്രിഡ് ഉപയോഗിക്കാൻ പറയുന്നു
STA നോഡുകൾ. ക്ലാസിനായി ഡോക്‌സിജൻ പര്യവേക്ഷണം ചെയ്യാൻ മടിക്കേണ്ടതില്ല ns3::GridPositionAllocator കാണാൻ
കൃത്യമായി എന്താണ് ചെയ്യുന്നത്.

ഒരു പ്രാരംഭ ഗ്രിഡിൽ ഞങ്ങൾ ഞങ്ങളുടെ നോഡുകൾ ക്രമീകരിച്ചിട്ടുണ്ട്, എന്നാൽ ഇപ്പോൾ എങ്ങനെ നീങ്ങണമെന്ന് അവരോട് പറയേണ്ടതുണ്ട്.
ഞങ്ങൾ തിരഞ്ഞെടുക്കുന്നു RandomWalk2dMobilityModel നോഡുകൾ ക്രമരഹിതമായ ദിശയിലേക്ക് നീങ്ങുന്നു
ഒരു ബൗണ്ടിംഗ് ബോക്സിനുള്ളിൽ ക്രമരഹിതമായ വേഗത.

mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
"ബൗണ്ടുകൾ", ദീർഘചതുരം മൂല്യം (ദീർഘചതുരം (-50, 50, -50, 50)));

ഞങ്ങൾ ഇപ്പോൾ പറയുന്നു മൊബിലിറ്റി ഹെൽപ്പർ STA നോഡുകളിൽ മൊബിലിറ്റി മോഡലുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ.

mobility.Install (wifiStaNodes);

സിമുലേഷൻ സമയത്ത് ആക്സസ് പോയിന്റ് ഒരു നിശ്ചിത സ്ഥാനത്ത് തുടരണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഞങ്ങൾ
ഈ നോഡിനായി മൊബിലിറ്റി മോഡൽ സജ്ജീകരിച്ച് ഇത് പൂർത്തിയാക്കുക
ns3::കോൺസ്റ്റന്റ് പൊസിഷൻമൊബിലിറ്റി മോഡൽ:

mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (wifiApNode);

ഇപ്പോൾ ഞങ്ങളുടെ നോഡുകളും ഉപകരണങ്ങളും ചാനലുകളും സൃഷ്‌ടിച്ചിട്ടുണ്ട്, കൂടാതെ ഇതിനായി തിരഞ്ഞെടുത്ത മൊബിലിറ്റി മോഡലുകളും ഉണ്ട്
വൈഫൈ നോഡുകൾ, പക്ഷേ ഞങ്ങൾക്ക് പ്രോട്ടോക്കോൾ സ്റ്റാക്കുകളൊന്നുമില്ല. നമ്മൾ മുമ്പ് പലതും ചെയ്തതുപോലെ
സമയങ്ങളിൽ, ഞങ്ങൾ ഉപയോഗിക്കും InternetStackHelper ഈ സ്റ്റാക്കുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ.

InternetStackHelper സ്റ്റാക്ക്;
stack.Install (csmaNodes);
stack.Install (wifiApNode);
stack.Install (wifiStaNodes);

ലെ പോലെ തന്നെ second.cc ഉദാഹരണ സ്ക്രിപ്റ്റ്, ഞങ്ങൾ ഉപയോഗിക്കാൻ പോകുന്നു Ipv4 വിലാസം സഹായി ലേക്ക്
ഞങ്ങളുടെ ഉപകരണ ഇന്റർഫേസുകളിലേക്ക് IP വിലാസങ്ങൾ നൽകുക. ആദ്യം നമ്മൾ നെറ്റ്‌വർക്ക് 10.1.1.0 സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു
ഞങ്ങളുടെ രണ്ട് പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണങ്ങൾക്ക് ആവശ്യമായ രണ്ട് വിലാസങ്ങൾ. അപ്പോൾ നമ്മൾ നെറ്റ്വർക്ക് 10.1.2.0 ഉപയോഗിക്കുന്നു
CSMA നെറ്റ്‌വർക്കിലേക്ക് വിലാസങ്ങൾ നൽകുന്നതിന് ഞങ്ങൾ നെറ്റ്‌വർക്ക് 10.1.3.0-ൽ നിന്ന് വിലാസങ്ങൾ നൽകുന്നു
STA ഉപകരണങ്ങളിലേക്കും വയർലെസ് നെറ്റ്‌വർക്കിലെ എപിയിലേക്കും.

Ipv4Addressസഹായ വിലാസം;

വിലാസം.സെറ്റ്ബേസ് ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = വിലാസം.അസൈൻ (p2pDevices);

വിലാസം.സെറ്റ്ബേസ് ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = വിലാസം.അസൈൻ (csmaDevices);

വിലാസം.സെറ്റ്ബേസ് ("10.1.3.0", "255.255.255.0");
വിലാസം.അസൈൻ (സ്റ്റെഡിവൈസസ്);
വിലാസം.അസൈൻ (apDevices);

ഞങ്ങൾ എക്കോ സെർവർ "വലതുവശത്തുള്ള" നോഡിൽ ഇട്ടു
ഫയൽ. ഞങ്ങൾ ഇത് മുമ്പ് ചെയ്തിട്ടുണ്ട്.

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (csmaNodes.Get (nCsma));
serverApps.Start (സെക്കൻഡ് (1.0));
serverApps.Stop (സെക്കൻഡ് (10.0));

ഞങ്ങൾ സൃഷ്‌ടിച്ച അവസാന STA നോഡിൽ എക്കോ ക്ലയന്റ് ഇട്ടു, അത് സെർവറിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു
CSMA നെറ്റ്‌വർക്ക്. മുമ്പും സമാനമായ പ്രവർത്തനങ്ങൾ ഞങ്ങൾ കണ്ടിട്ടുണ്ട്.

UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("ഇന്റർവെൽ", ടൈംവാല്യൂ (സെക്കൻഡ് (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps =
echoClient.Install (wifiStaNodes.Get (nWifi - 1));
clientApps.Start (സെക്കൻഡ് (2.0));
clientApps.Stop (സെക്കൻഡ് (10.0));

ഞങ്ങൾ ഇവിടെ ഒരു ഇന്റർനെറ്റ് വർക്ക് നിർമ്മിച്ചിരിക്കുന്നതിനാൽ, ഞങ്ങൾ ഇന്റർനെറ്റ് വർക്ക് റൂട്ടിംഗ് പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ട്
ഞങ്ങൾ ചെയ്തു second.cc ഉദാഹരണ സ്ക്രിപ്റ്റ്.

Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

ചില ഉപയോക്താക്കളെ അത്ഭുതപ്പെടുത്തുന്ന ഒരു കാര്യം ഞങ്ങൾ ഇപ്പോൾ സൃഷ്ടിച്ച സിമുലേഷൻ ആണ്
ഒരിക്കലും "സ്വാഭാവികമായി" നിർത്തുകയില്ല. ഞങ്ങൾ വയർലെസ് ആക്‌സസ് പോയിന്റ് ആവശ്യപ്പെട്ടതിനാലാണിത്
ബീക്കണുകൾ സൃഷ്ടിക്കുക. ഇത് ശാശ്വതമായി ബീക്കണുകൾ സൃഷ്ടിക്കും, ഇത് സിമുലേറ്ററിന് കാരണമാകും
ഇവന്റുകൾ ഭാവിയിലേക്ക് അനിശ്ചിതമായി ഷെഡ്യൂൾ ചെയ്യുന്നു, അതിനാൽ ഞങ്ങൾ സിമുലേറ്ററോട് നിർത്താൻ പറയണം
ബീക്കൺ ജനറേഷൻ ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്തിട്ടുണ്ടെങ്കിലും. കോഡിന്റെ ഇനിപ്പറയുന്ന വരി
സിമുലേറ്ററിനോട് നിർത്താൻ പറയുന്നു, അങ്ങനെ ഞങ്ങൾ ബീക്കണുകൾ എന്നെന്നേക്കുമായി അനുകരിക്കാതിരിക്കുകയും എന്താണെന്ന് നൽകുകയും ചെയ്യുന്നു
അടിസ്ഥാനപരമായി ഒരു അനന്തമായ ലൂപ്പ്.

സിമുലേറ്റർ:: നിർത്തുക (സെക്കൻഡ് (10.0));

മൂന്ന് നെറ്റ്‌വർക്കുകളും ഉൾക്കൊള്ളാൻ ആവശ്യമായ ട്രെയ്‌സിംഗ് ഞങ്ങൾ സൃഷ്‌ടിക്കുന്നു:

pointToPoint.EnablePcapAll ("മൂന്നാം");
phy.EnablePcap ("മൂന്നാം", apDevices.Get (0));
csma.EnablePcap ("മൂന്നാം", csmaDevices.Get (0), true);

ഈ മൂന്ന് വരി കോഡ് പോയിന്റ്-ടു-പോയിന്റ് നോഡുകളിൽ pcap ട്രെയ്‌സിംഗ് ആരംഭിക്കും
ഞങ്ങളുടെ നട്ടെല്ലായി വർത്തിക്കുന്നു, വൈഫൈ നെറ്റ്‌വർക്കിൽ ഒരു പ്രോമിസ്ക്യൂസ് (മോണിറ്റർ) മോഡ് ട്രെയ്സ് ആരംഭിക്കും,
കൂടാതെ CSMA നെറ്റ്‌വർക്കിൽ ഒരു പ്രോമിസ്ക്യൂസ് ട്രെയ്സ് ആരംഭിക്കും. ഇത് നമുക്ക് എല്ലാം കാണാൻ അനുവദിക്കും
ഏറ്റവും കുറഞ്ഞ എണ്ണം ട്രേസ് ഫയലുകളുള്ള ട്രാഫിക്.

അവസാനമായി, ഞങ്ങൾ യഥാർത്ഥത്തിൽ സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുകയും വൃത്തിയാക്കുകയും തുടർന്ന് പ്രോഗ്രാമിൽ നിന്ന് പുറത്തുകടക്കുകയും ചെയ്യുന്നു.

സിമുലേറ്റർ:: റൺ ();
സിമുലേറ്റർ:: നശിപ്പിക്കുക ();
തിരികെ വരുക;
}

ഈ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾ പകർത്തേണ്ടതുണ്ട് മൂന്നാം.സി.സി ഉദാഹരണം സ്ക്രിപ്റ്റ്
ഡയറക്‌ടറി സ്‌ക്രാച്ച് ചെയ്‌ത് നിങ്ങൾ ചെയ്‌തതുപോലെ നിർമ്മിക്കാൻ Waf ഉപയോഗിക്കുക second.cc ഉദാഹരണം. നിങ്ങൾ എങ്കിൽ
നിങ്ങൾ ടൈപ്പ് ചെയ്യുന്ന റിപ്പോസിറ്ററിയുടെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറിയിലാണ്,

$ cp ഉദാഹരണങ്ങൾ/tutorial/third.cc സ്ക്രാച്ച്/mythird.cc
$ ./waf
$ ./waf --റൺ സ്ക്രാച്ച്/മിതേർഡ്

വീണ്ടും, ഞങ്ങൾ UDP എക്കോ ആപ്ലിക്കേഷനുകൾ സജ്ജീകരിച്ചിരിക്കുന്നതിനാൽ second.cc
സ്ക്രിപ്റ്റ്, നിങ്ങൾ സമാനമായ ഔട്ട്പുട്ട് കാണും.

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.407സെ)
സമയത്ത് 2s ക്ലയന്റ് 1024 പോർട്ട് 10.1.2.4 ലേക്ക് 9 ബൈറ്റുകൾ അയച്ചു
2.01796s സെർവറിന് 1024 പോർട്ടിൽ നിന്ന് 10.1.3.3 ബൈറ്റുകൾ ലഭിച്ചു 49153
സമയം 2.01796s സെർവർ 1024 പോർട്ട് 10.1.3.3 ലേക്ക് 49153 ബൈറ്റുകൾ അയച്ചു
സമയത്ത് 2.03364s ക്ലയന്റിന് 1024 പോർട്ട് 10.1.2.4 ൽ നിന്ന് 9 ബൈറ്റുകൾ ലഭിച്ചു

ആദ്യത്തെ സന്ദേശം ഓർക്കുക, അയച്ചു 1024 ബൈറ്റുകൾ ലേക്ക് 10.1.2.4," ആണ് UDP എക്കോ ക്ലയന്റ്
സെർവറിലേക്ക് ഒരു പാക്കറ്റ് അയയ്ക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ക്ലയന്റ് വയർലെസ് നെറ്റ്വർക്കിലാണ്
(10.1.3.0). രണ്ടാമത്തെ സന്ദേശം, "ലഭിച്ചു 1024 ബൈറ്റുകൾ നിന്ന് 10.1.3.3," യുഡിപി പ്രതിധ്വനിയിൽ നിന്നുള്ളതാണ്
സെർവർ, എക്കോ പാക്കറ്റ് ലഭിക്കുമ്പോൾ ജനറേറ്റ് ചെയ്യുന്നു. അവസാന സന്ദേശം, "ലഭിച്ചു 1024
ബൈറ്റുകൾ നിന്ന് 10.1.2.4," എക്കോ ക്ലയന്റിൽ നിന്നുള്ളതാണ്, അതിന്റെ പ്രതിധ്വനി ലഭിച്ചതായി സൂചിപ്പിക്കുന്നു
സെർവറിൽ നിന്ന് തിരികെ.

നിങ്ങൾ ഇപ്പോൾ പോയി ടോപ്പ് ലെവൽ ഡയറക്‌ടറിയിൽ നോക്കിയാൽ, അതിൽ നിന്ന് നാല് ട്രേസ് ഫയലുകൾ നിങ്ങൾ കണ്ടെത്തും
ഈ സിമുലേഷൻ, നോഡ് പൂജ്യത്തിൽ നിന്ന് രണ്ട്, നോഡ് ഒന്നിൽ നിന്ന് രണ്ട്:

third-0-0.pcap third-0-1.pcap third-1-0.pcap third-1-1.pcap

"third-0-0.pcap" എന്ന ഫയൽ നോഡ് സീറോയിലെ പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണവുമായി പൊരുത്തപ്പെടുന്നു --
"നട്ടെല്ലിന്റെ" ഇടതുവശം. "third-1-0.pcap" എന്ന ഫയൽ പോയിന്റ്-ടു-പോയിന്റുമായി യോജിക്കുന്നു
നോഡ് ഒന്നിലെ ഉപകരണം -- "നട്ടെല്ലിന്റെ" വലതുവശം. "third-0-1.pcap" എന്ന ഫയൽ ആയിരിക്കും
വൈഫൈ നെറ്റ്‌വർക്കിൽ നിന്നും "മൂന്നാം-1-1.pcap" എന്ന ഫയലിൽ നിന്നുള്ള പ്രോമിസ്‌ക്യൂസ് (മോണിറ്റർ മോഡ്) ട്രെയ്‌സ്
CSMA നെറ്റ്‌വർക്കിൽ നിന്നുള്ള അശ്ലീല സൂചനയായിരിക്കും. പരിശോധിച്ച് നിങ്ങൾക്ക് ഇത് സ്ഥിരീകരിക്കാമോ
കോഡ്?

എക്കോ ക്ലയന്റ് വൈഫൈ നെറ്റ്‌വർക്കിലായതിനാൽ, നമുക്ക് അവിടെ നിന്ന് ആരംഭിക്കാം. നമുക്ക് ഒന്ന് നോക്കാം
ആ നെറ്റ്‌വർക്കിൽ ഞങ്ങൾ പിടിച്ചെടുക്കുന്ന പ്രോമിസ്‌ക്യൂസ് (മോണിറ്റർ മോഡ്) ട്രെയ്സ്.

$ tcpdump -nn -tt -r മൂന്നാം-0-1.pcap

നിങ്ങൾ മുമ്പ് ഇവിടെ കണ്ടിട്ടില്ലാത്ത ചില വൈഫൈ-രൂപത്തിലുള്ള ഉള്ളടക്കങ്ങൾ നിങ്ങൾ കാണും:

മൂന്നാം-0-1.pcap എന്ന ഫയലിൽ നിന്നുള്ള വായന, ലിങ്ക്-തരം IEEE802_11 (802.11)
0.000025 ബീക്കൺ (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
0.000308 അസോക് അഭ്യർത്ഥന (ns-3-ssid) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit]
0.000324 Acknowledgment RA:00:00:00:00:00:08
0.000402 അസോക് പ്രതികരണം സഹായം(0) :: വിജയിച്ചു
0.000546 Acknowledgment RA:00:00:00:00:00:0a
0.000721 അസോക് അഭ്യർത്ഥന (ns-3-ssid) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit]
0.000737 Acknowledgment RA:00:00:00:00:00:07
0.000824 അസോക് പ്രതികരണം സഹായം(0) :: വിജയിച്ചു
0.000968 Acknowledgment RA:00:00:00:00:00:0a
0.001134 അസോക് അഭ്യർത്ഥന (ns-3-ssid) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit]
0.001150 Acknowledgment RA:00:00:00:00:00:09
0.001273 അസോക് പ്രതികരണം സഹായം(0) :: വിജയിച്ചു
0.001417 Acknowledgment RA:00:00:00:00:00:0a
0.102400 ബീക്കൺ (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
0.204800 ബീക്കൺ (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
0.307200 ബീക്കൺ (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS

നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് പോലെ ലിങ്ക് തരം ഇപ്പോൾ 802.11 ആണെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും. നിങ്ങൾക്ക് ഒരുപക്ഷേ കഴിയും
എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കുക, ഇതിൽ ഐപി എക്കോ അഭ്യർത്ഥനയും പ്രതികരണ പാക്കറ്റുകളും കണ്ടെത്തുക
ട്രെയ്സ്. ട്രെയ്‌സ് ഡംപ് പൂർണ്ണമായും പാഴ്‌സ് ചെയ്യുന്നതിനുള്ള ഒരു വ്യായാമമായി ഞങ്ങൾ ഇത് ഉപേക്ഷിക്കുന്നു.

ഇപ്പോൾ, പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന്റെ വലതുവശത്തുള്ള pcap ഫയൽ നോക്കുക,

$ tcpdump -nn -tt -r മൂന്നാം-0-0.pcap

വീണ്ടും, പരിചിതമായ ചില ഉള്ളടക്കങ്ങൾ നിങ്ങൾ കാണും:

മൂന്നാം-0-0.pcap എന്ന ഫയലിൽ നിന്നുള്ള വായന, ലിങ്ക്-തരം PPP (PPP)
2.008151 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.026758 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, ദൈർഘ്യം 1024

ഇടത്തുനിന്ന് വലത്തോട്ട് (വൈഫൈയിൽ നിന്ന് സിഎസ്എംഎയിലേക്ക്) വീണ്ടും ഉടനീളം പോകുന്ന എക്കോ പാക്കറ്റാണിത്
പോയിന്റ്-ടു-പോയിന്റ് ലിങ്ക്.

ഇപ്പോൾ, പോയിന്റ്-ടു-പോയിന്റ് ലിങ്കിന്റെ വലതുവശത്തുള്ള pcap ഫയൽ നോക്കുക,

$ tcpdump -nn -tt -r മൂന്നാം-1-0.pcap

വീണ്ടും, പരിചിതമായ ചില ഉള്ളടക്കങ്ങൾ നിങ്ങൾ കാണും:

മൂന്നാം-1-0.pcap എന്ന ഫയലിൽ നിന്നുള്ള വായന, ലിങ്ക്-തരം PPP (PPP)
2.011837 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.023072 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, ദൈർഘ്യം 1024

ഇടത്തുനിന്ന് വലത്തോട്ട് (വൈഫൈയിൽ നിന്ന് സിഎസ്എംഎയിലേക്ക്) വീണ്ടും തിരികെ പോകുന്ന എക്കോ പാക്കറ്റും ഇതാണ്
പോയിന്റ് ടു പോയിന്റ് ലിങ്കിൽ ഉടനീളം, നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് പോലെ അല്പം വ്യത്യസ്ത സമയങ്ങൾ.

എക്കോ സെർവർ CSMA നെറ്റ്‌വർക്കിലാണ്, അവിടെയുള്ള അശ്ലീലമായ ട്രെയ്സ് നോക്കാം:

$ tcpdump -nn -tt -r മൂന്നാം-1-1.pcap

പരിചിതമായ ചില ഉള്ളടക്കങ്ങൾ നിങ്ങൾ കാണണം:

മൂന്നാം-1-1.pcap എന്ന ഫയലിൽ നിന്നുള്ള വായന, ലിങ്ക്-തരം EN10MB (ഇഥർനെറ്റ്)
2.017837 ARP, 10.1.2.4 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.1-നോട് പറയുക, ദൈർഘ്യം 50
2.017861 ARP, മറുപടി 10.1.2.4 is- at 00:00:00:00:00:06, ദൈർഘ്യം 50
2.017861 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, ദൈർഘ്യം 1024
2.022966 ARP, 10.1.2.1 ഉള്ളവരോട് അഭ്യർത്ഥിക്കുക (ff:ff:ff:ff:ff:ff) 10.1.2.4-നോട് പറയുക, ദൈർഘ്യം 50
2.022966 ARP, മറുപടി 10.1.2.1 is- at 00:00:00:00:00:03, ദൈർഘ്യം 50
2.023072 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, ദൈർഘ്യം 1024

ഇത് എളുപ്പത്തിൽ മനസ്സിലാക്കണം. നിങ്ങൾ മറന്നെങ്കിൽ, തിരികെ പോയി ചർച്ച നോക്കുക
in second.cc. ഇതും ഇതേ ക്രമമാണ്.

ഇപ്പോൾ, വയർലെസ് നെറ്റ്‌വർക്കിനായി മൊബിലിറ്റി മോഡലുകൾ സജ്ജീകരിക്കാൻ ഞങ്ങൾ ധാരാളം സമയം ചെലവഴിച്ചു
STA നോഡുകൾ യഥാർത്ഥത്തിൽ ചലിക്കുന്നുണ്ടെന്ന് പോലും കാണിക്കാതെ പൂർത്തിയാക്കുന്നത് ലജ്ജാകരമാണ്
സിമുലേഷൻ സമയത്ത് ചുറ്റും. ഇതിലേക്ക് ഹുക്ക് ചെയ്തുകൊണ്ട് നമുക്ക് ഇത് ചെയ്യാം മൊബിലിറ്റി മോഡൽ ഗതി
ട്രേസ് ഉറവിടം മാറ്റുക. ഇത് വിശദമായ ട്രേസിംഗ് വിഭാഗത്തിലേക്കുള്ള ഒരു ഒളിഞ്ഞുനോട്ടം മാത്രമാണ്
വരാനിരിക്കുന്നു, പക്ഷേ ഇത് ഒരു ഉദാഹരണം ലഭിക്കാൻ വളരെ നല്ല സ്ഥലമാണെന്ന് തോന്നുന്നു.

"Tweaking ns-3" വിഭാഗത്തിൽ സൂചിപ്പിച്ചതുപോലെ, the ns-3 ട്രെയ്‌സിംഗ് സിസ്റ്റം ട്രെയ്‌സായി തിരിച്ചിരിക്കുന്നു
ഉറവിടങ്ങളും ട്രെയ്സ് സിങ്കുകളും, ഇവ രണ്ടും ബന്ധിപ്പിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ ഞങ്ങൾ നൽകുന്നു. ഞങ്ങൾ ഉപയോഗിക്കും
ട്രെയ്‌സ് ഇവന്റുകൾ ഉത്ഭവിക്കുന്നതിന് മൊബിലിറ്റി മോഡൽ മുൻ‌നിർവചിച്ച കോഴ്‌സ് ട്രെയ്‌സ് സോഴ്‌സ് മാറ്റുന്നു. ഞങ്ങൾ
ആ ഉറവിടത്തിലേക്ക് കണക്റ്റുചെയ്യുന്നതിന് ഒരു ട്രെയ്സ് സിങ്ക് എഴുതേണ്ടതുണ്ട്, അത് കുറച്ച് മനോഹരം പ്രദർശിപ്പിക്കും
ഞങ്ങൾക്ക് വിവരങ്ങൾ. ബുദ്ധിമുട്ടുള്ളതായി അതിന്റെ പ്രശസ്തി ഉണ്ടായിരുന്നിട്ടും, ഇത് വളരെ ലളിതമാണ്.
യുടെ പ്രധാന പരിപാടിക്ക് തൊട്ടുമുമ്പ് സ്ക്രാച്ച്/mythird.cc സ്ക്രിപ്റ്റ് (അതായത്, അതിന് ശേഷം
NS_LOG_COMPONENT_DEFINE പ്രസ്താവന), ഇനിപ്പറയുന്ന പ്രവർത്തനം ചേർക്കുക:

ശൂന്യം
CourseChange (std::string സന്ദർഭം, Ptr മോഡൽ)
{
വെക്റ്റർ സ്ഥാനം = മോഡൽ->GetPosition ();
NS_LOG_UNCOND (സന്ദർഭം <
" x = " << സ്ഥാനം.x << ", y = " << position.y);
}

ഈ കോഡ് മൊബിലിറ്റി മോഡലിൽ നിന്നും നിരുപാധികമായും സ്ഥാന വിവരങ്ങൾ പിൻവലിക്കുന്നു
നോഡിന്റെ x, y സ്ഥാനം രേഖപ്പെടുത്തുന്നു. ഈ ചടങ്ങ് ഞങ്ങൾ ക്രമീകരിക്കാൻ പോകുന്നു
എക്കോ ക്ലയന്റുള്ള വയർലെസ് നോഡ് അതിന്റെ സ്ഥാനം മാറുമ്പോഴെല്ലാം വിളിക്കുന്നു. ഞങ്ങൾ ഇത് ചെയ്യുന്നു
ഉപയോഗിച്ച് കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക പ്രവർത്തനം. സ്ക്രിപ്റ്റിലേക്ക് കോഡിന്റെ ഇനിപ്പറയുന്ന വരികൾ ചേർക്കുക
അതിനു മുമ്പ് സിമുലേറ്റർ:: റൺ വിളി.

std::ostringstream oss;
oss <
"/NodeList/" << wifiStaNodes.Get (nWifi - 1)->GetId () <
"/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്സ് ചേഞ്ച്";

കോൺഫിഗറേഷൻ::Connect (oss.str (), MakeCallback (&CourseChange));

ഇവന്റിന്റെ ട്രെയ്‌സിംഗ് നെയിംസ്‌പേസ് പാത്ത് അടങ്ങിയ ഒരു സ്‌ട്രിംഗ് സൃഷ്‌ടിക്കുക എന്നതാണ് ഞങ്ങൾ ഇവിടെ ചെയ്യുന്നത്
ഞങ്ങൾ ബന്ധിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നത്. ആദ്യം, ഏത് നോഡാണ് നമ്മൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നതെന്ന് കണ്ടെത്തേണ്ടതുണ്ട്
The GetId നേരത്തെ വിവരിച്ച രീതി. CSMA യുടെ ഡിഫോൾട്ട് നമ്പറിന്റെ കാര്യത്തിൽ ഒപ്പം
വയർലെസ് നോഡുകൾ, ഇത് നോഡ് സെവൻ ആയി മാറുന്നു, കൂടാതെ നെയിംസ്പേസ് പാത്ത് കണ്ടെത്തുന്നു
മൊബിലിറ്റി മോഡൽ ഇതുപോലെ കാണപ്പെടും,

/നോഡ്‌ലിസ്റ്റ്/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം

ട്രെയ്‌സിംഗ് വിഭാഗത്തിലെ ചർച്ചയെ അടിസ്ഥാനമാക്കി, ഈ ട്രെയ്സ് പാത്ത് നിങ്ങൾക്ക് അനുമാനിക്കാം
ആഗോള നോഡ്‌ലിസ്റ്റിലെ ഏഴാമത്തെ നോഡിനെ പരാമർശിക്കുന്നു. an എന്ന് വിളിക്കുന്നത് അത് വ്യക്തമാക്കുന്നു
തരം സമാഹരിച്ച വസ്തു ns3::മൊബിലിറ്റി മോഡൽ. ഡോളർ ചിഹ്നത്തിന്റെ പ്രിഫിക്സ് സൂചിപ്പിക്കുന്നത്
മൊബിലിറ്റി മോഡൽ നോഡ് ഏഴിലേക്ക് സമാഹരിച്ചിരിക്കുന്നു. പാതയുടെ അവസാന ഘടകം അർത്ഥമാക്കുന്നത് നമ്മൾ എന്നാണ്
ആ മോഡലിന്റെ "കോഴ്‌സ് ചേഞ്ച്" ഇവന്റിലേക്ക് ഹുക്ക് ചെയ്യുന്നു.

നോഡ് ഏഴിലെ ട്രെയ്‌സ് സോഴ്‌സുമായി ഞങ്ങളുടെ ട്രെയ്‌സ് സിങ്കുമായി ഞങ്ങൾ ഒരു കണക്ഷൻ ഉണ്ടാക്കുന്നു
കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക ഈ നെയിംസ്പേസ് പാത്ത് കടന്നുപോകുന്നു. ഇത് ചെയ്തുകഴിഞ്ഞാൽ, ഓരോ കോഴ്സും മാറുന്നു
നോഡ് ഏഴിലെ ഇവന്റ് ഞങ്ങളുടെ ട്രേസ് സിങ്കിലേക്ക് ഹുക്ക് ചെയ്യപ്പെടും, അത് പ്രിന്റ് ഔട്ട് ചെയ്യും
പുതിയ സ്ഥാനം.

നിങ്ങൾ ഇപ്പോൾ സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, കോഴ്‌സ് മാറ്റങ്ങൾ സംഭവിക്കുമ്പോൾ പ്രദർശിപ്പിക്കുന്നത് നിങ്ങൾ കാണും.

'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (5.989സെ)
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10, y = 0
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10.3841, y = 0.923277
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10.2049, y = 1.90708
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10.8136, y = 1.11368
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10.8452, y = 2.11318
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10.9797, y = 3.10409
സമയത്ത് 2s ക്ലയന്റ് 1024 പോർട്ട് 10.1.2.4 ലേക്ക് 9 ബൈറ്റുകൾ അയച്ചു
2.01796s സെർവറിന് 1024 പോർട്ടിൽ നിന്ന് 10.1.3.3 ബൈറ്റുകൾ ലഭിച്ചു 49153
സമയം 2.01796s സെർവർ 1024 പോർട്ട് 10.1.3.3 ലേക്ക് 49153 ബൈറ്റുകൾ അയച്ചു
സമയത്ത് 2.03364s ക്ലയന്റിന് 1024 പോർട്ട് 10.1.2.4 ൽ നിന്ന് 9 ബൈറ്റുകൾ ലഭിച്ചു
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 11.3273, y = 4.04175
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 12.013, y = 4.76955
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 12.4317, y = 5.67771
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 11.4607, y = 5.91681
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 12.0155, y = 6.74878
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 13.0076, y = 6.62336
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 12.6285, y = 5.698
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 13.32, y = 4.97559
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 13.1134, y = 3.99715
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 13.8359, y = 4.68851
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 13.5953, y = 3.71789
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 12.7595, y = 4.26688
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 11.7629, y = 4.34913
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 11.2292, y = 5.19485
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 10.2344, y = 5.09394
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 9.3601, y = 4.60846
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 8.40025, y = 4.32795
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 9.14292, y = 4.99761
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 9.08299, y = 5.99581
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 8.26068, y = 5.42677
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 8.35917, y = 6.42191
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 7.66805, y = 7.14466
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 6.71414, y = 6.84456
/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം x = 6.42489, y = 7.80181

ട്രാക്കിംഗ്

പശ്ചാത്തലം
UsingTracingSystem-ൽ സൂചിപ്പിച്ചതുപോലെ, പ്രവർത്തിപ്പിക്കുന്നതിന്റെ മുഴുവൻ പോയിന്റും ns-3 സിമുലേഷൻ ആണ്
പഠനത്തിനായി ഔട്ട്പുട്ട് ഉണ്ടാക്കുക. നിങ്ങൾക്ക് ഔട്ട്പുട്ട് ലഭിക്കുന്നതിന് രണ്ട് അടിസ്ഥാന തന്ത്രങ്ങളുണ്ട് ns-3:
ജനറിക് മുൻകൂട്ടി നിർവചിക്കപ്പെട്ട ബൾക്ക് ഔട്ട്പുട്ട് മെക്കാനിസങ്ങൾ ഉപയോഗിക്കുകയും എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതിന് അവയുടെ ഉള്ളടക്കം പാഴ്‌സ് ചെയ്യുകയും ചെയ്യുന്നു
രസകരമായ വിവരങ്ങൾ; അല്ലെങ്കിൽ എങ്ങനെയെങ്കിലും കൃത്യമായി അറിയിക്കുന്ന ഒരു ഔട്ട്പുട്ട് മെക്കാനിസം വികസിപ്പിക്കുന്നു
(ഒരുപക്ഷേ മാത്രം) ആവശ്യമുള്ള വിവരങ്ങൾ.

മുൻകൂട്ടി നിർവചിക്കപ്പെട്ട ബൾക്ക് ഔട്ട്പുട്ട് മെക്കാനിസങ്ങൾ ഉപയോഗിക്കുന്നത് മാറ്റങ്ങളൊന്നും ആവശ്യമില്ല എന്നതിന്റെ ഗുണമാണ്
ns-3, എന്നാൽ താൽപ്പര്യമുള്ള ഡാറ്റയ്ക്കായി പാഴ്‌സ് ചെയ്യാനും ഫിൽട്ടർ ചെയ്യാനും സ്ക്രിപ്റ്റുകൾ എഴുതേണ്ടി വന്നേക്കാം. പലപ്പോഴും,
PCAP അല്ലെങ്കിൽ NS_LOG സിമുലേഷൻ റൺ സമയത്ത് ഔട്ട്പുട്ട് സന്ദേശങ്ങൾ ശേഖരിക്കുകയും പ്രത്യേകം പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു
ഉപയോഗിക്കുന്ന സ്ക്രിപ്റ്റുകളിലൂടെ grep, sed or ഉണരുക സന്ദേശങ്ങൾ പാഴ്‌സ് ചെയ്യാനും കുറയ്ക്കാനും രൂപാന്തരപ്പെടുത്താനും
കൈകാര്യം ചെയ്യാവുന്ന ഫോമിലേക്ക് ഡാറ്റ. പരിവർത്തനം ചെയ്യാൻ പ്രോഗ്രാമുകൾ എഴുതണം, അതിനാൽ ഇത്
സൗജന്യമായി വരുന്നില്ല. NS_LOG ഔട്ട്പുട്ട് അതിന്റെ ഭാഗമായി കണക്കാക്കില്ല ns-3 API, കൂടാതെ കഴിയും
റിലീസുകൾക്കിടയിൽ മുന്നറിയിപ്പില്ലാതെ മാറ്റുക. ഇതുകൂടാതെ, NS_LOG ൽ മാത്രമേ ഔട്ട്പുട്ട് ലഭ്യമാകൂ
ഡീബഗ് നിർമ്മിക്കുന്നു, അതിനാൽ അതിനെ ആശ്രയിക്കുന്നത് ഒരു പെർഫോമൻസ് പെനാൽറ്റി ചുമത്തുന്നു. തീർച്ചയായും, എങ്കിൽ
മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുള്ള ഔട്ട്‌പുട്ട് മെക്കാനിസങ്ങളിലൊന്നും താൽപ്പര്യമുള്ള വിവരങ്ങൾ നിലവിലില്ല, ഇത്
സമീപനം പരാജയപ്പെടുന്നു.

മുൻകൂട്ടി നിർവചിച്ചിരിക്കുന്ന ബൾക്ക് മെക്കാനിസങ്ങളിലേക്ക് നിങ്ങൾക്ക് കുറച്ച് വിവരങ്ങൾ ചേർക്കണമെങ്കിൽ, ഇതിന് കഴിയും
തീർച്ചയായും ചെയ്യും; നിങ്ങൾ അതിലൊന്ന് ഉപയോഗിക്കുകയാണെങ്കിൽ ns-3 മെക്കാനിസങ്ങൾ, നിങ്ങളുടെ കോഡ് ചേർത്തേക്കാം
ഒരു സംഭാവനയായി.

ns-3 അന്തർലീനമായ ചില പ്രശ്‌നങ്ങൾ ഒഴിവാക്കുന്ന ട്രെയ്‌സിംഗ് എന്ന മറ്റൊരു സംവിധാനം നൽകുന്നു
ബൾക്ക് ഔട്ട്പുട്ട് മെക്കാനിസങ്ങളിൽ. ഇതിന് നിരവധി പ്രധാന ഗുണങ്ങളുണ്ട്. ആദ്യം, നിങ്ങൾക്ക് കഴിയും
നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഇവന്റുകൾ മാത്രം കണ്ടെത്തുന്നതിലൂടെ നിങ്ങൾ മാനേജ് ചെയ്യേണ്ട ഡാറ്റയുടെ അളവ് കുറയ്ക്കുക
(വലിയ സിമുലേഷനുകൾക്കായി, പോസ്റ്റ്-പ്രോസസിംഗിനായി എല്ലാം ഡിസ്കിലേക്ക് വലിച്ചെറിയുന്നത് I/O സൃഷ്ടിക്കും
തടസ്സങ്ങൾ). രണ്ടാമതായി, നിങ്ങൾ ഈ രീതി ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഔട്ട്പുട്ടിന്റെ ഫോർമാറ്റ് നിയന്ത്രിക്കാനാകും
നേരിട്ട് അതിനാൽ നിങ്ങൾ പോസ്റ്റ് പ്രോസസ്സിംഗ് ഘട്ടം ഒഴിവാക്കുക sed, ഉണരുക, മുത്ത് or പൈത്തൺ സ്ക്രിപ്റ്റുകൾ. എങ്കിൽ
നിങ്ങൾ ആഗ്രഹിക്കുന്നു, നിങ്ങളുടെ ഔട്ട്‌പുട്ട് നേരിട്ട് gnuplot-ന് സ്വീകാര്യമായ ഒരു ഫോമിലേക്ക് ഫോർമാറ്റ് ചെയ്യാൻ കഴിയും
ഉദാഹരണം (GnuplotHelper എന്നതും കാണുക). നിങ്ങൾക്ക് കാമ്പിൽ കൊളുത്തുകൾ ചേർക്കാം, അത് പിന്നീട് ആകാം
മറ്റ് ഉപയോക്താക്കൾ ആക്‌സസ് ചെയ്‌തിരിക്കുന്നു, എന്നാൽ ഇത് വ്യക്തമായി ആവശ്യപ്പെടുന്നില്ലെങ്കിൽ ഒരു വിവരവും നൽകില്ല
അങ്ങിനെ ചെയ്യ്. ഈ കാരണങ്ങളാൽ, ഞങ്ങൾ വിശ്വസിക്കുന്നു ns-3 ട്രെയ്‌സിംഗ് സംവിധാനമാണ് ലഭിക്കാനുള്ള ഏറ്റവും നല്ല മാർഗം
ഒരു സിമുലേഷനിൽ നിന്നുള്ള വിവരങ്ങൾ, അതിനാൽ ഏറ്റവും പ്രധാനപ്പെട്ട മെക്കാനിസങ്ങളിൽ ഒന്നാണ്
മനസ്സിലാക്കാൻ ns-3.

മൂര്ച്ചയില്ലാത്ത ഇന്സ്ട്രുമെന്റുകള്
ഒരു പ്രോഗ്രാമിൽ നിന്ന് വിവരങ്ങൾ ലഭിക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്. ഏറ്റവും നേരായ വഴി
സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടിലേക്ക് വിവരങ്ങൾ നേരിട്ട് പ്രിന്റ് ചെയ്യാൻ, ഇനിപ്പറയുന്നത് പോലെ:

#ഉൾപ്പെടുന്നു
...
ശൂന്യം
ചില പ്രവർത്തനം (അസാധു)
{
uint32_t x = SOME_INTERESTING_VALUE;
...
std::cout << "x ന്റെ മൂല്യം " << x << std::endl;
...
}

കാമ്പിന്റെ ആഴങ്ങളിലേക്ക് പോകുന്നതിൽ നിന്ന് നിങ്ങളെ ആരും തടയാൻ പോകുന്നില്ല ns-3 കൂടാതെ പ്രിന്റ് ചേർക്കുന്നു
പ്രസ്താവനകൾ. ഇത് ചെയ്യാൻ വളരെ എളുപ്പമാണ്, എല്ലാത്തിനുമുപരി, നിങ്ങൾക്ക് നിങ്ങളുടെ പൂർണ്ണമായ നിയന്ത്രണമുണ്ട്
സ്വന്തം ns-3 ശാഖ. ഇത് ഒരുപക്ഷേ ദീർഘകാലത്തേക്ക് വളരെ തൃപ്തികരമായി മാറില്ല
കാലാവധി, എങ്കിലും.

നിങ്ങളുടെ പ്രോഗ്രാമുകളിൽ പ്രിന്റ് സ്റ്റേറ്റ്‌മെന്റുകളുടെ എണ്ണം വർദ്ധിക്കുന്നതിനനുസരിച്ച്, കൈകാര്യം ചെയ്യേണ്ട ചുമതല
ധാരാളം ഔട്ട്പുട്ടുകൾ കൂടുതൽ കൂടുതൽ സങ്കീർണ്ണമാകും. ഒടുവിൽ, നിങ്ങൾക്ക് തോന്നിയേക്കാം
ഏത് തരത്തിലുള്ള വിവരങ്ങളാണ് അച്ചടിക്കുന്നത് എന്നത് നിയന്ത്രിക്കേണ്ടതിന്റെ ആവശ്യകത, ഒരുപക്ഷേ ഓണാക്കുന്നതിലൂടെ
പ്രിന്റുകളുടെ ചില വിഭാഗങ്ങൾ ഓഫ് ചെയ്യുക, അല്ലെങ്കിൽ തുക കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്യുക
നിങ്ങൾക്ക് ആവശ്യമുള്ള വിവരങ്ങൾ. നിങ്ങൾ ഈ പാതയിലൂടെ തുടരുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഉണ്ടെന്ന് കണ്ടെത്തിയേക്കാം
വീണ്ടും നടപ്പിലാക്കി NS_LOG മെക്കാനിസം (UsingLogging കാണുക). അതൊഴിവാക്കാൻ, അതിലൊന്ന്
നിങ്ങൾ ആദ്യം പരിഗണിച്ചേക്കാവുന്നത് ഉപയോഗിക്കുന്നതാണ് NS_LOG സ്വയം.

വിവരങ്ങൾ പുറത്തെടുക്കുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഞങ്ങൾ മുകളിൽ സൂചിപ്പിച്ചു ns-3 നിലവിലുള്ളത് പാഴ്‌സ് ചെയ്യുക എന്നതാണ് NS_LOG
രസകരമായ വിവരങ്ങൾക്ക് ഔട്ട്പുട്ട്. ചില വിവരങ്ങൾ നിങ്ങൾ കണ്ടെത്തുകയാണെങ്കിൽ
നിലവിലുള്ള ലോഗ് ഔട്ട്പുട്ടിൽ ആവശ്യം ഇല്ല, നിങ്ങൾക്ക് ഇതിന്റെ കോർ എഡിറ്റ് ചെയ്യാം ns-3 കൂടാതെ ലളിതമായി ചേർക്കുക
ഔട്ട്പുട്ട് സ്ട്രീമിലേക്ക് നിങ്ങളുടെ രസകരമായ വിവരങ്ങൾ. ഇപ്പോൾ, ഇത് തീർച്ചയായും മികച്ചതാണ്
അത് പിന്തുടരുന്നതിനാൽ നിങ്ങളുടെ സ്വന്തം പ്രിന്റ് സ്റ്റേറ്റ്‌മെന്റുകൾ ചേർക്കുന്നു ns-3 കോഡിംഗ് കൺവെൻഷനുകളും സാധ്യമാണ്
നിലവിലുള്ള കാമ്പിലേക്കുള്ള ഒരു പാച്ച് ആയി മറ്റ് ആളുകൾക്ക് ഉപയോഗപ്രദമാകാൻ സാധ്യതയുണ്ട്.

നമുക്ക് ക്രമരഹിതമായ ഒരു ഉദാഹരണം എടുക്കാം. ഇതിലേക്ക് കൂടുതൽ ലോഗിംഗ് ചേർക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ns-3 TCP സോക്കറ്റ്
(tcp-socket-base.cc) നടപ്പിലാക്കുന്നതിൽ നിങ്ങൾക്ക് ഒരു പുതിയ സന്ദേശം ചേർക്കാം. ശ്രദ്ധിക്കുക
അത് TcpSocketBase::ReceivedAck() ACK ഇല്ല എന്നതിന് ലോഗ് സന്ദേശമൊന്നുമില്ല. നിങ്ങൾ
കോഡ് മാറ്റിക്കൊണ്ട് ഒന്ന് ചേർക്കാം. ഒറിജിനൽ ഇതാ:

/** പുതുതായി ലഭിച്ച ACK പ്രോസസ്സ് ചെയ്യുക */
ശൂന്യം
TcpSocketBase::ReceivedAck (Ptr പാക്കറ്റ്, const TcpHeader & tcpHeader)
{
NS_LOG_FUNCTION (ഈ << tcpHeader);

// ACK ലഭിച്ചു. ACK സംഖ്യയെ ഏറ്റവും ഉയർന്ന അൺക് സെക്നോയുമായി താരതമ്യം ചെയ്യുക
എങ്കിൽ (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))
{ // ACK ഫ്ലാഗ് ഇല്ലെങ്കിൽ അവഗണിക്കുക
}
...

No ACK കേസ് ലോഗ് ചെയ്യാൻ, നിങ്ങൾക്ക് പുതിയത് ചേർക്കാവുന്നതാണ് NS_LOG_LOGIC ലെ if പ്രസ്താവന ബോഡി:

/** പുതുതായി ലഭിച്ച ACK പ്രോസസ്സ് ചെയ്യുക */
ശൂന്യം
TcpSocketBase::ReceivedAck (Ptr പാക്കറ്റ്, const TcpHeader & tcpHeader)
{
NS_LOG_FUNCTION (ഈ << tcpHeader);

// ACK ലഭിച്ചു. ACK സംഖ്യയെ ഏറ്റവും ഉയർന്ന അൺക് സെക്നോയുമായി താരതമ്യം ചെയ്യുക
എങ്കിൽ (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))
{ // ACK ഫ്ലാഗ് ഇല്ലെങ്കിൽ അവഗണിക്കുക
NS_LOG_LOGIC ("TcpSocketBase " << ഈ << " ACK ഫ്ലാഗ് ഇല്ല");
}
...

ഒറ്റനോട്ടത്തിൽ ഇത് വളരെ ലളിതവും തൃപ്തികരവുമാണെന്ന് തോന്നിയേക്കാം, എന്നാൽ പരിഗണിക്കേണ്ട ഒന്ന്
ചേർക്കാൻ നിങ്ങൾ കോഡ് എഴുതുമെന്ന് NS_LOG പ്രസ്താവനകൾ കൂടാതെ നിങ്ങൾ എഴുതേണ്ടി വരും
കോഡ് (ഇതുപോലെ grep, sed or ഉണരുക സ്ക്രിപ്റ്റുകൾ) നിങ്ങളുടെ ഒറ്റപ്പെടുത്തുന്നതിന് ലോഗ് ഔട്ട്പുട്ട് പാഴ്സ് ചെയ്യാൻ
വിവരങ്ങൾ. എന്തെന്നാൽ, എന്താണ് ഔട്ട്‌പുട്ട് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് കുറച്ച് നിയന്ത്രണമുണ്ടെങ്കിലും
ലോഗിംഗ് സിസ്റ്റം, നിങ്ങൾക്ക് ലോഗ് ഘടക തലത്തിലേക്ക് മാത്രമേ നിയന്ത്രണമുള്ളൂ, അത് സാധാരണമാണ്
ഒരു മുഴുവൻ സോഴ്സ് കോഡ് ഫയൽ.

നിലവിലുള്ള ഒരു മൊഡ്യൂളിലേക്ക് നിങ്ങൾ കോഡ് ചേർക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഔട്ട്പുട്ടിനൊപ്പം ജീവിക്കേണ്ടിവരും
മറ്റെല്ലാ ഡെവലപ്പർമാരും രസകരമായി കണ്ടെത്തി. ലഭിക്കുന്നതിന് നിങ്ങൾ അത് കണ്ടെത്തിയേക്കാം
നിങ്ങൾക്ക് ആവശ്യമുള്ള ചെറിയ അളവിലുള്ള വിവരങ്ങൾ, നിങ്ങൾക്ക് വലിയ അളവുകളിൽ സഞ്ചരിക്കേണ്ടി വന്നേക്കാം
നിങ്ങൾക്ക് താൽപ്പര്യമില്ലാത്ത ബാഹ്യ സന്ദേശങ്ങൾ. വലിയ ലോഗ് സംരക്ഷിക്കാൻ നിങ്ങൾ നിർബന്ധിതരായേക്കാം
ഫയലുകൾ ഡിസ്കിലേക്ക് പോയി നിങ്ങൾക്ക് എന്തെങ്കിലും ചെയ്യാൻ താൽപ്പര്യപ്പെടുമ്പോഴെല്ലാം അവ കുറച്ച് വരികളായി പ്രോസസ്സ് ചെയ്യുക.

ഗ്യാരണ്ടികളൊന്നും ഇല്ലാത്തതിനാൽ ns-3 സ്ഥിരതയെക്കുറിച്ച് NS_LOG ഔട്ട്പുട്ട്, നിങ്ങൾക്കും ചെയ്യാം
നിങ്ങൾ ആശ്രയിക്കുന്ന ലോഗ് ഔട്ട്പുട്ടിന്റെ ഭാഗങ്ങൾ അപ്രത്യക്ഷമാകുകയോ അവയ്ക്കിടയിൽ മാറുകയോ ചെയ്യുന്നതായി കണ്ടെത്തുക
റിലീസ് ചെയ്യുന്നു. നിങ്ങൾ ഔട്ട്‌പുട്ടിന്റെ ഘടനയെ ആശ്രയിച്ചിരിക്കുന്നുവെങ്കിൽ, മറ്റ് സന്ദേശങ്ങൾ നിങ്ങൾ കണ്ടെത്താനിടയുണ്ട്
നിങ്ങളുടെ പാഴ്‌സിംഗ് കോഡിനെ ബാധിച്ചേക്കാവുന്ന ചേർത്തു അല്ലെങ്കിൽ ഇല്ലാതാക്കി.

ഒടുവിൽ NS_LOG ഡീബഗ് ബിൽഡുകളിൽ മാത്രമേ ഔട്ട്പുട്ട് ലഭ്യമാകൂ, നിങ്ങൾക്ക് ലോഗ് ഔട്ട്പുട്ട് ലഭിക്കില്ല
ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡുകൾ, ഏകദേശം ഇരട്ടി വേഗത്തിൽ പ്രവർത്തിക്കുന്നു. ആശ്രയിക്കുന്നത് NS_LOG ഒരു പ്രകടനം അടിച്ചേൽപ്പിക്കുന്നു
പെനാൽറ്റി.

ഈ കാരണങ്ങളാൽ, ഞങ്ങൾ പ്രിന്റുകൾ പരിഗണിക്കുന്നു std::cout ഒപ്പം NS_LOG സന്ദേശങ്ങൾ വേഗത്തിലാക്കാനും
കൂടുതൽ വിവരങ്ങൾ ലഭിക്കുന്നതിനുള്ള വൃത്തികെട്ട വഴികൾ ns-3, എന്നാൽ ഗുരുതരമായ ജോലിക്ക് അനുയോജ്യമല്ല.

ഒരാളെ എത്തിച്ചേരാൻ അനുവദിക്കുന്ന സ്ഥിരതയുള്ള API-കൾ ഉപയോഗിച്ച് സ്ഥിരതയുള്ള ഒരു സൗകര്യം ഉണ്ടായിരിക്കുന്നത് അഭികാമ്യമാണ്
കോർ സിസ്റ്റം, ആവശ്യമായ വിവരങ്ങൾ മാത്രം നേടുക. ചെയ്യാൻ കഴിയുന്നത് അഭികാമ്യമാണ്
കോർ സിസ്റ്റം മാറ്റാതെയും വീണ്ടും കമ്പൈൽ ചെയ്യാതെയും ഇത്. ഇതിലും നല്ലത് ഒരു ആയിരിക്കും
താൽപ്പര്യമുള്ള ഒരു ഇനം മാറുമ്പോഴോ രസകരമായ ഒരു ഇവന്റിലോ ഉപയോക്തൃ കോഡ് അറിയിക്കുന്ന സിസ്റ്റം
അങ്ങനെ സംഭവിച്ചതിനാൽ ഉപയോക്താവിന് തിരയുന്ന സിസ്റ്റത്തിൽ സജീവമായി കുത്തേണ്ടതില്ല
കാര്യങ്ങൾ.

ദി ns-3 ട്രെയ്‌സിംഗ് സിസ്റ്റം ആ ലൈനുകളിൽ പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നതും നന്നായി സംയോജിപ്പിച്ചതുമാണ്
ആട്രിബ്യൂട്ട് ഒപ്പം കോൺഫിഗറേഷൻ താരതമ്യേന ലളിതമായ ഉപയോഗ സാഹചര്യങ്ങൾ അനുവദിക്കുന്ന ഉപസിസ്റ്റങ്ങൾ.

പൊതു അവലോകനം
ദി ns-3 ട്രെയ്‌സിംഗ് സിസ്റ്റം സ്വതന്ത്ര ട്രേസിംഗ് സ്രോതസ്സുകളുടെ ആശയങ്ങളെ അടിസ്ഥാനമാക്കിയാണ് നിർമ്മിച്ചിരിക്കുന്നത്
സ്രോതസ്സുകളെ സിങ്കുകളിലേക്ക് ബന്ധിപ്പിക്കുന്നതിനുള്ള ഏകീകൃത സംവിധാനത്തിനൊപ്പം സിങ്കുകൾ കണ്ടെത്തുന്നു.

ഒരു സിമുലേഷനിൽ സംഭവിക്കുന്ന സംഭവങ്ങളെ സൂചിപ്പിക്കാനും നൽകാനുമുള്ള എന്റിറ്റികളാണ് ട്രേസ് ഉറവിടങ്ങൾ
രസകരമായ അടിസ്ഥാന ഡാറ്റയിലേക്കുള്ള ആക്സസ്. ഉദാഹരണത്തിന്, ഒരു ട്രെയ്സ് ഉറവിടം എപ്പോൾ സൂചിപ്പിക്കാം
പാക്കറ്റ് ഒരു നെറ്റ് ഉപകരണം വഴി സ്വീകരിക്കുകയും പാക്കറ്റ് ഉള്ളടക്കങ്ങളിലേക്ക് ആക്സസ് നൽകുകയും ചെയ്യുന്നു
താൽപ്പര്യമുള്ള ട്രേസ് സിങ്കുകൾ. രസകരമായ ഒരു അവസ്ഥ എപ്പോഴാണെന്ന് ഒരു ട്രെയ്സ് ഉറവിടം സൂചിപ്പിക്കാം
ഒരു മോഡലിൽ മാറ്റം സംഭവിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു TCP മോഡലിന്റെ കൺജഷൻ വിൻഡോ ഒരു പ്രൈം ആണ്
ഒരു ട്രെയ്സ് ഉറവിടത്തിനായുള്ള സ്ഥാനാർത്ഥി. ഓരോ തവണയും കൺജഷൻ വിൻഡോ കണക്റ്റുചെയ്‌ത ട്രെയ്‌സ് മാറ്റുന്നു
പഴയതും പുതിയതുമായ മൂല്യം ഉപയോഗിച്ച് സിങ്കുകൾ അറിയിക്കുന്നു.

ട്രെയ്സ് ഉറവിടങ്ങൾ സ്വയം ഉപയോഗപ്രദമല്ല; അവ മറ്റ് കോഡുകളുമായി ബന്ധിപ്പിച്ചിരിക്കണം
ഉറവിടം നൽകുന്ന വിവരങ്ങൾ ഉപയോഗിച്ച് യഥാർത്ഥത്തിൽ ഉപയോഗപ്രദമായ എന്തെങ്കിലും ചെയ്യുക. ദി
ട്രെയ്സ് വിവരങ്ങൾ ഉപയോഗിക്കുന്ന എന്റിറ്റികളെ ട്രേസ് സിങ്കുകൾ എന്ന് വിളിക്കുന്നു. ട്രെയ്സ് ഉറവിടങ്ങളാണ്
ഡാറ്റ ജനറേറ്ററുകളും ട്രെയ്സ് സിങ്കുകളും ഉപഭോക്താക്കളാണ്. ഈ വ്യക്തമായ വിഭജനം വലിയതിനെ അനുവദിക്കുന്നു
രചയിതാക്കളെ മാതൃകയാക്കുന്ന സ്ഥലങ്ങളിൽ സിസ്റ്റത്തിന് ചുറ്റും ചിതറിക്കിടക്കുന്ന ട്രെയ്സ് ഉറവിടങ്ങളുടെ എണ്ണം
ഉപയോഗപ്രദമാകുമെന്ന് വിശ്വസിക്കുന്നു. ട്രെയ്‌സ് ഉറവിടങ്ങൾ ചേർക്കുന്നത് വളരെ ചെറിയ എക്‌സിക്യൂഷൻ അവതരിപ്പിക്കുന്നു
ഓവർഹെഡ്.

ഒരു ട്രെയ്‌സ് ഉറവിടം സൃഷ്‌ടിച്ച ട്രെയ്‌സ് ഇവന്റുകളുടെ പൂജ്യമോ അതിലധികമോ ഉപഭോക്താക്കൾ ഉണ്ടാകാം. ഒരാൾക്ക് കഴിയും
ഒരു തരം പോയിന്റ്-ടു-മൾട്ടിപോയിന്റ് ഇൻഫർമേഷൻ ലിങ്ക് എന്ന നിലയിൽ ട്രേസ് ഉറവിടത്തെക്കുറിച്ച് ചിന്തിക്കുക. നിങ്ങളുടെ കോഡ്
ഒരു പ്രത്യേക കോർ കോഡിൽ നിന്ന് ട്രെയ്‌സ് ഇവന്റുകൾക്കായി തിരയുന്നത് സന്തോഷത്തോടെ സഹവസിക്കാനാകും
ഒരേ വിവരങ്ങളിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമായ എന്തെങ്കിലും ചെയ്യുന്ന മറ്റ് കോഡ്.

ഒരു ഉപയോക്താവ് ഈ ഉറവിടങ്ങളിലൊന്നിലേക്ക് ഒരു ട്രെയ്സ് സിങ്ക് കണക്റ്റുചെയ്യുന്നില്ലെങ്കിൽ, ഒന്നും ഔട്ട്പുട്ട് ആകില്ല. ഉപയോഗിച്ച്
ട്രെയ്‌സിംഗ് സിസ്റ്റം, നിങ്ങൾക്കും ഒരേ ട്രെയ്‌സ് സോഴ്‌സുമായി ബന്ധമുള്ള മറ്റ് ആളുകൾക്കും ലഭിക്കുന്നു
കൃത്യമായി അവർ ആഗ്രഹിക്കുന്നതും സിസ്റ്റത്തിൽ നിന്ന് അവർക്ക് ആവശ്യമുള്ളതും മാത്രം. നിങ്ങളാരും അല്ല
സിസ്റ്റം ഔട്ട്‌പുട്ട് ചെയ്യുന്ന വിവരങ്ങൾ മാറ്റുന്നതിലൂടെ മറ്റേതെങ്കിലും ഉപയോക്താവിനെ സ്വാധീനിക്കുന്നു. നിങ്ങൾ എങ്കിൽ
ഒരു ട്രെയ്‌സ് സോഴ്‌സ് ചേർക്കുമ്പോൾ, ഒരു നല്ല ഓപ്പൺ സോഴ്‌സ് പൗരനെന്ന നിലയിൽ നിങ്ങളുടെ ജോലി മറ്റുള്ളവരെ അനുവദിച്ചേക്കാം
ഉപയോക്താക്കൾ പുതിയ യൂട്ടിലിറ്റികൾ നൽകുന്നതിന്, ഒരുപക്ഷേ മൊത്തത്തിൽ വളരെ ഉപയോഗപ്രദമാണ്, ഒന്നും ഉണ്ടാക്കാതെ
എന്നതിലേക്കുള്ള മാറ്റങ്ങൾ ns-3 കോർ.

ലഘുവായ ഉദാഹരണം
നമുക്ക് കുറച്ച് മിനിറ്റുകൾ എടുത്ത് ലളിതമായ ഒരു ട്രെയ്സിംഗ് ഉദാഹരണത്തിലൂടെ നടക്കാം. ഞങ്ങൾക്ക് ആവശ്യം വരാൻ പോകുന്നു
ഉദാഹരണത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ കോൾബാക്കുകളിലെ ഒരു ചെറിയ പശ്ചാത്തലം, അതിനാൽ ഞങ്ങൾ
ഉടനെ ഒരു ചെറിയ വഴിമാറി പോകണം.

കോൾബാക്കുകൾ
കോൾബാക്ക് സിസ്റ്റത്തിന്റെ ലക്ഷ്യം ns-3 ഒരു ഫംഗ്‌ഷൻ കോൾ ചെയ്യാൻ ഒരു കോഡ് അനുവദിക്കുക എന്നതാണ്
(അല്ലെങ്കിൽ C++ ലെ രീതി) പ്രത്യേക ഇന്റർ-മൊഡ്യൂൾ ഡിപൻഡൻസി ഇല്ലാതെ. ഇത് ആത്യന്തികമായി അർത്ഥമാക്കുന്നത്
നിങ്ങൾക്ക് ഒരു തരത്തിലുള്ള പരോക്ഷ നിർദ്ദേശം ആവശ്യമാണ് -- നിങ്ങൾ വിളിക്കുന്ന ഫംഗ്‌ഷന്റെ വിലാസം a ആയി കണക്കാക്കുന്നു
വേരിയബിൾ. ഈ വേരിയബിളിനെ പോയിന്റർ-ടു-ഫംഗ്ഷൻ വേരിയബിൾ എന്ന് വിളിക്കുന്നു. ബന്ധം
ഫംഗ്‌ഷനും പോയിന്റർ-ടു-ഫംഗ്‌ഷനും തമ്മിൽ യഥാർത്ഥത്തിൽ ഒബ്‌ജക്റ്റിന്റേതിൽ നിന്നും വ്യത്യസ്തമല്ല
പോയിന്റർ-ടു-ഒബ്ജക്റ്റ്.

സിയിൽ ഒരു പോയിന്റർ-ടു-ഫംഗ്‌ഷന്റെ കാനോനിക്കൽ ഉദാഹരണം a ആണ്
പോയിന്റർ-ടു-ഫംഗ്ഷൻ-റിട്ടേണിംഗ്-ഇന്റീഗർ (PFI). ഒരു PFI എടുക്കുന്നതിന് int പരാമീറ്റർ, ഇത്
ഇങ്ങനെ പ്രഖ്യാപിക്കാം

int (*pfi)(int arg) = 0;

(എന്നാൽ വായിക്കുക C++-പതിവ് ചോദ്യങ്ങൾ വിഭാഗം 33 ഇതുപോലെ കോഡ് എഴുതുന്നതിന് മുമ്പ്!) ഇതിൽ നിന്ന് നിങ്ങൾക്ക് എന്ത് ലഭിക്കും
ലളിതമായി പേരുള്ള ഒരു വേരിയബിൾ ആണ് pfi അത് 0 എന്ന മൂല്യത്തിലേക്ക് ആരംഭിക്കുന്നു. നിങ്ങൾക്ക് വേണമെങ്കിൽ
അർത്ഥവത്തായ ഒന്നിലേക്ക് ഈ പോയിന്റർ ആരംഭിക്കുക, നിങ്ങൾക്ക് ഒരു ഫംഗ്‌ഷൻ ഉണ്ടായിരിക്കണം
പൊരുത്തപ്പെടുന്ന ഒപ്പ്. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് ഇതുപോലെയുള്ള ഒരു ഫംഗ്ഷൻ നൽകാം:

int MyFunction (int arg) {}

നിങ്ങൾക്ക് ഈ ലക്ഷ്യം ഉണ്ടെങ്കിൽ, നിങ്ങളുടെ ഫംഗ്‌ഷനിലേക്ക് പോയിന്റ് ചെയ്യുന്നതിനായി നിങ്ങൾക്ക് വേരിയബിൾ ആരംഭിക്കാൻ കഴിയും:

pfi = MyFunction;

കോളിന്റെ കൂടുതൽ നിർദ്ദേശിക്കുന്ന ഫോം ഉപയോഗിച്ച് നിങ്ങൾക്ക് MyFunction-നെ പരോക്ഷമായി വിളിക്കാം:

int ഫലം = (*pfi) (1234);

നിങ്ങൾ ഫംഗ്‌ഷൻ പോയിന്റർ ഡിറഫറൻസ് ചെയ്യുന്നതായി തോന്നുന്നതിനാൽ ഇത് നിർദ്ദേശിക്കുന്നു
നിങ്ങൾ ഏതെങ്കിലും പോയിന്റർ ശ്രദ്ധിക്കുന്നത് പോലെ. എന്നിരുന്നാലും, സാധാരണഗതിയിൽ, ആളുകൾ ഇത് പ്രയോജനപ്പെടുത്തുന്നു
എന്താണ് സംഭവിക്കുന്നതെന്ന് കംപൈലറിന് അറിയാമെന്നതും ഒരു ചെറിയ ഫോം ഉപയോഗിക്കുമെന്നതും വസ്തുതയാണ്:

int ഫലം = pfi (1234);

നിങ്ങൾ ഒരു ഫംഗ്‌ഷനെ വിളിക്കുന്നതായി തോന്നുന്നു pfi, എന്നാൽ കംപൈലർ വേണ്ടത്ര സ്മാർട്ടാണ്
വേരിയബിളിലൂടെ വിളിക്കാൻ അറിയാം pfi പരോക്ഷമായി പ്രവർത്തനത്തിലേക്ക് MyFunction.

ആശയപരമായി, ട്രെയ്‌സിംഗ് സിസ്റ്റം ഏതാണ്ട് ഇങ്ങനെയാണ് പ്രവർത്തിക്കുന്നത്. അടിസ്ഥാനപരമായി, ഒരു ട്രെയ്സ്
മുങ്ങുക is ഒരു കോൾബാക്ക്. ട്രെയ്സ് ഇവന്റുകൾ സ്വീകരിക്കാൻ ഒരു ട്രെയ്സ് സിങ്ക് താൽപ്പര്യം പ്രകടിപ്പിക്കുമ്പോൾ, അത്
ട്രെയ്‌സ് ഉറവിടം ആന്തരികമായി കൈവശം വച്ചിരിക്കുന്ന കോൾബാക്കുകളുടെ ഒരു ലിസ്റ്റിലേക്ക് ഒരു കോൾബാക്ക് ആയി സ്വയം ചേർക്കുന്നു.
രസകരമായ ഒരു സംഭവം നടക്കുമ്പോൾ, ട്രെയ്സ് സോഴ്സ് അതിനെ വിളിക്കുന്നു ഓപ്പറേറ്റർ(...) നല്കുന്നു
പൂജ്യം അല്ലെങ്കിൽ കൂടുതൽ ആർഗ്യുമെന്റുകൾ. ദി ഓപ്പറേറ്റർ(...) ഒടുവിൽ സിസ്റ്റത്തിലേക്ക് അലഞ്ഞുതിരിയുന്നു
നിങ്ങൾ ഇപ്പോൾ കണ്ട പരോക്ഷ കോൾ പോലെ ശ്രദ്ധേയമായ എന്തെങ്കിലും ചെയ്യുന്നു, പൂജ്യമോ അതിലധികമോ നൽകുന്നു
പാരാമീറ്ററുകൾ, വിളിക്കുന്നത് പോലെ pfi മുകളിൽ ഒരു പരാമീറ്റർ ടാർഗെറ്റ് ഫംഗ്‌ഷനിലേക്ക് കടന്നു
MyFunction.

ട്രെയ്‌സിംഗ് സിസ്റ്റം ചേർക്കുന്ന പ്രധാന വ്യത്യാസം അവിടെയുള്ള ഓരോ ട്രെയ്സ് ഉറവിടത്തിനും എന്നതാണ്
കോൾബാക്കുകളുടെ ആന്തരിക ലിസ്റ്റ് ആണ്. ഒരു പരോക്ഷ കോൾ ചെയ്യുന്നതിനുപകരം, ഒരു ട്രെയ്സ്
ഉറവിടം ഒന്നിലധികം കോൾബാക്കുകൾ അഭ്യർത്ഥിച്ചേക്കാം. ഒരു ട്രെയ്സ് സിങ്ക് താൽപ്പര്യം പ്രകടിപ്പിക്കുമ്പോൾ
ഒരു ട്രെയ്സ് ഉറവിടത്തിൽ നിന്നുള്ള അറിയിപ്പുകൾ, അത് അടിസ്ഥാനപരമായി അതിന്റെ സ്വന്തം ഫംഗ്ഷൻ ചേർക്കാൻ ക്രമീകരിക്കുന്നു
കോൾബാക്ക് ലിസ്റ്റ്.

ഇത് യഥാർത്ഥത്തിൽ എങ്ങനെ ക്രമീകരിച്ചിരിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങളിൽ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ ns-3, തോന്നുന്നു
എന്നതിന്റെ കോൾബാക്ക് വിഭാഗം സ്വതന്ത്രമായി പരിശോധിക്കാം ns-3 മാനുവൽ.

നടപ്പാത: നാലാമത്തെ.cc
ട്രെയ്‌സിംഗിന്റെ ഏറ്റവും ലളിതമായ ഉദാഹരണം നടപ്പിലാക്കാൻ ഞങ്ങൾ ചില കോഡ് നൽകിയിട്ടുണ്ട്
കൂട്ടിച്ചേർക്കാൻ കഴിയുന്നത്. ട്യൂട്ടോറിയൽ ഡയറക്ടറിയിൽ നിങ്ങൾക്ക് ഈ കോഡ് കണ്ടെത്താം നാലാമത്തെ.cc.
നമുക്ക് അതിലൂടെ നടക്കാം:

/* -*- മോഡ്:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* ഈ പ്രോഗ്രാം ഒരു സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ആണ്; നിങ്ങൾക്ക് ഇത് പുനർവിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കാനും കഴിയും
* ഇത് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ് പതിപ്പ് 2-ന്റെ നിബന്ധനകൾക്ക് കീഴിലാണ്
* സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ പ്രസിദ്ധീകരിച്ചത്;
*
* ഈ പ്രോഗ്രാം ഉപയോഗപ്രദമാകുമെന്ന പ്രതീക്ഷയിലാണ് വിതരണം ചെയ്യുന്നത്,
* എന്നാൽ യാതൊരു വാറന്റിയും ഇല്ലാതെ; യുടെ സൂചിപ്പിച്ച വാറന്റി പോലുമില്ലാതെ
* ഒരു പ്രത്യേക ഉദ്ദേശ്യത്തിനായുള്ള വ്യാപാരം അല്ലെങ്കിൽ ഫിറ്റ്നസ്. കാണുക
* കൂടുതൽ വിവരങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ്.
*
* നിങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസിന്റെ ഒരു പകർപ്പ് ലഭിച്ചിരിക്കണം
* ഈ പ്രോഗ്രാമിനൊപ്പം; ഇല്ലെങ്കിൽ, സ്വതന്ത്ര സോഫ്റ്റ്‌വെയറിലേക്ക് എഴുതുക
* ഫൗണ്ടേഷൻ, Inc., 59 ടെംപിൾ പ്ലേസ്, സ്യൂട്ട് 330, ബോസ്റ്റൺ, MA 02111-1307 USA
*/

#ഉൾപ്പെടുത്തുക "ns3/object.h"
#ഉൾപ്പെടുത്തുക "ns3/uinteger.h"
#ഉൾപ്പെടുത്തുക "ns3/traced-value.h"
#ഉൾപ്പെടുത്തുക "ns3/trace-source-accessor.h"

#ഉൾപ്പെടുന്നു

നെയിംസ്പേസ് ns3 ഉപയോഗിക്കുന്നു;

ഈ കോഡിന്റെ ഭൂരിഭാഗവും നിങ്ങൾക്ക് പരിചിതമായിരിക്കണം. മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ട്രെയ്സ് സിസ്റ്റം
ഒബ്‌ജക്റ്റ്, ആട്രിബ്യൂട്ട് സിസ്റ്റങ്ങൾ വളരെയധികം ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങൾ അവ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്.
മുകളിലുള്ള ആദ്യ രണ്ടെണ്ണം ആ സംവിധാനങ്ങൾക്കുള്ള പ്രഖ്യാപനങ്ങൾ വ്യക്തമായി കൊണ്ടുവരുന്നു. നിങ്ങൾ
എല്ലാം ഒറ്റയടിക്ക് ലഭിക്കാൻ കോർ മൊഡ്യൂൾ ഹെഡർ ഉപയോഗിക്കാം, പക്ഷേ ഞങ്ങൾ ഉൾപ്പെടുന്നു
ഇതെല്ലാം ശരിക്കും എത്ര ലളിതമാണെന്ന് വ്യക്തമാക്കാൻ ഇവിടെ വ്യക്തമായി.

ഫയല്, ട്രേസ്ഡ്-മൂല്യം.എച്ച് ഡാറ്റ കണ്ടെത്തുന്നതിന് ആവശ്യമായ പ്രഖ്യാപനങ്ങൾ കൊണ്ടുവരുന്നു
മൂല്യ അർത്ഥശാസ്ത്രം അനുസരിക്കുന്നു. പൊതുവേ, മൂല്യം അർത്ഥമാക്കുന്നത് നിങ്ങൾക്ക് കടന്നുപോകാൻ കഴിയും എന്നാണ്
ഒബ്‌ജക്‌റ്റിന്റെ വിലാസം കൈമാറുന്നതിനുപകരം, ചുറ്റുമുള്ള വസ്തു. ഇതെല്ലാം ശരിക്കും എന്താണ്
ഒരു TracedValue-ൽ വരുത്തിയ എല്ലാ മാറ്റങ്ങളും നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ കണ്ടെത്താൻ കഴിയും എന്നാണ് അർത്ഥമാക്കുന്നത്
ലളിതമായ വഴി.

ട്രെയ്‌സിംഗ് സിസ്റ്റം ആട്രിബ്യൂട്ടുകളുമായി സംയോജിപ്പിച്ചിരിക്കുന്നതിനാൽ, ആട്രിബ്യൂട്ടുകൾ ഒബ്‌ജക്റ്റുകളുമായി പ്രവർത്തിക്കുന്നു,
ഒരു ഉണ്ടായിരിക്കണം ns-3 വസ്തു ജീവിക്കാനുള്ള ട്രെയ്സ് ഉറവിടത്തിനായി. അടുത്ത കോഡ് സ്നിപ്പറ്റ്
നമുക്ക് പ്രവർത്തിക്കാൻ കഴിയുന്ന ലളിതമായ ഒരു വസ്തുവിനെ പ്രഖ്യാപിക്കുകയും നിർവചിക്കുകയും ചെയ്യുന്നു.

ക്ലാസ് MyObject : പൊതു വസ്തു
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("MyObject")
.SetParent (Object::GetTypeId ())
.AddConstructor ()
.AddTraceSource ("MyInteger",
"ട്രേസ് ചെയ്യാനുള്ള ഒരു പൂർണ്ണസംഖ്യ മൂല്യം.",
MakeTraceSourceAccessor (&MyObject::m_myInt),
"ns3::ട്രേസ്ഡ്::മൂല്യം::Int32Callback")
;
റിട്ടേൺ ടിഡ്;
}

MyObject () {}
ട്രേസ്ഡ് വാല്യൂ m_myInt;
};

ട്രെയ്‌സിംഗുമായി ബന്ധപ്പെട്ട് മുകളിലുള്ള രണ്ട് പ്രധാന കോഡുകളാണ് .AddTraceSource
ഒപ്പം ട്രേസ്ഡ് വാല്യൂ പ്രഖ്യാപനം m_myInt.

ദി .AddTraceSource എന്നതിലേക്ക് ട്രെയ്സ് സോഴ്സിനെ ബന്ധിപ്പിക്കുന്നതിന് ഉപയോഗിക്കുന്ന "ഹുക്കുകൾ" നൽകുന്നു
കോൺഫിഗറേഷൻ സംവിധാനത്തിലൂടെ പുറം ലോകം. ആദ്യത്തെ വാദം ഈ ട്രേസിനുള്ള ഒരു പേരാണ്
ഉറവിടം, അത് കോൺഫിഗറേഷൻ സിസ്റ്റത്തിൽ ദൃശ്യമാക്കുന്നു. രണ്ടാമത്തെ വാദം ഒരു സഹായ സ്ട്രിംഗാണ്.
ഇപ്പോൾ മൂന്നാമത്തെ വാദം നോക്കുക, വാസ്തവത്തിൽ അതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുക വാദം മൂന്നാമത്തെ വാദത്തിൽ:
&MyObject::m_myInt. ഇതാണ് TracedValue ക്ലാസിലേക്ക് ചേർക്കുന്നത്; അത്
എപ്പോഴും ഒരു ക്ലാസ് ഡാറ്റ അംഗം. (അവസാന വാദം a യുടെ പേരാണ് ടൈപ്പ്ഡ് വേണ്ടി
TracedValue തരം, ഒരു സ്ട്രിംഗ് ആയി. ശരിക്കുള്ള ഡോക്യുമെന്റേഷൻ സൃഷ്ടിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു
കോൾബാക്ക് ഫംഗ്‌ഷൻ സിഗ്നേച്ചർ, ഇത് കൂടുതൽ പൊതുവായ തരങ്ങൾക്ക് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്
തിരിച്ചുവിളികൾ.)

ദി Traced Value<> കോൾബാക്ക് പ്രേരിപ്പിക്കുന്ന ഇൻഫ്രാസ്ട്രക്ചർ ഡിക്ലറേഷൻ നൽകുന്നു
പ്രക്രിയ. ഏത് സമയത്തും അടിസ്ഥാന മൂല്യം മാറ്റുമ്പോൾ TracedValue മെക്കാനിസം നൽകും
ആ വേരിയബിളിന്റെ പഴയതും പുതിയതുമായ മൂല്യം, ഈ സാഹചര്യത്തിൽ ഒരു int32_t മൂല്യം. ട്രെയ്സ്
ഈ TracedValue-നുള്ള സിങ്ക് ഫംഗ്‌ഷന് ഒപ്പ് ആവശ്യമാണ്

അസാധുവാണ് (* TracedValueCallback)(const int32_t oldvalue, const int32_t newValue);

ഈ ട്രെയ്സ് സോഴ്സ് ഹുക്ക് ചെയ്യുന്ന എല്ലാ ട്രെയ്സ് സിങ്കുകളിലും ഈ ഒപ്പ് ഉണ്ടായിരിക്കണം. ഞങ്ങൾ താഴെ ചർച്ച ചെയ്യും
മറ്റ് സന്ദർഭങ്ങളിൽ ആവശ്യമായ കോൾബാക്ക് ഒപ്പ് നിങ്ങൾക്ക് എങ്ങനെ നിർണ്ണയിക്കാനാകും.

തീർച്ചയായും, തുടരുന്നു നാലാമത്തെ.cc ഞങ്ങൾ കാണുന്നു:

ശൂന്യം
IntTrace (int32_t പഴയ മൂല്യം, int32_t പുതിയ മൂല്യം)
{
std::cout << "ട്രേസ് ചെയ്തു " << oldvalue << " to " << newValue << std::endl;
}

പൊരുത്തപ്പെടുന്ന ട്രേസ് സിങ്കിന്റെ നിർവചനം ഇതാണ്. ഇത് കോൾബാക്കിനോട് നേരിട്ട് യോജിക്കുന്നു
ഫംഗ്ഷൻ സിഗ്നേച്ചർ. ഇത് കണക്‌റ്റ് ചെയ്‌തുകഴിഞ്ഞാൽ, എപ്പോൾ വേണമെങ്കിലും ഈ ഫംഗ്‌ഷൻ വിളിക്കപ്പെടും
ട്രേസ്ഡ് വാല്യൂ മാറ്റങ്ങൾ.

ട്രെയ്‌സ് സോഴ്‌സും ട്രേസ് സിങ്കും നമ്മൾ ഇപ്പോൾ കണ്ടു. കണക്റ്റുചെയ്യാനുള്ള കോഡാണ് അവശേഷിക്കുന്നത്
സിങ്കിലേക്കുള്ള ഉറവിടം, അത് സംഭവിക്കുന്നത് പ്രധാന:

int
പ്രധാനം (int argc, char *argv[])
{
Ptr myObject = CreateObject ();
myObject->TraceConnectWithoutContext ("MyInteger", MakeCallback(&IntTrace));

myObject->m_myInt = 1234;
}

ട്രെയ്സ് സോഴ്സ് ജീവിക്കുന്ന MyObject ഉദാഹരണം ഇവിടെ ഞങ്ങൾ ആദ്യം സൃഷ്ടിക്കുന്നു.

അടുത്ത ഘട്ടം, ദി TraceConnect WithoutContext, ട്രെയ്സ് തമ്മിലുള്ള ബന്ധം രൂപീകരിക്കുന്നു
ഉറവിടവും ട്രേസ് സിങ്കും. ആദ്യത്തെ വാദം "MyInteger" എന്ന ഉറവിട നാമം മാത്രമാണ്.
ഞങ്ങൾ മുകളിൽ കണ്ടു. ശ്രദ്ധിക്കുക തിരികെ വിളിക്കുക ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ. ഈ പ്രവർത്തനം മാന്ത്രികത ചെയ്യുന്നു
അടിസ്ഥാനം സൃഷ്ടിക്കാൻ ആവശ്യമാണ് ns-3 കോൾബാക്ക് ഒബ്ജക്റ്റ് അതിനെ ഫംഗ്ഷനുമായി ബന്ധപ്പെടുത്തുക
ഇൻട്രേസ്. TraceConnect നിങ്ങൾ നൽകിയ ഫംഗ്‌ഷനും തമ്മിലുള്ള ബന്ധവും ഉണ്ടാക്കുന്നു
ഓവർലോഡ് ചെയ്തു ഓപ്പറേറ്റർ() "MyInteger" ആട്രിബ്യൂട്ട് സൂചിപ്പിക്കുന്ന ട്രേസ്ഡ് വേരിയബിളിൽ.
ഈ ബന്ധം ഉണ്ടാക്കിയ ശേഷം, നിങ്ങൾ നൽകിയ കോൾബാക്ക് ട്രെയ്സ് ഉറവിടം "ഫയർ" ചെയ്യും
പ്രവർത്തനം.

ഇതെല്ലാം സംഭവിക്കാനുള്ള കോഡ് തീർച്ചയായും നിസ്സാരമല്ല, പക്ഷേ സാരം അതാണ്
സമാനമായി തോന്നുന്ന എന്തെങ്കിലും നിങ്ങൾ ക്രമീകരിക്കുകയാണ് pfi() വിളിക്കാൻ മുകളിലുള്ള ഉദാഹരണം
ട്രെയ്സ് ഉറവിടം വഴി. യുടെ പ്രഖ്യാപനം ട്രേസ്ഡ് വാല്യൂ m_myInt; വസ്തുവിൽ
ഓവർലോഡ് ചെയ്ത അസൈൻമെന്റ് ഓപ്പറേറ്റർമാർക്ക് നൽകാൻ ആവശ്യമായ മാജിക് സ്വയം നിർവഹിക്കുന്നു
ഉപയോഗിക്കുക ഓപ്പറേറ്റർ() ആവശ്യമുള്ള പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് യഥാർത്ഥത്തിൽ കോൾബാക്ക് അഭ്യർത്ഥിക്കാൻ. ദി
.AddTraceSource കോൺഫിഗറേഷൻ സിസ്റ്റത്തിലേക്ക് കോൾബാക്ക് ബന്ധിപ്പിക്കുന്നതിനുള്ള മാജിക് ചെയ്യുന്നു, കൂടാതെ
TraceConnect WithoutContext നിങ്ങളുടെ ഫംഗ്‌ഷൻ ട്രെയ്‌സുമായി ബന്ധിപ്പിക്കുന്നതിനുള്ള മാജിക് ചെയ്യുന്നു
ആട്രിബ്യൂട്ട് നാമത്തിൽ വ്യക്തമാക്കിയ ഉറവിടം.

സന്ദർഭത്തെ കുറിച്ചുള്ള കാര്യങ്ങൾ ഇപ്പോൾ അവഗണിക്കാം.

അവസാനമായി, ഒരു മൂല്യം നൽകുന്ന ലൈൻ m_myInt:

myObject->m_myInt = 1234;

യുടെ ആഹ്വാനമായി വ്യാഖ്യാനിക്കണം ഓപ്പറേറ്റർ= അംഗ വേരിയബിളിൽ m_myInt കൂടെ
പൂർണ്ണസംഖ്യ 1234 ഒരു പരാമീറ്ററായി പാസ്സാക്കി.

മുതലുള്ള m_myInt ഒരു ആണ് ട്രേസ്ഡ് വാല്യൂ, ഈ ഓപ്പറേറ്റർ ഒരു കോൾബാക്ക് എക്സിക്യൂട്ട് ചെയ്യാൻ നിർവ്വചിച്ചിരിക്കുന്നു
അസാധുവായി നൽകുകയും രണ്ട് പൂർണ്ണസംഖ്യ മൂല്യങ്ങൾ പാരാമീറ്ററുകളായി എടുക്കുകയും ചെയ്യുന്നു - ഒരു പഴയ മൂല്യവും പുതിയ മൂല്യവും
ചോദ്യം ചെയ്യപ്പെടുന്ന പൂർണ്ണസംഖ്യയ്ക്ക്. അതാണ് കോൾബാക്കിനുള്ള ഫംഗ്‌ഷൻ സിഗ്‌നേച്ചർ
ഞങ്ങൾ നൽകിയ പ്രവർത്തനം --- ഇൻട്രേസ്.

ചുരുക്കത്തിൽ, ഒരു ട്രെയ്സ് ഉറവിടം, സാരാംശത്തിൽ, കോൾബാക്കുകളുടെ ഒരു ലിസ്റ്റ് കൈവശമുള്ള ഒരു വേരിയബിളാണ്. എ
ഒരു കോൾബാക്കിന്റെ ലക്ഷ്യമായി ഉപയോഗിക്കുന്ന ഒരു ഫംഗ്‌ഷനാണ് ട്രെയ്സ് സിങ്ക്. ആട്രിബ്യൂട്ടും ഒബ്ജക്റ്റ് തരവും
സിങ്കുകൾ കണ്ടെത്തുന്നതിന് ട്രെയ്സ് ഉറവിടങ്ങളെ ബന്ധിപ്പിക്കുന്നതിനുള്ള ഒരു മാർഗം നൽകാൻ വിവര സംവിധാനങ്ങൾ ഉപയോഗിക്കുന്നു.
ഒരു ട്രേസ് സോഴ്‌സ് "അടിക്കുക" എന്ന പ്രവർത്തനം ട്രേസ് ഉറവിടത്തിൽ ഒരു ഓപ്പറേറ്ററെ നിർവ്വഹിക്കുന്നു
വിളി കോളുകൾ. ഇതിൽ താൽപ്പര്യം രജിസ്റ്റർ ചെയ്യുന്ന ട്രെയ്‌സ് സിങ്ക് കോൾബാക്കുകൾക്ക് ഇത് കാരണമാകുന്നു
ഉറവിടം നൽകുന്ന പരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഉറവിടം വിളിക്കുന്നു.

നിങ്ങൾ ഇപ്പോൾ ഈ ഉദാഹരണം നിർമ്മിച്ച് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ,

$ ./waf --റൺ നാലാമത്

എന്നതിൽ നിന്നുള്ള ഔട്ട്പുട്ട് നിങ്ങൾ കാണും ഇൻട്രേസ് ട്രെയ്സ് സോഴ്സ് ആയ ഉടൻ തന്നെ ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുക
ഹിറ്റ്:

0 മുതൽ 1234 വരെ കണ്ടെത്തി

ഞങ്ങൾ കോഡ് എക്സിക്യൂട്ട് ചെയ്തപ്പോൾ, myObject->m_myInt = 1234;, ട്രെയ്സ് ഉറവിടം വെടിവച്ചു ഒപ്പം
ട്രേസ് സിങ്കിന് മുമ്പും ശേഷവുമുള്ള മൂല്യങ്ങൾ സ്വയമേവ നൽകി. ചടങ്ങ്
ഇൻട്രേസ് തുടർന്ന് ഇത് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് പ്രിന്റ് ചെയ്തു.

ബന്ധിപ്പിക്കുക കൂടെ കോൺഫിഗറേഷൻ
ദി TraceConnect WithoutContext ലളിതമായ ഉദാഹരണത്തിൽ മുകളിൽ കാണിച്ചിരിക്കുന്ന കോൾ യഥാർത്ഥത്തിൽ വളരെ ആണ്
സിസ്റ്റത്തിൽ അപൂർവ്വമായി ഉപയോഗിക്കുന്നു. കൂടുതൽ സാധാരണമായി, ദി കോൺഫിഗറേഷൻ ഒരു ട്രെയ്സ് തിരഞ്ഞെടുക്കാൻ സബ്സിസ്റ്റം ഉപയോഗിക്കുന്നു
എ എന്ന് വിളിക്കപ്പെടുന്നവ ഉപയോഗിച്ച് സിസ്റ്റത്തിലെ ഉറവിടം കോൺഫിഗറേഷൻ പാത. ഇതിന്റെ ഒരു ഉദാഹരണം ഞങ്ങൾ ഇതിൽ കണ്ടു
ഞങ്ങൾ പരീക്ഷണം നടത്തുമ്പോൾ "കോഴ്‌സ് ചേഞ്ച്" ഇവന്റ് ഹുക്ക് ചെയ്ത മുൻ വിഭാഗം
മൂന്നാം.സി.സി.

മൊബിലിറ്റിയിൽ നിന്ന് കോഴ്‌സ് മാറ്റ വിവരങ്ങൾ പ്രിന്റ് ചെയ്യാൻ ഞങ്ങൾ ഒരു ട്രെയ്സ് സിങ്ക് നിർവചിച്ചതായി ഓർക്കുക
ഞങ്ങളുടെ സിമുലേഷന്റെ മാതൃകകൾ. ഈ പ്രവർത്തനം എന്താണെന്ന് ഇപ്പോൾ നിങ്ങൾക്ക് കൂടുതൽ വ്യക്തമായിരിക്കണം
ചെയ്യുന്നത്:

ശൂന്യം
CourseChange (std::string സന്ദർഭം, Ptr മോഡൽ)
{
വെക്റ്റർ സ്ഥാനം = മോഡൽ->GetPosition ();
NS_LOG_UNCOND (സന്ദർഭം <
" x = " << സ്ഥാനം.x << ", y = " << position.y);
}

മുകളിലെ ട്രെയ്‌സ് സിങ്കിലേക്ക് "കോഴ്‌സ് ചേഞ്ച്" ട്രെയ്‌സ് സോഴ്‌സ് കണക്റ്റുചെയ്‌തപ്പോൾ, ഞങ്ങൾ എ ഉപയോഗിച്ചു
മുൻകൂട്ടി നിർവചിച്ചവയ്‌ക്കിടയിൽ ഞങ്ങൾ ഒരു കണക്ഷൻ ക്രമീകരിക്കുമ്പോൾ ഉറവിടം വ്യക്തമാക്കുന്നതിനുള്ള പാത്ത് കോൺഫിഗർ ചെയ്യുക
ട്രെയ്സ് ഉറവിടവും പുതിയ ട്രെയ്സ് സിങ്കും:

std::ostringstream oss;
oss << "/NodeList/"
<< wifiStaNodes.Get (nWifi - 1)->GetId ()
<< "/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്സ് ചേഞ്ച്";

കോൺഫിഗറേഷൻ::Connect (oss.str (), MakeCallback (&CourseChange));

ചിലപ്പോഴൊക്കെ താരതമ്യേന നിഗൂഢമായ കോഡായി കണക്കാക്കുന്നത് എന്താണെന്ന് മനസിലാക്കാൻ ശ്രമിക്കാം.
ചർച്ചയുടെ ഉദ്ദേശ്യങ്ങൾക്കായി, നോഡ് നമ്പർ നൽകിയെന്ന് കരുതുക GetId() is
"7". ഈ സാഹചര്യത്തിൽ, മുകളിലുള്ള പാത മാറുന്നു

"/നോഡ്‌ലിസ്റ്റ്/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം"

ഒരു കോൺഫിഗറേഷൻ പാതയുടെ അവസാന ഭാഗം ഒരു ആയിരിക്കണം ഗുണങ്ങളെ ഒരു വസ്തു. വാസ്തവത്തിൽ, നിങ്ങൾക്ക് ഉണ്ടായിരുന്നെങ്കിൽ
ഒരു പോയിന്റർ വസ്തു അതിന് "കോഴ്‌സ് മാറ്റം" ഉണ്ട് ഗുണങ്ങളെ ഹാൻഡി, നിങ്ങൾക്ക് ഇത് എഴുതാം
മുമ്പത്തെ ഉദാഹരണത്തിൽ ഞങ്ങൾ ചെയ്തതുപോലെ. ഞങ്ങൾ സാധാരണയായി സംഭരിക്കുന്നുണ്ടെന്ന് ഇപ്പോൾ നിങ്ങൾക്കറിയാം
നമ്മുടെ സൂചനകൾ നോഡുകൾ ഒരു നോഡ് കണ്ടെയ്നറിൽ. ൽ മൂന്നാം.സി.സി ഉദാഹരണത്തിന്, താൽപ്പര്യമുള്ള നോഡുകൾ
ൽ സംഭരിച്ചിരിക്കുന്നു wifiStaNodes നോഡ് കണ്ടെയ്നർ. വാസ്തവത്തിൽ, പാത ഒരുമിച്ച് ചേർക്കുമ്പോൾ,
ഒരു ലഭിക്കാൻ ഞങ്ങൾ ഈ കണ്ടെയ്നർ ഉപയോഗിച്ചു Ptr ഞങ്ങൾ വിളിച്ചിരുന്നത് GetId(). നമുക്ക് കഴിയുമായിരുന്നു
ഇത് ഉപയോഗിച്ചു Ptr ഒരു കണക്റ്റ് രീതി നേരിട്ട് വിളിക്കാൻ:

Ptr theObject = wifiStaNodes.Get (nWifi - 1);
TheObject->TraceConnect WithoutContext ("CourseChange", MakeCallback (&CourseChange));

ൽ മൂന്നാം.സി.സി ഉദാഹരണത്തിന്, ഒരു അധിക "സന്ദർഭം" നൽകണമെന്ന് ഞങ്ങൾ ആഗ്രഹിച്ചു
കോൾബാക്ക് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് (അത് ചുവടെ വിശദീകരിക്കും) അതിനാൽ നമുക്ക് യഥാർത്ഥത്തിൽ ഉപയോഗിക്കാനാകും
ഇനിപ്പറയുന്ന തത്തുല്യ കോഡ്:

Ptr theObject = wifiStaNodes.Get (nWifi - 1);
TheObject->TraceConnect ("CourseChange", MakeCallback (&CourseChange));

അതിനുള്ള ആന്തരിക കോഡ് ആണെന്ന് ഇത് മാറുന്നു കോൺഫിഗറേഷൻ::കണക്ട് വിതൗട്ട് കോൺടെക്സ്റ്റ് ഒപ്പം കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക
യഥാർത്ഥത്തിൽ ഒരു കണ്ടെത്തുക Ptr ഉചിതമായവരെ വിളിക്കുകയും ചെയ്യുക TraceConnect ഏറ്റവും കുറഞ്ഞ രീതി
നില.

ദി കോൺഫിഗറേഷൻ പ്രവർത്തനങ്ങൾ ഒരു ശൃംഖലയെ പ്രതിനിധീകരിക്കുന്ന ഒരു പാത സ്വീകരിക്കുന്നു വസ്തു സൂചനകൾ. ഓരോ വിഭാഗവും
ഒരു പാതയുടെ ഒരു ഒബ്ജക്റ്റ് ആട്രിബ്യൂട്ടിനോട് യോജിക്കുന്നു. എന്നതിന്റെ ആട്രിബ്യൂട്ട് ആണ് അവസാന ഭാഗം
താൽപ്പര്യം, കൂടാതെ ഒബ്‌ജക്റ്റുകൾ ഉൾക്കൊള്ളുന്നതിനോ കണ്ടെത്തുന്നതിനോ മുൻ സെഗ്‌മെന്റുകൾ ടൈപ്പ് ചെയ്യണം. ദി കോൺഫിഗറേഷൻ കോഡ്
പാതയുടെ അവസാന സെഗ്‌മെന്റിൽ എത്തുന്നതുവരെ ഈ പാത പാഴ്‌സ് ചെയ്യുകയും "നടക്കുകയും" ചെയ്യുന്നു. അത് അപ്പോൾ
അവസാന സെഗ്‌മെന്റിനെ ഒരു ആയി വ്യാഖ്യാനിക്കുന്നു ഗുണങ്ങളെ നടക്കുമ്പോൾ കണ്ടെത്തിയ അവസാന വസ്തുവിൽ
പാത. ദി കോൺഫിഗറേഷൻ ഫംഗ്ഷനുകൾ തുടർന്ന് ഉചിതമായത് വിളിക്കുക TraceConnect or
TraceConnect WithoutContext അന്തിമ വസ്തുവിലെ രീതി. കുറച്ച് കഴിഞ്ഞ് എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം
മുകളിലുള്ള വഴി നടക്കുമ്പോൾ കൂടുതൽ വിശദമായി.

പാതയിലെ പ്രധാന "/" പ്രതീകം നെയിംസ്പേസ് എന്ന് വിളിക്കപ്പെടുന്നതിനെ സൂചിപ്പിക്കുന്നു. അതിലൊന്ന്
കോൺഫിഗറേഷൻ സിസ്റ്റത്തിലെ മുൻനിർവചിക്കപ്പെട്ട നെയിംസ്‌പേസുകൾ "നോഡ്‌ലിസ്റ്റ്" ആണ്, ഇത് എല്ലാവരുടേയും പട്ടികയാണ്.
സിമുലേഷനിലെ നോഡുകൾ. ലിസ്റ്റിലെ ഇനങ്ങൾ സൂചികകളാൽ സൂചിപ്പിക്കപ്പെടുന്നു, അതിനാൽ
"/NodeList/7" എന്നത് സിമുലേഷൻ സമയത്ത് സൃഷ്ടിച്ച നോഡുകളുടെ പട്ടികയിലെ എട്ടാമത്തെ നോഡാണ്.
(വീണ്ടെടുക്കൽ സൂചികകൾ ആരംഭിക്കുന്നത് 0'). ഈ സൂചന is യഥാർത്ഥത്തിൽ a ``Ptr ` അതുപോലെ എ
ഒരു ഉപവിഭാഗം ns3::ഒബ്ജക്റ്റ്.

യുടെ ഒബ്ജക്റ്റ് മോഡൽ വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ ns-3 മാനുവൽ, ഞങ്ങൾ വ്യാപകമായി ഉപയോഗിക്കുന്നു
ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ. വ്യത്യസ്ത വസ്തുക്കൾക്കിടയിൽ ഒരു ബന്ധം സ്ഥാപിക്കാൻ ഇത് നമ്മെ അനുവദിക്കുന്നു
സങ്കീർണ്ണമായ ഒരു പൈതൃകവൃക്ഷം നിർമ്മിക്കാതെ അല്ലെങ്കിൽ ഏതൊക്കെ വസ്തുക്കൾ ഭാഗമാകുമെന്ന് മുൻകൂട്ടി നിശ്ചയിക്കാതെ
ഒരു നോഡിന്റെ. ഒരു അഗ്രിഗേഷനിലെ ഓരോ വസ്തുവും മറ്റ് ഒബ്ജക്റ്റുകളിൽ നിന്ന് എത്തിച്ചേരാം.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, അടുത്ത പാത്ത് സെഗ്‌മെന്റ് "$" എന്ന അക്ഷരത്തിൽ ആരംഭിക്കുന്നു. ഈ
സെഗ്‌മെന്റ് ഒരു ഒബ്‌ജക്റ്റ് തരത്തിന്റെ പേരാണെന്ന് കോൺഫിഗറേഷൻ സിസ്റ്റത്തിലേക്ക് സൂചിപ്പിക്കുന്നു, അതിനാൽ a
GetObject ആ തരം നോക്കി വിളിക്കണം. അത് മാറുന്നു മൊബിലിറ്റി ഹെൽപ്പർ
ഉപയോഗിച്ചു മൂന്നാം.സി.സി ഓരോന്നിനും മൊബിലിറ്റി മോഡൽ സംയോജിപ്പിക്കാൻ അല്ലെങ്കിൽ അസോസിയേറ്റ് ചെയ്യാൻ ക്രമീകരിക്കുന്നു
വയർലെസ് നോഡുകൾ. നിങ്ങൾ "$" ചേർക്കുമ്പോൾ, ഉള്ള മറ്റൊരു ഒബ്‌ജക്റ്റാണ് നിങ്ങൾ ആവശ്യപ്പെടുന്നത്
അനുമാനിക്കുന്നത് മുമ്പ് സമാഹരിച്ചതാണ്. ഇതിൽ നിന്ന് പോയിന്ററുകൾ മാറുന്നതായി നിങ്ങൾക്ക് കരുതാം
യഥാർത്ഥ Ptr അതിന്റെ അനുബന്ധ മൊബിലിറ്റി മോഡലിലേക്ക് "/NodeList/7" വ്യക്തമാക്കിയത് പോലെ ---
ഏത് തരത്തിലുള്ളതാണ് ns3::മൊബിലിറ്റി മോഡൽ. നിങ്ങൾക്ക് പരിചയമുണ്ടെങ്കിൽ GetObject, ഞങ്ങൾ ചോദിച്ചിട്ടുണ്ട്
ഇനിപ്പറയുന്നവ ചെയ്യാനുള്ള സിസ്റ്റം:

Ptr mobilityModel = node->GetObject ()

ഞങ്ങൾ ഇപ്പോൾ പാതയിലെ അവസാന ഒബ്ജക്റ്റിലാണ്, അതിനാൽ ഞങ്ങൾ ആട്രിബ്യൂട്ടുകളിലേക്ക് ശ്രദ്ധ തിരിക്കുന്നു
ആ വസ്തു. ദി മൊബിലിറ്റി മോഡൽ ക്ലാസ് "കോഴ്‌സ് ചേഞ്ച്" എന്ന ആട്രിബ്യൂട്ട് നിർവചിക്കുന്നു. നിങ്ങൾക്ക് കഴിയും
സോഴ്സ് കോഡ് നോക്കി ഇത് കാണുക src/mobility/model/mobility-model.cc ഒപ്പം
നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ "CourseChange" തിരയുന്നു. നിങ്ങൾ കണ്ടെത്തണം

.AddTraceSource ("CourseChange",
"സ്ഥാനത്തിന്റെയും/അല്ലെങ്കിൽ വേഗത വെക്‌ടറിന്റെയും മൂല്യം മാറി",
MakeTraceSourceAccessor (&MobilityModel::m_courseChangeTrace),
"ns3::മൊബിലിറ്റി മോഡൽ::കോഴ്‌സ് മാറ്റുക കോൾബാക്ക്")

ഈ അവസരത്തിൽ വളരെ പരിചിതമായി കാണണം.

അണ്ടർലൈയിംഗ് ട്രേസ്ഡ് വേരിയബിളിന്റെ അനുബന്ധ പ്രഖ്യാപനത്തിനായി നിങ്ങൾ നോക്കുകയാണെങ്കിൽ
mobility-model.h നിങ്ങൾ കണ്ടെത്തും

TracedCallback > m_courseChangeTrace;

തരം പ്രഖ്യാപനം TracedCallback തിരിച്ചറിയുന്നു m_courseChangeTrace ഒരു പ്രത്യേക പട്ടികയായി
മുകളിൽ വിവരിച്ച കോൺഫിഗറേഷൻ ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് ഹുക്ക് ചെയ്യാവുന്ന കോൾബാക്കുകൾ. ദി ടൈപ്പ്ഡ് വേണ്ടി
കോൾബാക്ക് ഫംഗ്ഷൻ സിഗ്നേച്ചറും ഹെഡർ ഫയലിൽ നിർവചിച്ചിരിക്കുന്നു:

ടൈപ്പ്ഡെഫ് അസാധുവാണ് (* കോഴ്‌സ് മാറ്റുക കോൾബാക്ക്)(പിടിആർ * മോഡൽ);

ദി മൊബിലിറ്റി മോഡൽ ഒരു പൊതു ഇന്റർഫേസ് നൽകുന്ന ഒരു അടിസ്ഥാന ക്ലാസായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു
എല്ലാ പ്രത്യേക ഉപവിഭാഗങ്ങളും. ഫയലിന്റെ അവസാനം വരെ തിരഞ്ഞാൽ എ
എന്ന് നിർവചിച്ചിരിക്കുന്ന രീതി NotifyCourseChange():

ശൂന്യം
മൊബിലിറ്റി മോഡൽ::NotifyCourseChange (അസാധു) const
{
m_courseChangeTrace(ഇത്);
}

ഒരു കോഴ്‌സ് പിന്തുണയ്‌ക്കായി മാറ്റുമ്പോഴെല്ലാം ഡെറൈവ്ഡ് ക്ലാസുകൾ ഈ രീതിയിലേക്ക് വിളിക്കും
കണ്ടെത്തൽ. ഈ രീതി ആവശ്യപ്പെടുന്നു ഓപ്പറേറ്റർ() അടിവസ്ത്രത്തിൽ m_courseChangeTraceഏത്
അതാകട്ടെ, രജിസ്റ്റർ ചെയ്ത എല്ലാ കോൾബാക്കുകളും അഭ്യർത്ഥിക്കുകയും എല്ലാ ട്രെയ്സ് സിങ്കുകളെയും വിളിക്കുകയും ചെയ്യും
ഒരു കോൺഫിഗറേഷൻ ഫംഗ്‌ഷൻ വിളിച്ച് ട്രേസ് ഉറവിടത്തിൽ താൽപ്പര്യം രേഖപ്പെടുത്തി.

അതിനാൽ, ൽ മൂന്നാം.സി.സി ഒരു കോഴ്‌സ് മാറ്റം വരുത്തുമ്പോഴെല്ലാം ഞങ്ങൾ നോക്കിയ ഉദാഹരണം
RandomWalk2dMobilityModel ഇൻസ്റ്റോൾ ചെയ്ത സന്ദർഭങ്ങൾ, ഒരു ഉണ്ടാകും NotifyCourseChange() വിളി
അതിലേക്ക് വിളിക്കുന്നു മൊബിലിറ്റി മോഡൽ അടിസ്ഥാന ക്ലാസ്. മുകളിൽ കാണുന്നത് പോലെ, ഇത് വിളിക്കുന്നു ഓപ്പറേറ്റർ()
on m_courseChangeTrace, അതാകട്ടെ, രജിസ്റ്റർ ചെയ്ത ഏതെങ്കിലും ട്രേസ് സിങ്കുകളെ വിളിക്കുന്നു. ഉദാഹരണത്തിൽ,
കോൺഫിഗറേഷൻ പാത്ത് നൽകുന്ന കോഡ് മാത്രമാണ് താൽപ്പര്യം രജിസ്റ്റർ ചെയ്യുന്ന ഏക കോഡ്.
അതുകൊണ്ടു, അങ്ങനെ കോഴ്സ് മാറ്റം നോഡ് നമ്പർ ഏഴിൽ നിന്ന് ഹുക്ക് ചെയ്ത പ്രവർത്തനം ആയിരിക്കും
കോൾബാക്ക് മാത്രമാണ് വിളിച്ചത്.

പസിലിന്റെ അവസാനഭാഗം "സന്ദർഭം" ആണ്. ഒരു ഔട്ട്‌പുട്ട് നോക്കുന്നത് ഞങ്ങൾ കണ്ടുവെന്ന് ഓർക്കുക
ഇനിപ്പറയുന്നത് പോലെ ഒന്ന് മൂന്നാം.സി.സി:

/NodeList/7/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്സ് ചേഞ്ച് x = 7.27897, y =
2.22677

ഔട്ട്പുട്ടിന്റെ ആദ്യഭാഗം സന്ദർഭമാണ്. ഇത് കേവലം വഴിയാണ്
കോൺഫിഗറേഷൻ കോഡ് ട്രേസ് ഉറവിടം കണ്ടെത്തി. നമ്മൾ നോക്കിക്കൊണ്ടിരുന്ന സാഹചര്യത്തിൽ ഉണ്ടാകാം
സിസ്റ്റത്തിലെ ഏത് നോഡുകളുമായും പൊരുത്തപ്പെടുന്ന ഏതെങ്കിലും ട്രേസ് ഉറവിടങ്ങൾ
മൊബിലിറ്റി മോഡലുകൾ. യഥാർത്ഥത്തിൽ ഏത് ട്രെയ്സ് സ്രോതസ്സാണ് എന്ന് തിരിച്ചറിയാൻ ചില വഴികൾ ആവശ്യമാണ്
കോൾബാക്ക് വെടിവെച്ചത്. ബന്ധപ്പെടുക എന്നതാണ് എളുപ്പവഴി കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക, പകരം
of കോൺഫിഗറേഷൻ::കണക്ട് വിതൗട്ട് കോൺടെക്സ്റ്റ്.

കണ്ടെത്തുന്നു ഉറവിടങ്ങൾ
ട്രെയ്‌സിംഗ് സിസ്റ്റത്തിന്റെ പുതിയ ഉപയോക്താക്കൾക്ക് അനിവാര്യമായും ഉയർന്നുവരുന്ന ആദ്യത്തെ ചോദ്യം ഇതാണ്, "ശരി,
I അറിയുക ആ അവിടെ ആവശമാകുന്നു be പിന്തുടരുക ഉറവിടങ്ങൾ in The സിമുലേഷൻ കാമ്പ്, പക്ഷേ എങ്ങനെ do I കണ്ടെത്തുക പുറത്ത് എന്ത്
പിന്തുടരുക ഉറവിടങ്ങൾ ആകുന്നു ലഭ്യമായ ലേക്ക് ഞാൻ?"

രണ്ടാമത്തെ ചോദ്യം, "ശരി, I കണ്ടെത്തി a പിന്തുടരുക ഉറവിടം, എങ്ങനെ do I ചിത്രം പുറത്ത് The കോൺഫിഗറേഷൻ പാത
ലേക്ക് ഉപയോഗം എപ്പോൾ I കണക്ട് ലേക്ക് അത്?"

മൂന്നാമത്തെ ചോദ്യം, "ശരി, I കണ്ടെത്തി a പിന്തുടരുക ഉറവിടം ഒപ്പം The കോൺഫിഗറേഷൻ പാത, എങ്ങനെ do I ചിത്രം
പുറത്ത് എന്ത് The മടക്കം ടൈപ്പ് ചെയ്യുക ഒപ്പം formal പചാരികം വാദങ്ങൾ of my തിരിച്ചു വിളിക്കുക ഫംഗ്ഷൻ ആവശ്യം ലേക്ക് ആകുമോ?"

നാലാമത്തെ ചോദ്യം, "ശരി, I ടൈപ്പുചെയ്തു ആ എല്ലാം in ഒപ്പം കിട്ടി ഈ അവിശ്വസനീയമാം വിധം വിലക്ഷണമായ പിശക്
സന്ദേശം, എന്ത് in The ലോകം ചെയ്യുന്നവൻ it അർത്ഥം?"

ഇവ ഓരോന്നും ഞങ്ങൾ ക്രമത്തിൽ അഭിസംബോധന ചെയ്യും.

ലഭ്യമായ ഉറവിടങ്ങൾ
ശരി, I അറിയുക ആ അവിടെ ആവശമാകുന്നു be പിന്തുടരുക ഉറവിടങ്ങൾ in The സിമുലേഷൻ കാമ്പ്, പക്ഷേ എങ്ങനെ do I കണ്ടെത്തുക
പുറത്ത് എന്ത് പിന്തുടരുക ഉറവിടങ്ങൾ ആകുന്നു ലഭ്യമായ ലേക്ക് ഞാൻ?

ആദ്യ ചോദ്യത്തിനുള്ള ഉത്തരം ൽ കാണാം ns-3 API ഡോക്യുമെന്റേഷൻ. ലേക്ക് പോയാൽ
പദ്ധതി വെബ് സൈറ്റ്, ns-3 പദ്ധതി, നാവിഗേഷനിൽ "ഡോക്യുമെന്റേഷൻ" എന്നതിലേക്കുള്ള ഒരു ലിങ്ക് നിങ്ങൾ കണ്ടെത്തും
ബാർ. നിങ്ങൾ ഈ ലിങ്ക് തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, നിങ്ങളെ ഞങ്ങളുടെ ഡോക്യുമെന്റേഷൻ പേജിലേക്ക് കൊണ്ടുപോകും. ഒരു ഉണ്ട്
ഏറ്റവും പുതിയ സ്റ്റേബിളിനായുള്ള ഡോക്യുമെന്റേഷനിലേക്ക് നിങ്ങളെ കൊണ്ടുപോകുന്ന "ഏറ്റവും പുതിയ റിലീസ്" എന്നതിലേക്കുള്ള ലിങ്ക്
റിലീസ് ns-3. നിങ്ങൾ "API ഡോക്യുമെന്റേഷൻ" ലിങ്ക് തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, നിങ്ങളെ ഇതിലേക്ക് കൊണ്ടുപോകും
ns-3 API ഡോക്യുമെന്റേഷൻ പേജ്.

സൈഡ്‌ബാറിൽ നിങ്ങൾ ആരംഭിക്കുന്ന ഒരു ശ്രേണി കാണണം

· ns-3

· ns-3 ഡോക്യുമെന്റേഷൻ

· എല്ലാ ട്രേസ് സോഴ്സുകളും

· എല്ലാ ആട്രിബ്യൂട്ടുകളും

· എല്ലാ ആഗോള മൂല്യങ്ങളും

ഇവിടെ ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ള ലിസ്റ്റ് "എല്ലാ ട്രേസ് സോഴ്‌സുകളും" ആണ്. മുന്നോട്ട് പോയി ആ ​​ലിങ്ക് തിരഞ്ഞെടുക്കുക.
ലഭ്യമായ എല്ലാ ഉറവിടങ്ങളുടെയും ഒരു ലിസ്റ്റ് നിങ്ങൾ കാണും, ഒരുപക്ഷേ അതിശയിക്കാനില്ല.
in ns-3.

ഒരു ഉദാഹരണമായി, താഴേക്ക് സ്ക്രോൾ ചെയ്യുക ns3::മൊബിലിറ്റി മോഡൽ. ഇതിനായി നിങ്ങൾ ഒരു എൻട്രി കണ്ടെത്തും

കോഴ്‌സ് മാറ്റം: സ്ഥാനത്തിന്റെയും/അല്ലെങ്കിൽ വേഗത വെക്‌ടറിന്റെയും മൂല്യം മാറി

ഞങ്ങൾ ഉപയോഗിച്ച ട്രെയ്സ് ഉറവിടമായി ഇത് നിങ്ങൾ തിരിച്ചറിയണം മൂന്നാം.സി.സി ഉദാഹരണം. പരിശോധിക്കുന്നു
ഈ ലിസ്റ്റ് സഹായകമാകും.

കോൺഫിഗറേഷൻ പാതകൾ
ശരി, I കണ്ടെത്തി a പിന്തുടരുക ഉറവിടം, എങ്ങനെ do I ചിത്രം പുറത്ത് The കോൺഫിഗറേഷൻ പാത ലേക്ക് ഉപയോഗം എപ്പോൾ I കണക്ട് ലേക്ക്
ഇത്?

നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഒബ്ജക്റ്റ് ഏതെന്ന് അറിയാമെങ്കിൽ, "വിശദമായ വിവരണം" എന്ന വിഭാഗം
ലഭ്യമായ എല്ലാ ട്രെയ്സ് ഉറവിടങ്ങളും ക്ലാസ് ലിസ്റ്റ് ചെയ്യും. ഉദാഹരണത്തിന്, "എല്ലാം" എന്ന പട്ടികയിൽ നിന്ന് ആരംഭിക്കുന്നു
TraceSources," ക്ലിക്ക് ചെയ്യുക ns3::മൊബിലിറ്റി മോഡൽ എന്നതിലേക്ക് നിങ്ങളെ കൊണ്ടുപോകുന്ന ലിങ്ക്
എന്നതിനായുള്ള ഡോക്യുമെന്റേഷൻ മൊബിലിറ്റി മോഡൽ ക്ലാസ്. പേജിന്റെ ഏതാണ്ട് മുകളിൽ ഒരു വരിയാണ്
ക്ലാസിന്റെ ഹ്രസ്വ വിവരണം, "കൂടുതൽ..." എന്ന ലിങ്കിൽ അവസാനിക്കുന്നു. ഒഴിവാക്കാൻ ഈ ലിങ്കിൽ ക്ലിക്ക് ചെയ്യുക
API സംഗ്രഹം, ക്ലാസ്സിന്റെ "വിശദമായ വിവരണം" എന്നതിലേക്ക് പോകുക. അവസാനം
വിവരണം (വരെ) മൂന്ന് ലിസ്റ്റുകളായിരിക്കും:

· കോൺഫിഗറേഷൻ പാതകൾ: ഈ ക്ലാസിനുള്ള സാധാരണ കോൺഫിഗറേഷൻ പാതകളുടെ ഒരു ലിസ്റ്റ്.

· ഗുണവിശേഷങ്ങൾ: ഈ ക്ലാസ് നൽകുന്ന എല്ലാ ആട്രിബ്യൂട്ടുകളുടെയും ഒരു ലിസ്റ്റ്.

· ട്രേസ് സോഴ്‌സ്: ഈ ക്ലാസിൽ നിന്ന് ലഭ്യമായ എല്ലാ ട്രേസ് സോഴ്സുകളുടെയും ഒരു ലിസ്റ്റ്.

ആദ്യം നമ്മൾ കോൺഫിഗറേഷൻ പാതകൾ ചർച്ച ചെയ്യും.

"All" എന്നതിൽ "CourseChange" ട്രെയ്സ് ഉറവിടം നിങ്ങൾ ഇപ്പോൾ കണ്ടെത്തിയെന്ന് നമുക്ക് അനുമാനിക്കാം.
TraceSources" ലിസ്‌റ്റ്, അതിലേക്ക് എങ്ങനെ കണക്‌റ്റ് ചെയ്യണമെന്ന് നിങ്ങൾ കണ്ടെത്തണം. നിങ്ങളാണെന്ന് നിങ്ങൾക്കറിയാം
ഉപയോഗിക്കുന്നത് (വീണ്ടും, മുതൽ മൂന്നാം.സി.സി ഉദാഹരണം) an ns3::RandomWalk2dMobilityModel. അങ്ങനെ ഒന്നുകിൽ
"എല്ലാ ട്രേസ് സോഴ്‌സുകളും" ലിസ്റ്റിലെ ക്ലാസ്സിന്റെ പേരിൽ ക്ലിക്ക് ചെയ്യുക അല്ലെങ്കിൽ കണ്ടെത്തുക
ns3::RandomWalk2dMobilityModel "ക്ലാസ് ലിസ്റ്റിൽ". എന്തായാലും നിങ്ങൾ ഇപ്പോൾ നോക്കണം
"ns3::RandomWalk2dMobilityModel Class Reference" പേജിൽ.

നിങ്ങൾ ഇപ്പോൾ "വിശദമായ വിവരണം" വിഭാഗത്തിലേക്ക് സ്ക്രോൾ ചെയ്യുകയാണെങ്കിൽ, സംഗ്രഹ പട്ടികയ്ക്ക് ശേഷം
ക്ലാസ് രീതികളും ആട്രിബ്യൂട്ടുകളും (അല്ലെങ്കിൽ ക്ലാസിന്റെ അവസാനത്തിലുള്ള "കൂടുതൽ..." ലിങ്കിൽ ക്ലിക്ക് ചെയ്യുക
പേജിന്റെ മുകളിൽ ഹ്രസ്വ വിവരണം) ഇതിനായി മൊത്തത്തിലുള്ള ഡോക്യുമെന്റേഷൻ നിങ്ങൾ കാണും
ക്ലാസ്. താഴേക്ക് സ്ക്രോൾ ചെയ്യുന്നത് തുടരുന്നു, "കോൺഫിഗ് പാഥുകൾ" ലിസ്റ്റ് കണ്ടെത്തുക:
കോൺഫിഗറേഷൻ പാതകൾ

ns3::RandomWalk2dMobilityModel ഇനിപ്പറയുന്ന പാതകളിലൂടെ ആക്സസ് ചെയ്യാൻ കഴിയും
കോൺഫിഗറേഷൻ::സെറ്റ് ഒപ്പം കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക:

· "/NodeList/[i]/$ns3::MobilityModel/$ns3::RandomWalk2dMobilityModel"

എങ്ങനെ എത്തിച്ചേരാമെന്ന് ഡോക്യുമെന്റേഷൻ നിങ്ങളോട് പറയുന്നു RandomWalk2dMobilityModel വസ്തു. താരതമ്യം ചെയ്യുക
ഉദാഹരണ കോഡിൽ ഞങ്ങൾ യഥാർത്ഥത്തിൽ ഉപയോഗിച്ച സ്ട്രിംഗിനൊപ്പം മുകളിലുള്ള സ്ട്രിംഗ്:

"/നോഡ്‌ലിസ്റ്റ്/7/$ns3::മൊബിലിറ്റി മോഡൽ"

രണ്ട് എന്ന വസ്തുതയാണ് വ്യത്യാസത്തിന് കാരണം GetObject കണ്ടെത്തിയ സ്ട്രിംഗിൽ കോളുകൾ സൂചിപ്പിച്ചിരിക്കുന്നു
ഡോക്യുമെന്റേഷനിൽ. ആദ്യത്തേത്, വേണ്ടി $ns3::മൊബിലിറ്റി മോഡൽ എന്ന സംഗ്രഹം അന്വേഷിക്കും
അടിസ്ഥാന ക്ലാസ്. രണ്ടാമത്തേത് സൂചിപ്പിച്ചു GetObject വിളിക്കുക, വേണ്ടി $ns3::RandomWalk2dMobilityModel,
അടിസ്ഥാന ക്ലാസ് കോൺക്രീറ്റ് ഇംപ്ലിമെന്റേഷൻ ക്ലാസിലേക്ക് കാസ്റ്റുചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഡോക്യുമെന്റേഷൻ
നിങ്ങൾക്കായി ഈ രണ്ട് പ്രവർത്തനങ്ങളും കാണിക്കുന്നു. നിങ്ങളാണ് യഥാർത്ഥ ട്രെയ്സ് ഉറവിടം എന്ന് ഇത് മാറുന്നു
തിരയുന്നത് അടിസ്ഥാന ക്ലാസിൽ കാണപ്പെടുന്നു.

ട്രേസ് ഉറവിടങ്ങളുടെ ലിസ്റ്റിനായി "വിശദമായ വിവരണം" വിഭാഗത്തിൽ കൂടുതൽ താഴേക്ക് നോക്കുക.
നിങ്ങൾ കണ്ടെത്തും
ഈ തരത്തിന് ട്രേസ് സോഴ്‌സുകളൊന്നും നിർവചിച്ചിട്ടില്ല.

ട്രേസ് സോഴ്‌സ് നിർവചിച്ചിരിക്കുന്നത് in പാരന്റ് ക്ലാസ് `ns3::മൊബിലിറ്റി മോഡൽ``

· കോഴ്സ് മാറ്റം: സ്ഥാനത്തിന്റെയും/അല്ലെങ്കിൽ വേഗത വെക്‌ടറിന്റെയും മൂല്യം മാറി.

കോൾബാക്ക് ഒപ്പ്: ns3::മൊബിലിറ്റി മോഡൽ:: കോഴ്സ് മാറ്റുക കോൾബാക്ക്

നിങ്ങൾ അറിയേണ്ടത് ഇതാണ്. താൽപ്പര്യത്തിന്റെ ഉറവിടം കണ്ടെത്തുന്നത്
ns3::മൊബിലിറ്റി മോഡൽ (എന്തായാലും നിങ്ങൾക്കറിയാമായിരുന്നു). API-യുടെ ഈ ബിറ്റ് രസകരമായ കാര്യം
മുകളിലുള്ള കോൺഫിഗറേഷൻ പാതയിൽ നിങ്ങൾക്ക് അധിക കാസ്റ്റ് ആവശ്യമില്ലെന്നാണ് ഡോക്യുമെന്റേഷൻ നിങ്ങളോട് പറയുന്നത്
ട്രെയ്സ് സോഴ്സ് യഥാർത്ഥത്തിൽ അടിസ്ഥാന ക്ലാസിലായതിനാൽ കോൺക്രീറ്റ് ക്ലാസിലേക്ക് പോകുക.
അതിനാൽ അധിക GetObject ആവശ്യമില്ല, നിങ്ങൾ പാത ഉപയോഗിക്കുക:

"/NodeList/[i]/$ns3::മൊബിലിറ്റി മോഡൽ"

ഇത് ഉദാഹരണ പാതയുമായി തികച്ചും പൊരുത്തപ്പെടുന്നു:

"/നോഡ്‌ലിസ്റ്റ്/7/$ns3::മൊബിലിറ്റി മോഡൽ"

ഒരു വശത്ത്, കോൺഫിഗറേഷൻ പാത്ത് കണ്ടെത്താനുള്ള മറ്റൊരു മാർഗ്ഗം grep ചുറ്റും ns-3 കോഡ്ബേസ്
ഇതിനകം മനസ്സിലാക്കിയ ഒരാൾക്ക്. നിങ്ങൾ എപ്പോഴും മറ്റൊരാളുടെ പകർത്താൻ ശ്രമിക്കണം
നിങ്ങൾ സ്വന്തമായി എഴുതാൻ തുടങ്ങുന്നതിനുമുമ്പ് പ്രവർത്തന കോഡ്. ഇതുപോലുള്ള ഒന്ന് പരീക്ഷിക്കുക:

$ കണ്ടെത്തുക. -പേര് '*.cc' | xargs grep CourseChange | grep കണക്ട്

വർക്കിംഗ് കോഡിനൊപ്പം നിങ്ങളുടെ ഉത്തരം കണ്ടെത്തുകയും ചെയ്യാം. ഉദാഹരണത്തിന്, ഈ സാഹചര്യത്തിൽ,
src/mobility/examples/main-random-topology.cc നിങ്ങൾ ഉപയോഗിക്കുന്നതിനായി എന്തെങ്കിലും കാത്തിരിക്കുന്നു:

കോൺഫിഗറേഷൻ::കണക്റ്റ് ("/നോഡ്‌ലിസ്റ്റ്/*/$ns3::മൊബിലിറ്റി മോഡൽ/കോഴ്‌സ് മാറ്റം",
MakeCallback (&CourseChange));

ഒരു നിമിഷത്തിനുള്ളിൽ ഞങ്ങൾ ഈ ഉദാഹരണത്തിലേക്ക് മടങ്ങും.

തിരിച്ചുവിളിക്കുക ഒപ്പുകൾ
ശരി, I കണ്ടെത്തി a പിന്തുടരുക ഉറവിടം ഒപ്പം The കോൺഫിഗറേഷൻ പാത, എങ്ങനെ do I ചിത്രം പുറത്ത് എന്ത് The മടക്കം ടൈപ്പ് ചെയ്യുക
ഒപ്പം formal പചാരികം വാദങ്ങൾ of my തിരിച്ചു വിളിക്കുക ഫംഗ്ഷൻ ആവശ്യം ലേക്ക് ആകണോ?

കോൾബാക്ക് ഒപ്പ് പരിശോധിക്കുന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗം ടൈപ്പ്ഡ്, ൽ നൽകിയിരിക്കുന്നത്
ക്ലാസിനായുള്ള "വിശദമായ വിവരണത്തിൽ" ട്രെയ്സ് ഉറവിടത്തിന്റെ "കോൾബാക്ക് സിഗ്നേച്ചർ"
മുകളിൽ കാണിച്ചിരിക്കുന്നു.

"CourseChange" ട്രെയ്സ് ഉറവിട എൻട്രി ആവർത്തിക്കുന്നു ns3::RandomWalk2dMobilityModel we
ഉണ്ട്:

· കോഴ്സ് മാറ്റം: സ്ഥാനത്തിന്റെയും/അല്ലെങ്കിൽ വേഗത വെക്‌ടറിന്റെയും മൂല്യം മാറി.

കോൾബാക്ക് ഒപ്പ്: ns3::മൊബിലിറ്റി മോഡൽ:: കോഴ്സ് മാറ്റുക കോൾബാക്ക്

കോൾബാക്ക് സിഗ്നേച്ചർ പ്രസക്തമായതിലേക്കുള്ള ലിങ്കായി നൽകിയിരിക്കുന്നു ടൈപ്പ്ഡ്, ഞങ്ങൾ എവിടെ കണ്ടെത്തുന്നു
ടൈപ്പ്ഡ് ശൂന്യം (* കോഴ്‌സ് മാറ്റുക കോൾബാക്ക്)(കൺസ്റ്റ് std::സ്ട്രിംഗ് സന്ദർഭം, Ptr
മൊബിലിറ്റി മോഡൽ> * മോഡൽ);

TracedCallback കോഴ്‌സ് മാറ്റ അറിയിപ്പുകൾക്കുള്ള ഒപ്പ്.

ഉപയോഗിച്ച് കോൾബാക്ക് ബന്ധിപ്പിച്ചിട്ടുണ്ടെങ്കിൽ സന്ദർഭമില്ലാതെ ബന്ധിപ്പിക്കുക ഒഴിവാക്കുക സന്ദർഭം നിന്ന് വാദം
ഒപ്പ്.

പരാമീറ്ററുകൾ:
[ഇൻ] സന്ദർഭത്തിൽ ട്രെയ്സ് ഉറവിടം നൽകിയ സന്ദർഭ സ്ട്രിംഗ്.
[ഇൻ] മോഡൽ ഗതി മാറിക്കൊണ്ടിരിക്കുന്ന മൊബിലിറ്റി മോഡൽ.

മുകളിൽ പറഞ്ഞതുപോലെ, ഇത് ഉപയോഗത്തിൽ കാണാൻ grep ചുറ്റും ns-3 ഒരു ഉദാഹരണത്തിനുള്ള കോഡ്ബേസ്. ഉദാഹരണം
മുകളിൽ, നിന്ന് src/mobility/examples/main-random-topology.cc, "കോഴ്‌സ് ചേഞ്ച്" ബന്ധിപ്പിക്കുന്നു
ഉറവിടം കണ്ടെത്തുക കോഴ്സ് മാറ്റം ഒരേ ഫയലിലെ പ്രവർത്തനം:

സ്റ്റാറ്റിക് അസാധുവാണ്
CourseChange (std::string സന്ദർഭം, Ptr മോഡൽ)
{
...
}

ഈ പ്രവർത്തനം ശ്രദ്ധിക്കുക:

· ഒരു "സന്ദർഭം" സ്ട്രിംഗ് ആർഗ്യുമെന്റ് എടുക്കുന്നു, അത് ഞങ്ങൾ ഒരു മിനിറ്റിനുള്ളിൽ വിവരിക്കും. (കോൾബാക്ക് ആണെങ്കിൽ
ഉപയോഗിച്ച് ബന്ധിപ്പിച്ചിരിക്കുന്നു സന്ദർഭമില്ലാതെ ബന്ധിപ്പിക്കുക പ്രവർത്തനം സന്ദർഭം വാദം ആയിരിക്കും
ഒഴിവാക്കി.)

· ഉണ്ട് മൊബിലിറ്റി മോഡൽ അവസാന ആർഗ്യുമെന്റ് (അല്ലെങ്കിൽ ആർഗ്യുമെന്റ് എങ്കിൽ മാത്രം
സന്ദർഭമില്ലാതെ ബന്ധിപ്പിക്കുക ഉപയോഗിക്കുന്നു).

· മടങ്ങുന്നു ശൂന്യം.

യാദൃശ്ചികമായി, കോൾബാക്ക് ഒപ്പ് രേഖപ്പെടുത്തിയിട്ടില്ലെങ്കിൽ, അതിന് ഉദാഹരണങ്ങളൊന്നുമില്ല
ഇതിൽ നിന്ന് പ്രവർത്തിക്കുക, ശരിയായ കോൾബാക്ക് ഫംഗ്‌ഷൻ സിഗ്നേച്ചർ നിർണ്ണയിക്കുന്നത് വെല്ലുവിളിയാണ്
യഥാർത്ഥത്തിൽ സോഴ്സ് കോഡിൽ നിന്ന് കണ്ടെത്തുക.

കോഡിന്റെ ഒരു നടപ്പാത ആരംഭിക്കുന്നതിന് മുമ്പ്, ഞാൻ ദയ കാണിക്കും, നിങ്ങൾക്ക് ഒരു ലളിതമായ വഴി പറയാം
ഇത് മനസിലാക്കാൻ: നിങ്ങളുടെ കോൾബാക്കിന്റെ റിട്ടേൺ മൂല്യം എപ്പോഴും ആയിരിക്കും ശൂന്യം. ഔപചാരികമായ
a എന്നതിനായുള്ള പരാമീറ്റർ ലിസ്റ്റ് TracedCallback എന്നതിലെ ടെംപ്ലേറ്റ് പാരാമീറ്റർ ലിസ്റ്റിൽ നിന്ന് കണ്ടെത്താനാകും
പ്രഖ്യാപനം. ഞങ്ങളുടെ നിലവിലെ ഉദാഹരണത്തിനായി, ഇത് ഇതിലാണെന്ന് ഓർക്കുക mobility-model.h, ഞങ്ങൾ എവിടെ
മുമ്പ് കണ്ടെത്തിയിട്ടുണ്ട്:

TracedCallback > m_courseChangeTrace;

എന്നതിലെ ടെംപ്ലേറ്റ് പാരാമീറ്റർ ലിസ്‌റ്റ് തമ്മിൽ വൺ-ടു-വൺ കത്തിടപാടുകൾ ഉണ്ട്
പ്രഖ്യാപനവും കോൾബാക്ക് ഫംഗ്‌ഷന്റെ ഔപചാരിക വാദങ്ങളും. ഇവിടെ, ഒന്നുണ്ട്
ടെംപ്ലേറ്റ് പാരാമീറ്റർ, അത് a Ptr മൊബിലിറ്റി മോഡൽ>. നിങ്ങൾക്ക് ഒരു ആവശ്യമുണ്ടെന്ന് ഇത് നിങ്ങളോട് പറയുന്നു
അസാധുവാക്കി എ എടുക്കുന്ന പ്രവർത്തനം Ptr മൊബിലിറ്റി മോഡൽ>. ഉദാഹരണത്തിന്:

ശൂന്യം
കോഴ്സ് മാറ്റം (Ptr മോഡൽ)
{
...
}

വേണമെങ്കിൽ ഇത്രയേ വേണ്ടൂ കോൺഫിഗറേഷൻ::കണക്ട് വിതൗട്ട് കോൺടെക്സ്റ്റ്. നിങ്ങൾക്ക് ഒരു സന്ദർഭം വേണമെങ്കിൽ,
നീ ചെയ്യണം കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക ഒരു സ്ട്രിംഗ് സന്ദർഭം എടുക്കുന്ന ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കുക
ടെംപ്ലേറ്റ് വാദങ്ങൾ:

ശൂന്യം
കോഴ്സ് മാറ്റം (const std::string സന്ദർഭം, Ptr മോഡൽ)
{
...
}

നിങ്ങൾക്ക് അത് ഉറപ്പാക്കണമെങ്കിൽ നിങ്ങളുടെ CourseCallback നിങ്ങളുടെ ഫംഗ്‌ഷൻ മാത്രമേ ദൃശ്യമാകൂ
ലോക്കൽ ഫയൽ, നിങ്ങൾക്ക് കീവേഡ് ചേർക്കാൻ കഴിയും സ്റ്റാറ്റിക്ക് ഒപ്പം വരൂ:

സ്റ്റാറ്റിക് അസാധുവാണ്
കോഴ്സ് മാറ്റം (const std::string path, Ptr മോഡൽ)
{
...
}

ഇതിൽ ഞങ്ങൾ ഉപയോഗിച്ചത് തന്നെയാണ് മൂന്നാം.സി.സി ഉദാഹരണം.

നടപ്പിലാക്കൽ
ഈ വിഭാഗം പൂർണ്ണമായും ഓപ്ഷണൽ ആണ്. ഇത് ഒരു കുതിച്ചുചാട്ടമുള്ള റൈഡ് ആയിരിക്കും, പ്രത്യേകിച്ച് അവർക്ക്
ടെംപ്ലേറ്റുകളുടെ വിശദാംശങ്ങൾ പരിചിതമല്ല. എന്നിരുന്നാലും, നിങ്ങൾ ഇതിലൂടെ കടന്നുപോകുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ലഭിക്കും
പല കാര്യങ്ങളിലും വളരെ നല്ല ഹാൻഡിൽ ns-3 താഴ്ന്ന നിലയിലുള്ള ഭാഷകൾ.

അതിനാൽ, വീണ്ടും, കോൾബാക്ക് ഫംഗ്‌ഷന്റെ സിഗ്‌നേച്ചർ എന്താണ് ആവശ്യമെന്ന് നമുക്ക് നോക്കാം
"കോഴ്‌സ് ചേഞ്ച്" ഉറവിടം കണ്ടെത്തുക. ഇത് വേദനാജനകമായിരിക്കും, പക്ഷേ നിങ്ങൾ ഇത് ചെയ്യേണ്ടതുണ്ട്
ഒരിക്കല്. നിങ്ങൾ ഇതിലൂടെ കടന്നുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് ഒരു നോക്കാൻ കഴിയും TracedCallback ഒപ്പം
ഇത് മനസ്സിലാക്കൂ.

നാം ആദ്യം നോക്കേണ്ടത് ട്രെയ്സ് ഉറവിടത്തിന്റെ പ്രഖ്യാപനമാണ്. അത് ഓർക്കുക
ഇത് ഉള്ളതാണ് mobility-model.h, ഞങ്ങൾ മുമ്പ് കണ്ടെത്തിയിടത്ത്:

TracedCallback > m_courseChangeTrace;

ഈ പ്രഖ്യാപനം ഒരു ടെംപ്ലേറ്റിനുള്ളതാണ്. ടെംപ്ലേറ്റ് പാരാമീറ്റർ ആംഗിൾ-ബ്രാക്കറ്റുകൾക്കുള്ളിലാണ്,
അതിനാൽ അത് എന്താണെന്ന് കണ്ടെത്താൻ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട് TracedCallback<> ആണ്. താങ്കളുടെ കയ്യില് ഉണ്ടെങ്കില്
ഇത് എവിടെ കണ്ടെത്തുമെന്ന് തീർത്തും അറിയില്ല, grep നിങ്ങളുടെ സുഹൃത്ത്.

എന്നതിലെ ഏതെങ്കിലും തരത്തിലുള്ള പ്രഖ്യാപനത്തിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടാകാൻ സാധ്യതയുണ്ട് ns-3 ഉറവിടം, അങ്ങനെ
ആദ്യം മാറ്റുക ഉറവിട ഡയറക്ടറി. അപ്പോൾ, ഈ പ്രഖ്യാപനം നടത്തേണ്ടിവരുമെന്ന് ഞങ്ങൾക്കറിയാം
ഏതെങ്കിലും തരത്തിലുള്ള ഹെഡർ ഫയലിൽ ആയിരിക്കുക, അങ്ങനെ മാത്രം grep ഇതിനായി ഉപയോഗിക്കുന്നത്:

$ കണ്ടെത്തുക. -പേര് '*.h' | xargs grep TracedCallback

303 വരികൾ പറക്കുന്നത് നിങ്ങൾ കാണും (ഞാൻ ഇതിലൂടെ പൈപ്പ് ചെയ്തു wc അത് എത്ര മോശമാണെന്ന് കാണാൻ). എങ്കിലും
അത് ഒരുപാട് പോലെ തോന്നിയേക്കാം, അത് ശരിക്കും ഒരുപാട് അല്ല. ഔട്ട്പുട്ട് വഴി പൈപ്പ് ചെയ്യുക കൂടുതൽ ഒപ്പം
അതിലൂടെ സ്കാൻ ചെയ്യാൻ തുടങ്ങുക. ആദ്യ പേജിൽ, വളരെ സംശയാസ്പദമായ ചിലത് നിങ്ങൾ കാണും
ടെംപ്ലേറ്റ് രൂപത്തിലുള്ള സാധനങ്ങൾ.

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::TracedCallback ()
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::ConnectWithoutContext (c ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::Connect (const CallbackB ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::DisconnectWithoutContext ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::Disconnect (const Callba ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (void) const ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1) const ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...

ഇതെല്ലാം ഹെഡർ ഫയലിൽ നിന്നാണ് വരുന്നതെന്ന് ഇത് മാറുന്നു ട്രേസ്ഡ്-കോൾബാക്ക്.എച്ച് ഏത് ശബ്ദം
വളരെ വാഗ്ദാനമാണ്. അപ്പോൾ നിങ്ങൾക്ക് നോക്കാം mobility-model.h ഒരു വരി ഉണ്ടെന്ന് നോക്കുക
ഇത് ഈ ഊഹത്തെ സ്ഥിരീകരിക്കുന്നു:

#ഉൾപ്പെടുത്തുക "ns3/traced-callback.h"

തീർച്ചയായും, നിങ്ങൾക്ക് ഇത് മറ്റൊരു ദിശയിൽ നിന്ന് പോയി നോക്കിക്കൊണ്ട് ആരംഭിക്കാമായിരുന്നു
ഉൾപ്പെടുന്നു mobility-model.h ഉൾപ്പെടുത്തുന്നത് ശ്രദ്ധിക്കുന്നു ട്രേസ്ഡ്-കോൾബാക്ക്.എച്ച് ഒപ്പം
നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഫയൽ ഇതായിരിക്കണം എന്ന് അനുമാനിക്കുന്നു.

ഏത് സാഹചര്യത്തിലും, അടുത്ത ഘട്ടം നോക്കുക എന്നതാണ് src/core/model/traced-callback.h in
എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണാൻ നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്റർ.

ഫയലിന്റെ മുകളിൽ ആശ്വാസകരമായ ഒരു അഭിപ്രായം നിങ്ങൾ കാണും:
ഒരു ns3::TracedCallback-ന് ഒരു സാധാരണ ns3::Callback-ന്റെ ഏതാണ്ട് അതേ API ഉണ്ട്.
ഒരൊറ്റ ഫംഗ്‌ഷനിലേക്ക് കോളുകൾ ഫോർവേഡ് ചെയ്യുന്നതിനുപകരം (ഒരു ns3 ::കോൾബാക്ക് സാധാരണയായി ചെയ്യുന്നതുപോലെ),
ഇത് ns3::Callback എന്ന ശൃംഖലയിലേക്ക് കോളുകൾ ഫോർവേഡ് ചെയ്യുന്നു.

ഇത് വളരെ പരിചിതമായി തോന്നുകയും നിങ്ങൾ ശരിയായ പാതയിലാണെന്ന് നിങ്ങളെ അറിയിക്കുകയും ചെയ്യും.

ഈ അഭിപ്രായത്തിന് ശേഷം, നിങ്ങൾ കണ്ടെത്തും

ടെംപ്ലേറ്റ്
ടൈപ്പ് നാമം T3 = ശൂന്യം, ടൈപ്പ് നാമം T4 = ശൂന്യം,
ടൈപ്പ് നാമം T5 = ശൂന്യം, ടൈപ്പ് നാമം T6 = ശൂന്യം,
ടൈപ്പ് നാമം T7 = ശൂന്യം, ടൈപ്പ് നാമം T8 = ശൂന്യം>
ക്ലാസ് TracedCallback
{
...

TracedCallback ഒരു ടെംപ്ലേറ്റഡ് ക്ലാസാണെന്ന് ഇത് നിങ്ങളോട് പറയുന്നു. ഇതിന് എട്ട് സാധ്യമായ തരങ്ങളുണ്ട്
സ്ഥിര മൂല്യങ്ങളുള്ള പാരാമീറ്ററുകൾ. തിരികെ പോയി നിങ്ങളുടേതായ പ്രഖ്യാപനവുമായി ഇത് താരതമ്യം ചെയ്യുക
മനസ്സിലാക്കാൻ ശ്രമിക്കുന്നു:

TracedCallback > m_courseChangeTrace;

ദി ടൈപ്പ്നാമം T1 ടെംപ്ലേറ്റ് ചെയ്ത ക്ലാസ് ഡിക്ലറേഷനിൽ Ptr
മൊബിലിറ്റി മോഡൽ> മുകളിലുള്ള പ്രഖ്യാപനത്തിൽ. മറ്റെല്ലാ തരം പാരാമീറ്ററുകളും ഇതുപോലെ അവശേഷിക്കുന്നു
സ്ഥിരസ്ഥിതികൾ. കൺസ്ട്രക്‌ടറെ നോക്കുന്നത് ശരിക്കും നിങ്ങളോട് കൂടുതൽ പറയുന്നില്ല. ഉള്ള ഒരു സ്ഥലം
നിങ്ങളുടെ കോൾബാക്ക് ഫംഗ്‌ഷനും ട്രെയ്‌സിംഗ് സിസ്റ്റവും തമ്മിൽ ഒരു കണക്ഷൻ ഉണ്ടാക്കിയിരിക്കുന്നത് നിങ്ങൾ കണ്ടു
ലെ ബന്ധിപ്പിക്കുക ഒപ്പം സന്ദർഭമില്ലാതെ ബന്ധിപ്പിക്കുക പ്രവർത്തനങ്ങൾ. താഴേക്ക് സ്ക്രോൾ ചെയ്താൽ എ
സന്ദർഭമില്ലാതെ ബന്ധിപ്പിക്കുക ഇവിടെ രീതി:

ടെംപ്ലേറ്റ്
ടൈപ്പ്നാമം T3, ടൈപ്പ്നാമം T4,
ടൈപ്പ്നാമം T5, ടൈപ്പ്നാമം T6,
ടൈപ്പ്നാമം T7, ടൈപ്പ്നാമം T8>
ശൂന്യം
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::ConnectWithoutContext ...
{
Callback<void,T1,T2,T3,T4,T5,T6,T7,T8> cb;
cb.Assign (കോൾബാക്ക്);
m_callbackList.push_back (cb);
}

നിങ്ങൾ ഇപ്പോൾ മൃഗത്തിന്റെ ഉദരത്തിലാണ്. ടെംപ്ലേറ്റ് തൽക്ഷണം ചെയ്യുമ്പോൾ
മുകളിലെ പ്രഖ്യാപനം, കംപൈലർ മാറ്റിസ്ഥാപിക്കും T1 കൂടെ Ptr മൊബിലിറ്റി മോഡൽ>.

ശൂന്യം
TracedCallback ::ConnectWithoutContext ... cb
{
തിരിച്ചുവിളിക്കുക > സിബി;
cb.Assign (കോൾബാക്ക്);
m_callbackList.push_back (cb);
}

ഞങ്ങൾ സംസാരിച്ച എല്ലാ കാര്യങ്ങളും നടപ്പിലാക്കുന്നത് ഇപ്പോൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും. കോഡ്
ശരിയായ തരത്തിലുള്ള ഒരു കോൾബാക്ക് സൃഷ്‌ടിക്കുകയും അതിന് നിങ്ങളുടെ ഫംഗ്‌ഷൻ നൽകുകയും ചെയ്യുന്നു. ഇതാണ്
എന്നതിന് തുല്യമാണ് pfi = MyFunction ഈ വിഭാഗത്തിന്റെ തുടക്കത്തിൽ ഞങ്ങൾ ചർച്ച ചെയ്തു. കോഡ്
തുടർന്ന് ഈ ഉറവിടത്തിനായുള്ള കോൾബാക്കുകളുടെ ലിസ്റ്റിലേക്ക് കോൾബാക്ക് ചേർക്കുന്നു. ബാക്കിയുള്ളത് മാത്രം
കോൾബാക്കിന്റെ നിർവചനം നോക്കാൻ. അതേ ഉപയോഗിക്കുന്നത് grep ഞങ്ങൾ കണ്ടെത്തുന്നത് പോലെ തന്ത്രം
TracedCallback, നിങ്ങൾക്ക് ആ ഫയൽ കണ്ടെത്താൻ കഴിയും ./core/callback.h നമ്മളാണ്
നോക്കേണ്ടതുണ്ട്.

നിങ്ങൾ ഫയലിലൂടെ താഴേക്ക് നോക്കുകയാണെങ്കിൽ, മിക്കവാറും മനസ്സിലാക്കാൻ കഴിയാത്ത പലതും നിങ്ങൾ കാണും
ടെംപ്ലേറ്റ് കോഡ്. കോൾബാക്കിനായുള്ള ചില API ഡോക്യുമെന്റേഷനിലേക്ക് നിങ്ങൾ ഒടുവിൽ വരും
ടെംപ്ലേറ്റ് ക്ലാസ്, എങ്കിലും. ഭാഗ്യവശാൽ, കുറച്ച് ഇംഗ്ലീഷ് ഉണ്ട്:
തിരിച്ചുവിളിക്കുക ടെംപ്ലേറ്റ് ക്ലാസ്.

ഈ ക്ലാസ് ടെംപ്ലേറ്റ് ഫങ്‌റ്റർ ഡിസൈൻ പാറ്റേൺ നടപ്പിലാക്കുന്നു. ഇത് പ്രഖ്യാപിക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു തരം തിരിച്ചുവിളിക്കുക:

· ആദ്യത്തെ നോൺ-ഓപ്ഷണൽ ടെംപ്ലേറ്റ് ആർഗ്യുമെന്റ് കോൾബാക്കിന്റെ റിട്ടേൺ തരത്തെ പ്രതിനിധീകരിക്കുന്നു.

· ശേഷിക്കുന്ന (ഓപ്ഷണൽ) ടെംപ്ലേറ്റ് ആർഗ്യുമെന്റുകൾ തുടർന്നുള്ള തരത്തെ പ്രതിനിധീകരിക്കുന്നു
തിരിച്ചുവിളിക്കുന്നതിനുള്ള വാദങ്ങൾ.

· ഒമ്പത് വാദങ്ങൾ വരെ പിന്തുണയ്ക്കുന്നു.

എന്താണെന്ന് കണ്ടെത്താൻ ഞങ്ങൾ ശ്രമിക്കുന്നു

തിരിച്ചുവിളിക്കുക > സിബി;

പ്രഖ്യാപനം അർത്ഥമാക്കുന്നത്. ഇപ്പോൾ നമ്മൾ ആദ്യത്തേത് (ഓപ്ഷണൽ അല്ലാത്തത്) എന്ന് മനസ്സിലാക്കേണ്ട അവസ്ഥയിലാണ്.
ടെംപ്ലേറ്റ് വാദം, ശൂന്യം, കോൾബാക്കിന്റെ റിട്ടേൺ തരത്തെ പ്രതിനിധീകരിക്കുന്നു. രണ്ടാമത്തെ
(ഓപ്ഷണൽ) ടെംപ്ലേറ്റ് വാദം, Ptr മൊബിലിറ്റി മോഡൽ> ആദ്യത്തേതിന്റെ തരം പ്രതിനിധീകരിക്കുന്നു
തിരിച്ചുവിളിക്കുന്നതിനുള്ള വാദം.

ട്രെയ്സ് ഇവന്റുകൾ സ്വീകരിക്കുന്നതിനുള്ള നിങ്ങളുടെ പ്രവർത്തനമാണ് ചോദ്യം ചെയ്യപ്പെടുന്ന കോൾബാക്ക്. ഇതിൽ നിന്ന് നിങ്ങൾക്ക് കഴിയും
നിങ്ങൾക്ക് തിരികെ നൽകുന്ന ഒരു ഫംഗ്‌ഷൻ ആവശ്യമാണെന്ന് അനുമാനിക്കുക ശൂന്യം ഒപ്പം എ എടുക്കുന്നു Ptr മൊബിലിറ്റി മോഡൽ>.
ഉദാഹരണത്തിന്,

ശൂന്യം
കോഴ്‌സ് മാറ്റുക കോൾബാക്ക് (Ptr മോഡൽ)
{
...
}

വേണമെങ്കിൽ ഇത്രയേ വേണ്ടൂ കോൺഫിഗറേഷൻ::കണക്ട് വിതൗട്ട് കോൺടെക്സ്റ്റ്. നിങ്ങൾക്ക് ഒരു സന്ദർഭം വേണമെങ്കിൽ,
നീ ചെയ്യണം കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക ഒരു സ്ട്രിംഗ് സന്ദർഭം എടുക്കുന്ന ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കുക. ഈ
കാരണം ബന്ധിപ്പിക്കുക ഫംഗ്ഷൻ നിങ്ങൾക്ക് സന്ദർഭം നൽകും. നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

ശൂന്യം
CourseChangeCallback (std::string സന്ദർഭം, Ptr മോഡൽ)
{
...
}

നിങ്ങൾക്ക് അത് ഉറപ്പാക്കണമെങ്കിൽ നിങ്ങളുടെ CourseCallback നിങ്ങളുടെ പ്രാദേശിക ഫയലിൽ മാത്രമേ ദൃശ്യമാകൂ,
നിങ്ങൾക്ക് കീവേഡ് ചേർക്കാൻ കഴിയും സ്റ്റാറ്റിക്ക് ഒപ്പം വരൂ:

സ്റ്റാറ്റിക് അസാധുവാണ്
CourseChangeCallback (std::string path, Ptr മോഡൽ)
{
...
}

ഇതിൽ ഞങ്ങൾ ഉപയോഗിച്ചത് തന്നെയാണ് മൂന്നാം.സി.സി ഉദാഹരണം. ഒരുപക്ഷേ നിങ്ങൾ ഇപ്പോൾ തിരികെ പോകണം
മുമ്പത്തെ ഭാഗം വീണ്ടും വായിക്കുക (ഇതിനായി എന്റെ വാക്ക് എടുക്കുക).

കോൾബാക്കുകൾ നടപ്പിലാക്കുന്നതുമായി ബന്ധപ്പെട്ട കൂടുതൽ വിശദാംശങ്ങളിൽ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, മടിക്കേണ്ടതില്ല
ഒരു നോക്കുക ns-3 മാനുവൽ. അവയിൽ ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന നിർമ്മിതികളിൽ ഒന്നാണ്
താഴ്ന്ന നിലയിലുള്ള ഭാഗങ്ങൾ ns-3. എന്റെ അഭിപ്രായത്തിൽ, ഇത് തികച്ചും ഗംഭീരമായ ഒരു കാര്യമാണ്.

കണ്ടുപിടിച്ച മൂല്യങ്ങൾ
നേരത്തെ ഈ വിഭാഗത്തിൽ, a ഉപയോഗിക്കുന്ന ഒരു ലളിതമായ കോഡ് ഞങ്ങൾ അവതരിപ്പിച്ചു
ട്രേസ്ഡ് വാല്യൂ ട്രേസിംഗ് കോഡിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന്. ഞങ്ങൾ വെറുതെ തിളങ്ങി
ഒരു TracedValue യഥാർത്ഥത്തിൽ എന്താണെന്നും റിട്ടേൺ തരവും ഔപചാരികമായ ആർഗ്യുമെന്റുകളും എങ്ങനെ കണ്ടെത്താമെന്നും
തിരിച്ചുവിളിക്കൽ.

ഞങ്ങൾ സൂചിപ്പിച്ചതുപോലെ, ഫയൽ, ട്രേസ്ഡ്-മൂല്യം.എച്ച് കണ്ടെത്തുന്നതിന് ആവശ്യമായ പ്രഖ്യാപനങ്ങൾ കൊണ്ടുവരുന്നു
മൂല്യം സെമാന്റിക്സ് അനുസരിക്കുന്ന ഡാറ്റയുടെ. പൊതുവേ, മൂല്യം അർത്ഥമാക്കുന്നത് നിങ്ങൾക്ക് കഴിയും എന്നാണ്
ഒബ്‌ജക്‌റ്റിന്റെ വിലാസം കൈമാറുന്നതിനുപകരം, ഒബ്‌ജക്‌റ്റിന് ചുറ്റും കടന്നുപോകുക. ഞങ്ങൾ നീട്ടുന്നു
അസൈൻമെന്റ്-സ്റ്റൈൽ ഓപ്പറേറ്റർമാരുടെ മുഴുവൻ സെറ്റും ഉൾപ്പെടുത്തേണ്ട ആവശ്യകത
പ്ലെയിൻ-ഓൾഡ്-ഡാറ്റ (പിഒഡി) തരങ്ങൾക്കായി മുൻകൂട്ടി നിർവചിച്ചിരിക്കുന്നത്:

┌───────────────────────────
│ഓപ്പറേറ്റർ= (അസൈൻമെന്റ്) │ │
──────────────────────────
│ഓപ്പറേറ്റർ*= │ ഓപ്പറേറ്റർ/= │
──────────────────────────
│ഓപ്പറേറ്റർ+= │ ഓപ്പറേറ്റർ-= │
──────────────────────────
│ഓപ്പറേറ്റർ++ (പ്രിഫിക്സും │ │
│പോസ്റ്റ്ഫിക്സ്) │ │
──────────────────────────
│ഓപ്പറേറ്റർ-- (പ്രിഫിക്സും │ │
│പോസ്റ്റ്ഫിക്സ്) │ │
──────────────────────────
│ഓപ്പറേറ്റർ<<= │ ഓപ്പറേറ്റർ>>= │
──────────────────────────
│ഓപ്പറേറ്റർ&= │ ഓപ്പറേറ്റർ|= │
──────────────────────────
│ഓപ്പറേറ്റർ%= │ ഓപ്പറേറ്റർ^= │
──────────────────────────

ഇതെല്ലാം യഥാർത്ഥത്തിൽ അർത്ഥമാക്കുന്നത്, അവ ഉപയോഗിച്ച് വരുത്തിയ എല്ലാ മാറ്റങ്ങളും നിങ്ങൾക്ക് കണ്ടെത്താനാകും എന്നതാണ്
മൂല്യമുള്ള സെമാന്റിക്‌സ് ഉള്ള ഒരു C++ ഒബ്‌ജക്‌റ്റിലേക്കുള്ള ഓപ്പറേറ്റർമാർ.

ദി Traced Value<> നമ്മൾ മുകളിൽ കണ്ട ഡിക്ലറേഷൻ ഓവർലോഡ് ചെയ്യുന്ന ഇൻഫ്രാസ്ട്രക്ചർ നൽകുന്നു
മുകളിൽ സൂചിപ്പിച്ച ഓപ്പറേറ്റർമാർ കോൾബാക്ക് പ്രക്രിയയെ നയിക്കുന്നു. ഏതെങ്കിലും ഓപ്പറേറ്റർമാരുടെ ഉപയോഗത്തിൽ
മുകളിൽ a ട്രേസ്ഡ് വാല്യൂ അത് ആ വേരിയബിളിന്റെ പഴയതും പുതിയതുമായ മൂല്യം നൽകും,
ഈ സാഹചര്യത്തിൽ ഒരു int32_t മൂല്യം. യുടെ പരിശോധനയിലൂടെ ട്രേസ്ഡ് വാല്യൂ പ്രഖ്യാപനം, നമുക്കറിയാം
ട്രെയ്‌സ് സിങ്ക് ഫംഗ്‌ഷനിൽ ആർഗ്യുമെന്റുകൾ ഉണ്ടാകും (സ്ഥിരത int32_t പഴയ മൂല്യം, കൺസ്ട്രക്റ്റർ int32_t പുതിയ മൂല്യം).
a എന്നതിനായുള്ള മടക്ക തരം ട്രേസ്ഡ് വാല്യൂ കോൾബാക്ക് പ്രവർത്തനം എപ്പോഴും ആണ് ശൂന്യം, അങ്ങനെ പ്രതീക്ഷിച്ചത്
കോൾബാക്ക് ഒപ്പ് ഇതായിരിക്കും:

അസാധുവാണ് (* TracedValueCallback)(const int32_t oldvalue, const int32_t newValue);

ദി .AddTraceSource ലെ GetTypeId ബന്ധിപ്പിക്കുന്നതിന് ഉപയോഗിക്കുന്ന "ഹുക്കുകൾ" രീതി നൽകുന്നു
കോൺഫിഗറേഷൻ സിസ്റ്റം വഴി പുറം ലോകത്തേക്കുള്ള ഉറവിടം കണ്ടെത്തുക. ഞങ്ങൾ ഇതിനകം ചർച്ച ചെയ്തു
ആദ്യ മൂന്ന് കരാറുകൾ AddTraceSource: കോൺഫിഗറേഷൻ സിസ്റ്റത്തിനായുള്ള ആട്രിബ്യൂട്ട് നാമം, ഒരു സഹായം
സ്ട്രിംഗ്, കൂടാതെ TracedValue ക്ലാസ് ഡാറ്റ അംഗത്തിന്റെ വിലാസം.

ഉദാഹരണത്തിലെ അവസാന സ്ട്രിംഗ് ആർഗ്യുമെന്റ്, "ns3::Traced::Value::Int32" എന്നതിന്റെ പേരാണ്
ടൈപ്പ്ഡ് കോൾബാക്ക് ഫംഗ്‌ഷൻ സിഗ്‌നേച്ചറിനായി. ഈ ഒപ്പുകൾ നിർവചിക്കണമെന്ന് ഞങ്ങൾ ആവശ്യപ്പെടുന്നു,
കൂടാതെ പൂർണ്ണ യോഗ്യതയുള്ള തരം പേര് നൽകുക AddTraceSource, അതിനാൽ API ഡോക്യുമെന്റേഷന് കഴിയും
ഫംഗ്‌ഷൻ സിഗ്‌നേച്ചറിലേക്ക് ഒരു ട്രെയ്‌സ് സോഴ്‌സ് ലിങ്ക് ചെയ്യുക. TracedValue എന്നതിന് ഒപ്പ് ആണ്
നേരേചൊവ്വേ; TracedCallbacks-ന് API ഡോക്‌സ് ശരിക്കും സഹായിക്കുമെന്ന് ഞങ്ങൾ ഇതിനകം കണ്ടിട്ടുണ്ട്.

റിയൽ ഉദാഹരണം
ചുറ്റുമുള്ള ടിസിപിയിലെ ഏറ്റവും അറിയപ്പെടുന്ന പുസ്തകങ്ങളിലൊന്നിൽ നിന്ന് എടുത്ത ഒരു ഉദാഹരണം നോക്കാം. "TCP/IP
ഇല്ലസ്ട്രേറ്റഡ്, വാല്യം 1: ദി പ്രോട്ടോക്കോളുകൾ," ഡബ്ല്യു. റിച്ചാർഡ് സ്റ്റീവൻസ് എഴുതിയത് ഒരു ക്ലാസിക് ആണ്. ഞാൻ ഇപ്പോൾ മറിച്ചു.
പുസ്തകം തുറന്ന് തിരക്കുള്ള ജാലകത്തിന്റെയും ക്രമത്തിന്റെയും ഒരു നല്ല പ്ലോട്ടിലൂടെ ഓടി
പേജ് 366-ലെ സംഖ്യകളും സമയവും. സ്റ്റീവൻസ് ഇതിനെ വിളിക്കുന്നു, "ചിത്രം 21.10. cwnd ന്റെ മൂല്യവും
ഡാറ്റ കൈമാറ്റം ചെയ്യപ്പെടുമ്പോൾ സീക്വൻസ് നമ്പർ അയയ്ക്കുക." നമുക്ക് cwnd ഭാഗം പുനഃസൃഷ്ടിക്കാം
ആ പ്ലോട്ടിന്റെ ns-3 ട്രേസിംഗ് സിസ്റ്റം ഉപയോഗിച്ച് ഗ്നുപ്ലോട്ട്.

ലഭ്യമായ ഉറവിടങ്ങൾ
ഡാറ്റ എങ്ങനെ പുറത്തെടുക്കണം എന്നതാണ് ആദ്യം ചിന്തിക്കേണ്ടത്. അതെന്താ നമ്മൾ
കണ്ടെത്തേണ്ടതുണ്ടോ? അതിനാൽ നമുക്ക് എന്താണ് ചെയ്യേണ്ടതെന്ന് കാണാൻ "എല്ലാ ട്രേസ് ഉറവിടങ്ങളും" ലിസ്റ്റ് പരിശോധിക്കാം
കൂടെ. യിൽ ഇത് കണ്ടെത്തിയതായി ഓർക്കുക ns-3 API ഡോക്യുമെന്റേഷൻ. നിങ്ങൾ സ്ക്രോൾ ചെയ്യുകയാണെങ്കിൽ
പട്ടിക, നിങ്ങൾ ഒടുവിൽ കണ്ടെത്തും:
ns3::TcpNewReno

· തിരക്കുള്ള ജാലകം: TCP കണക്ഷന്റെ കൺജഷൻ വിൻഡോ

· സ്ലോസ്റ്റാർട്ട് ത്രെഷോൾഡ്: TCP സ്ലോ സ്റ്റാർട്ട് ത്രെഷോൾഡ് (ബൈറ്റുകൾ)

അത് മാറുന്നു ns-3 TCP നടപ്പിലാക്കൽ ഫയലിൽ (മിക്കവാറും) ജീവിക്കുന്നു
src/internet/model/tcp-socket-base.cc തിരക്ക് നിയന്ത്രണ വകഭേദങ്ങൾ ഫയലുകളിൽ ഉള്ളപ്പോൾ
as src/internet/model/tcp-newreno.cc. നിങ്ങൾക്ക് ഇത് അറിയില്ലെങ്കിൽ a priori, നിങ്ങൾക്ക് ഉപയോഗിക്കാം
ആവർത്തന grep തന്ത്രം:

$ കണ്ടെത്തുക. -പേര് '*.cc' | xargs grep -i tcp

ആ ഫയലിലേക്ക് നിങ്ങളെ ചൂണ്ടിക്കാണിക്കുന്ന tcp സംഭവങ്ങളുടെ ഓരോ പേജും നിങ്ങൾ കണ്ടെത്തും.

ക്ലാസ് ഡോക്യുമെന്റേഷൻ കൊണ്ടുവരുന്നു TcpNewReno കൂടാതെ ലിസ്റ്റിലേക്ക് സ്കിപ്പ് ചെയ്യുന്നു
TraceSources നിങ്ങൾ കണ്ടെത്തും
ട്രേസ് സോഴ്‌സ്

· തിരക്കുള്ള ജാലകം: TCP കണക്ഷന്റെ കൺജഷൻ വിൻഡോ

കോൾബാക്ക് ഒപ്പ്: ns3::ട്രേസ്ഡ്::മൂല്യം::Uint322കോൾബാക്ക്

കോൾബാക്കിൽ ക്ലിക്ക് ചെയ്യുക ടൈപ്പ്ഡ് ലിങ്ക് നിങ്ങൾ ഇപ്പോൾ പ്രതീക്ഷിക്കുന്ന ഒപ്പ് ഞങ്ങൾ കാണുന്നു:

typedef void(* ns3::Traced::Value::Int32Callback)(const int32_t oldValue, const int32_t newValue)

നിങ്ങൾ ഇപ്പോൾ ഈ കോഡ് പൂർണ്ണമായും മനസ്സിലാക്കണം. നമുക്ക് ഒരു പോയിന്റർ ഉണ്ടെങ്കിൽ TcpNewReno,
നമുക്ക് കഴിയും TraceConnect ഞങ്ങൾ ഉചിതമായത് നൽകിയാൽ "CongestionWindow" ട്രെയ്സ് ഉറവിടത്തിലേക്ക്
കോൾബാക്ക് ലക്ഷ്യം. ലളിതമായ ഉദാഹരണത്തിൽ നമ്മൾ കണ്ട അതേ തരത്തിലുള്ള ട്രെയ്സ് ഉറവിടമാണിത്
ഈ വിഭാഗത്തിന്റെ തുടക്കത്തിൽ, നമ്മൾ സംസാരിക്കുന്നത് ഒഴികെ uint32_t ഇതിനുപകരമായി
int32_t. ആ ഒപ്പിനൊപ്പം ഒരു കോൾബാക്ക് ഫംഗ്‌ഷൻ നൽകേണ്ടതുണ്ടെന്ന് ഞങ്ങൾക്കറിയാം.

കണ്ടെത്തുന്നു ഉദാഹരണങ്ങൾ
പകരം നിങ്ങൾക്ക് പരിഷ്‌ക്കരിക്കാവുന്ന വർക്കിംഗ് കോഡ് കണ്ടെത്താൻ ശ്രമിക്കുന്നതാണ് എപ്പോഴും നല്ലത്
ആദ്യം മുതൽ ആരംഭിക്കുന്നതിനേക്കാൾ. അതിനാൽ ഇപ്പോൾ ബിസിനസ്സിന്റെ ആദ്യ ക്രമം ചില കോഡ് കണ്ടെത്തുക എന്നതാണ്
"CongestionWindow" ട്രെയ്‌സ് സോഴ്‌സ് ഇതിനകം ഹുക്ക് ചെയ്‌ത് ഞങ്ങൾക്ക് അത് പരിഷ്‌ക്കരിക്കാൻ കഴിയുമോ എന്ന് നോക്കുക. സാധാരണത്തേത് പോലെ,
grep നിങ്ങളുടെ സുഹൃത്താണ്:

$ കണ്ടെത്തുക. -പേര് '*.cc' | xargs grep CongestionWindow

ഇത് വാഗ്ദാനമുള്ള രണ്ട് സ്ഥാനാർത്ഥികളെ ചൂണ്ടിക്കാണിക്കും: ഉദാഹരണങ്ങൾ/tcp/tcp-large-transfer.cc
ഒപ്പം src/test/ns3tcp/ns3tcp-cwnd-test-suite.cc.

ഞങ്ങൾ ഇതുവരെ ഒരു ടെസ്റ്റ് കോഡും സന്ദർശിച്ചിട്ടില്ല, അതിനാൽ നമുക്ക് അവിടെ നോക്കാം. നിങ്ങൾ ഇത് ചെയ്യും
ടെസ്റ്റ് കോഡ് വളരെ കുറവാണെന്ന് സാധാരണയായി കണ്ടെത്താം, അതിനാൽ ഇത് വളരെ നല്ല പന്തയമാണ്.
തുറക്കുക src/test/ns3tcp/ns3tcp-cwnd-test-suite.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ തിരയുക
"തിരക്കേറിയ ജാലകം". നിങ്ങൾ കണ്ടെത്തും,

ns3TcpSocket->TraceConnect WithoutContext ("CongestionWindow",
MakeCallback (&Ns3TcpCwndTestCase1::CwndChange, ഇത്));

ഇത് നിങ്ങൾക്ക് വളരെ പരിചിതമായി തോന്നണം. ഒരു പോയിന്റർ ഉണ്ടെങ്കിൽ ഞങ്ങൾ മുകളിൽ സൂചിപ്പിച്ചു
TcpNewReno, നമുക്ക് TraceConnect "CongestionWindow" ട്രെയ്സ് ഉറവിടത്തിലേക്ക്. അത് കൃത്യമായി
ഞങ്ങൾക്ക് ഇവിടെ എന്താണ് ഉള്ളത്; അതിനാൽ ഈ കോഡിന്റെ വരി നമ്മൾ ആഗ്രഹിക്കുന്നത് കൃത്യമായി ചെയ്യുന്നു.
നമുക്ക് മുന്നോട്ട് പോയി ഈ ഫംഗ്‌ഷനിൽ നിന്ന് ആവശ്യമായ കോഡ് എക്‌സ്‌ട്രാക്റ്റ് ചെയ്യാം (Ns3TcpCwndTestCase1::DoRun
(അസാധു)). നിങ്ങൾ ഈ ഫംഗ്‌ഷൻ നോക്കുകയാണെങ്കിൽ, ഇത് ഒരു പോലെയാണെന്ന് നിങ്ങൾ കണ്ടെത്തും ns-3
സ്ക്രിപ്റ്റ്. അത് കൃത്യമായി എന്താണ് എന്ന് മാറുന്നു. ഇത് ടെസ്റ്റ് നടത്തുന്ന ഒരു സ്ക്രിപ്റ്റാണ്
ചട്ടക്കൂട്, അതിനാൽ നമുക്ക് അത് പുറത്തെടുത്ത് പൊതിയാൻ കഴിയും പ്രധാന പകരം ഇൻ ഡോറൺ. മറിച്ച്
ഇതിലൂടെ നടക്കുന്നതിനേക്കാൾ, ഘട്ടം ഘട്ടമായി, പോർട്ടിംഗിന്റെ ഫലമായുണ്ടാകുന്ന ഫയൽ ഞങ്ങൾ നൽകിയിട്ടുണ്ട്
ഈ പരിശോധന ഒരു സ്വദേശിക്ക് തിരികെ നൽകണം ns-3 സ്ക്രിപ്റ്റ് -- ഉദാഹരണങ്ങൾ/tutorial/fifth.cc.

ഡൈനാമിക് ട്രെയ്സ് ഉറവിടങ്ങൾ
ദി fifth.cc നിങ്ങൾ മനസ്സിലാക്കേണ്ട വളരെ പ്രധാനപ്പെട്ട ഒരു നിയമം ഉദാഹരണം കാണിക്കുന്നു
ഏതെങ്കിലും തരത്തിലുള്ള ട്രെയ്സ് ഉറവിടം ഉപയോഗിക്കുന്നതിന് മുമ്പ്: a-യുടെ ലക്ഷ്യം നിങ്ങൾ ഉറപ്പാക്കണം
കോൺഫിഗറേഷൻ ::കണക്റ്റ് ചെയ്യുക കമാൻഡ് ഉപയോഗിക്കുന്നതിന് മുമ്പ് നിലവിലുണ്ട്. ഇത് പറയുന്നതിൽ നിന്ന് വ്യത്യസ്തമല്ല
ഒരു വസ്തുവിനെ വിളിക്കാൻ ശ്രമിക്കുന്നതിന് മുമ്പ് അത് തൽക്ഷണം ചെയ്യണം. ഇത് വ്യക്തമായതായി തോന്നാമെങ്കിലും
ഈ രീതിയിൽ പ്രസ്താവിക്കുമ്പോൾ, ആദ്യം സിസ്റ്റം ഉപയോഗിക്കാൻ ശ്രമിക്കുന്ന പലരെയും ഇത് ട്രിപ്പ് ചെയ്യുന്നു
സമയം.

നമുക്ക് ഒരു നിമിഷം അടിസ്ഥാനകാര്യങ്ങളിലേക്ക് മടങ്ങാം. മൂന്ന് അടിസ്ഥാന നിർവ്വഹണ ഘട്ടങ്ങൾ നിലവിലുണ്ട്
എന്തെങ്കിലും ns-3 സ്ക്രിപ്റ്റ്. ആദ്യ ഘട്ടത്തെ ചിലപ്പോൾ "കോൺഫിഗറേഷൻ സമയം" അല്ലെങ്കിൽ "സെറ്റപ്പ്" എന്ന് വിളിക്കുന്നു
സമയം," എന്ന കാലയളവിൽ നിലവിലുണ്ട് പ്രധാന നിങ്ങളുടെ സ്ക്രിപ്റ്റിന്റെ പ്രവർത്തനം പ്രവർത്തിക്കുന്നു, പക്ഷേ
മുമ്പ് സിമുലേറ്റർ:: റൺ വിളിച്ചു. രണ്ടാം ഘട്ടത്തെ ചിലപ്പോൾ "സിമുലേഷൻ സമയം" എന്ന് വിളിക്കുന്നു
എപ്പോൾ കാലഘട്ടത്തിൽ നിലവിലുണ്ട് സിമുലേറ്റർ:: റൺ അതിന്റെ ഇവന്റുകൾ സജീവമായി നടപ്പിലാക്കുന്നു.
സിമുലേഷൻ നടപ്പിലാക്കുന്നത് പൂർത്തിയാക്കിയ ശേഷം, സിമുലേറ്റർ:: റൺ എന്നതിലേക്ക് നിയന്ത്രണം തിരികെ നൽകും
The പ്രധാന പ്രവർത്തനം. ഇത് സംഭവിക്കുമ്പോൾ, സ്ക്രിപ്റ്റ് "ടിയർഡൗൺ" എന്ന് വിളിക്കാവുന്നതിലേക്ക് പ്രവേശിക്കുന്നു
ഘട്ടം," സജ്ജീകരണ സമയത്ത് സൃഷ്ടിക്കപ്പെട്ട ഘടനകളും വസ്തുക്കളും വേർപെടുത്തുമ്പോൾ
പുറത്തിറക്കി.

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

ഈ ആശയക്കുഴപ്പത്തിനുള്ള രണ്ട് പരിഹാരങ്ങളാണ്

1. ഡൈനാമിക് ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിച്ചതിന് ശേഷം പ്രവർത്തിപ്പിക്കുന്ന ഒരു സിമുലേറ്റർ ഇവന്റ് സൃഷ്‌ടിക്കുകയും ഹുക്ക് ചെയ്യുകയും ചെയ്യുക
ആ ഇവന്റ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ കണ്ടെത്തുക; അഥവാ

2. കോൺഫിഗറേഷൻ സമയത്ത് ഡൈനാമിക് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുക, തുടർന്ന് അത് ഹുക്ക് ചെയ്യുക, തുടർന്ന് ഒബ്‌ജക്റ്റ് നൽകുക
സിമുലേഷൻ സമയത്ത് ഉപയോഗിക്കേണ്ട സിസ്റ്റം.

ഞങ്ങൾ രണ്ടാമത്തെ സമീപനം സ്വീകരിച്ചു fifth.cc ഉദാഹരണം. ഈ തീരുമാനം ഞങ്ങൾക്ക് സൃഷ്ടിക്കാൻ ആവശ്യമായിരുന്നു
The എന്റെ ആപ്പ് അപേക്ഷ, ഇതിന്റെ മുഴുവൻ ഉദ്ദേശവും ഒരു എടുക്കുക എന്നതാണ് സോക്കറ്റ് ഒരു പരാമീറ്ററായി.

നടപ്പാത: fifth.cc
ഇപ്പോൾ, തിരക്ക് വേർതിരിച്ചുകൊണ്ട് ഞങ്ങൾ നിർമ്മിച്ച ഉദാഹരണ പ്രോഗ്രാം നോക്കാം
വിൻഡോ ടെസ്റ്റ്. തുറക്കുക ഉദാഹരണങ്ങൾ/tutorial/fifth.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ. നിങ്ങൾ കാണണം
പരിചിതമായ ചില കോഡ്:

/* -*- മോഡ്:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* ഈ പ്രോഗ്രാം ഒരു സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ആണ്; നിങ്ങൾക്ക് ഇത് പുനർവിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കാനും കഴിയും
* ഇത് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ് പതിപ്പ് 2-ന്റെ നിബന്ധനകൾക്ക് കീഴിലാണ്
* സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ പ്രസിദ്ധീകരിച്ചത്;
*
* ഈ പ്രോഗ്രാം ഉപയോഗപ്രദമാകുമെന്ന പ്രതീക്ഷയിലാണ് വിതരണം ചെയ്യുന്നത്,
* എന്നാൽ യാതൊരു വാറന്റിയും ഇല്ലാതെ; യുടെ സൂചിപ്പിച്ച വാറന്റി പോലുമില്ലാതെ
* ഒരു പ്രത്യേക ഉദ്ദേശ്യത്തിനായുള്ള വ്യാപാരം അല്ലെങ്കിൽ ഫിറ്റ്നസ്. കാണുക
* കൂടുതൽ വിവരങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസ്.
*
* നിങ്ങൾക്ക് ഗ്നു ജനറൽ പബ്ലിക് ലൈസൻസിന്റെ ഒരു പകർപ്പ് ലഭിച്ചിരിക്കണം
* ഈ പ്രോഗ്രാമിനൊപ്പം; ഇല്ലെങ്കിൽ, സ്വതന്ത്ര സോഫ്റ്റ്‌വെയറിലേക്ക് എഴുതുക
* ഫൗണ്ടേഷൻ, ഉൾപ്പെടുത്തുക., 59 ടെമ്പിൾ പ്ലേസ്, സ്യൂട്ട് 330, ബോസ്റ്റൺ, എംഎ 02111-1307 യുഎസ്എ
*/

#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുത്തുക "ns3/core-module.h"
#ഉൾപ്പെടുത്തുക "ns3/network-module.h"
#ഉൾപ്പെടുത്തുക "ns3/internet-module.h"
#ഉൾപ്പെടുത്തുക "ns3/point-to-point-module.h"
#ഉൾപ്പെടുത്തുക "ns3/applications-module.h"

നെയിംസ്പേസ് ns3 ഉപയോഗിക്കുന്നു;

NS_LOG_COMPONENT_DEFINE ("FifthScriptExample");

ഇതെല്ലാം കവർ ചെയ്‌തിരിക്കുന്നു, അതിനാൽ ഞങ്ങൾ ഇത് വീണ്ടും കാണിക്കില്ല. ഉറവിടത്തിന്റെ അടുത്ത വരികൾ
നെറ്റ്‌വർക്ക് ചിത്രീകരണവും മുകളിൽ വിവരിച്ച പ്രശ്നത്തെ അഭിസംബോധന ചെയ്യുന്ന ഒരു കമന്റും സോക്കറ്റ്.

// ================================================== ============================
//
// നോഡ് 0 നോഡ് 1
// +------------------+ +------------------+
// | ns-3 TCP | | ns-3 TCP |
// +------------------+ +------------------+
// | 10.1.1.1 | | 10.1.1.2 |
// +------------------+ +------------------+
// | പോയിന്റ്-ടു-പോയിന്റ് | | പോയിന്റ്-ടു-പോയിന്റ് |
// +------------------+ +------------------+
// | |
// +------------------------+
// 5 Mbps, 2 ms
//
//
// ns-3 TCP കൺജഷൻ വിൻഡോയിലെ മാറ്റങ്ങൾ നോക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. നമുക്ക് വേണം
// ഒരു ഒഴുക്ക് വർദ്ധിപ്പിക്കാനും സോക്കറ്റിൽ CongestionWindow ആട്രിബ്യൂട്ട് ഹുക്ക് ചെയ്യാനും
അയച്ചയാളുടെ //. ഒരു ജനറേറ്റ് ചെയ്യുന്നതിന് സാധാരണയായി ഒരാൾ ഓൺ-ഓഫ് ആപ്ലിക്കേഷൻ ഉപയോഗിക്കും
// ഒഴുക്ക്, പക്ഷേ ഇതിന് കുറച്ച് പ്രശ്‌നങ്ങളുണ്ട്. ആദ്യം, ഓൺ-ഓഫിന്റെ സോക്കറ്റ്
// ആപ്ലിക്കേഷൻ ആരംഭിക്കുന്ന സമയം വരെ ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കപ്പെട്ടിട്ടില്ല, അതിനാൽ ഞങ്ങൾ അങ്ങനെ ചെയ്യില്ല
// കോൺഫിഗറേഷൻ സമയത്ത് സോക്കറ്റ് (ഇപ്പോൾ) ഹുക്ക് ചെയ്യാൻ കഴിയും. രണ്ടാമത്, നമ്മൾ ആണെങ്കിലും
// ആരംഭിക്കുന്ന സമയത്തിന് ശേഷം ഒരു കോൾ ക്രമീകരിക്കാം, സോക്കറ്റ് പൊതുവായതല്ല അതിനാൽ ഞങ്ങൾ
//അത് മനസ്സിലാക്കാൻ കഴിഞ്ഞില്ല.
//
// അതിനാൽ, ഓൺ-ഓഫ് ആപ്ലിക്കേഷന്റെ ലളിതമായ ഒരു പതിപ്പ് നമുക്ക് തയ്യാറാക്കാം
// ഞങ്ങൾക്ക് വേണം. പ്ലസ് വശത്ത്, ഓൺ-ഓഫിന്റെ എല്ലാ സങ്കീർണ്ണതയും ഞങ്ങൾക്ക് ആവശ്യമില്ല
// ആപ്ലിക്കേഷൻ. മൈനസ് സൈഡിൽ, ഞങ്ങൾക്ക് ഒരു സഹായി ഇല്ല, അതിനാൽ നമുക്ക് ലഭിക്കണം
// വിശദാംശങ്ങളിൽ കുറച്ചുകൂടി ഉൾപ്പെടുന്നു, പക്ഷേ ഇത് നിസ്സാരമാണ്.
//
// അതിനാൽ ആദ്യം, ഞങ്ങൾ ഒരു സോക്കറ്റ് സൃഷ്ടിച്ച് അതിൽ ട്രേസ് കണക്ട് ചെയ്യുന്നു; അപ്പോൾ ഞങ്ങൾ കടന്നുപോകുന്നു
// ഈ സോക്കറ്റ് ഞങ്ങളുടെ ലളിതമായ ആപ്ലിക്കേഷന്റെ കൺസ്ട്രക്റ്ററിലേക്ക് ഞങ്ങൾ പിന്നീട്
// സോഴ്സ് നോഡിൽ ഇൻസ്റ്റാൾ ചെയ്യുക.
// ================================================== ============================
//

ഇതും സ്വയം വിശദീകരിക്കേണ്ടതാണ്.

യുടെ പ്രഖ്യാപനമാണ് അടുത്ത ഭാഗം എന്റെ ആപ്പ് അപേക്ഷ അനുവദിക്കുന്നതിനായി ഞങ്ങൾ ഒരുമിച്ച് ചേർത്തത്
The സോക്കറ്റ് കോൺഫിഗറേഷൻ സമയത്ത് സൃഷ്ടിക്കേണ്ടതാണ്.

ക്ലാസ് MyApp: പൊതു ആപ്ലിക്കേഷൻ
{
പൊതുവായത്:

MyApp ();
വെർച്വൽ ~MyApp();

അസാധുവായ സജ്ജീകരണം (Ptr സോക്കറ്റ്, വിലാസ വിലാസം, uint32_t packetSize,
uint32_t nPackets, DataRate dataRate);

സ്വകാര്യം:
വെർച്വൽ ശൂന്യമായ StartApplication (അസാധു);
വെർച്വൽ ശൂന്യമായ സ്റ്റോപ്പ് ആപ്ലിക്കേഷൻ (അസാധു);

ശൂന്യമായ ScheduleTx (അസാധു);
അസാധുവായ SendPacket (അസാധു);

Ptr m_socket;
വിലാസം m_peer;
uint32_t m_packetSize;
uint32_t m_nPackets;
ഡാറ്റാ റേറ്റ് m_dataRate;
EventId m_sendEvent;
bool m_running;
uint32_t m_packetsSent;
};

ഈ വർഗ്ഗത്തിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നത് നിങ്ങൾക്ക് കാണാൻ കഴിയും ns-3 അപേക്ഷ ക്ലാസ്. ഒന്ന് നോക്കിക്കോളു
src/network/model/application.h നിങ്ങൾക്ക് പാരമ്പര്യമായി ലഭിച്ചതിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ. ദി എന്റെ ആപ്പ്
ക്ലാസ് മറികടക്കാൻ ബാധ്യസ്ഥനാണ് ആപ്ലിക്കേഷൻ ആരംഭിക്കുക ഒപ്പം അപേക്ഷ നിർത്തുക രീതികൾ. ഇവ
എപ്പോൾ രീതികൾ സ്വയമേവ വിളിക്കപ്പെടുന്നു എന്റെ ആപ്പ് ഡാറ്റ അയയ്ക്കുന്നത് ആരംഭിക്കുന്നതിനും നിർത്തുന്നതിനും ആവശ്യമാണ്
സിമുലേഷൻ സമയത്ത്.

ആരംഭിക്കുന്നു/നിർത്തുന്നു അപ്ലിക്കേഷനുകൾ
ഇവന്റുകൾ യഥാർത്ഥത്തിൽ എങ്ങനെ ആരംഭിക്കുന്നുവെന്ന് വിശദീകരിക്കാൻ കുറച്ച് സമയം ചെലവഴിക്കുന്നത് മൂല്യവത്താണ്
സിസ്റ്റം. ഇത് വളരെ ആഴത്തിലുള്ള മറ്റൊരു വിശദീകരണമാണ്, നിങ്ങൾ അങ്ങനെയല്ലെങ്കിൽ അവഗണിക്കാവുന്നതാണ്
സിസ്റ്റത്തിന്റെ ധൈര്യത്തിലേക്ക് ഇറങ്ങാൻ പദ്ധതിയിടുന്നു. എന്നിരുന്നാലും, അതിൽ ഇത് ഉപയോഗപ്രദമാണ്
വളരെ പ്രധാനപ്പെട്ട ചില ഭാഗങ്ങൾ എങ്ങനെ എന്നതിനെയാണ് ചർച്ച സ്പർശിക്കുന്നത് ns-3 പ്രവർത്തിക്കുകയും ചിലത് തുറന്നുകാട്ടുകയും ചെയ്യുന്നു
പ്രധാനപ്പെട്ട പദപ്രയോഗങ്ങൾ. നിങ്ങൾ പുതിയ മോഡലുകൾ നടപ്പിലാക്കാൻ പദ്ധതിയിടുകയാണെങ്കിൽ, നിങ്ങൾ ഒരുപക്ഷേ ആഗ്രഹിക്കും
ഈ വിഭാഗം മനസ്സിലാക്കുക.

പമ്പിംഗ് ഇവന്റുകൾ ആരംഭിക്കുന്നതിനുള്ള ഏറ്റവും സാധാരണമായ മാർഗ്ഗം ഒരു ആരംഭിക്കുക എന്നതാണ് അപേക്ഷ. എന്ന നിലയിലാണ് ഇത് ചെയ്യുന്നത്
ഇനിപ്പറയുന്ന (പ്രതീക്ഷയോടെ) പരിചിതമായ വരികളുടെ ഫലം ns-3 സ്ക്രിപ്റ്റ്:

ApplicationContainer ആപ്പുകൾ =...
apps.Start (സെക്കൻഡ് (1.0));
apps.Stop (സെക്കൻഡ് (10.0));

ആപ്ലിക്കേഷൻ കണ്ടെയ്നർ കോഡ് (കാണുക src/network/helper/application-container.h നിങ്ങളാണെങ്കിൽ
താൽപ്പര്യമുള്ളത്) അതിൽ അടങ്ങിയിരിക്കുന്ന ആപ്ലിക്കേഷനുകളിലൂടെയും കോളുകളിലൂടെയും ലൂപ്പ് ചെയ്യുന്നു,

app->SetStartTime (startTime);

അതിന്റെ ഫലമായി apps.ആരംഭിക്കുക വിളിക്കുക ഒപ്പം

app->SetStopTime (stopTime);

അതിന്റെ ഫലമായി apps.നിർത്തുക വിളി.

ഈ കോളുകളുടെ ആത്യന്തിക ഫലം നമുക്ക് സ്വയമേവ സിമുലേറ്റർ വേണമെന്നതാണ്
ഞങ്ങളിലേക്ക് കോളുകൾ ചെയ്യുക അപ്ലിക്കേഷനുകൾ എപ്പോൾ തുടങ്ങണമെന്നും നിർത്തണമെന്നും അവരോട് പറയാൻ. ഈ സന്ദർഭത്തിൽ
എന്റെ ആപ്പ്, അത് ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു അപേക്ഷ അസാധുവാക്കുകയും ചെയ്യുന്നു ആപ്ലിക്കേഷൻ ആരംഭിക്കുക, ഒപ്പം
അപേക്ഷ നിർത്തുക. യിലെ സിമുലേറ്റർ വിളിക്കുന്ന ഫംഗ്‌ഷനുകൾ ഇവയാണ്
ഉചിതമായ സമയം. ഈ സന്ദർഭത്തിൽ എന്റെ ആപ്പ് നിങ്ങൾ അത് കണ്ടെത്തും MyApp::ആപ്ലിക്കേഷൻ ആരംഭിക്കുക ചെയ്യുന്നവൻ
പ്രാരംഭം ബൈൻഡ് ചെയ്യുക, ഒപ്പം ബന്ധിപ്പിക്കുക സോക്കറ്റിൽ, തുടർന്ന് കോളിംഗ് വഴി ഡാറ്റ ഒഴുകാൻ തുടങ്ങുന്നു
MyApp::SendPacket. MyApp::StopApplication ഏതെങ്കിലും റദ്ദാക്കി പാക്കറ്റുകൾ നിർമ്മിക്കുന്നത് നിർത്തുന്നു
തീർച്ചപ്പെടുത്താത്ത അയയ്‌ക്കുന്ന ഇവന്റുകൾ തുടർന്ന് സോക്കറ്റ് അടയ്ക്കുന്നു.

നല്ല കാര്യങ്ങളിൽ ഒന്ന് ns-3 നിങ്ങൾ നടപ്പിലാക്കുന്നത് പൂർണ്ണമായും അവഗണിക്കാം എന്നതാണ്
നിങ്ങളുടെ എങ്ങനെ എന്നതിന്റെ വിശദാംശങ്ങൾ അപേക്ഷ ശരിയായ ഭാഗത്ത് സിമുലേറ്റർ "യാന്ത്രികമായി" വിളിക്കുന്നു
സമയം. എന്നാൽ ഞങ്ങൾ ഇതിനകം ആഴത്തിൽ ഇറങ്ങിയതിനാൽ ns-3 ഇതിനകം, നമുക്ക് അതിനായി പോകാം.

നിങ്ങൾ നോക്കുകയാണെങ്കിൽ src/network/model/application.cc നിങ്ങൾ അത് കണ്ടെത്തും SetStartTime രീതി
ഒരു അപേക്ഷ അംഗ വേരിയബിൾ സജ്ജമാക്കുന്നു m_startTime ഒപ്പം SetStopTime രീതി
വെറും സെറ്റ് m_stopTime. അവിടെ നിന്ന്, ചില സൂചനകളില്ലാതെ, പാത മിക്കവാറും അവസാനിക്കും.

എല്ലാറ്റിന്റെയും ഒരു ആഗോള ലിസ്റ്റ് ഉണ്ടെന്ന് അറിയുക എന്നതാണ് പാത വീണ്ടും എടുക്കുന്നതിനുള്ള പ്രധാന കാര്യം
സിസ്റ്റത്തിലെ നോഡുകൾ. നിങ്ങൾ ഒരു സിമുലേഷനിൽ ഒരു നോഡ് സൃഷ്ടിക്കുമ്പോഴെല്ലാം, ആ നോഡിലേക്കുള്ള ഒരു പോയിന്റർ
ആഗോളതലത്തിൽ ചേർത്തിരിക്കുന്നു നോഡ് ലിസ്റ്റ്.

ഒന്ന് നോക്കിക്കോളു src/network/model/node-list.cc കൂടാതെ തിരയുക നോഡ്‌ലിസ്റ്റ്::ചേർക്കുക. പൊതുജനം
സ്റ്റാറ്റിക് നടപ്പിലാക്കൽ എന്ന് വിളിക്കപ്പെടുന്ന ഒരു സ്വകാര്യ നടപ്പിലാക്കലിലേക്ക് വിളിക്കുന്നു NodeListPriv::ചേർക്കുക. ഈ
താരതമ്യേന സാധാരണമായ ഒരു വിഗ്രഹമാണ് ns-3. അതിനാൽ, ഒന്ന് നോക്കൂ NodeListPriv::ചേർക്കുക. അവിടെ നിങ്ങൾ
കണ്ടെത്തും,

സിമുലേറ്റർ::ScheduleWithContext (സൂചിക, ടൈംസ്റ്റെപ്പ് (0), &നോഡ്::ഇനിഷ്യലൈസ്, നോഡ്);

ഒരു സിമുലേഷനിൽ ഒരു നോഡ് സൃഷ്ടിക്കപ്പെടുമ്പോഴെല്ലാം, ഒരു പാർശ്വഫലമായി, ഒരു കോൾ എന്ന് ഇത് നിങ്ങളോട് പറയുന്നു.
ആ നോഡിലേക്ക് ആരംഭിക്കുക പൂജ്യം സമയത്ത് സംഭവിക്കുന്ന രീതി നിങ്ങൾക്കായി ഷെഡ്യൂൾ ചെയ്തിട്ടുണ്ട്. ചെയ്യരുത്
ആ പേരിൽ വളരെയധികം വായിച്ചു, എന്നിട്ടും. നോഡ് ചെയ്യാൻ തുടങ്ങുമെന്ന് ഇതിനർത്ഥമില്ല
എന്തും, നോഡിലേക്കുള്ള ഒരു വിവര കോളായി അതിനെ വ്യാഖ്യാനിക്കാം
സിമുലേഷൻ ആരംഭിച്ചു, എന്തെങ്കിലും ചെയ്യാൻ തുടങ്ങാൻ നോഡിനോട് പറയുന്ന പ്രവർത്തനത്തിനുള്ള കോളല്ല.

അങ്ങനെ, നോഡ്‌ലിസ്റ്റ്::ചേർക്കുക പരോക്ഷമായി ഒരു കോൾ ഷെഡ്യൂൾ ചെയ്യുന്നു നോഡ്::ആരംഭിക്കുക ഉപദേശിക്കാൻ പൂജ്യം സമയത്ത് a
സിമുലേഷൻ ആരംഭിച്ച പുതിയ നോഡ്. അകത്തേക്ക് നോക്കിയാൽ src/network/model/node.h നിങ്ങളെ
എന്നിരുന്നാലും, എന്നൊരു രീതി കണ്ടെത്തുകയില്ല നോഡ്::ആരംഭിക്കുക. അത് മാറുന്നു
ആരംഭിക്കുക രീതി ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു വസ്തു. സിസ്റ്റത്തിലെ എല്ലാ വസ്തുക്കളും ആകാം
സിമുലേഷൻ ആരംഭിക്കുമ്പോൾ അറിയിക്കുന്നു, കൂടാതെ ക്ലാസ് നോഡിന്റെ ഒബ്‌ജക്‌റ്റുകൾ അവയിൽ ഒരു തരം മാത്രമാണ്
വസ്തുക്കൾ.

ഒന്ന് നോക്കിക്കോളു src/core/model/object.cc അടുത്തത് തിരയുക ഒബ്ജക്റ്റ്::ആരംഭിക്കുക. ഈ കോഡ്
നിങ്ങൾ പ്രതീക്ഷിച്ചത് പോലെ നേരായ കാര്യമല്ല ns-3 വസ്തുക്കൾ പിന്തുണ
സമാഹരണം. കോഡ് ഇൻ ഒബ്ജക്റ്റ്::ആരംഭിക്കുക തുടർന്ന് എല്ലാ വസ്തുക്കളിലൂടെയും ലൂപ്പ് ചെയ്യുന്നു
ഒന്നിച്ചു സമാഹരിച്ചു അവരുടെ വിളിക്കുന്നു ആരംഭിക്കുക രീതി. ഇത് മറ്റൊരു പ്രയോഗമാണ്
അത് വളരെ സാധാരണമാണ് ns-3, ചിലപ്പോൾ "ടെംപ്ലേറ്റ് ഡിസൈൻ പാറ്റേൺ" എന്ന് വിളിക്കുന്നു: ഒരു പൊതു
നോൺ-വെർച്വൽ API രീതി, അത് നടപ്പിലാക്കലുകളിലുടനീളം സ്ഥിരമായി നിലകൊള്ളുന്നു, അത് വിളിക്കുന്നു a
സ്വകാര്യ വെർച്വൽ നടപ്പിലാക്കൽ രീതി, അത് ഉപവിഭാഗങ്ങൾ വഴി പാരമ്പര്യമായി ലഭിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു.
പേരുകൾ സാധാരണയായി ഇതുപോലെയാണ് രീതിയുടെ പേര് പൊതു API-യ്‌ക്കും DoMethodName വേണ്ടി
സ്വകാര്യ API.

ഒരു തിരയണമെന്ന് ഇത് നമ്മോട് പറയുന്നു നോഡ്::DoInitialize രീതി
src/network/model/node.cc ഞങ്ങളുടെ പാത തുടരുന്ന രീതിക്കായി. നിങ്ങൾ കണ്ടെത്തുകയാണെങ്കിൽ
കോഡ്, നോഡിലെ എല്ലാ ഉപകരണങ്ങളിലൂടെയും ലൂപ്പ് ചെയ്യുന്ന ഒരു രീതി നിങ്ങൾ കണ്ടെത്തും
നോഡ് കോളിംഗിലെ എല്ലാ ആപ്ലിക്കേഷനുകളും ഉപകരണം->ആരംഭിക്കുക ഒപ്പം ആപ്ലിക്കേഷൻ->ആരംഭിക്കുക
യഥാക്രമം.

ക്ലാസുകൾ നിങ്ങൾക്ക് ഇതിനകം അറിയാമായിരിക്കും ഉപകരണ ഒപ്പം അപേക്ഷ രണ്ടും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു വസ്തു
അതിനാൽ എപ്പോൾ എന്ത് സംഭവിക്കും എന്നതായിരിക്കും അടുത്ത ഘട്ടം അപേക്ഷ::DoInitialize is
വിളിച്ചു. ഒന്ന് നോക്കിക്കോളു src/network/model/application.cc നിങ്ങൾ കണ്ടെത്തും:

ശൂന്യം
അപേക്ഷ::DoInitialize (അസാധു)
{
m_startEvent = സിമുലേറ്റർ :: ഷെഡ്യൂൾ (m_startTime, &Application ::StartApplication, ഇത്);
എങ്കിൽ (m_stopTime != TimeStep (0))
{
m_stopEvent = സിമുലേറ്റർ :: ഷെഡ്യൂൾ (m_stopTime, &Application ::StopApplication, ഇത്);
}
ഒബ്ജക്റ്റ്::DoInitialize ();
}

ഇവിടെ, ഞങ്ങൾ ഒടുവിൽ പാതയുടെ അവസാനത്തിൽ എത്തി. നിങ്ങൾ എല്ലാം നേരെയാക്കി എങ്കിൽ, നിങ്ങൾ എപ്പോൾ
ഒരു നടപ്പിലാക്കുക ns-3 അപേക്ഷ, നിങ്ങളുടെ പുതിയ ആപ്ലിക്കേഷൻ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു അപേക്ഷ. നിങ്ങൾ
അസാധുവാക്കുക ആപ്ലിക്കേഷൻ ആരംഭിക്കുക ഒപ്പം അപേക്ഷ നിർത്തുക രീതികളും സംവിധാനങ്ങളും നൽകുന്നു
നിങ്ങളുടെ പുതിയതിൽ നിന്ന് ഡാറ്റയുടെ ഒഴുക്ക് ആരംഭിക്കുകയും നിർത്തുകയും ചെയ്യുന്നു അപേക്ഷ. ഒരു നോഡ് ആയിരിക്കുമ്പോൾ
സിമുലേഷനിൽ സൃഷ്ടിച്ചത്, അത് ഒരു ഗ്ലോബലിലേക്ക് ചേർത്തു നോഡ് ലിസ്റ്റ്. ഇതിലേക്ക് ഒരു നോഡ് ചേർക്കുന്ന പ്രവർത്തനം
ഈ നോഡ് ലിസ്റ്റ് ഒരു സിമുലേറ്റർ ഇവന്റ് സമയ പൂജ്യത്തിൽ ഷെഡ്യൂൾ ചെയ്യപ്പെടുന്നതിന് കാരണമാകുന്നു
നോഡ്::ആരംഭിക്കുക സിമുലേഷൻ ആരംഭിക്കുമ്പോൾ വിളിക്കേണ്ട പുതുതായി ചേർത്ത നോഡിന്റെ രീതി.
ഒരു നോഡ് പാരമ്പര്യമായി ലഭിക്കുന്നതിനാൽ വസ്തു, ഇത് വിളിക്കുന്നു ഒബ്ജക്റ്റ്::ആരംഭിക്കുക നോഡിലെ രീതി
ഏത്, അതാകട്ടെ, വിളിക്കുന്നു ആരംഭിക്കുക എല്ലാത്തിലുമുള്ള രീതികൾ വസ്തുക്കൾ ലേക്ക് സമാഹരിച്ചു
നോഡ് (മൊബിലിറ്റി മോഡലുകൾ ചിന്തിക്കുക). നോഡ് മുതൽ വസ്തു അസാധുവാക്കിയിട്ടുണ്ട് ആരംഭിക്കുക, അത്
സിമുലേഷൻ ആരംഭിക്കുമ്പോൾ രീതി വിളിക്കുന്നു. ദി നോഡ്::DoInitialize രീതി വിളിക്കുന്നു
ആരംഭിക്കുക എല്ലാത്തിന്റെയും രീതികൾ അപ്ലിക്കേഷനുകൾ നോഡിൽ. മുതലുള്ള അപ്ലിക്കേഷനുകൾ ഇവയും ഉണ്ട്
വസ്തുക്കൾ, ഇത് കാരണമാകുന്നു അപേക്ഷ::DoInitialize വിളിക്കണം. എപ്പോൾ
അപേക്ഷ::DoInitialize വിളിക്കുന്നു, ഇത് ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യുന്നു ആപ്ലിക്കേഷൻ ആരംഭിക്കുക ഒപ്പം
അപേക്ഷ നിർത്തുക വിളിക്കുന്നു അപേക്ഷ. ഈ കോളുകൾ ആരംഭിക്കുന്നതിനും നിർത്തുന്നതിനുമായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു
എന്നതിൽ നിന്നുള്ള ഡാറ്റയുടെ ഒഴുക്ക് അപേക്ഷ

ഇതൊരു സാമാന്യം ദൈർഘ്യമേറിയ മറ്റൊരു യാത്രയാണ്, എന്നാൽ ഇത് ഒരിക്കൽ മാത്രം നടത്തിയാൽ മതി, നിങ്ങൾ ഇപ്പോൾ
വളരെ ആഴത്തിലുള്ള മറ്റൊരു ഭാഗം മനസ്സിലാക്കുക ns-3.

ദി എന്റെ ആപ്പ് അപേക്ഷ
ദി എന്റെ ആപ്പ് അപേക്ഷ ഒരു കൺസ്ട്രക്റ്ററും ഡിസ്ട്രക്റ്ററും ആവശ്യമാണ്, തീർച്ചയായും:

MyApp::MyApp ()
: m_socket (0),
m_peer (),
m_packetSize (0),
m_nപാക്കറ്റുകൾ (0),
m_dataRate (0),
m_sendEvent (),
m_running (തെറ്റായ),
m_packetsSent (0)
{
}

MyApp::~MyApp()
{
m_socket = 0;
}

അടുത്ത ബിറ്റ് കോഡിന്റെ നിലനിൽപ്പാണ് ഞങ്ങൾ ഇത് എഴുതിയതിന്റെ മുഴുവൻ കാരണം അപേക്ഷ in
ഒന്നാം സ്ഥാനം.

ശൂന്യം
MyApp::സെറ്റപ്പ് (Ptr സോക്കറ്റ്, വിലാസ വിലാസം, uint32_t packetSize,
uint32_t nPackets, DataRate dataRate)
{
m_socket = സോക്കറ്റ്;
m_peer = വിലാസം;
m_packetSize = packetSize;
m_nPackets = nPackets;
m_dataRate = ഡാറ്റാ നിരക്ക്;
}

ഈ കോഡ് വളരെ സ്വയം വിശദീകരണമായിരിക്കണം. ഞങ്ങൾ അംഗ വേരിയബിളുകൾ ആരംഭിക്കുക മാത്രമാണ് ചെയ്യുന്നത്.
ട്രെയ്‌സിംഗിന്റെ വീക്ഷണകോണിൽ നിന്നുള്ള പ്രധാനപ്പെട്ട ഒന്ന് Ptr സോക്കറ്റ് ഏത് ഞങ്ങൾ
കോൺഫിഗറേഷൻ സമയത്ത് ആപ്ലിക്കേഷന് നൽകേണ്ടതുണ്ട്. ഞങ്ങൾ പോകുന്നു എന്ന് ഓർക്കുക
സൃഷ്ടിക്കാൻ സോക്കറ്റ് പോലെ TcpSocket (ഇത് നടപ്പിലാക്കുന്നത് TcpNewReno) കൂടാതെ അതിന്റെ ഹുക്ക്
"CongestionWindow" അത് കൈമാറുന്നതിന് മുമ്പ് ഉറവിടം കണ്ടെത്തുക സജ്ജീകരണം രീതി.

ശൂന്യം
MyApp ::ആപ്ലിക്കേഷൻ ആരംഭിക്കുക (അസാധുവാണ്)
{
m_running = true;
m_packetsSent = 0;
m_socket->ബൈൻഡ് ();
m_socket->Connect (m_peer);
SendPacket ();
}

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

അടുത്ത ബിറ്റ് കോഡ് വിശദീകരിക്കുന്നു അപേക്ഷ സിമുലേഷൻ ഇവന്റുകൾ സൃഷ്ടിക്കുന്നത് എങ്ങനെ നിർത്താം.

ശൂന്യം
MyApp::StopApplication (അസാധു)
{
m_running = തെറ്റ്;

എങ്കിൽ (m_sendEvent.IsRunning ())
{
സിമുലേറ്റർ:: റദ്ദാക്കുക (m_sendEvent);
}

എങ്കിൽ (m_socket)
{
m_socket->അടയ്ക്കുക ();
}
}

ഒരു സിമുലേഷൻ ഇവന്റ് ഷെഡ്യൂൾ ചെയ്യുമ്പോഴെല്ലാം, ഒരു സംഭവം സൃഷ്ടിക്കപ്പെടുന്നു. എങ്കിൽ സംഭവം കെട്ടിക്കിടക്കുന്നു
എക്സിക്യൂഷൻ അല്ലെങ്കിൽ എക്സിക്യൂട്ടിംഗ്, അതിന്റെ രീതി ഓടിക്കൊണ്ടിരിക്കുന്നു തിരിച്ചു വരും യഥാർഥ. ഈ കോഡിൽ, എങ്കിൽ
ഓടിക്കൊണ്ടിരിക്കുന്നു() സത്യമായി തിരിച്ചുവരുന്നു, ഞങ്ങൾ റദ്ദാക്കുക സിമുലേറ്റർ ഇവന്റിൽ നിന്ന് നീക്കം ചെയ്യുന്ന ഇവന്റ്
ക്യൂ. ഇത് ചെയ്യുന്നതിലൂടെ, സംഭവങ്ങളുടെ ശൃംഖല ഞങ്ങൾ തകർക്കുന്നു അപേക്ഷ സൂക്ഷിക്കാൻ ഉപയോഗിക്കുന്നു
അതിന്റെ അയയ്ക്കുന്നു പാക്കറ്റുകൾ ഒപ്പം അപേക്ഷ നിശബ്ദമായി പോകുന്നു. ഞങ്ങൾ നിശബ്ദരായ ശേഷം അപേക്ഷ we
അടയ്ക്കുക TCP കണക്ഷൻ കീറുന്ന സോക്കറ്റ്.

ഡിസ്ട്രക്ടറിൽ സോക്കറ്റ് യഥാർത്ഥത്തിൽ ഇല്ലാതാക്കപ്പെടും m_socket = 0 നിർവ്വഹിക്കുന്നു. ഈ
അന്തർലീനമായ Ptr-ലേക്കുള്ള അവസാന റഫറൻസ് നീക്കം ചെയ്യുന്നു വിനാശകാരിക്ക് കാരണമാകുന്നത്
വിളിക്കേണ്ട വസ്തു.

അത് ഓർക്കുക ആപ്ലിക്കേഷൻ ആരംഭിക്കുക വിളിച്ചു SendPacket വിവരിക്കുന്ന സംഭവങ്ങളുടെ ശൃംഖല ആരംഭിക്കാൻ
The അപേക്ഷ പെരുമാറ്റം.

ശൂന്യം
MyApp::SendPacket (അസാധു)
{
Ptr പാക്കറ്റ് = സൃഷ്ടിക്കുക (m_packetSize);
m_socket->Send (പാക്കറ്റ്);

എങ്കിൽ (++m_packetsSent < m_nPackets)
{
ScheduleTx ();
}
}

ഇതാ, നിങ്ങൾ അത് കാണുന്നു SendPacket അത് ചെയ്യുന്നു. ഇത് എ സൃഷ്ടിക്കുന്നു പാക്കറ്റ് തുടർന്ന് എ ചെയ്യുന്നു അയയ്ക്കുക
നിങ്ങൾക്ക് ബെർക്ക്‌ലി സോക്കറ്റുകൾ അറിയാമെങ്കിൽ, നിങ്ങൾ കാണാൻ പ്രതീക്ഷിച്ചത് മാത്രമായിരിക്കും ഇത്.

യുടെ ഉത്തരവാദിത്തമാണ് അപേക്ഷ സംഭവങ്ങളുടെ ശൃംഖല ഷെഡ്യൂൾ ചെയ്യുന്നത് തുടരാൻ, അങ്ങനെ
അടുത്ത വരികൾ വിളിക്കുന്നു ഷെഡ്യൂൾTx മറ്റൊരു ട്രാൻസ്മിറ്റ് ഇവന്റ് ഷെഡ്യൂൾ ചെയ്യാൻ (എ SendPacket) അത് വരെ
അപേക്ഷ മതി അയച്ചു എന്ന് തീരുമാനിക്കുന്നു.

ശൂന്യം
MyApp::ScheduleTx (അസാധു)
{
എങ്കിൽ (m_running)
{
സമയം tNext (സെക്കൻഡ് (m_packetSize * 8 / static_cast (m_dataRate.GetBitRate ())));
m_sendEvent = സിമുലേറ്റർ:: ഷെഡ്യൂൾ (tNext, &MyApp::SendPacket, ഇത്);
}
}

ഇതാ, നിങ്ങൾ അത് കാണുന്നു ഷെഡ്യൂൾTx അത് കൃത്യമായി ചെയ്യുന്നു. എങ്കിൽ അപേക്ഷ പ്രവർത്തിക്കുന്നു (എങ്കിൽ
അപേക്ഷ നിർത്തുക വിളിച്ചിട്ടില്ല) ഇത് ഒരു പുതിയ ഇവന്റ് ഷെഡ്യൂൾ ചെയ്യും, അത് വിളിക്കുന്നു SendPacket
വീണ്ടും. പുതിയ ഉപയോക്താക്കളെ ട്രിപ്പ് ചെയ്യുന്ന എന്തെങ്കിലും അലേർട്ട് റീഡർ കണ്ടെത്തും. ഡാറ്റ നിരക്ക്
ഒരു അപേക്ഷ അത്രമാത്രം. ഒരു അന്തർലീനത്തിന്റെ ഡാറ്റാ നിരക്കുമായി ഇതിന് ബന്ധമില്ല
ചാനൽ. ഇതാണ് നിരക്ക് അപേക്ഷ ബിറ്റുകൾ ഉത്പാദിപ്പിക്കുന്നു. അത് എടുക്കുന്നില്ല
ട്രാൻസ്പോർട്ട് ചെയ്യാൻ ഉപയോഗിക്കുന്ന വിവിധ പ്രോട്ടോക്കോളുകൾക്കോ ​​ചാനലുകൾക്കോ ​​വേണ്ടിയുള്ള ഏതെങ്കിലും ഓവർഹെഡ് കണക്കിലെടുക്കുക
ഡാറ്റ. നിങ്ങൾ ഒരു ഡാറ്റ നിരക്ക് സജ്ജമാക്കുകയാണെങ്കിൽ അപേക്ഷ നിങ്ങളുടെ അടിസ്ഥാന നിരക്കിന്റെ അതേ ഡാറ്റാ നിരക്കിലേക്ക്
ചാനൽ നിങ്ങൾക്ക് ഒടുവിൽ ഒരു ബഫർ ഓവർഫ്ലോ ലഭിക്കും.

ട്രെയ്സ് സിങ്കുകൾ
ഈ വ്യായാമത്തിന്റെ മുഴുവൻ പോയിന്റും ടിസിപിയിൽ നിന്ന് ട്രെയ്‌സ് കോൾബാക്കുകൾ നേടുക എന്നതാണ്
തിരക്ക് ജനൽ അപ്ഡേറ്റ് ചെയ്തു. കോഡിന്റെ അടുത്ത ഭാഗം അനുബന്ധം നടപ്പിലാക്കുന്നു
ട്രെയ്സ് സിങ്ക്:

സ്റ്റാറ്റിക് അസാധുവാണ്
CwndChange (uint32_t oldCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (സിമുലേറ്റർ::Now ().GetSeconds () << "\t" << newCwnd);
}

ഇത് ഇപ്പോൾ നിങ്ങൾക്ക് വളരെ പരിചിതമായിരിക്കും, അതിനാൽ ഞങ്ങൾ വിശദാംശങ്ങളിൽ താമസിക്കില്ല. ഈ പ്രവർത്തനം
നിലവിലെ സിമുലേഷൻ സമയവും കൺജഷൻ വിൻഡോയുടെ പുതിയ മൂല്യവും ലോഗ് ചെയ്യുന്നു
സമയം മാറ്റി. ഫലമായുണ്ടാകുന്ന ഔട്ട്പുട്ട് നിങ്ങൾക്ക് ലോഡ് ചെയ്യാൻ കഴിയുമെന്ന് നിങ്ങൾക്ക് സങ്കൽപ്പിക്കാൻ കഴിയും
ഒരു ഗ്രാഫിക്സ് പ്രോഗ്രാമിലേക്ക് (gnuplot അല്ലെങ്കിൽ Excel) ഉടൻ തന്നെ അതിന്റെ ഒരു നല്ല ഗ്രാഫ് കാണുക
കാലക്രമേണ തിരക്ക് ജനൽ പെരുമാറ്റം.

പാക്കറ്റുകൾ എവിടെയാണ് വീണതെന്ന് കാണിക്കാൻ ഞങ്ങൾ ഒരു പുതിയ ട്രെയ്സ് സിങ്ക് ചേർത്തു. ഞങ്ങൾ ഒരു പിശക് ചേർക്കാൻ പോകുന്നു
ഈ കോഡിന്റെ മാതൃകയും, അതിനാൽ ഈ പ്രവർത്തനം പ്രകടിപ്പിക്കാൻ ഞങ്ങൾ ആഗ്രഹിച്ചു.

സ്റ്റാറ്റിക് അസാധുവാണ്
RxDrop (Ptr പി)
{
NS_LOG_UNCOND ("RxDrop at " << സിമുലേറ്റർ::Now ().GetSeconds ());
}

ഈ ട്രെയ്സ് സിങ്ക് പോയിന്റ്-ടു-പോയിന്റിന്റെ "PhyRxDrop" ട്രെയ്സ് ഉറവിടവുമായി ബന്ധിപ്പിക്കും
നെറ്റ് ഡിവൈസ്. a യുടെ ഫിസിക്കൽ ലെയറിലൂടെ ഒരു പാക്കറ്റ് വീഴുമ്പോൾ ഈ ട്രെയ്സ് സോഴ്സ് ഫയർ ചെയ്യുന്നു
നെറ്റ് ഡിവൈസ്. നിങ്ങൾ ഉറവിടത്തിലേക്ക് ഒരു ചെറിയ വഴിമാറി നടത്തിയാൽ
(src/point-to-point/model/point-to-point-net-device.cc) ഈ ട്രെയ്സ് നിങ്ങൾ കാണും
ഉറവിടം സൂചിപ്പിക്കുന്നു PointToPointNetDevice::m_phyRxDropTrace. പിന്നെ അകത്തേക്ക് നോക്കിയാൽ
src/point-to-point/model/point-to-point-net-device.h ഈ അംഗ വേരിയബിളിനായി, നിങ്ങൾ ചെയ്യും
a ആയി പ്രഖ്യാപിക്കപ്പെട്ടതായി കണ്ടെത്തുക TracedCallback പാക്കറ്റ്> >. ഇത് നിങ്ങളോട് പറയണം
കോൾബാക്ക് ടാർഗെറ്റ് അസാധുവായി നൽകുകയും സിംഗിൾ എടുക്കുകയും ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷനായിരിക്കണം
പരാമീറ്റർ a Ptr പാക്കറ്റ്> (ഞങ്ങൾ ഉപയോഗിക്കുമെന്ന് കരുതുക സന്ദർഭമില്ലാതെ ബന്ധിപ്പിക്കുക) -- വെറും
നമുക്ക് മുകളിൽ ഉള്ളത്.

മെയിൻ പ്രോഗ്രാം
ഇനിപ്പറയുന്ന കോഡ് ഇപ്പോൾ നിങ്ങൾക്ക് വളരെ പരിചിതമായിരിക്കണം:

int
പ്രധാനം (int argc, char *argv[])
{
നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
നോഡുകൾ.സൃഷ്ടിക്കുക (2);

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

NetDeviceContainer ഉപകരണങ്ങൾ;
ഉപകരണങ്ങൾ = pointToPoint.Install (നോഡുകൾ);

ഇത് രണ്ട് നോഡുകൾ സൃഷ്ടിക്കുന്നു, അവയ്ക്കിടയിൽ ഒരു പോയിന്റ്-ടു-പോയിന്റ് ചാനൽ, അതിൽ കാണിച്ചിരിക്കുന്നതുപോലെ
ഫയലിന്റെ തുടക്കത്തിൽ ചിത്രീകരണം.

കോഡിന്റെ അടുത്ത കുറച്ച് വരികൾ പുതിയ എന്തെങ്കിലും കാണിക്കുന്നു. ഞങ്ങൾ ഒരു കണക്ഷൻ കണ്ടെത്തുകയാണെങ്കിൽ അത് പ്രവർത്തിക്കുന്നു
പൂർണ്ണമായി, ഏകതാനമായി വർദ്ധിക്കുന്ന തിരക്ക് ജാലകത്തിൽ ഞങ്ങൾ അവസാനിക്കും. ഏതെങ്കിലും കാണാൻ
രസകരമായ പെരുമാറ്റം, പാക്കറ്റുകൾ ഡ്രോപ്പ് ചെയ്യുന്ന ലിങ്ക് പിശകുകൾ അവതരിപ്പിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു,
ഡ്യൂപ്ലിക്കേറ്റ് ACK-കൾ ഉണ്ടാക്കുകയും തിരക്ക് ജാലകത്തിന്റെ കൂടുതൽ രസകരമായ പെരുമാറ്റങ്ങൾ ട്രിഗർ ചെയ്യുകയും ചെയ്യുന്നു.

ns-3 നൽകുന്നു പിശക് മോഡൽ ഘടിപ്പിക്കാൻ കഴിയുന്ന വസ്തുക്കൾ ചാനലുകൾ. ഞങ്ങൾ ഉപയോഗിക്കുന്നത്
RateErrorModel എയിൽ പിശകുകൾ അവതരിപ്പിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു ചാനൽ തന്നിരിക്കുന്ന സമയത്ത് നിരക്ക്.

Ptr em = CreateObject ();
em->SetAttribute ("ErrorRate", DoubleValue (0.00001));
device.Get (1)->SetAttribute ("ReceiveErrorModel", PointerValue (em));

മുകളിലെ കോഡ് തൽക്ഷണം എ RateErrorModel ഒബ്ജക്റ്റ്, ഞങ്ങൾ "പിശക് നിരക്ക്" സജ്ജമാക്കി ഗുണങ്ങളെ
ആവശ്യമുള്ള മൂല്യത്തിലേക്ക്. അപ്പോൾ തത്ഫലമായുണ്ടാകുന്ന തൽക്ഷണം ഞങ്ങൾ സജ്ജമാക്കി RateErrorModel പിശക് പോലെ
പോയിന്റ്-ടു-പോയിന്റ് ഉപയോഗിക്കുന്ന മോഡൽ നെറ്റ് ഡിവൈസ്. ഇത് നമുക്ക് ചില പുനഃസംപ്രേഷണങ്ങളും നൽകും
ഞങ്ങളുടെ പ്ലോട്ട് കുറച്ചുകൂടി രസകരമാക്കുക.

InternetStackHelper സ്റ്റാക്ക്;
സ്റ്റാക്ക്.ഇൻസ്റ്റാൾ (നോഡുകൾ);

Ipv4Addressസഹായ വിലാസം;
വിലാസം.സെറ്റ്ബേസ് ("10.1.1.0", "255.255.255.252");
Ipv4InterfaceContainer ഇന്റർഫേസുകൾ = വിലാസം.അസൈൻ (ഉപകരണങ്ങൾ);

മുകളിലുള്ള കോഡ് പരിചിതമായിരിക്കണം. ഇത് ഞങ്ങളുടെ രണ്ട് നോഡുകളിലും ഇന്റർനെറ്റ് സ്റ്റാക്കുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു
ഇന്റർഫേസുകൾ സൃഷ്ടിക്കുകയും പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണങ്ങൾക്കായി IP വിലാസങ്ങൾ നൽകുകയും ചെയ്യുന്നു.

ഞങ്ങൾ ടിസിപി ഉപയോഗിക്കുന്നതിനാൽ, ടിസിപി ലഭിക്കാൻ ലക്ഷ്യസ്ഥാന നോഡിൽ എന്തെങ്കിലും ആവശ്യമാണ്
കണക്ഷനുകളും ഡാറ്റയും. ദി പാക്കറ്റ്സിങ്ക് അപേക്ഷ ൽ സാധാരണയായി ഉപയോഗിക്കുന്നു ns-3 അതിനു വേണ്ടി
ഉദ്ദേശ്യം.

uint16_t sinkPort = 8080;
വിലാസം sinkAddress (InetSocketAddress(interfaces.GetAddress (1), sinkPort));
PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny (), sinkPort));
ApplicationContainer sinkApps = packetSinkHelper.Install (nodes.Get (1));
sinkApps.Start (സെക്കൻഡ് (0.));
sinkApps.Stop (സെക്കൻഡ് (20.));

ഇവയെല്ലാം പരിചിതമായിരിക്കണം, ഒഴികെ,

PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny (), sinkPort));

ഈ കോഡ് തൽക്ഷണം എ പാക്കറ്റ്സിങ്ക് ഹെൽപ്പർ ക്ലാസ് ഉപയോഗിച്ച് സോക്കറ്റുകൾ സൃഷ്ടിക്കാൻ പറയുന്നു
ns3::TcpSocketFactory. ഈ ക്ലാസ് "ഒബ്ജക്റ്റ് ഫാക്ടറി" എന്ന ഡിസൈൻ പാറ്റേൺ നടപ്പിലാക്കുന്നു
a എന്നതിൽ ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ക്ലാസ് വ്യക്തമാക്കുന്നതിന് സാധാരണയായി ഉപയോഗിക്കുന്ന ഒരു സംവിധാനമാണിത്
അമൂർത്തമായ വഴി. ഇവിടെ, ഒബ്ജക്റ്റുകൾ സ്വയം സൃഷ്ടിക്കുന്നതിനുപകരം, നിങ്ങൾ നൽകുന്നു
പാക്കറ്റ്സിങ്ക് ഹെൽപ്പർ a വ്യക്തമാക്കുന്ന ഒരു സ്ട്രിംഗ് ടൈപ്പ് ഐഡി ഒരു വസ്തു സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന സ്ട്രിംഗ്
പിന്നീട് ഫാക്ടറി സൃഷ്ടിച്ച വസ്തുക്കളുടെ ഉദാഹരണങ്ങൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കാം.

ശേഷിക്കുന്ന പരാമീറ്റർ പറയുന്നു അപേക്ഷ ഏത് വിലാസവും പോർട്ടും ആയിരിക്കണം ബൈൻഡ് ചെയ്യുക ടു.

കോഡിന്റെ അടുത്ത രണ്ട് വരികൾ സോക്കറ്റ് സൃഷ്ടിക്കുകയും ട്രെയ്സ് ഉറവിടത്തെ ബന്ധിപ്പിക്കുകയും ചെയ്യും.

Ptr ns3TcpSocket = സോക്കറ്റ്::CreateSocket (nodes.Get (0),
TcpSocketFactory ::GetTypeId ());
ns3TcpSocket->TraceConnect WithoutContext ("CongestionWindow",
MakeCallback (&CwndChange));

ആദ്യത്തെ പ്രസ്താവന സ്റ്റാറ്റിക് അംഗത്തിന്റെ പ്രവർത്തനത്തെ വിളിക്കുന്നു സോക്കറ്റ്::ക്രിയേറ്റ്സോക്കറ്റ് ഒരു നൽകുന്നു
നോഡും ഒരു സ്പഷ്ടവും ടൈപ്പ് ഐഡി സോക്കറ്റ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന ഒബ്ജക്റ്റ് ഫാക്ടറിക്ക്. ഇതൊരു
എന്നതിനേക്കാൾ അല്പം താഴ്ന്ന ലെവൽ കോൾ പാക്കറ്റ്സിങ്ക് ഹെൽപ്പർ മുകളിൽ വിളിക്കുക, ഒരു വ്യക്തമായ C++ ഉപയോഗിക്കുന്നു
ഒരു സ്ട്രിംഗ് സൂചിപ്പിക്കുന്നതിന് പകരം ടൈപ്പ് ചെയ്യുക. അല്ലെങ്കിൽ, അത് ആശയപരമായി ഒന്നുതന്നെയാണ്
കാര്യം.

ഒരിക്കൽ ഒരു TcpSocket സൃഷ്ടിച്ച് നോഡിൽ ഘടിപ്പിച്ചിരിക്കുന്നു, നമുക്ക് ഉപയോഗിക്കാം
TraceConnect WithoutContext CongestionWindow ട്രെയ്സ് ഉറവിടം ഞങ്ങളുടെ ട്രേസ് സിങ്കിലേക്ക് ബന്ധിപ്പിക്കുന്നതിന്.

ഞങ്ങൾ ഒരു കോഡ് ചെയ്തതായി ഓർക്കുക അപേക്ഷ അതിനാൽ ഞങ്ങൾക്ക് അത് എടുക്കാം സോക്കറ്റ് ഞങ്ങൾ ഉണ്ടാക്കി (സമയത്ത്
കോൺഫിഗറേഷൻ സമയം) കൂടാതെ ഇത് സിമുലേഷൻ സമയത്ത് ഉപയോഗിക്കുക. നമ്മൾ ഇപ്പോൾ അത് ഉടനടി സ്ഥാപിക്കേണ്ടതുണ്ട്
അപേക്ഷ. മാനേജ് ചെയ്യാൻ ഒരു സഹായിയെ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ഒരു പ്രശ്നത്തിനും പോയില്ല അപേക്ഷ so
ഞങ്ങൾ ഇത് "സ്വമേധയാ" സൃഷ്ടിക്കുകയും ഇൻസ്റ്റാൾ ചെയ്യുകയും വേണം. ഇത് യഥാർത്ഥത്തിൽ വളരെ എളുപ്പമാണ്:

Ptr app = CreateObject ();
app->സെറ്റപ്പ് (ns3TcpSocket, sinkAddress, 1040, 1000, DataRate ("1Mbps"));
nodes.Get (0)->AddApplication (app);
അപ്ലിക്കേഷൻ->ആരംഭിക്കുക (സെക്കൻഡ് (1.));
ആപ്പ്->സ്റ്റോപ്പ് (സെക്കൻഡ് (20.));

ആദ്യ വരി ഒരു സൃഷ്ടിക്കുന്നു വസ്തു തരം എന്റെ ആപ്പ് -- നമ്മുടെ അപേക്ഷ. രണ്ടാമത്തെ വരി പറയുന്നു
The അപേക്ഷ എന്ത് സോക്കറ്റ് ഉപയോഗിക്കാൻ, ഏത് വിലാസത്തിലേക്ക് കണക്റ്റുചെയ്യണം, എത്ര ഡാറ്റ അയക്കണം
ഓരോ അയയ്‌ക്കുന്ന ഇവന്റും, എത്ര ഇവന്റുകൾ ജനറേറ്റുചെയ്യാൻ അയയ്ക്കുന്നു, ഡാറ്റ നിർമ്മിക്കുന്നതിനുള്ള നിരക്കും
ആ സംഭവങ്ങളിൽ നിന്ന്.

അടുത്തതായി, ഞങ്ങൾ സ്വമേധയാ ചേർക്കുന്നു എന്റെ ആപ്പ് അപേക്ഷ ഉറവിട നോഡിലേക്ക് വ്യക്തമായി വിളിക്കുക
ആരംഭിക്കുക ഒപ്പം നിർത്തുക രീതികൾ അപേക്ഷ എപ്പോൾ തുടങ്ങണമെന്നും അത് ചെയ്യുന്നത് നിർത്തണമെന്നും അതിനോട് പറയാൻ
കാര്യം.

നമ്മൾ യഥാർത്ഥത്തിൽ റിസീവറിൽ നിന്ന് പോയിന്റ്-ടു-പോയിന്റ് കണക്ട് ചെയ്യേണ്ടതുണ്ട് നെറ്റ് ഡിവൈസ് ഡ്രോപ്പ് ഇവന്റ്
ഞങ്ങളുടെ RxDrop ഇപ്പോൾ തിരികെ വിളിക്കുക.

device.Get (1)->TraceConnectWithoutContext("PhyRxDrop", MakeCallback (&RxDrop));

സ്വീകരിക്കുന്നതിനെ കുറിച്ച് നമുക്ക് ഒരു റഫറൻസ് ലഭിക്കുന്നുണ്ടെന്ന് ഇപ്പോൾ വ്യക്തമായിരിക്കണം നോഡ് നെറ്റ് ഡിവൈസ്
അതിന്റെ കണ്ടെയ്‌നറിൽ നിന്നും "PhyRxDrop" എന്ന ആട്രിബ്യൂട്ട് നിർവചിച്ചിരിക്കുന്ന ട്രെയ്സ് ഉറവിടത്തെ ബന്ധിപ്പിക്കുന്നു
ആ ഉപകരണം ട്രേസ് സിങ്കിലേക്ക് RxDrop.

അവസാനമായി, ഞങ്ങൾ സിമുലേറ്ററിനോട് എന്തെങ്കിലും അസാധുവാക്കാൻ പറയുന്നു അപ്ലിക്കേഷനുകൾ പ്രോസസ്സിംഗ് നിർത്തുക
സിമുലേഷനിൽ 20 സെക്കൻഡിനുള്ളിൽ ഇവന്റുകൾ.

സിമുലേറ്റർ:: നിർത്തുക (സെക്കൻഡ്(20));
സിമുലേറ്റർ:: റൺ ();
സിമുലേറ്റർ:: നശിപ്പിക്കുക ();

തിരികെ വരുക;
}

അത് എത്രയും പെട്ടെന്ന് ഓർക്കുക സിമുലേറ്റർ:: റൺ വിളിക്കുന്നു, കോൺഫിഗറേഷൻ സമയം അവസാനിക്കുന്നു, സിമുലേഷൻ
സമയം ആരംഭിക്കുന്നു. സൃഷ്ടിച്ചുകൊണ്ട് ഞങ്ങൾ ക്രമീകരിച്ച എല്ലാ ജോലികളും അപേക്ഷ അത് പഠിപ്പിക്കുകയും ചെയ്യുന്നു
ഈ ഫംഗ്‌ഷൻ കോളിനിടെ യഥാർത്ഥത്തിൽ എങ്ങനെ ഡാറ്റ കണക്‌റ്റ് ചെയ്യുകയും അയയ്ക്കുകയും ചെയ്യാം.

ഉടനടി സിമുലേറ്റർ:: റൺ തിരിച്ചുവരുന്നു, സിമുലേഷൻ പൂർത്തിയായി, ഞങ്ങൾ ടിയർഡൗണിലേക്ക് പ്രവേശിക്കുന്നു
ഘട്ടം. ഈ സാഹചര്യത്തിൽ, സിമുലേറ്റർ:: നശിപ്പിക്കുക ഭയാനകമായ വിശദാംശങ്ങൾ ശ്രദ്ധിക്കുന്നു, ഞങ്ങൾ മടങ്ങുന്നു
പൂർത്തിയായതിന് ശേഷം ഒരു വിജയ കോഡ്.

പ്രവർത്തിക്കുന്ന fifth.cc
ഞങ്ങൾ ഫയൽ നൽകിയതിനാൽ fifth.cc നിങ്ങൾക്കായി, നിങ്ങളുടെ വിതരണം നിർമ്മിച്ചിട്ടുണ്ടെങ്കിൽ (ഇൻ
ഡീബഗ് മോഡ് ഉപയോഗിക്കുന്നത് മുതൽ NS_LOG -- ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡുകൾ ഒപ്റ്റിമൈസ് ഔട്ട് എന്ന് ഓർക്കുക NS_LOG) അത്
നിങ്ങൾ ഓടാൻ കാത്തിരിക്കും.

$ ./waf --റൺ അഞ്ചാമത്
വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone-dev/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone-dev/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.684സെ)
1 536
1.0093 1072
1.01528 1608
1.02167 2144
...
1.11319 8040
1.12151 8576
1.12983 9112
1.13696-ൽ RxDrop
...

നിങ്ങളുടെ ട്രെയ്‌സിൽ ഏതെങ്കിലും തരത്തിലുള്ള പ്രിന്റുകൾ ഉപയോഗിക്കുന്നതിന്റെ ഒരു പോരായ്മ നിങ്ങൾക്ക് പെട്ടെന്ന് കാണാൻ കഴിയും.
ഞങ്ങളുടെ താൽപ്പര്യമുണർത്തുന്ന വിവരങ്ങളിലുടനീളം അച്ചടിച്ച ആ ബാഹ്യമായ വാഫ് സന്ദേശങ്ങൾ ഞങ്ങൾക്ക് ലഭിക്കും
ആ RxDrop സന്ദേശങ്ങൾക്കൊപ്പം. ഞങ്ങൾ അത് ഉടൻ പരിഹരിക്കും, പക്ഷേ നിങ്ങൾക്ക് കാണാൻ കാത്തിരിക്കാനാവില്ലെന്ന് എനിക്ക് ഉറപ്പുണ്ട്
ഈ ജോലിയുടെ എല്ലാ ഫലങ്ങളും. നമുക്ക് ആ ഔട്ട്പുട്ട് എന്ന ഫയലിലേക്ക് റീഡയറക്ട് ചെയ്യാം cwnd.dat:

$ ./waf --ഓൺ ഫിഫ്ത് > cwnd.dat 2>&1

ഇപ്പോൾ നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ "cwnd.dat" എഡിറ്റ് ചെയ്‌ത് waf ബിൽഡ് സ്റ്റാറ്റസും ഡ്രോപ്പും നീക്കം ചെയ്യുക
ലൈനുകൾ, കണ്ടെത്തിയ ഡാറ്റ മാത്രം അവശേഷിക്കുന്നു (നിങ്ങൾക്ക് അഭിപ്രായമിടാം
TraceConnect WithoutContext("PhyRxDrop", തിരികെ വിളിക്കുക (&RxDrop)); രക്ഷപ്പെടാൻ തിരക്കഥയിൽ
ഡ്രോപ്പ് പ്രിന്റുകൾ വളരെ എളുപ്പത്തിൽ.

നിങ്ങൾക്ക് ഇപ്പോൾ gnuplot പ്രവർത്തിപ്പിക്കാം (നിങ്ങൾ ഇത് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ) ഒപ്പം കുറച്ച് മനോഹരമായി സൃഷ്ടിക്കാൻ പറയുക
ചിത്രങ്ങൾ:

$ gnuplot
gnuplot> ടെർമിനൽ png വലുപ്പം 640,480 സജ്ജമാക്കുക
gnuplot> ഔട്ട്പുട്ട് "cwnd.png" സജ്ജമാക്കുക
gnuplot> പ്ലോട്ട് "cwnd.dat" 1:2 ടൈറ്റിൽ 'കോൺജഷൻ വിൻഡോ' ഉപയോഗിച്ച് ലൈൻ പോയിന്റുകൾ ഉപയോഗിച്ച്
gnuplot> പുറത്തുകടക്കുക

ഫയലിൽ ഇരിക്കുന്ന സമയത്തിനെതിരായ തിരക്ക് വിൻഡോയുടെ ഒരു ഗ്രാഫ് നിങ്ങൾക്ക് ഇപ്പോൾ ഉണ്ടായിരിക്കണം
"cwnd.png" loading="lazy" ഇതുപോലെ കാണപ്പെടുന്നു:
[ചിത്രം]

ഉപയോഗിക്കുന്നു മിഡ് ലെവൽ സഹായികൾ
മുമ്പത്തെ വിഭാഗത്തിൽ, ഒരു ട്രെയ്‌സ് ഉറവിടം എങ്ങനെ ഹുക്ക് ചെയ്യാമെന്നും പ്രതീക്ഷയോടെ നേടാമെന്നും ഞങ്ങൾ കാണിച്ചു
ഒരു സിമുലേഷനിൽ നിന്നുള്ള രസകരമായ വിവരങ്ങൾ. ഞങ്ങൾ വിളിച്ചത് നിങ്ങൾ ഓർക്കും
ഉപയോഗിച്ച് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് ലോഗ് ചെയ്യുന്നു std::cout ഇതിൽ വളരെ നേരത്തെ ഒരു "മൂർച്ചയുള്ള ഉപകരണം"
അധ്യായം. ലോഗ് ഔട്ട്‌പുട്ട് ക്രമത്തിൽ പാഴ്‌സ് ചെയ്യേണ്ടത് എങ്ങനെയാണ് പ്രശ്‌നമായതെന്നും ഞങ്ങൾ എഴുതി
രസകരമായ വിവരങ്ങൾ വേർതിരിച്ചെടുക്കാൻ. ഞങ്ങൾ ഒരുപാട് ചിലവഴിച്ചുവെന്ന് നിങ്ങൾക്ക് തോന്നിയിരിക്കാം
ഞങ്ങൾ പരിഹരിക്കാൻ ഉദ്ദേശിക്കുന്ന എല്ലാ പ്രശ്നങ്ങളും കാണിക്കുന്ന ഒരു ഉദാഹരണം നടപ്പിലാക്കുന്ന സമയം
The ns-3 ട്രേസിംഗ് സിസ്റ്റം! നിങ്ങൾ ശരിയായിരിക്കും. പക്ഷേ, ഞങ്ങളോട് സഹിക്കുക. ഞങ്ങൾ ഇതുവരെ പൂർത്തിയാക്കിയിട്ടില്ല.

നമ്മൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യങ്ങളിലൊന്ന് എളുപ്പത്തിൽ ചെയ്യാനുള്ള കഴിവാണ്
സിമുലേഷനിൽ നിന്ന് പുറത്തുവരുന്ന ഔട്ട്പുട്ടിന്റെ അളവ് നിയന്ത്രിക്കുക; അവ സംരക്ഷിക്കാനും ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
ഒരു ഫയലിലേക്കുള്ള ഡാറ്റ, അതിനാൽ നമുക്ക് അത് പിന്നീട് റഫർ ചെയ്യാം. നമുക്ക് മിഡ്-ലെവൽ ട്രെയ്സ് സഹായികളെ ഉപയോഗിക്കാം
നൽകിയിരിക്കുന്നു ns-3 അത് ചെയ്യാനും ചിത്രം പൂർത്തിയാക്കാനും.

ഉദാഹരണത്തിൽ വികസിപ്പിച്ച Cwnd മാറ്റവും ഡ്രോപ്പ് ഇവന്റുകളും എഴുതുന്ന ഒരു സ്ക്രിപ്റ്റ് ഞങ്ങൾ നൽകുന്നു
fifth.cc പ്രത്യേക ഫയലുകളിൽ ഡിസ്കിലേക്ക്. Cwnd മാറ്റങ്ങൾ ഒരു ടാബ്-വേർതിരിക്കപ്പെട്ട ASCII ആയി സംഭരിച്ചിരിക്കുന്നു
ഫയലും ഡ്രോപ്പ് ഇവന്റുകളും ഒരു PCAP ഫയലിൽ സംഭരിച്ചിരിക്കുന്നു. ഇത് സാധ്യമാക്കാനുള്ള മാറ്റങ്ങളാണ്
തികച്ചും ചെറിയ.

നടപ്പാത: ആറാം. സി.സി
പോകേണ്ട മാറ്റങ്ങൾ എന്തൊക്കെയെന്ന് നോക്കാം fifth.cc ലേക്ക് ആറാം. സി.സി. തുറക്കുക
ഉദാഹരണങ്ങൾ/tutorial/sixth.cc നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്ററിൽ. വഴി ആദ്യ മാറ്റം കാണാം
CwndChange-നായി തിരയുന്നു. ട്രെയ്‌സിനായി ഞങ്ങൾ ഒപ്പുകൾ മാറ്റിയതായി നിങ്ങൾ കണ്ടെത്തും
സിങ്കുകൾ കൂടാതെ ഓരോ സിങ്കിലേക്കും ഒരൊറ്റ വരി ചേർത്തിട്ടുണ്ട്, അത് കണ്ടെത്തി വിവരങ്ങൾ എഴുതുന്നു a
ഒരു ഫയലിനെ പ്രതിനിധീകരിക്കുന്ന സ്ട്രീം.

സ്റ്റാറ്റിക് അസാധുവാണ്
CwndChange (Ptr സ്ട്രീം, uint32_t oldCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (സിമുലേറ്റർ::Now ().GetSeconds () << "\t" << newCwnd);
*stream->GetStream () << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;
}

സ്റ്റാറ്റിക് അസാധുവാണ്
RxDrop (Ptr ഫയൽ, Ptr പി)
{
NS_LOG_UNCOND ("RxDrop at " << സിമുലേറ്റർ::Now ().GetSeconds ());
ഫയൽ->എഴുതുക (സിമുലേറ്റർ:: ഇപ്പോൾ (), പി);
}

എന്നതിലേക്ക് ഞങ്ങൾ ഒരു "സ്ട്രീം" പാരാമീറ്റർ ചേർത്തു CwndChange ട്രെയ്സ് സിങ്ക്. ഇത് ഒരു വസ്തുവാണ്
ഒരു C++ ഔട്ട്‌പുട്ട് സ്ട്രീം പിടിക്കുന്നു (സുരക്ഷിതമായി നിലനിർത്തുന്നു). ഇത് വളരെ ലളിതമാണെന്ന് മാറുന്നു
ഒബ്‌ജക്‌റ്റ്, എന്നാൽ സ്‌ട്രീമിന്റെ ആജീവനാന്ത പ്രശ്‌നങ്ങൾ കൈകാര്യം ചെയ്യുകയും പ്രശ്‌നം പരിഹരിക്കുകയും ചെയ്യുന്ന ഒന്ന്
പരിചയസമ്പന്നരായ C++ ഉപയോക്താക്കൾ പ്രവർത്തിക്കുന്നു. അതിനുള്ള കോപ്പി കൺസ്ട്രക്റ്റർ ആണെന്ന് ഇത് മാറുന്നു std::ostream
സ്വകാര്യമായി അടയാളപ്പെടുത്തിയിരിക്കുന്നു. എന്ന് വച്ചാൽ അത് std::ostreams മൂല്യ അർത്ഥശാസ്ത്രം അനുസരിക്കരുത്, കഴിയില്ല
സ്ട്രീം പകർത്താൻ ആവശ്യമായ ഏത് മെക്കാനിസത്തിലും ഉപയോഗിക്കും. ഇതിൽ ഉൾപ്പെടുന്നു ns-3
കോൾബാക്ക് സിസ്റ്റത്തിന്, നിങ്ങൾ ഓർക്കുന്നതുപോലെ, മൂല്യം സെമാന്റിക്സ് അനുസരിക്കുന്ന വസ്തുക്കൾ ആവശ്യമാണ്.
എന്നതിൽ ഇനിപ്പറയുന്ന വരി ഞങ്ങൾ ചേർത്തിട്ടുണ്ടെന്ന് കൂടുതൽ ശ്രദ്ധിക്കുക CwndChange ട്രെയ്സ് സിങ്ക്
നടപ്പാക്കൽ:

*stream->GetStream () << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;

നിങ്ങൾ മാറ്റിസ്ഥാപിക്കുകയാണെങ്കിൽ ഇത് വളരെ പരിചിതമായ കോഡായിരിക്കും *സ്ട്രീം->GetStream () കൂടെ std::cout, as
ലെ:

std::cout << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;

ഇത് വ്യക്തമാക്കുന്നു Ptr ശരിക്കും ഒരു ചുറ്റുന്നു
std::ഓഫ്സ്ട്രീം നിങ്ങൾക്കായി, മറ്റേതൊരു ഔട്ട്‌പുട്ട് സ്ട്രീമും പോലെ നിങ്ങൾക്ക് ഇത് ഇവിടെ ഉപയോഗിക്കാനാകും.

സമാനമായ ഒരു സാഹചര്യം സംഭവിക്കുന്നു RxDrop വസ്തു ചുറ്റിക്കറങ്ങുന്നത് ഒഴികെ (എ
Ptr) ഒരു PCAP ഫയലിനെ പ്രതിനിധീകരിക്കുന്നു. ട്രേസ് സിങ്കിൽ ഒരു വൺ-ലൈനർ ഉണ്ട്
ഒരു ടൈംസ്റ്റാമ്പും പാക്കറ്റിലെ ഉള്ളടക്കങ്ങളും PCAP ഫയലിലേക്ക് ഡ്രോപ്പ് ചെയ്യുക:

ഫയൽ->എഴുതുക (സിമുലേറ്റർ:: ഇപ്പോൾ (), പി);

തീർച്ചയായും, രണ്ട് ഫയലുകളെ പ്രതിനിധീകരിക്കുന്ന ഒബ്‌ജക്‌റ്റുകൾ ഉണ്ടെങ്കിൽ, അവ എവിടെയെങ്കിലും സൃഷ്‌ടിക്കേണ്ടതുണ്ട്
കൂടാതെ അവയെ ട്രെയ്സ് സിങ്കുകളിലേക്ക് കടത്തിവിടുകയും ചെയ്യും. നിങ്ങൾ അതിൽ നോക്കിയാൽ പ്രധാന പ്രവർത്തനം,
അത് ചെയ്യാൻ നിങ്ങൾ പുതിയ കോഡ് കണ്ടെത്തും:

AsciiTraceHelper asciiTraceHelper;
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("sixth.cwnd");
ns3TcpSocket->TraceConnect WithoutContext ("CongestionWindow", MakeBoundCallback (&CwndChange, സ്ട്രീം));

...

PcapHelper pcapHelper;
Ptr ഫയൽ = pcapHelper.CreateFile ("sixth.pcap", std::ios::out, PcapHelper::DLT_PPP);
device.Get (1)->TraceConnect WithoutContext("PhyRxDrop", MakeBoundCallback (&RxDrop, ഫയൽ));

മുകളിലുള്ള കോഡ് സ്‌നിപ്പെറ്റിന്റെ ആദ്യ വിഭാഗത്തിൽ, ഞങ്ങൾ ASCII ട്രെയ്‌സ് ഫയൽ സൃഷ്‌ടിക്കുന്നു,
അത് കൈകാര്യം ചെയ്യുന്നതിനും കോൾബാക്കിന്റെ ഒരു വകഭേദം ഉപയോഗിക്കുന്നതിനും ഉത്തരവാദിത്തമുള്ള ഒരു വസ്തു സൃഷ്ടിക്കുന്നു
സിങ്കിലേക്ക് ഒബ്ജക്റ്റ് കൈമാറുന്നതിനുള്ള ക്രമീകരണം സൃഷ്ടിക്കുന്നതിനുള്ള പ്രവർത്തനം. ഞങ്ങളുടെ ASCII ട്രെയ്സ്
ടെക്സ്റ്റ് (ASCII) ഫയലുകൾ ഉപയോഗിക്കുന്നത് എളുപ്പമാക്കുന്നതിന് സഹായകർ സമ്പന്നമായ ഒരു കൂട്ടം ഫംഗ്‌ഷനുകൾ നൽകുന്നു. ഞങ്ങൾ ആകുന്നു
ഇവിടെ ഫയൽ സ്ട്രീം സൃഷ്‌ടിക്കൽ ഫംഗ്‌ഷന്റെ ഉപയോഗം ചിത്രീകരിക്കാൻ പോകുന്നു.

ദി ഫയൽസ്ട്രീം സൃഷ്‌ടിക്കുക ഫംഗ്ഷൻ അടിസ്ഥാനപരമായി തൽക്ഷണം ചെയ്യാൻ പോകുന്നു a std::ഓഫ്സ്ട്രീം വസ്തുവും
ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കുക (അല്ലെങ്കിൽ നിലവിലുള്ള ഒരു ഫയൽ വെട്ടിച്ചുരുക്കുക). ഈ std::ഓഫ്സ്ട്രീം എന്നതിൽ പാക്കേജുചെയ്‌തിരിക്കുന്നു
ns-3 ലൈഫ് ടൈം മാനേജ്മെന്റിനും കോപ്പി കൺസ്ട്രക്റ്റർ പ്രശ്ന പരിഹാരത്തിനുമുള്ള ഒബ്ജക്റ്റ്.

അപ്പോൾ ഞങ്ങൾ ഇത് എടുക്കുന്നു ns-3 ഫയലിനെ പ്രതിനിധീകരിക്കുന്ന ഒബ്ജക്റ്റ് അത് കൈമാറുക MakeBoundCallback().
ഈ പ്രവർത്തനം പോലെ ഒരു കോൾബാക്ക് സൃഷ്ടിക്കുന്നു വിളിക്കുക(), എന്നാൽ ഇത് ഒരു പുതിയ മൂല്യത്തിലേക്ക് "ബന്ധിക്കുന്നു"
തിരിച്ചുവിളിക്കൽ. കോൾബാക്കിന് മുമ്പുള്ള ആദ്യത്തെ ആർഗ്യുമെന്റായി ഈ മൂല്യം ചേർക്കുന്നു
വിളിച്ചു.

അടിസ്ഥാനപരമായി, MakeBoundCallback(&CwndChange, ധാര) ട്രെയ്സ് സോഴ്സ് ചേർക്കുന്നതിന് കാരണമാകുന്നു
അഭ്യർത്ഥിക്കുന്നതിന് മുമ്പ് ഔപചാരിക പാരാമീറ്റർ ലിസ്റ്റിന്റെ മുൻവശത്തുള്ള അധിക "സ്ട്രീം" പാരാമീറ്റർ
തിരിച്ചുവിളിക്കൽ. ഇത് ആവശ്യമായ ഒപ്പ് മാറ്റുന്നു CwndChange ഒന്നിനോട് പൊരുത്തപ്പെടാൻ മുങ്ങുക
മുകളിൽ കാണിച്ചിരിക്കുന്നത്, അതിൽ "അധിക" പരാമീറ്റർ ഉൾപ്പെടുന്നു Ptr സ്ട്രീം.

മുകളിലെ സ്‌നിപ്പെറ്റിലെ കോഡിന്റെ രണ്ടാമത്തെ വിഭാഗത്തിൽ, ഞങ്ങൾ a PcapHelper ചെയ്യാൻ
ഞങ്ങളുടെ PCAP ട്രെയ്‌സ് ഫയലിനായി ഞങ്ങൾ ചെയ്ത അതേ കാര്യം AsciiTraceHelper. എന്ന വരി
കോഡ്,

Ptr ഫയൽ = pcapHelper.CreateFile ("sixth.pcap",
"w", PcapHelper ::DLT_PPP);

ഫയൽ മോഡ് "w" ഉപയോഗിച്ച് "sixth.pcap" എന്ന പേരിൽ ഒരു PCAP ഫയൽ സൃഷ്ടിക്കുന്നു. ഇതിനർത്ഥം പുതിയ ഫയൽ എന്നാണ്
ആ പേരിൽ നിലവിലുള്ള ഒരു ഫയൽ കണ്ടെത്തിയാൽ വെട്ടിച്ചുരുക്കപ്പെടും (ഉള്ളടക്കം ഇല്ലാതാക്കി). അവസാനം
പാരാമീറ്റർ എന്നത് പുതിയ PCAP ഫയലിന്റെ "ഡാറ്റ ലിങ്ക് തരം" ആണ്. ഇവ പിസിഎപി പോലെ തന്നെ
ലൈബ്രറി ഡാറ്റ ലിങ്ക് തരങ്ങൾ നിർവചിച്ചിരിക്കുന്നു bpf.h നിങ്ങൾക്ക് PCAP പരിചിതമാണെങ്കിൽ. ഈ സാഹചര്യത്തിൽ,
DLT_PPP PCAP ഫയലിൽ പോയിന്റ് to എന്ന പ്രിഫിക്‌സ് പാക്കറ്റുകൾ അടങ്ങിയിരിക്കുമെന്ന് സൂചിപ്പിക്കുന്നു
പോയിന്റ് തലക്കെട്ടുകൾ. ഞങ്ങളുടെ പോയിന്റ്-ടു-പോയിന്റ് ഉപകരണത്തിൽ നിന്നാണ് പാക്കറ്റുകൾ വരുന്നത് എന്നതിനാൽ ഇത് ശരിയാണ്
ഡ്രൈവർ. മറ്റ് പൊതുവായ ഡാറ്റ ലിങ്ക് തരങ്ങളാണ് csma-യ്ക്ക് അനുയോജ്യമായ DLT_EN10MB (10 MB ഇഥർനെറ്റ്)
ഉപകരണങ്ങളും വൈഫൈ ഉപകരണങ്ങൾക്ക് അനുയോജ്യമായ DLT_IEEE802_11 (IEEE 802.11). ഇവ നിർവ്വചിച്ചിരിക്കുന്നു
in src/network/helper/trace-helper.h നിങ്ങൾക്ക് പട്ടിക കാണാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ. ദി
ലിസ്റ്റിലെ എൻട്രികൾ ഉള്ളവയുമായി പൊരുത്തപ്പെടുന്നു bpf.h എന്നാൽ PCAP ഉറവിടം ഒഴിവാക്കാൻ ഞങ്ങൾ അവ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യുന്നു
ആശ്രയത്വം.

A ns-3 പിസിഎപി ഫയലിനെ പ്രതിനിധീകരിക്കുന്ന ഒബ്‌ജക്റ്റ് ഇതിൽ നിന്ന് തിരികെ നൽകുന്നു ഫയൽ സൃഷ്‌ടിക്കുക ഒരു ബൗണ്ടിൽ ഉപയോഗിക്കുകയും ചെയ്യുന്നു
ASCII കേസിൽ സംഭവിച്ചതുപോലെ തന്നെ തിരികെ വിളിക്കുക.

ഒരു പ്രധാന വഴിത്തിരിവ്: ഈ രണ്ട് വസ്തുക്കളും ഉണ്ടെങ്കിലും ശ്രദ്ധിക്കേണ്ടത് പ്രധാനമാണ്
വളരെ സമാനമായ രീതിയിൽ പ്രഖ്യാപിച്ചു,

Ptr ഫയൽ...
Ptr ധാര ...

അടിസ്ഥാന വസ്തുക്കൾ തികച്ചും വ്യത്യസ്തമാണ്. ഉദാഹരണത്തിന്, ദി Ptr ഒരു ആണ്
ഒരു സ്മാർട്ട് പോയിന്റർ ns-3 സപ്പോർട്ട് ചെയ്യുന്ന സാമാന്യം ഹെവി വെയ്റ്റ് ആയ ഒബ്ജക്റ്റ്
ആട്രിബ്യൂട്ടുകളും കോൺഫിഗറേഷൻ സിസ്റ്റത്തിലേക്ക് സംയോജിപ്പിച്ചിരിക്കുന്നു. ദി Ptrആ സമയത്ത്
മറുവശത്ത്, വളരെ ഭാരം കുറഞ്ഞ ഒരു റഫറൻസ് എണ്ണപ്പെട്ട ഒബ്‌ജക്റ്റിലേക്കുള്ള ഒരു സ്മാർട്ട് പോയിന്ററാണ്
കാര്യം. എന്തെങ്കിലും അനുമാനങ്ങൾ നടത്തുന്നതിന് മുമ്പ് നിങ്ങൾ പരാമർശിക്കുന്ന ഒബ്ജക്റ്റ് നോക്കാൻ ഓർക്കുക
വസ്തുവിന് ഉണ്ടായേക്കാവുന്ന "ശക്തികളെ" കുറിച്ച്.

ഉദാഹരണത്തിന്, ഒന്ന് നോക്കൂ src/network/utils/pcap-file-wrapper.h വിതരണത്തിലും
ശ്രദ്ധിക്കുക,

ക്ലാസ് PcapFileWrapper : പൊതു വസ്തു

ആ ക്ലാസ് PcapFileWrapper ഒരു ആണ് ns-3 വസ്തു അതിന്റെ അനന്തരാവകാശത്താൽ. എന്നിട്ട് നോക്കൂ
src/network/model/output-stream-wrapper.h ഒപ്പം ശ്രദ്ധിക്കുക,

ക്ലാസ് ഔട്ട്പുട്ട് സ്ട്രീം റാപ്പർ: പൊതു
SimpleRefCount

ഈ വസ്തു ഒരു അല്ല എന്ന് ns-3 ഒബ്ജക്റ്റ് എല്ലാം, അത് സംഭവിക്കുന്നത് "വെറും" ഒരു C++ വസ്തുവാണ്
നുഴഞ്ഞുകയറ്റ റഫറൻസ് കൗണ്ടിംഗ് പിന്തുണയ്ക്കുക.

നിങ്ങൾ വായിച്ചതുകൊണ്ടാണ് ഇവിടെ കാര്യം Ptr അത് അർത്ഥമാക്കണമെന്നില്ല
ആ എന്തെങ്കിലും ഒരു ആണ് ns-3 നിങ്ങൾക്ക് തൂക്കിയിടാൻ കഴിയുന്ന വസ്തു ns-3 ആട്രിബ്യൂട്ടുകൾ, ഉദാഹരണത്തിന്.

ഇപ്പോൾ, ഉദാഹരണത്തിലേക്ക് മടങ്ങുക. നിങ്ങൾ ഈ ഉദാഹരണം നിർമ്മിച്ച് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ,

$ ./waf --ഓൺ ആറാമത്

നിങ്ങൾ "അഞ്ചാമത്" ഓടുമ്പോൾ അതേ സന്ദേശങ്ങൾ ദൃശ്യമാകുന്നത് നിങ്ങൾ കാണും, എന്നാൽ രണ്ട് പുതിയ ഫയലുകൾ ദൃശ്യമാകും
നിങ്ങളുടെ ഉയർന്ന തലത്തിലുള്ള ഡയറക്ടറിയിൽ ദൃശ്യമാകും ns-3 വിതരണ.

ആറാം.സി.വി.എൻ.ഡി ആറാം.പിക്യാപ്

"sixth.cwnd" എന്നത് ഒരു ASCII ടെക്സ്റ്റ് ഫയലായതിനാൽ, നിങ്ങൾക്ക് ഇത് കാണാൻ കഴിയും പൂച്ച അല്ലെങ്കിൽ നിങ്ങളുടെ പ്രിയപ്പെട്ട ഫയൽ
കാഴ്ചക്കാരൻ.

1 0 536
1.0093 536 1072
1.01528 1072 1608
1.02167 1608 2144
...
9.69256 5149 5204
9.89311 5204 5259

നിങ്ങൾക്ക് ടൈംസ്റ്റാമ്പും പഴയ തിരക്കുള്ള ജാലകവും പുതിയതും ഉള്ള ഒരു ടാബ് വേർതിരിച്ച ഫയൽ ഉണ്ട്
നിങ്ങളുടെ പ്ലോട്ട് പ്രോഗ്രാമിലേക്ക് നേരിട്ട് ഇറക്കുമതി ചെയ്യുന്നതിന് അനുയോജ്യമായ കൺജഷൻ വിൻഡോ. ഇല്ല
ഫയലിലെ അധിക പ്രിന്റുകൾ, പാഴ്സിംഗും എഡിറ്റിംഗും ആവശ്യമില്ല.

"sixth.pcap" ഒരു PCAP ഫയലായതിനാൽ, നിങ്ങൾക്ക് ഇത് ഉപയോഗിച്ച് നോക്കാവുന്നതാണ് tcpdump.

ആറാമത്തെ ഫയലിൽ നിന്ന് വായിക്കുന്നു.pcap, ലിങ്ക്-ടൈപ്പ് PPP (PPP)
1.136956 IP 10.1.1.1.49153 > 10.1.1.2.8080: ഫ്ലാഗുകൾ [.], seq 17177:17681, ack 1, win 32768, ഓപ്ഷനുകൾ [TS val 1133 ecr 1127, 504 നീളം],XNUMX
1.403196 IP 10.1.1.1.49153 > 10.1.1.2.8080: ഫ്ലാഗുകൾ [.], seq 33280:33784, ack 1, win 32768, ഓപ്ഷനുകൾ [TS val 1399 ecr 1394, 504 നീളം],XNUMX
...
7.426220 IP 10.1.1.1.49153 > 10.1.1.2.8080: ഫ്ലാഗുകൾ [.], seq 785704:786240, ack 1, win 32768, ഓപ്ഷനുകൾ [TS val 7423 ecr 7421, 536 നീളം],XNUMX
9.630693 IP 10.1.1.1.49153 > 10.1.1.2.8080: ഫ്ലാഗുകൾ [.], seq 882688:883224, ack 1, win 32768, ഓപ്ഷനുകൾ [TS val 9620 ecr 9618, 536 നീളം],XNUMX

സിമുലേഷനിൽ ഉപേക്ഷിച്ച പാക്കറ്റുകളുള്ള ഒരു PCAP ഫയൽ നിങ്ങളുടെ പക്കലുണ്ട്. ഇല്ല
ഫയലിൽ മറ്റ് പാക്കറ്റുകൾ ഉണ്ട്, ജീവൻ ഉണ്ടാക്കാൻ മറ്റൊന്നും ഇല്ല
ബുദ്ധിമുട്ടുള്ള.

ഇത് ഒരു നീണ്ട യാത്രയാണ്, പക്ഷേ ഞങ്ങൾ ഇപ്പോൾ അഭിനന്ദിക്കാൻ കഴിയുന്ന ഒരു ഘട്ടത്തിലാണ് ns-3
ട്രേസിംഗ് സിസ്റ്റം. ഒരു ടിസിപി നടപ്പാക്കലിന്റെ മധ്യത്തിൽ നിന്ന് ഞങ്ങൾ പ്രധാനപ്പെട്ട ഇവന്റുകൾ പുറത്തെടുത്തു
ഒരു ഉപകരണ ഡ്രൈവറും. സാധാരണയായി അറിയപ്പെടുന്ന ഫയലുകളിൽ ഞങ്ങൾ ആ ഇവന്റുകൾ നേരിട്ട് സംഭരിച്ചു
ഉപകരണങ്ങൾ. ഉൾപ്പെട്ടിരിക്കുന്ന കോർ കോഡുകളൊന്നും പരിഷ്കരിക്കാതെയാണ് ഞങ്ങൾ ഇത് ചെയ്തത്, ഞങ്ങൾ ഇത് ചെയ്തു
കോഡിന്റെ 18 വരികൾ മാത്രം:

സ്റ്റാറ്റിക് അസാധുവാണ്
CwndChange (Ptr സ്ട്രീം, uint32_t oldCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (സിമുലേറ്റർ::Now ().GetSeconds () << "\t" << newCwnd);
*stream->GetStream () << Simulator::Now ().GetSeconds () << "\t" << oldCwnd << "\t" << newCwnd << std::endl;
}

...

AsciiTraceHelper asciiTraceHelper;
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("sixth.cwnd");
ns3TcpSocket->TraceConnect WithoutContext ("CongestionWindow", MakeBoundCallback (&CwndChange, സ്ട്രീം));

...

സ്റ്റാറ്റിക് അസാധുവാണ്
RxDrop (Ptr ഫയൽ, Ptr പി)
{
NS_LOG_UNCOND ("RxDrop at " << സിമുലേറ്റർ::Now ().GetSeconds ());
ഫയൽ->എഴുതുക (സിമുലേറ്റർ:: ഇപ്പോൾ (), പി);
}

...

PcapHelper pcapHelper;
Ptr ഫയൽ = pcapHelper.CreateFile ("sixth.pcap", "w", PcapHelper ::DLT_PPP);
device.Get (1)->TraceConnect WithoutContext("PhyRxDrop", MakeBoundCallback (&RxDrop, ഫയൽ));

ട്രെയ്സ് സഹായികൾ
ദി ns-3 വ്യത്യസ്തമായവ കോൺഫിഗർ ചെയ്യുന്നതിനും തിരഞ്ഞെടുക്കുന്നതിനുമുള്ള സമ്പന്നമായ അന്തരീക്ഷം ട്രെയ്‌സ് സഹായികൾ നൽകുന്നു
ഇവന്റുകൾ കണ്ടെത്തി ഫയലുകളിലേക്ക് എഴുതുക. മുമ്പത്തെ വിഭാഗങ്ങളിൽ, പ്രാഥമികമായി
ബിൽഡിംഗ് ടോപ്പോളജീസ്, രൂപകൽപ്പന ചെയ്ത ട്രെയ്‌സ് ഹെൽപ്പർ രീതികളുടെ നിരവധി ഇനങ്ങൾ ഞങ്ങൾ കണ്ടു
മറ്റ് (ഉപകരണം) സഹായികൾക്കുള്ളിൽ ഉപയോഗിക്കുന്നതിന്.

ഈ വ്യതിയാനങ്ങളിൽ ചിലത് നിങ്ങൾ കണ്ടത് ഒരുപക്ഷേ നിങ്ങൾ ഓർക്കും:

pointToPoint.EnablePcapAll ("രണ്ടാം");
pointToPoint.EnablePcap ("രണ്ടാം", p2pNodes.Get (0)->GetId (), 0);
csma.EnablePcap ("മൂന്നാം", csmaDevices.Get (0), true);
pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));

വ്യക്തമായിരിക്കില്ല, എന്നിരുന്നാലും, എല്ലാത്തിനും ഒരു സ്ഥിരമായ മാതൃകയുണ്ട് എന്നതാണ്
സിസ്റ്റത്തിൽ കണ്ടെത്തിയ ട്രെയ്‌സുമായി ബന്ധപ്പെട്ട രീതികൾ. ഞങ്ങൾ ഇപ്പോൾ കുറച്ച് സമയമെടുത്ത് നോക്കാം
"വലിയ ചിത്രത്തിൽ".

ട്രെയ്‌സിംഗ് ഹെൽപ്പർമാരുടെ രണ്ട് പ്രാഥമിക ഉപയോഗ കേസുകൾ നിലവിൽ ഉണ്ട് ns-3: ഉപകരണ സഹായികൾ
പ്രോട്ടോക്കോൾ സഹായികളും. ഉപകരണ സഹായികൾ ഏതൊക്കെ ട്രെയ്‌സുകൾ വ്യക്തമാക്കുന്നതിനുള്ള പ്രശ്നം നോക്കുന്നു
ഒരു (നോഡ്, ഉപകരണം) ജോടി വഴി പ്രവർത്തനക്ഷമമാക്കണം. ഉദാഹരണത്തിന്, നിങ്ങൾ വ്യക്തമാക്കാൻ താൽപ്പര്യപ്പെട്ടേക്കാം
ഒരു നിർദ്ദിഷ്ട നോഡിലെ ഒരു പ്രത്യേക ഉപകരണത്തിൽ PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കണം. ഈ
എന്നതിൽ നിന്ന് പിന്തുടരുന്നു ns-3 ഉപകരണ സങ്കല്പ മാതൃക, കൂടാതെ സങ്കല്പ മാതൃകകൾ
വിവിധ ഉപകരണ സഹായികൾ. ഇതിൽ നിന്ന് സ്വാഭാവികമായും, സൃഷ്ടിച്ച ഫയലുകൾ a പിന്തുടരുന്നു
- - നാമകരണ കൺവെൻഷൻ.

പ്രോട്ടോക്കോൾ സഹായികൾ ഏതൊക്കെ ട്രെയ്‌സുകളിലൂടെയാണ് പ്രവർത്തനക്ഷമമാക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്നതിനുള്ള പ്രശ്നം നോക്കുന്നു
ഒരു പ്രോട്ടോക്കോളും ഇന്റർഫേസ് ജോഡിയും. എന്നതിൽ നിന്ന് ഇത് പിന്തുടരുന്നു ns-3 പ്രോട്ടോക്കോൾ സ്റ്റാക്ക് ആശയപരമായ
മോഡൽ, കൂടാതെ ഇന്റർനെറ്റ് സ്റ്റാക്ക് സഹായികളുടെ ആശയപരമായ മോഡലുകളും. സ്വാഭാവികമായും, ട്രെയ്സ്
ഫയലുകൾ a പിന്തുടരേണ്ടതാണ് - - നാമകരണ കൺവെൻഷൻ.

അതിനാൽ ട്രെയ്സ് സഹായികൾ സ്വാഭാവികമായും ദ്വിമാന ടാക്സോണമിയിൽ വീഴുന്നു. ഇതുണ്ട്
നാല് വിഭാഗങ്ങളെയും ഒരേപോലെ പെരുമാറുന്നതിൽ നിന്ന് തടയുന്ന സൂക്ഷ്മതകൾ, പക്ഷേ ഞങ്ങൾ അതിനായി പരിശ്രമിക്കുന്നു
അവയെല്ലാം കഴിയുന്നത്ര ഒരേപോലെ പ്രവർത്തിക്കുക; സാധ്യമാകുമ്പോഴെല്ലാം അനലോഗ് ഉണ്ട്
എല്ലാ ക്ലാസുകളിലെയും എല്ലാ രീതികളും.

┌───────────────┬─────┬───────
│ │ PCAP │ ASCII │
└───────────────┴──────┴─────

│ഉപകരണ സഹായി │ │ │
├───────────────┼─────┼──────
│പ്രോട്ടോക്കോൾ സഹായി │ │ │
└───────────────┴──────┴─────

എ എന്ന ഒരു സമീപനമാണ് ഞങ്ങൾ ഉപയോഗിക്കുന്നത് മിക്സിൻ ഞങ്ങളുടെ സഹായ ക്ലാസുകളിലേക്ക് ട്രെയ്‌സിംഗ് പ്രവർത്തനം ചേർക്കുന്നതിന്. എ
മിക്സിൻ ഒരു ഉപവിഭാഗം പാരമ്പര്യമായി ലഭിക്കുമ്പോൾ പ്രവർത്തനക്ഷമത നൽകുന്ന ഒരു ക്ലാസ് ആണ്.
ഒരു മിക്‌സിനിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നത് സ്പെഷ്യലൈസേഷന്റെ ഒരു രൂപമായി കണക്കാക്കില്ല, പക്ഷേ യഥാർത്ഥത്തിൽ അതിനുള്ള ഒരു മാർഗമാണ്
പ്രവർത്തനക്ഷമത ശേഖരിക്കുക.

ഈ നാല് കേസുകളും അവയുടെ യഥാക്രമവും നമുക്ക് പെട്ടെന്ന് നോക്കാം മിക്സിനുകൾ.

ഉപകരണ സഹായികൾ
പിസിഎപി
ഒരു സ്ഥിരതയുള്ള PCAP ട്രെയ്‌സ് സൗകര്യം ചേർക്കുന്നത് എളുപ്പമാക്കുക എന്നതാണ് ഈ സഹായികളുടെ ലക്ഷ്യം
ns-3 ഉപകരണം. പിസിഎപി ട്രെയ്‌സിംഗിന്റെ വിവിധ ഫ്ലേവറുകൾ എല്ലായിടത്തും ഒരേപോലെ പ്രവർത്തിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
എല്ലാ ഉപകരണങ്ങളും, അതിനാൽ ഈ സഹായികളുടെ രീതികൾ ഉപകരണ സഹായികൾക്ക് പാരമ്പര്യമായി ലഭിക്കുന്നു. ഒന്നു നോക്കൂ
at src/network/helper/trace-helper.h നോക്കുമ്പോൾ ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ്.

വര്ഗം PcapHelperForDevice ഒരു ആണ് മിക്സിൻ ഉപയോഗിക്കുന്നതിന് ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം നൽകുന്നു
ഒരു പിസിഎപി ട്രെയ്‌സിംഗ് ns-3 ഉപകരണം. ഓരോ ഉപകരണവും ഒരൊറ്റ വെർച്വൽ രീതി നടപ്പിലാക്കണം
ഈ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി.

വെർച്വൽ ശൂന്യത EnablePcapInternal (std::string prefix, Ptr nd, bool promiscuous, bool explicitFilename) = 0;

ഈ രീതിയുടെ ഒപ്പ് ഈ സാഹചര്യത്തിന്റെ ഉപകരണ കേന്ദ്രീകൃത വീക്ഷണത്തെ പ്രതിഫലിപ്പിക്കുന്നു
നില. എല്ലാ പൊതു രീതികളും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചു PcapUserHelperForDevice ആയി കുറയ്ക്കുക
ഈ ഒരൊറ്റ ഉപകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള നടപ്പിലാക്കൽ രീതി എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന്, ഏറ്റവും താഴ്ന്ന നില
PCAP രീതി,

അസാധുവായ EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);

എന്ന ഉപകരണത്തിന്റെ നടപ്പാക്കലിനെ വിളിക്കും EnablePcapInternal നേരിട്ട്. മറ്റെല്ലാ പൊതു PCAP
അധിക ഉപയോക്തൃ-തലം നൽകുന്നതിന് ഈ നടപ്പാക്കലിൽ ട്രെയ്സിംഗ് രീതികൾ നിർമ്മിക്കുന്നു
പ്രവർത്തനക്ഷമത. ഇത് ഉപയോക്താവിന് എന്താണ് അർത്ഥമാക്കുന്നത്, സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണ സഹായികളും ഇത് ചെയ്യും
എല്ലാ PCAP ട്രെയ്സ് രീതികളും ലഭ്യമാണ്; ഈ രീതികളെല്ലാം ഒരേ രീതിയിൽ പ്രവർത്തിക്കും
ഉപകരണം നടപ്പിലാക്കുകയാണെങ്കിൽ ഉപകരണങ്ങളിലുടനീളം വഴി EnablePcapInternal ശരിയായി.

രീതികൾ
അസാധുവായ EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);
അസാധുവായ EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);
അസാധുവായ EnablePcap (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NetDeviceContainer d, bool promiscuous = false);
അസാധുവായ EnablePcap (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NodeContainer n, bool promiscuous = false);
അസാധുവായ EnablePcap (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, uint32_t nodeid, uint32_t deviceid, bool promiscuous = false);
അസാധുവായ EnablePcapAll (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, bool promiscuous = false);

മുകളിൽ കാണിച്ചിരിക്കുന്ന ഓരോ രീതിയിലും, ഒരു സ്ഥിരസ്ഥിതി പരാമീറ്റർ ഉണ്ട് വേശ്യാവൃത്തി ആ
സ്ഥിരസ്ഥിതിയായി തെറ്റായ. ഈ പരാമീറ്റർ സൂചിപ്പിക്കുന്നത് ട്രെയ്സ് ശേഖരിക്കാൻ പാടില്ല എന്നാണ്
പ്രോമിസ്ക്യൂസ് മോഡ്. നിങ്ങളുടെ ട്രെയ്‌സുകളിൽ ഉപകരണം കാണുന്ന എല്ലാ ട്രാഫിക്കും ഉൾപ്പെടുത്തണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
(ഉപകരണം ഒരു പ്രോമിസ്ക്യൂസ് മോഡിനെ പിന്തുണയ്ക്കുന്നുവെങ്കിൽ) ഏതെങ്കിലും ഒരു പരാമീറ്റർ ചേർക്കുക
മുകളിലെ കോളുകൾ. ഉദാഹരണത്തിന്,

Ptr nd;
...
helper.EnablePcap ("പ്രിഫിക്സ്", nd, true);

എന്നതിൽ പ്രോമിസ്‌ക്യൂസ് മോഡ് ക്യാപ്‌ചറുകൾ പ്രവർത്തനക്ഷമമാക്കും നെറ്റ് ഡിവൈസ് വ്യക്തമാക്കിയത് nd.

ആദ്യത്തെ രണ്ട് രീതികളിൽ ഒരു സ്ഥിരസ്ഥിതി പരാമീറ്ററും ഉൾപ്പെടുന്നു വ്യക്തമായ ഫയലിന്റെ പേര് ആ ഇഷ്ടം
താഴെ ചർച്ച ചെയ്യാം.

ക്ലാസ്സിനായി API ഡോക്യുമെന്റേഷൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു PcapHelperForDevice കണ്ടുപിടിക്കാൻ
ഈ രീതികളുടെ വിശദാംശങ്ങൾ; എന്നാൽ സംഗ്രഹിക്കാൻ ...

ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഉപകരണ ജോടിയിൽ നിങ്ങൾക്ക് പിസിഎപി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ptr ഒരു EnablePcap രീതി. ദി Ptr നെറ്റ് ഉപകരണം മുതൽ പരോക്ഷമാണ്
കൃത്യമായി ഒരു നോഡിൽ ഉൾപ്പെട്ടിരിക്കണം. ഉദാഹരണത്തിന്,

Ptr nd;
...
helper.EnablePcap ("പ്രിഫിക്സ്", nd);

ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഉപകരണ ജോടിയിൽ നിങ്ങൾക്ക് പിസിഎപി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
std::സ്ട്രിംഗ് ഒരു ഒബ്ജക്റ്റ് നെയിം സേവന സ്ട്രിംഗ് പ്രതിനിധീകരിക്കുന്നു EnablePcap രീതി. ദി
Ptr നെയിം സ്ട്രിംഗിൽ നിന്ന് നോക്കുന്നു. വീണ്ടും, ദി മുതൽ പരോക്ഷമാണ്
പേരിട്ടിരിക്കുന്ന നെറ്റ് ഉപകരണം കൃത്യമായി ഒരു നോഡിലേത് ആയിരിക്കണം. ഉദാഹരണത്തിന്,

പേരുകൾ:: ചേർക്കുക ("സെർവർ" ...);
പേരുകൾ::ചേർക്കുക ("സെർവർ/eth0" ...);
...
helper.EnablePcap ("പ്രിഫിക്സ്", "സെർവർ/അത്0");

· നിങ്ങൾക്ക് ഒരു നോഡ്/നെറ്റ്-ഡിവൈസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ പിസിഎപി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
NetDeviceContainer. ഓരോന്നിനും നെറ്റ് ഡിവൈസ് കണ്ടെയ്നറിൽ തരം പരിശോധിച്ചു. ഓരോന്നിനും
ശരിയായ തരത്തിലുള്ള ഉപകരണം (ഉപകരണ സഹായി നിയന്ത്രിക്കുന്ന അതേ തരം), ട്രേസിംഗ് ആണ്
പ്രവർത്തനക്ഷമമാക്കി. വീണ്ടും, ദി കണ്ടെത്തിയ നെറ്റ് ഉപകരണം ഉൾപ്പെട്ടതായിരിക്കണം എന്നതിനാൽ ഇത് പരോക്ഷമാണ്
കൃത്യമായി ഒരു നോഡ്. ഉദാഹരണത്തിന്,

NetDeviceContainer d = ...;
...
helper.EnablePcap ("പ്രിഫിക്സ്", d);

· നിങ്ങൾക്ക് ഒരു നോഡ്/നെറ്റ്-ഡിവൈസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ പിസിഎപി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
നോഡ് കണ്ടെയ്നർ. ലെ ഓരോ നോഡിനും നോഡ് കണ്ടെയ്നർ അതിന്റെ ഘടിപ്പിച്ചിരിക്കുന്നു നെറ്റ് ഡിവൈസുകൾ ആവർത്തിക്കപ്പെടുന്നു.
ഓരോന്നും നെറ്റ് ഡിവൈസ് കണ്ടെയ്‌നറിലെ ഓരോ നോഡിലും ഘടിപ്പിച്ചിരിക്കുന്നു, ആ ഉപകരണത്തിന്റെ തരം
പരിശോധിച്ചു. ശരിയായ തരത്തിലുള്ള ഓരോ ഉപകരണത്തിനും (ഉപകരണം നിയന്ത്രിക്കുന്ന അതേ തരം
സഹായി), ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കി.

നോഡ് കണ്ടെയ്നർ n;
...
helper.EnablePcap ("പ്രിഫിക്സ്", n);

· നോഡ് ഐഡിയുടെയും ഉപകരണ ഐഡിയുടെയും അടിസ്ഥാനത്തിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
സ്പഷ്ടമായത് Ptr. സിസ്റ്റത്തിലെ ഓരോ നോഡിനും ഒരു പൂർണ്ണസംഖ്യ നോഡ് ഐഡിയും ഓരോ ഉപകരണവും ബന്ധിപ്പിച്ചിരിക്കുന്നു
ഒരു നോഡിന് ഒരു പൂർണ്ണസംഖ്യ ഉപകരണ ഐഡി ഉണ്ട്.

helper.EnablePcap ("പ്രിഫിക്സ്", 21, 1);

അവസാനമായി, ഒരേ തരത്തിൽ, സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണങ്ങൾക്കും PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
ഉപകരണ സഹായി മാനേജ് ചെയ്യുന്നത് പോലെ.

helper.EnablePcapAll ("പ്രിഫിക്സ്");

ഫയലിന്റെ പേരുകൾ
ഒരു സമ്പൂർണ്ണ ഫയൽ നാമത്തിന്റെ നിർമ്മാണമാണ് മുകളിലെ രീതി വിവരണങ്ങളിൽ ഉള്ളത്
നടപ്പിലാക്കൽ രീതി. കൺവെൻഷൻ പ്രകാരം, PCAP ട്രെയ്‌സ് ഇൻ ns-3 സിസ്റ്റം രൂപത്തിലാണ്
- ഐഡി>- id>.pcap

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, സിസ്റ്റത്തിലെ എല്ലാ നോഡിനും ഒരു സിസ്റ്റം അസൈൻ ചെയ്ത നോഡ് ഐഡി ഉണ്ടായിരിക്കും; ഒപ്പം
ഓരോ ഉപകരണത്തിനും അതിന്റെ നോഡിന് ആപേക്ഷികമായി ഒരു ഇന്റർഫേസ് സൂചിക (ഉപകരണ ഐഡി എന്നും അറിയപ്പെടുന്നു) ഉണ്ടായിരിക്കും.
ഡിഫോൾട്ടായി, ആദ്യത്തേതിൽ ട്രേസിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നതിന്റെ ഫലമായി ഒരു PCAP ട്രെയ്സ് ഫയൽ സൃഷ്ടിച്ചു
"പ്രിഫിക്സ്" എന്ന പ്രിഫിക്സ് ഉപയോഗിക്കുന്ന നോഡ് 21-ന്റെ ഉപകരണം പ്രിഫിക്സ്-21-1.pcap.

നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം ns-3 ഇത് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഒബ്ജക്റ്റ് നെയിം സേവനം. ഉദാഹരണത്തിന്, എങ്കിൽ
നോഡ് 21-ലേക്ക് "സെർവർ" എന്ന പേര് നൽകുന്നതിന് നിങ്ങൾ ഒബ്ജക്റ്റ് നെയിം സേവനം ഉപയോഗിക്കുന്നു, തത്ഫലമായുണ്ടാകുന്ന PCAP
ട്രേസ് ഫയലിന്റെ പേര് സ്വയമേവ ആയി മാറും, prefix-server-1.pcap നിങ്ങൾ നിയോഗിക്കുകയാണെങ്കിൽ
ഉപകരണത്തിന് "eth0" എന്ന് പേര് നൽകുക, നിങ്ങളുടെ PCAP ഫയലിന്റെ പേര് ഇത് സ്വയമേവ തിരഞ്ഞെടുത്ത് ആയിരിക്കും
വിളിച്ചു prefix-server-eth0.pcap.

അവസാനമായി, മുകളിൽ കാണിച്ചിരിക്കുന്ന രണ്ട് രീതികൾ,

അസാധുവായ EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);
അസാധുവായ EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool explicitFilename = false);

എന്ന ഒരു ഡിഫോൾട്ട് പാരാമീറ്റർ ഉണ്ട് വ്യക്തമായ ഫയലിന്റെ പേര്. ശരി എന്ന് സജ്ജീകരിക്കുമ്പോൾ, ഈ പരാമീറ്റർ
സ്വയമേവയുള്ള ഫയൽനാമം പൂർത്തീകരണ സംവിധാനം പ്രവർത്തനരഹിതമാക്കുകയും സ്പഷ്ടമായത് സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു
ഫയലിന്റെ പേര്. a-യിൽ PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്ന രീതികളിൽ മാത്രമേ ഈ ഓപ്ഷൻ ലഭ്യമാകൂ
ഒറ്റ ഉപകരണം.

ഉദാഹരണത്തിന്, ഒരു ഉപകരണ സഹായിയെ ഏകോപിപ്പിച്ച പിസിഎപി സൃഷ്ടിക്കാൻ ക്രമീകരിക്കുന്നതിന്
ഒരു നിർദ്ദിഷ്ട പേരിന്റെ ഫയൽ ക്യാപ്‌ചർ ചെയ്യുക my-pcap-file.pcap നൽകിയിരിക്കുന്ന ഉപകരണത്തിൽ, ഒരാൾക്ക്:

Ptr nd;
...
helper.EnablePcap ("my-pcap-file.pcap", nd, true, true);

ആദ്യത്തേത് യഥാർഥ പരാമീറ്റർ പ്രോമിസ്ക്യൂസ് മോഡ് ട്രെയ്സ് പ്രാപ്തമാക്കുന്നു, രണ്ടാമത്തേത് സഹായിയെ അറിയിക്കുന്നു
വ്യാഖ്യാനിക്കാൻ പ്രിഫിക്‌സ് ഒരു സമ്പൂർണ്ണ ഫയൽ നാമമായി പരാമീറ്റർ.

ASCII
ASCII ട്രെയ്സ് സഹായിയുടെ പെരുമാറ്റം മിക്സിൻ PCAP പതിപ്പിനോട് സാമ്യമുള്ളതാണ്.
ഒന്ന് നോക്കിക്കോളു src/network/helper/trace-helper.h നിങ്ങൾക്ക് ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ് നോക്കുമ്പോൾ.

വര്ഗം AsciiTraceHelperForDevice ASCII ഉപയോഗിക്കുന്നതിനുള്ള ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം ചേർക്കുന്നു
ഒരു ഉപകരണ സഹായ ക്ലാസിലേക്ക് കണ്ടെത്തുന്നു. പിസിഎപി കേസിലെന്നപോലെ, എല്ലാ ഉപകരണവും നടപ്പിലാക്കണം a
ASCII ട്രെയ്‌സിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച ഒറ്റ വെർച്വൽ രീതി മിക്സിൻ.

വെർച്വൽ ശൂന്യത EnableAsciiInternal (Ptr ധാര,
std::സ്ട്രിംഗ് പ്രിഫിക്സ്,
Ptr nd,
bool explicitFilename) = 0;

ഈ രീതിയുടെ ഒപ്പ് ഈ സാഹചര്യത്തിന്റെ ഉപകരണ കേന്ദ്രീകൃത വീക്ഷണത്തെ പ്രതിഫലിപ്പിക്കുന്നു
നില; കൂടാതെ, സഹായി ഒരു പങ്കിട്ട ഔട്ട്‌പുട്ട് സ്ട്രീമിലേക്ക് എഴുതുന്നുണ്ടെന്ന വസ്തുതയും. എല്ലാം
ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച പൊതു ആസ്കി-ട്രേസ്-അനുബന്ധ രീതികൾ AsciiTraceHelperForDevice
ഈ ഒരൊറ്റ ഉപകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള നടപ്പിലാക്കൽ രീതിയിലേക്ക് വിളിക്കുന്നത് കുറയ്ക്കുക. ഉദാഹരണത്തിന്, ദി
ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള ascii ട്രെയ്സ് രീതികൾ,

അസാധുവായ EnableAscii (std::string prefix, Ptr nd, bool explicitFilename = false);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, Ptr nd);

എന്ന ഉപകരണത്തിന്റെ നടപ്പാക്കലിനെ വിളിക്കും AsciiInternal പ്രവർത്തനക്ഷമമാക്കുക നേരിട്ട്, ഒന്നുകിൽ ഒരു നൽകുന്നു
സാധുവായ പ്രിഫിക്സ് അല്ലെങ്കിൽ സ്ട്രീം. മറ്റെല്ലാ പൊതു ആസ്കി ട്രെയ്‌സിംഗ് രീതികളും ഇവയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
അധിക ഉപയോക്തൃ-തല പ്രവർത്തനം നൽകുന്നതിന് താഴ്ന്ന നിലയിലുള്ള പ്രവർത്തനങ്ങൾ. ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്
സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണ സഹായികൾക്കും എല്ലാ ASCII ട്രെയ്സ് രീതികളും ഉണ്ടായിരിക്കുമെന്നതാണ് ഉപയോക്താവ്
ലഭ്യമാണ്; ഈ രീതികളെല്ലാം ഉപകരണങ്ങളിൽ ഒരേ രീതിയിൽ പ്രവർത്തിക്കും
നടപ്പിലാക്കുക EnablAsciiInternal ശരിയായി.

രീതികൾ
അസാധുവായ EnableAscii (std::string prefix, Ptr nd, bool explicitFilename = false);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, Ptr nd);

അസാധുവായ EnableAscii (std::string prefix, std::string ndName, bool explicitFilename = false);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, std::string ndName);

അസാധുവായ EnableAscii (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NetDeviceContainer d);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, NetDeviceContainer d);

അസാധുവായ EnableAscii (std::string prefix, NodeContainer n);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, നോഡ് കണ്ടെയ്നർ n);

അസാധുവായ EnableAsciiAll (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്);
അസാധുവായ EnableAsciiAll (Ptr ധാര);

അസാധുവായ EnableAscii (std::string prefix, uint32_t nodeid, uint32_t deviceid, bool explicitFilename);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, uint32_t nodeid, uint32_t deviceid);

ക്ലാസ്സിനായി API ഡോക്യുമെന്റേഷൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു AsciiTraceHelperForDevice ലേക്ക്
ഈ രീതികളുടെ വിശദാംശങ്ങൾ കണ്ടെത്തുക; എന്നാൽ സംഗ്രഹിക്കാൻ ...

ASCII ട്രെയ്‌സിങ്ങിന് PCAP-ന് ഉണ്ടായിരുന്നതിന്റെ ഇരട്ടി രീതികൾ ലഭ്യമാണ്
കണ്ടെത്തൽ. കാരണം, പിസിഎപി-സ്റ്റൈൽ മോഡലിന് പുറമെ ഓരോന്നിൽ നിന്നും ട്രെയ്‌സ് ചെയ്യുന്നു
അദ്വിതീയ നോഡ്/ഉപകരണ ജോടി ഒരു അദ്വിതീയ ഫയലിലേക്കാണ് എഴുതിയിരിക്കുന്നത്, ഒരു മാതൃകയെ ഞങ്ങൾ പിന്തുണയ്ക്കുന്നു
നിരവധി നോഡ്/ഉപകരണ ജോഡികൾക്കുള്ള വിവരങ്ങൾ ഒരു സാധാരണ ഫയലിൽ എഴുതിയിരിക്കുന്നു. ഇതിനർത്ഥം ദി
- - ഫയൽ നെയിം ജനറേഷൻ മെക്കാനിസത്തിന് പകരം ഒരു മെക്കാനിസം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു
ഒരു സാധാരണ ഫയൽ കാണുക; കൂടാതെ എല്ലാം അനുവദിക്കുന്നതിനായി API രീതികളുടെ എണ്ണം ഇരട്ടിയാക്കി
കോമ്പിനേഷനുകൾ.

· PCAP ട്രെയ്‌സിംഗിലെന്നപോലെ, നിങ്ങൾക്ക് ഒരു പ്രത്യേക (നോഡ്, നെറ്റ്-ഡിവൈസ്) ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം.
ഒരു നൽകിക്കൊണ്ട് ജോടിയാക്കുക Ptr ഒരു Ascii പ്രവർത്തനക്ഷമമാക്കുക രീതി. ദി Ptr പരോക്ഷമാണ്
കാരണം നെറ്റ് ഉപകരണം കൃത്യമായി ഒരു നോഡിലേത് ആയിരിക്കണം. ഉദാഹരണത്തിന്,

Ptr nd;
...
helper.EnableAscii ("പ്രിഫിക്സ്", nd);

· ആദ്യത്തെ നാല് രീതികളിൽ ഒരു ഡിഫോൾട്ട് പാരാമീറ്ററും ഉൾപ്പെടുന്നു വ്യക്തമായ ഫയലിന്റെ പേര് ആ
PCAP കേസിൽ തത്തുല്യമായ പരാമീറ്ററുകൾക്ക് സമാനമായി പ്രവർത്തിക്കുക.

ഈ സാഹചര്യത്തിൽ, ASCII ട്രെയ്സ് ഫയലിലേക്ക് ട്രെയ്സ് സന്ദർഭങ്ങളൊന്നും എഴുതപ്പെടുന്നില്ല
അനാവശ്യമായ. അതേ നിയമങ്ങൾ ഉപയോഗിച്ച് സൃഷ്ടിക്കേണ്ട ഫയലിന്റെ പേര് സിസ്റ്റം തിരഞ്ഞെടുക്കും
PCAP വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നത്, ഫയലിന് പ്രത്യയം ഉണ്ടായിരിക്കുമെന്നതൊഴിച്ചാൽ .tr ഇതിനുപകരമായി
.pcap.

· നിങ്ങൾക്ക് ഒന്നിലധികം നെറ്റ് ഉപകരണങ്ങളിൽ ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാനും എല്ലാ ട്രെയ്‌സുകളും അയച്ചിരിക്കാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ഒരൊറ്റ ഫയലിലേക്ക്, ഒരൊറ്റ ഫയലിലേക്ക് റഫർ ചെയ്യാൻ ഒരു ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അത് ചെയ്യാൻ കഴിയും.
മുകളിലുള്ള "cwnd" ഉദാഹരണത്തിൽ ഞങ്ങൾ ഇത് ഇതിനകം കണ്ടു:

Ptr nd1;
Ptr nd2;
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (സ്ട്രീം, nd1);
helper.EnableAscii (സ്ട്രീം, nd2);

ഈ സാഹചര്യത്തിൽ, സന്ദർഭങ്ങൾ കണ്ടെത്തുക ആകുന്നു അവ ആവശ്യമുള്ളതിനാൽ ASCII ട്രേസ് ഫയലിലേക്ക് എഴുതി
രണ്ട് ഉപകരണങ്ങളിൽ നിന്നുള്ള ട്രെയ്സ് അവ്യക്തമാക്കാൻ. ഉപയോക്താവ് പൂർണ്ണമായും ആയതിനാൽ ശ്രദ്ധിക്കുക
ഫയലിന്റെ പേര് വ്യക്തമാക്കുമ്പോൾ, സ്ട്രിംഗിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുത്തണം ,TR സ്ഥിരതയ്ക്കുള്ള പ്രത്യയം.

· നിങ്ങൾക്ക് ഒരു പ്രത്യേക (നോഡ്, നെറ്റ്-ഡിവൈസ്) ജോഡിയിൽ ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
std::സ്ട്രിംഗ് ഒരു ഒബ്ജക്റ്റ് നെയിം സേവന സ്ട്രിംഗ് പ്രതിനിധീകരിക്കുന്നു EnablePcap രീതി. ദി
Ptr നെയിം സ്ട്രിംഗിൽ നിന്ന് നോക്കുന്നു. വീണ്ടും, ദി മുതൽ പരോക്ഷമാണ്
പേരിട്ടിരിക്കുന്ന നെറ്റ് ഉപകരണം കൃത്യമായി ഒരു നോഡിലേത് ആയിരിക്കണം. ഉദാഹരണത്തിന്,

പേരുകൾ:: ചേർക്കുക ("ക്ലയന്റ്" ...);
പേരുകൾ::ചേർക്കുക ("ക്ലയന്റ്/eth0" ...);
പേരുകൾ:: ചേർക്കുക ("സെർവർ" ...);
പേരുകൾ::ചേർക്കുക ("സെർവർ/eth0" ...);
...
helper.EnableAscii ("പ്രിഫിക്സ്", "ക്ലയന്റ്/eth0");
helper.EnableAscii ("പ്രിഫിക്സ്", "സെർവർ/eth0");

ഇത് ``prefix-client-eth0.tr` എന്ന പേരിലുള്ള രണ്ട് ഫയലുകൾക്ക് കാരണമാകും
എന്നതിലെ ഓരോ ഉപകരണത്തിനും ട്രെയ്‌സുകളുള്ള ``prefix-server-eth0.tr``
ബന്ധപ്പെട്ട ട്രേസ് ഫയൽ. എല്ലാ ``EnableAscii`` ഫംഗ്‌ഷനുകളും മുതൽ
ഒരു സ്ട്രീം റാപ്പർ എടുക്കാൻ ഓവർലോഡ് ആണ്, നിങ്ങൾക്ക് ആ ഫോം ഇതുപോലെ ഉപയോഗിക്കാം
നന്നായി::

പേരുകൾ:: ചേർക്കുക ("ക്ലയന്റ്" ...);
പേരുകൾ::ചേർക്കുക ("ക്ലയന്റ്/eth0" ...);
പേരുകൾ:: ചേർക്കുക ("സെർവർ" ...);
പേരുകൾ::ചേർക്കുക ("സെർവർ/eth0" ...);
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (സ്ട്രീം, "client/eth0");
helper.EnableAscii (സ്ട്രീം, "സെർവർ/eth0");

ഇത് ഒരൊറ്റ ട്രെയ്സ് ഫയലിന് കാരണമാകും trace-file-name.tr അതിൽ എല്ലാം അടങ്ങിയിരിക്കുന്നു
രണ്ട് ഉപകരണങ്ങളുടെയും ട്രെയ്സ് ഇവന്റുകൾ. സംഭവങ്ങൾ ട്രെയ്സ് സന്ദർഭത്താൽ അവ്യക്തമാകും
സ്ട്രിംഗുകൾ.

ഒരു (നോഡ്, നെറ്റ്-ഡിവൈസ്) ജോഡികളുടെ ഒരു ശേഖരത്തിൽ നിങ്ങൾക്ക് ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
NetDeviceContainer. ഓരോന്നിനും നെറ്റ് ഡിവൈസ് കണ്ടെയ്നറിൽ തരം പരിശോധിച്ചു. ഓരോന്നിനും
ശരിയായ തരത്തിലുള്ള ഉപകരണം (ഉപകരണ സഹായി നിയന്ത്രിക്കുന്ന അതേ തരം), ട്രേസിംഗ് ആണ്
പ്രവർത്തനക്ഷമമാക്കി. വീണ്ടും, ദി കണ്ടെത്തിയ നെറ്റ് ഉപകരണം ഉൾപ്പെട്ടതായിരിക്കണം എന്നതിനാൽ ഇത് പരോക്ഷമാണ്
കൃത്യമായി ഒരു നോഡ്. ഉദാഹരണത്തിന്,

NetDeviceContainer d = ...;
...
helper.EnableAscii ("പ്രിഫിക്സ്", d);

ഇത് നിരവധി ASCII ട്രെയ്സ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിലേക്ക് നയിക്കും,
ഓരോന്നും `` പിന്തുടരുന്നു - - .tr``
കൺവെൻഷൻ.

എല്ലാ ട്രെയ്‌സുകളും ഒരൊറ്റ ഫയലിലേക്ക് സംയോജിപ്പിക്കുന്നത് ഉദാഹരണങ്ങൾക്ക് സമാനമായി നടപ്പിലാക്കുന്നു
മുകളിൽ:

NetDeviceContainer d = ...;
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (സ്ട്രീം, ഡി);

ഒരു (നോഡ്, നെറ്റ്-ഡിവൈസ്) ജോഡികളുടെ ഒരു ശേഖരത്തിൽ നിങ്ങൾക്ക് ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
നോഡ് കണ്ടെയ്നർ. ലെ ഓരോ നോഡിനും നോഡ് കണ്ടെയ്നർ അതിന്റെ ഘടിപ്പിച്ചിരിക്കുന്നു നെറ്റ് ഡിവൈസുകൾ ആവർത്തിക്കപ്പെടുന്നു.
ഓരോന്നും നെറ്റ് ഡിവൈസ് കണ്ടെയ്‌നറിലെ ഓരോ നോഡിലും ഘടിപ്പിച്ചിരിക്കുന്നു, ആ ഉപകരണത്തിന്റെ തരം
പരിശോധിച്ചു. ശരിയായ തരത്തിലുള്ള ഓരോ ഉപകരണത്തിനും (ഉപകരണം നിയന്ത്രിക്കുന്ന അതേ തരം
സഹായി), ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കി.

നോഡ് കണ്ടെയ്നർ n;
...
helper.EnableAscii ("പ്രിഫിക്സ്", n);

ഇത് നിരവധി ASCII ട്രെയ്‌സ് ഫയലുകൾ സൃഷ്‌ടിക്കുന്നതിന് കാരണമാകും, അവ ഓരോന്നും പിന്തുടരുന്നു
The - ഐഡി>- id>.tr കൺവെൻഷൻ. എല്ലാ അടയാളങ്ങളും സംയോജിപ്പിച്ച് a
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി സിംഗിൾ ഫയൽ നിർവ്വഹിച്ചിരിക്കുന്നു.

· നോഡ് ഐഡിയുടെയും ഉപകരണ ഐഡിയുടെയും അടിസ്ഥാനത്തിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
സ്പഷ്ടമായത് Ptr. സിസ്റ്റത്തിലെ ഓരോ നോഡിനും ഒരു പൂർണ്ണസംഖ്യ നോഡ് ഐഡിയും ഓരോ ഉപകരണവും ബന്ധിപ്പിച്ചിരിക്കുന്നു
ഒരു നോഡിന് ഒരു പൂർണ്ണസംഖ്യ ഉപകരണ ഐഡി ഉണ്ട്.

helper.EnableAscii ("പ്രിഫിക്സ്", 21, 1);

തീർച്ചയായും, മുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ട്രെയ്‌സുകൾ ഒരൊറ്റ ഫയലായി സംയോജിപ്പിക്കാം.

അവസാനമായി, ഒരേ തരത്തിൽ, സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണങ്ങൾക്കും PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
ഉപകരണ സഹായി മാനേജ് ചെയ്യുന്നത് പോലെ.

helper.EnableAsciiAll ("പ്രിഫിക്സ്");

ഇത് ഓരോ ഉപകരണത്തിനും ഒന്നായി നിരവധി ASCII ട്രെയ്സ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിലേക്ക് നയിക്കും
സഹായി കൈകാര്യം ചെയ്യുന്ന തരത്തിലുള്ള സിസ്റ്റത്തിൽ. ഈ ഫയലുകളെല്ലാം പിന്തുടരും
- ഐഡി>- id>.tr കൺവെൻഷൻ. എല്ലാ ട്രെയ്‌സുകളും ഒരു സിംഗിൾ ആയി സംയോജിപ്പിക്കുന്നു
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി ഫയൽ നിർവ്വഹിച്ചിരിക്കുന്നു.

ഫയലിന്റെ പേരുകൾ
മുകളിലുള്ള പ്രിഫിക്‌സ്-സ്റ്റൈൽ രീതി വിവരണങ്ങളിൽ അന്തർലീനമായത് പൂർണ്ണമായ നിർമ്മാണമാണ്
നടപ്പിലാക്കൽ രീതി പ്രകാരം ഫയൽ നാമങ്ങൾ. കൺവെൻഷൻ പ്രകാരം, ASCII ട്രെയ്സ് ചെയ്യുന്നു ns-3 സിസ്റ്റം
രൂപത്തിലുള്ളവയാണ് - ഐഡി>- id>.tr

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, സിസ്റ്റത്തിലെ എല്ലാ നോഡിനും ഒരു സിസ്റ്റം അസൈൻ ചെയ്ത നോഡ് ഐഡി ഉണ്ടായിരിക്കും; ഒപ്പം
ഓരോ ഉപകരണത്തിനും അതിന്റെ നോഡിന് ആപേക്ഷികമായി ഒരു ഇന്റർഫേസ് സൂചിക (ഉപകരണ ഐഡി എന്നും അറിയപ്പെടുന്നു) ഉണ്ടായിരിക്കും.
ഡിഫോൾട്ടായി, ആദ്യത്തേതിൽ ട്രേസിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നതിന്റെ ഫലമായി ഒരു ASCII ട്രെയ്സ് ഫയൽ സൃഷ്ടിച്ചു
"പ്രിഫിക്സ്" എന്ന പ്രിഫിക്സ് ഉപയോഗിച്ച് നോഡ് 21-ന്റെ ഉപകരണം ഉപസർഗ്ഗം-21-1.tr.

നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം ns-3 ഇത് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഒബ്ജക്റ്റ് നെയിം സേവനം. ഉദാഹരണത്തിന്, എങ്കിൽ
നോഡ് 21 ലേക്ക് "സെർവർ" എന്ന പേര് നൽകുന്നതിന് നിങ്ങൾ ഒബ്ജക്റ്റ് നെയിം സേവനം ഉപയോഗിക്കുന്നു
ASCII ട്രെയ്സ് ഫയലിന്റെ പേര് സ്വയമേവ ആയി മാറും, prefix-server-1.tr നിങ്ങൾ നിയോഗിക്കുകയാണെങ്കിൽ
ഉപകരണത്തിന് "eth0" എന്ന പേര്, നിങ്ങളുടെ ASCII ട്രെയ്സ് ഫയലിന്റെ പേര് ഇത് സ്വയമേവ എടുക്കും
വിളിക്കപ്പെടുകയും ചെയ്യും prefix-server-eth0.tr.

പല രീതികൾക്കും ഒരു ഡിഫോൾട്ട് പാരാമീറ്റർ ഉണ്ട് വ്യക്തമായ ഫയലിന്റെ പേര്. സജ്ജമാക്കുമ്പോൾ
ശരിയാണ്, ഈ പരാമീറ്റർ സ്വയമേവയുള്ള ഫയൽനാമം പൂർത്തീകരണ സംവിധാനം പ്രവർത്തനരഹിതമാക്കുകയും നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു
ഒരു വ്യക്തമായ ഫയൽനാമം സൃഷ്ടിക്കാൻ. എ എടുക്കുന്ന രീതികളിൽ മാത്രമേ ഈ ഓപ്ഷൻ ലഭ്യമാകൂ
പ്രിഫിക്‌സ് ചെയ്ത് ഒരൊറ്റ ഉപകരണത്തിൽ ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുക.

പ്രോട്ടോകോൾ സഹായികൾ
പിസിഎപി
ഇവയുടെ ലക്ഷ്യം മിക്സിനുകൾ സ്ഥിരമായ PCAP ട്രെയ്സ് സൗകര്യം ചേർക്കുന്നത് എളുപ്പമാക്കുക എന്നതാണ്
പ്രോട്ടോക്കോളുകൾ. പിസിഎപി ട്രെയ്‌സിംഗിന്റെ വിവിധ ഫ്ലേവറുകൾ എല്ലായിടത്തും ഒരേപോലെ പ്രവർത്തിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
പ്രോട്ടോക്കോളുകൾ, അതിനാൽ ഈ സഹായികളുടെ രീതികൾ സ്റ്റാക്ക് ഹെൽപ്പർമാർക്ക് പാരമ്പര്യമായി ലഭിക്കുന്നു. ഒന്ന് നോക്കിക്കോളു
src/network/helper/trace-helper.h നോക്കുമ്പോൾ ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ്.

ഈ വിഭാഗത്തിൽ ഞങ്ങൾ പ്രോട്ടോക്കോളിൽ പ്രയോഗിക്കുന്ന രീതികൾ ചിത്രീകരിക്കും IPv4. ലേക്ക്
സമാന പ്രോട്ടോക്കോളുകളിൽ ട്രെയ്സ് വ്യക്തമാക്കുക, ഉചിതമായ തരം പകരം വയ്ക്കുക. ഉദാഹരണത്തിന്,
ഒരു ഉപയോഗിക്കുക Ptr പകരം a Ptr വിളിക്കുക EnablePcapIpv6 ഇതിനുപകരമായി EnablePcapIpv4.

വര്ഗം PcapHelperForIpv4 PCAP ട്രെയ്‌സിംഗ് ഉപയോഗിക്കുന്നതിന് ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം നൽകുന്നു
ലെ IPv4 പ്രോട്ടോക്കോൾ. ഈ രീതികൾ പ്രാപ്തമാക്കുന്ന ഓരോ പ്രോട്ടോക്കോൾ സഹായിയും ഒരു സിംഗിൾ നടപ്പിലാക്കണം
ഈ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച വെർച്വൽ രീതി. ഇതിനായി പ്രത്യേകം നടപ്പാക്കും
IPv6, ഉദാഹരണത്തിന്, എന്നാൽ ഒരേയൊരു വ്യത്യാസം രീതിയുടെ പേരുകളിലും ഒപ്പുകളിലും ആയിരിക്കും.
ക്ലാസ് അവ്യക്തമാക്കാൻ വ്യത്യസ്ത രീതി നാമങ്ങൾ ആവശ്യമാണ് IPv4 നിന്ന് IPv6 ഇവ രണ്ടും
ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞത് വസ്തു, ഒപ്പം ഒരേ ഒപ്പ് പങ്കിടുന്ന രീതികളും.

വെർച്വൽ ശൂന്യത EnablePcapIpv4Internal (std::സ്ട്രിംഗ് പ്രിഫിക്സ്,
Ptr ipv4,
uint32_t ഇന്റർഫേസ്,
bool explicitFilename) = 0;

ഈ രീതിയുടെ ഒപ്പ് പ്രോട്ടോക്കോളും ഇന്റർഫേസ് കേന്ദ്രീകൃത കാഴ്ചയും പ്രതിഫലിപ്പിക്കുന്നു
ഈ തലത്തിലുള്ള സാഹചര്യം. എല്ലാ പൊതു രീതികളും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചു PcapHelperForIpv4
ഈ ഒരൊറ്റ ഉപകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള നടപ്പിലാക്കൽ രീതിയിലേക്ക് വിളിക്കുക. ഉദാഹരണത്തിന്, ദി
ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള PCAP രീതി,

അസാധുവായ EnablePcapIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്, bool explicitFilename = false);

എന്ന ഉപകരണത്തിന്റെ നടപ്പാക്കലിനെ വിളിക്കും EnablePcapIpv4Internal നേരിട്ട്. മറ്റെല്ലാ പൊതുജനങ്ങളും
അധിക ഉപയോക്തൃ നില നൽകുന്നതിന് PCAP ട്രെയ്‌സിംഗ് രീതികൾ ഈ നടപ്പാക്കലിൽ നിർമ്മിക്കുന്നു
പ്രവർത്തനക്ഷമത. ഇത് ഉപയോക്താവിന് എന്താണ് അർത്ഥമാക്കുന്നത്, സിസ്റ്റത്തിലെ എല്ലാ പ്രോട്ടോക്കോൾ സഹായികളും
എല്ലാ PCAP ട്രെയ്സ് രീതികളും ലഭ്യമാകും; ഈ രീതികൾ എല്ലാം പ്രവർത്തിക്കും
സഹായി നടപ്പിലാക്കുകയാണെങ്കിൽ പ്രോട്ടോക്കോളുകളിലുടനീളം ഇതേ രീതിയിൽ EnablePcapIpv4Internal ശരിയായി.

രീതികൾ
ഈ രീതികൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് നോഡുമായി ഒന്നിൽ നിന്ന് ഒരു കത്തിടപാടിലാണ്
നെറ്റ് ഡിവൈസ്- ഉപകരണ പതിപ്പുകളുടെ കേന്ദ്രീകൃത പതിപ്പുകൾ. നോഡിന് പകരം ഒപ്പം നെറ്റ് ഡിവൈസ് ജോഡി
നിയന്ത്രണങ്ങൾ, ഞങ്ങൾ പ്രോട്ടോക്കോളും ഇന്റർഫേസ് നിയന്ത്രണങ്ങളും ഉപയോഗിക്കുന്നു.

ഉപകരണ പതിപ്പിലെന്നപോലെ, ആറ് രീതികളുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക:

അസാധുവായ EnablePcapIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്, bool explicitFilename = false);
അസാധുവായ EnablePcapIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, std::string ipv4Name, uint32_t ഇന്റർഫേസ്, bool explicitFilename = false);
അസാധുവായ EnablePcapIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, Ipv4InterfaceContainer c);
അസാധുവായ EnablePcapIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NodeContainer n);
അസാധുവായ EnablePcapIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്‌സ്, uint32_t nodeid, uint32_t ഇന്റർഫേസ്, bool explicitFilename);
അസാധുവായ EnablePcapIpv4All (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്);

ക്ലാസ്സിനായി API ഡോക്യുമെന്റേഷൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു PcapHelperForIpv4 കണ്ടെത്താൻ
ഈ രീതികളുടെ വിശദാംശങ്ങൾ; എന്നാൽ സംഗ്രഹിക്കാൻ ...

ഒരു പ്രത്യേക പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോടിയിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാൻ കഴിയും
Ptr ഒപ്പം ഇന്റർഫേസ് ഒരു EnablePcap രീതി. ഉദാഹരണത്തിന്,

Ptr ipv4 = നോഡ്->GetObject ();
...
helper.EnablePcapIpv4 ("പ്രിഫിക്സ്", ipv4, 0);

ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഉപകരണ ജോടിയിൽ നിങ്ങൾക്ക് പിസിഎപി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
std::സ്ട്രിംഗ് ഒരു ഒബ്ജക്റ്റ് നെയിം സേവന സ്ട്രിംഗ് പ്രതിനിധീകരിക്കുന്നു EnablePcap രീതി. ദി
Ptr നെയിം സ്ട്രിംഗിൽ നിന്ന് നോക്കുന്നു. ഉദാഹരണത്തിന്,

പേരുകൾ::ചേർക്കുക ("serverIPv4" ...);
...
helper.EnablePcapIpv4 ("പ്രിഫിക്സ്", "സെർവർഐപിവി4", 1);

ഒരു പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ipv4InterfaceContainer. ഓരോന്നിനും IPv4 / കണ്ടെയ്നർ പ്രോട്ടോക്കോളിൽ ഇന്റർഫേസ് ജോടി
തരം പരിശോധിച്ചു. ശരിയായ തരത്തിലുള്ള ഓരോ പ്രോട്ടോക്കോളിനും (മാനേജുചെയ്യുന്ന അതേ തരം
ഉപകരണ സഹായി), ബന്ധപ്പെട്ട ഇന്റർഫേസിനായി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു. ഉദാഹരണത്തിന്,

നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
...
NetDeviceContainer devices = deviceHelper.Install (nodes);
...
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer ഇന്റർഫേസുകൾ = ipv4.Assign (ഉപകരണങ്ങൾ);
...
helper.EnablePcapIpv4 ("പ്രിഫിക്സ്", ഇന്റർഫേസുകൾ);

ഒരു പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
നോഡ് കണ്ടെയ്നർ. ലെ ഓരോ നോഡിനും നോഡ് കണ്ടെയ്നർ ഉചിതമായ പ്രോട്ടോക്കോൾ കണ്ടെത്തി.
ഓരോ പ്രോട്ടോക്കോളിനും, അതിന്റെ ഇന്റർഫേസുകൾ എണ്ണിത്തീർക്കുകയും ഫലത്തിൽ ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്യുന്നു.
ജോഡികൾ. ഉദാഹരണത്തിന്,

നോഡ് കണ്ടെയ്നർ n;
...
helper.EnablePcapIpv4 ("പ്രിഫിക്സ്", n);

· നോഡ് ഐഡിയുടെയും ഇന്റർഫേസിന്റെയും അടിസ്ഥാനത്തിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം. ഇതിൽ
കേസ്, നോഡ്-ഐഡി a ലേക്ക് വിവർത്തനം ചെയ്തിരിക്കുന്നു Ptr ഉചിതമായ പ്രോട്ടോക്കോൾ നോക്കുകയും ചെയ്യുന്നു
നോഡിൽ. തത്ഫലമായുണ്ടാകുന്ന പ്രോട്ടോക്കോളും ഇന്റർഫേസും ഫലമായത് വ്യക്തമാക്കാൻ ഉപയോഗിക്കുന്നു
ഉറവിടം കണ്ടെത്തുക.

helper.EnablePcapIpv4 ("പ്രിഫിക്സ്", 21, 1);

അവസാനമായി, സിസ്റ്റത്തിലെ എല്ലാ ഇന്റർഫേസുകൾക്കുമായി നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
ഉപകരണ സഹായി നിയന്ത്രിക്കുന്ന അതേ തരത്തിലുള്ള പ്രോട്ടോക്കോൾ.

helper.EnablePcapIpv4All ("പ്രിഫിക്സ്");

ഫയലിന്റെ പേരുകൾ
മുകളിലുള്ള എല്ലാ രീതി വിവരണങ്ങളിലും അന്തർലീനമായത് പൂർണ്ണമായ നിർമ്മാണമാണ്
നടപ്പിലാക്കൽ രീതി പ്രകാരം ഫയൽ നാമങ്ങൾ. കൺവെൻഷൻ പ്രകാരം, ഉപകരണങ്ങൾക്കായി പിസിഎപി ട്രെയ്‌സുകൾ എടുത്തിട്ടുണ്ട്
The ns-3 സിസ്റ്റം രൂപത്തിലാണ് " - - .pcap". കേസിൽ
പ്രോട്ടോക്കോൾ ട്രെയ്‌സുകൾ, പ്രോട്ടോക്കോളുകൾ എന്നിവയ്‌ക്കിടയിൽ ഒന്നൊന്നായി കത്തിടപാടുകൾ ഉണ്ട് നോഡുകൾ. ഈ
പ്രോട്ടോക്കോൾ കാരണം വസ്തുക്കൾ സമാഹരിച്ചിരിക്കുന്നു നോഡ് വസ്തുക്കൾ. ആഗോളം ഇല്ലാത്തതിനാൽ
സിസ്റ്റത്തിലെ പ്രോട്ടോക്കോൾ ഐഡി, ഫയൽ നാമകരണത്തിൽ ഞങ്ങൾ അനുബന്ധ നോഡ് ഐഡി ഉപയോഗിക്കുന്നു. അതുകൊണ്ടു
സ്വയമേവ തിരഞ്ഞെടുത്ത ട്രേസ് ഫയൽ നാമങ്ങളിൽ ഫയൽ നെയിം കൂട്ടിയിടിക്ക് സാധ്യതയുണ്ട്.
ഇക്കാരണത്താൽ, പ്രോട്ടോക്കോൾ ട്രെയ്‌സുകൾക്കായി ഫയൽ നെയിം കൺവെൻഷൻ മാറ്റി.

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, സിസ്റ്റത്തിലെ എല്ലാ നോഡിനും ഒരു സിസ്റ്റം അസൈൻ ചെയ്ത നോഡ് ഐഡി ഉണ്ടായിരിക്കും.
പ്രോട്ടോക്കോൾ ഇൻസ്‌റ്റൻസുകളും നോഡ് ഇൻസ്‌റ്റൻസുകളും തമ്മിൽ വൺ-ടു-വൺ കത്തിടപാടുകൾ ഉള്ളതിനാൽ
ഞങ്ങൾ നോഡ് ഐഡി ഉപയോഗിക്കുന്നു. ഓരോ ഇന്റർഫേസിനും അതിന്റെ പ്രോട്ടോക്കോളുമായി ബന്ധപ്പെട്ട് ഒരു ഇന്റർഫേസ് ഐഡി ഉണ്ട്. ഞങ്ങൾ ഉപയോഗിക്കുന്നു
കൺവെൻഷൻ " -എൻ -ഐ .pcap" എന്ന ഫയലിന്റെ പേര് കണ്ടെത്തുന്നതിന്
പ്രോട്ടോക്കോൾ സഹായികൾ.

അതിനാൽ, ഡിഫോൾട്ടായി, ട്രേസിംഗ് ഓൺ പ്രവർത്തനക്ഷമമാക്കുന്നതിന്റെ ഫലമായി ഒരു PCAP ട്രെയ്സ് ഫയൽ സൃഷ്ടിച്ചു
"പ്രിഫിക്സ്" എന്ന പ്രിഫിക്‌സ് ഉപയോഗിക്കുന്ന നോഡ് 1-ന്റെ Ipv4 പ്രോട്ടോക്കോളിന്റെ ഇന്റർഫേസ് 21 ആയിരിക്കും
"prefix-n21-i1.pcap".

നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം ns-3 ഇത് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഒബ്ജക്റ്റ് നെയിം സേവനം. ഉദാഹരണത്തിന്, എങ്കിൽ
Ptr-ലേക്ക് "serverIpv4" എന്ന പേര് നൽകുന്നതിന് നിങ്ങൾ ഒബ്ജക്റ്റ് നെയിം സേവനം ഉപയോഗിക്കുന്നു നോഡിൽ
21, തത്ഫലമായുണ്ടാകുന്ന PCAP ട്രെയ്സ് ഫയലിന്റെ പേര് സ്വയമേവ ആയി മാറും,
"prefix-nserverIpv4-i1.pcap".

പല രീതികൾക്കും ഒരു ഡിഫോൾട്ട് പാരാമീറ്റർ ഉണ്ട് വ്യക്തമായ ഫയലിന്റെ പേര്. സജ്ജമാക്കുമ്പോൾ
ശരിയാണ്, ഈ പരാമീറ്റർ സ്വയമേവയുള്ള ഫയൽനാമം പൂർത്തീകരണ സംവിധാനം പ്രവർത്തനരഹിതമാക്കുകയും നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു
ഒരു വ്യക്തമായ ഫയൽനാമം സൃഷ്ടിക്കാൻ. എ എടുക്കുന്ന രീതികളിൽ മാത്രമേ ഈ ഓപ്ഷൻ ലഭ്യമാകൂ
പ്രിഫിക്‌സ് ചെയ്ത് ഒരൊറ്റ ഉപകരണത്തിൽ ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുക.

ASCII
ASCII ട്രെയ്‌സ് സഹായികളുടെ പെരുമാറ്റം പിസിഎപി കേസുമായി സാമ്യമുള്ളതാണ്. എ എടുക്കുക
നോക്കൂ src/network/helper/trace-helper.h നിങ്ങൾക്ക് ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ് നോക്കുന്നു.

ഈ വിഭാഗത്തിൽ ഞങ്ങൾ പ്രോട്ടോക്കോളിൽ പ്രയോഗിക്കുന്ന രീതികൾ ചിത്രീകരിക്കും IPv4. ലേക്ക്
സമാന പ്രോട്ടോക്കോളുകളിൽ ട്രെയ്സ് വ്യക്തമാക്കുക, ഉചിതമായ തരം പകരം വയ്ക്കുക. ഉദാഹരണത്തിന്,
ഒരു ഉപയോഗിക്കുക Ptr പകരം a Ptr വിളിക്കുക EnableAsciiIpv6 ഇതിനുപകരമായി
EnableAsciiIpv4.

വര്ഗം AsciiTraceHelperForIpv4 ASCII ഉപയോഗിക്കുന്നതിനുള്ള ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം ചേർക്കുന്നു
ഒരു പ്രോട്ടോക്കോൾ സഹായിയെ കണ്ടെത്തുന്നു. ഈ രീതികൾ പ്രാപ്തമാക്കുന്ന ഓരോ പ്രോട്ടോക്കോളും നടപ്പിലാക്കണം
ഈ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച ഏക വെർച്വൽ രീതി.

വെർച്വൽ ശൂന്യത EnableAsciiIpv4Internal (Ptr ധാര,
std::സ്ട്രിംഗ് പ്രിഫിക്സ്,
Ptr ipv4,
uint32_t ഇന്റർഫേസ്,
bool explicitFilename) = 0;

ഈ രീതിയുടെ ഒപ്പ് പ്രോട്ടോക്കോളും ഇന്റർഫേസ് കേന്ദ്രീകൃത കാഴ്ചയും പ്രതിഫലിപ്പിക്കുന്നു
ഈ തലത്തിലുള്ള സാഹചര്യം; കൂടാതെ സഹായി ഒരു പങ്കുവയ്ക്കലിന് എഴുതുന്നുണ്ടെന്ന വസ്തുതയും
ഔട്ട്പുട്ട് സ്ട്രീം. എല്ലാ പൊതു രീതികളും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചു
PcapAndAsciiTraceHelperForIpv4 ഈ ഒരൊറ്റ ഉപകരണത്തെ ആശ്രിതമായി വിളിക്കുന്നതിലേക്ക് ചുരുക്കുക
നടപ്പിലാക്കൽ രീതി. ഉദാഹരണത്തിന്, ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള ASCII ട്രെയ്സ് രീതികൾ,

അസാധുവാണ് EnableAsciiIpv4 (std::string prefix, Ptr ipv4, uint4_t ഇന്റർഫേസ്, bool explicitFilename = false);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, Ptr ipv4, uint4_t ഇന്റർഫേസ്);

എന്ന ഉപകരണത്തിന്റെ നടപ്പാക്കലിനെ വിളിക്കും EnableAsciiIpv4Internal നേരിട്ട്, ഒന്നുകിൽ നൽകുന്നു
പ്രിഫിക്സ് അല്ലെങ്കിൽ സ്ട്രീം. മറ്റെല്ലാ പൊതു ആസ്കി ട്രെയ്‌സിംഗ് രീതികളും ഇവയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
അധിക ഉപയോക്തൃ-തല പ്രവർത്തനം നൽകുന്നതിന് താഴ്ന്ന നിലയിലുള്ള പ്രവർത്തനങ്ങൾ. ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്
സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണ സഹായികൾക്കും എല്ലാ ASCII ട്രെയ്സ് രീതികളും ഉണ്ടായിരിക്കുമെന്നതാണ് ഉപയോക്താവ്
ലഭ്യമാണ്; എങ്കിൽ ഈ രീതികളെല്ലാം പ്രോട്ടോക്കോളുകളിലുടനീളം ഒരേ രീതിയിൽ പ്രവർത്തിക്കും
പ്രോട്ടോക്കോളുകൾ നടപ്പിലാക്കുന്നു EnablAsciiIpv4Internal ശരിയായി.

രീതികൾ
അസാധുവാണ് EnableAsciiIpv4 (std::string prefix, Ptr ipv4, uint4_t ഇന്റർഫേസ്, bool explicitFilename = false);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, Ptr ipv4, uint4_t ഇന്റർഫേസ്);

അസാധുവായ EnableAsciiIpv4 (std:: string prefix, std:: string ipv4Name, uint32_t ഇന്റർഫേസ്, bool explicitFilename = false);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, std::string ipv4Name, uint32_t ഇന്റർഫേസ്);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, Ipv4InterfaceContainer c);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, Ipv4InterfaceContainer c);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NodeContainer n);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, നോഡ് കണ്ടെയ്നർ n);

അസാധുവായ EnableAsciiIpv4All (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്);
അസാധുവായ EnableAsciiIpv4All (Ptr ധാര);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, uint32_t nodeid, uint32_t deviceid, bool explicitFilename);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, uint32_t nodeid, uint32_t ഇന്റർഫേസ്);

ക്ലാസ്സിനായി API ഡോക്യുമെന്റേഷൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു PcapAndAsciiHelperForIpv4 ലേക്ക്
ഈ രീതികളുടെ വിശദാംശങ്ങൾ കണ്ടെത്തുക; എന്നാൽ സംഗ്രഹിക്കാൻ ...

ASCII ട്രെയ്‌സിങ്ങിന് PCAP-ന് ഉണ്ടായിരുന്നതിന്റെ ഇരട്ടി രീതികൾ ലഭ്യമാണ്
കണ്ടെത്തൽ. കാരണം, പിസിഎപി-സ്റ്റൈൽ മോഡലിന് പുറമെ ഓരോന്നിൽ നിന്നും ട്രെയ്‌സ് ചെയ്യുന്നു
അദ്വിതീയ പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോടി ഒരു അദ്വിതീയ ഫയലിലേക്ക് എഴുതിയിരിക്കുന്നു, ഞങ്ങൾ ഒരു മോഡലിനെ പിന്തുണയ്ക്കുന്നു
പല പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോഡികൾക്കായുള്ള ട്രെയ്സ് വിവരങ്ങൾ ഒരു സാധാരണ ഫയലിൽ എഴുതിയിരിക്കുന്നു. ഈ
എന്നാണ് -എൻ - ഫയൽ നെയിം ജനറേഷൻ മെക്കാനിസം ആണ്
ഒരു സാധാരണ ഫയൽ റഫർ ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിച്ചു; കൂടാതെ API രീതികളുടെ എണ്ണം
എല്ലാ കോമ്പിനേഷനുകളും അനുവദിക്കുന്നതിന് ഇരട്ടിയാക്കി.

PCAP ട്രെയ്‌സിംഗിലെന്നപോലെ, ഒരു പ്രത്യേക പ്രോട്ടോക്കോൾ/ഇന്റർഫേസിൽ നിങ്ങൾക്ക് ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം.
ഒരു നൽകിക്കൊണ്ട് ജോടിയാക്കുക Ptr ഒരു ഇന്റർഫേസ് ഒരു Ascii പ്രവർത്തനക്ഷമമാക്കുക രീതി. ഉദാഹരണത്തിന്,

Ptr ipv4;
...
helper.EnableAsciiIpv4 ("പ്രിഫിക്സ്", ipv4, 1);

ഈ സാഹചര്യത്തിൽ, ASCII ട്രെയ്സ് ഫയലിലേക്ക് ട്രെയ്സ് സന്ദർഭങ്ങളൊന്നും എഴുതപ്പെടുന്നില്ല
അനാവശ്യമായ. അതേ നിയമങ്ങൾ ഉപയോഗിച്ച് സൃഷ്ടിക്കേണ്ട ഫയലിന്റെ പേര് സിസ്റ്റം തിരഞ്ഞെടുക്കും
PCAP വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നത്, ഫയലിന് പകരം ".tr" എന്ന പ്രത്യയം ഉണ്ടായിരിക്കുമെന്നതൊഴിച്ചാൽ
".pcap" എന്നതിന്റെ.

· നിങ്ങൾക്ക് ഒന്നിലധികം ഇന്റർഫേസുകളിൽ ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാനും എല്ലാ ട്രെയ്‌സുകളും അയച്ചിരിക്കാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ഒരൊറ്റ ഫയലിലേക്ക്, ഒരൊറ്റ ഫയലിലേക്ക് റഫർ ചെയ്യാൻ ഒരു ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അത് ചെയ്യാൻ കഴിയും.
മുകളിലുള്ള "cwnd" ഉദാഹരണത്തിൽ ഇതിന് സമാനമായ ഒന്ന് ഞങ്ങൾക്കുണ്ട്:

Ptr പ്രോട്ടോക്കോൾ4 = നോഡ്1->GetObject ();
Ptr പ്രോട്ടോക്കോൾ4 = നോഡ്2->GetObject ();
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAsciiIpv4 (സ്ട്രീം, പ്രോട്ടോക്കോൾ1, 1);
helper.EnableAsciiIpv4 (സ്ട്രീം, പ്രോട്ടോക്കോൾ2, 1);

ഈ സാഹചര്യത്തിൽ, ട്രെയ്സ് സന്ദർഭങ്ങൾ ആവശ്യമുള്ളതിനാൽ ASCII ട്രേസ് ഫയലിലേക്ക് എഴുതുന്നു
രണ്ട് ഇന്റർഫേസുകളിൽ നിന്നുള്ള ട്രെയ്സ് അവ്യക്തമാക്കാൻ. ഉപയോക്താവ് പൂർണ്ണമായും ആയതിനാൽ ശ്രദ്ധിക്കുക
ഫയലിന്റെ പേര് വ്യക്തമാക്കുമ്പോൾ, സ്ട്രിംഗിൽ സ്ഥിരതയ്ക്കായി ",tr" ഉൾപ്പെടുത്തണം.

ഒരു പ്രത്യേക പ്രോട്ടോക്കോളിൽ നിങ്ങൾക്ക് ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം std::സ്ട്രിംഗ്
ഒരു ഒബ്ജക്റ്റ് നെയിം സേവന സ്ട്രിംഗ് പ്രതിനിധീകരിക്കുന്നു EnablePcap രീതി. ദി Ptr is
നെയിം സ്ട്രിംഗിൽ നിന്ന് നോക്കി. ദി തത്ഫലമായുണ്ടാകുന്ന ഫയൽനാമങ്ങളിൽ മുതലാണ് സൂചിപ്പിക്കുന്നത്
പ്രോട്ടോക്കോൾ സംഭവങ്ങളും നോഡുകളും തമ്മിൽ പരസ്പരം കത്തിടപാടുകൾ ഉണ്ട്, ഉദാഹരണത്തിന്,

പേരുകൾ::ചേർക്കുക ("node1Ipv4" ...);
പേരുകൾ::ചേർക്കുക ("node2Ipv4" ...);
...
helper.EnableAsciiIpv4 ("പ്രിഫിക്സ്", "node1Ipv4", 1);
helper.EnableAsciiIpv4 ("പ്രിഫിക്സ്", "node2Ipv4", 1);

ഇത് "prefix-nnode1Ipv4-i1.tr" എന്ന പേരിലുള്ള രണ്ട് ഫയലുകൾക്ക് കാരണമാകും.
"prefix-nnode2Ipv4-i1.tr", അതത് ട്രേസ് ഫയലിലെ ഓരോ ഇന്റർഫേസിനും ട്രെയ്‌സുകൾ.
ഒരു സ്ട്രീം റാപ്പർ എടുക്കാൻ എല്ലാ EnableAscii ഫംഗ്ഷനുകളും ഓവർലോഡ് ആയതിനാൽ, നിങ്ങൾക്ക് കഴിയും
ആ ഫോമും ഉപയോഗിക്കുക:

പേരുകൾ::ചേർക്കുക ("node1Ipv4" ...);
പേരുകൾ::ചേർക്കുക ("node2Ipv4" ...);
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAsciiIpv4 (സ്ട്രീം, "node1Ipv4", 1);
helper.EnableAsciiIpv4 (സ്ട്രീം, "node2Ipv4", 1);

ഇത് "trace-file-name.tr" എന്ന ഒരൊറ്റ ട്രേസ് ഫയലിന് കാരണമാകും, അതിൽ എല്ലാം അടങ്ങിയിരിക്കും
രണ്ട് ഇന്റർഫേസുകളുടെയും ട്രെയ്സ് ഇവന്റുകൾ. സംഭവങ്ങൾ ട്രെയ്സ് വഴി അവ്യക്തമാകും
സന്ദർഭ സ്ട്രിംഗുകൾ.

· നിങ്ങൾക്ക് ഒരു പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ipv4InterfaceContainer. ശരിയായ തരത്തിലുള്ള ഓരോ പ്രോട്ടോക്കോളിനും (അതേ തരം
ഉപകരണ സഹായിയാണ് നിയന്ത്രിക്കുന്നത്), ബന്ധപ്പെട്ട ഇന്റർഫേസിനായി ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു.
വീണ്ടും, ആ ഓരോന്നിനും ഇടയിൽ പരസ്പരം കത്തിടപാടുകൾ ഉള്ളതിനാൽ പരോക്ഷമായി
പ്രോട്ടോക്കോളും അതിന്റെ നോഡും. ഉദാഹരണത്തിന്,

നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
...
NetDeviceContainer devices = deviceHelper.Install (nodes);
...
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer ഇന്റർഫേസുകൾ = ipv4.Assign (ഉപകരണങ്ങൾ);
...
...
helper.EnableAsciiIpv4 ("പ്രിഫിക്സ്", ഇന്റർഫേസുകൾ);

ഇത് നിരവധി ASCII ട്രെയ്‌സ് ഫയലുകൾ സൃഷ്‌ടിക്കുന്നതിന് കാരണമാകും, അവ ഓരോന്നും പിന്തുടരുന്നു
ദി -എൻ -ഐ .ടിആർ കൺവെൻഷൻ. എല്ലാ അടയാളങ്ങളും സംയോജിപ്പിച്ച് a
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി സിംഗിൾ ഫയൽ പൂർത്തിയാക്കി:

നോഡ് കണ്ടെയ്നർ നോഡുകൾ;
...
NetDeviceContainer devices = deviceHelper.Install (nodes);
...
Ipv4AddressHelper ipv4;
ipv4.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer ഇന്റർഫേസുകൾ = ipv4.Assign (ഉപകരണങ്ങൾ);
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAsciiIpv4 (സ്ട്രീം, ഇന്റർഫേസുകൾ);

ഒരു പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ നിങ്ങൾക്ക് ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
നോഡ് കണ്ടെയ്നർ. ലെ ഓരോ നോഡിനും നോഡ് കണ്ടെയ്നർ ഉചിതമായ പ്രോട്ടോക്കോൾ കണ്ടെത്തി.
ഓരോ പ്രോട്ടോക്കോളിനും, അതിന്റെ ഇന്റർഫേസുകൾ എണ്ണിത്തീർക്കുകയും ഫലത്തിൽ ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്യുന്നു.
ജോഡികൾ. ഉദാഹരണത്തിന്,

നോഡ് കണ്ടെയ്നർ n;
...
helper.EnableAsciiIpv4 ("പ്രിഫിക്സ്", n);

ഇത് നിരവധി ASCII ട്രെയ്‌സ് ഫയലുകൾ സൃഷ്‌ടിക്കുന്നതിന് കാരണമാകും, അവ ഓരോന്നും പിന്തുടരുന്നു
ദി - - .ടിആർ കൺവെൻഷൻ. എല്ലാ അടയാളങ്ങളും സംയോജിപ്പിച്ച് a
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി സിംഗിൾ ഫയൽ നിർവ്വഹിച്ചിരിക്കുന്നു.

· നോഡ് ഐഡിയുടെയും ഉപകരണ ഐഡിയുടെയും അടിസ്ഥാനത്തിൽ നിങ്ങൾക്ക് PCAP ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം. ഇതിൽ
കേസ്, നോഡ്-ഐഡി a ലേക്ക് വിവർത്തനം ചെയ്തിരിക്കുന്നു Ptr ഉചിതമായ പ്രോട്ടോക്കോൾ നോക്കുകയും ചെയ്യുന്നു
നോഡിൽ. തത്ഫലമായുണ്ടാകുന്ന പ്രോട്ടോക്കോളും ഇന്റർഫേസും ഫലമായത് വ്യക്തമാക്കാൻ ഉപയോഗിക്കുന്നു
ഉറവിടം കണ്ടെത്തുക.

helper.EnableAsciiIpv4 ("പ്രിഫിക്സ്", 21, 1);

തീർച്ചയായും, മുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ട്രെയ്‌സുകൾ ഒരൊറ്റ ഫയലായി സംയോജിപ്പിക്കാം.

അവസാനമായി, സിസ്റ്റത്തിലെ എല്ലാ ഇന്റർഫേസുകൾക്കും അനുബന്ധമായി നിങ്ങൾക്ക് ASCII ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
ഉപകരണ സഹായി നിയന്ത്രിക്കുന്ന അതേ തരത്തിലുള്ള പ്രോട്ടോക്കോൾ.

helper.EnableAsciiIpv4All ("പ്രിഫിക്സ്");

ഇത് നിരവധി ASCII ട്രെയ്സ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിലേക്ക് നയിക്കും, ഓരോന്നിനും ഒന്ന്
സഹായി നിയന്ത്രിക്കുന്ന തരത്തിലുള്ള ഒരു പ്രോട്ടോക്കോളുമായി ബന്ധപ്പെട്ട സിസ്റ്റത്തിലെ ഇന്റർഫേസ്. എല്ലാം
ഈ ഫയലുകൾ പിന്തുടരും -എൻ -ഐ
ഒരൊറ്റ ഫയലിലേക്കുള്ള എല്ലാ ട്രെയ്‌സുകളും മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി നടപ്പിലാക്കുന്നു.

ഫയലിന്റെ പേരുകൾ
മുകളിലുള്ള പ്രിഫിക്‌സ്-സ്റ്റൈൽ രീതി വിവരണങ്ങളിൽ അന്തർലീനമായത് പൂർണ്ണമായ നിർമ്മാണമാണ്
നടപ്പിലാക്കൽ രീതി പ്രകാരം ഫയൽ നാമങ്ങൾ. കൺവെൻഷൻ പ്രകാരം, ASCII ട്രെയ്സ് ചെയ്യുന്നു ns-3 സിസ്റ്റം
രൂപത്തിലാണ്" - - .tr"

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, സിസ്റ്റത്തിലെ എല്ലാ നോഡിനും ഒരു സിസ്റ്റം അസൈൻ ചെയ്ത നോഡ് ഐഡി ഉണ്ടായിരിക്കും.
പ്രോട്ടോക്കോളുകളും നോഡുകളും തമ്മിൽ പരസ്പരം കത്തിടപാടുകൾ ഉള്ളതിനാൽ ഞങ്ങൾ നോഡ്-ഐഡി ഉപയോഗിക്കുന്നു
പ്രോട്ടോക്കോൾ ഐഡന്റിറ്റി തിരിച്ചറിയാൻ. തന്നിരിക്കുന്ന പ്രോട്ടോക്കോളിലെ എല്ലാ ഇന്റർഫേസിനും ഒരു ഉണ്ടായിരിക്കും
അതിന്റെ പ്രോട്ടോക്കോളുമായി ബന്ധപ്പെട്ട ഇന്റർഫേസ് സൂചിക (വെറും ഒരു ഇന്റർഫേസ് എന്നും വിളിക്കുന്നു). സ്വതവേ,
തുടർന്ന്, ആദ്യ ഉപകരണത്തിൽ ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നതിന്റെ ഫലമായി സൃഷ്‌ടിച്ച ഒരു ASCII ട്രെയ്സ് ഫയൽ
"പ്രിഫിക്സ്" എന്ന പ്രിഫിക്‌സ് ഉപയോഗിക്കുന്ന നോഡ് 21, "പ്രിഫിക്‌സ്-n21-i1.tr" ആയിരിക്കും. എന്നതിന്റെ പ്രിഫിക്സ് ഉപയോഗിക്കുക
ഓരോ നോഡിനും ഒന്നിലധികം പ്രോട്ടോക്കോളുകൾ അവ്യക്തമാക്കുക.

നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം ns-3 ഇത് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഒബ്ജക്റ്റ് നെയിം സേവനം. ഉദാഹരണത്തിന്, എങ്കിൽ
നോഡിലെ പ്രോട്ടോക്കോളിലേക്ക് "serverIpv4" എന്ന പേര് നൽകുന്നതിന് നിങ്ങൾ ഒബ്ജക്റ്റ് നെയിം സേവനം ഉപയോഗിക്കുന്നു
21, കൂടാതെ ഇന്റർഫേസ് ഒന്ന് വ്യക്തമാക്കുക, തത്ഫലമായുണ്ടാകുന്ന ASCII ട്രേസ് ഫയലിന്റെ പേര് സ്വയമേവ ലഭിക്കും
"prefix-nserverIpv4-1.tr" ആകുക.

പല രീതികൾക്കും ഒരു ഡിഫോൾട്ട് പാരാമീറ്റർ ഉണ്ട് വ്യക്തമായ ഫയലിന്റെ പേര്. സജ്ജമാക്കുമ്പോൾ
ശരിയാണ്, ഈ പരാമീറ്റർ സ്വയമേവയുള്ള ഫയൽനാമം പൂർത്തീകരണ സംവിധാനം പ്രവർത്തനരഹിതമാക്കുകയും നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു
ഒരു വ്യക്തമായ ഫയൽനാമം സൃഷ്ടിക്കാൻ. എ എടുക്കുന്ന രീതികളിൽ മാത്രമേ ഈ ഓപ്ഷൻ ലഭ്യമാകൂ
പ്രിഫിക്‌സ് ചെയ്ത് ഒരൊറ്റ ഉപകരണത്തിൽ ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുക.

ചുരുക്കം
ns-3 വിവിധ തലങ്ങളിലുള്ള ഉപയോക്താക്കളെ ഇഷ്‌ടാനുസൃതമാക്കാൻ അനുവദിക്കുന്ന വളരെ സമ്പന്നമായ അന്തരീക്ഷം ഉൾപ്പെടുന്നു
സിമുലേഷനുകളിൽ നിന്ന് വേർതിരിച്ചെടുക്കാൻ കഴിയുന്ന തരത്തിലുള്ള വിവരങ്ങൾ.

ശേഖരം നിയന്ത്രിക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്ന ഉയർന്ന തലത്തിലുള്ള സഹായ പ്രവർത്തനങ്ങൾ ഉണ്ട്
ഒരു നല്ല ഗ്രാനുലാരിറ്റിയിലേക്ക് മുൻകൂട്ടി നിർവചിച്ച ഔട്ട്പുട്ടുകൾ. അനുവദിക്കുന്നതിന് മിഡ്-ലെവൽ ഹെൽപ്പർ ഫംഗ്‌ഷനുകളുണ്ട്
വിവരങ്ങൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതും സംരക്ഷിക്കുന്നതും എങ്ങനെ ഇഷ്‌ടാനുസൃതമാക്കാൻ കൂടുതൽ സങ്കീർണ്ണമായ ഉപയോക്താക്കൾ; പിന്നെ അവിടെയും
വിദഗ്ധരായ ഉപയോക്താക്കളെ പുതിയതും അവതരിപ്പിക്കുന്നതിനും സിസ്റ്റത്തിൽ മാറ്റം വരുത്താൻ അനുവദിക്കുന്നതിനുള്ള ലോ-ലെവൽ കോർ ഫംഗ്ഷനുകളാണ്
മുമ്പ് കയറ്റുമതി ചെയ്യാത്ത വിവരങ്ങൾ ഉപയോക്താക്കൾക്ക് ഉടനടി ആക്സസ് ചെയ്യാവുന്ന വിധത്തിൽ
ഉയർന്ന തലങ്ങൾ.

ഇത് വളരെ സമഗ്രമായ ഒരു സംവിധാനമാണ്, ഇത് ദഹിപ്പിക്കാൻ ധാരാളം ഉണ്ടെന്ന് ഞങ്ങൾ മനസ്സിലാക്കുന്നു, പ്രത്യേകിച്ച്
പുതിയ ഉപയോക്താക്കൾക്ക് അല്ലെങ്കിൽ C++ ഉം അതിന്റെ ഭാഷകളും അടുത്തറിയാത്തവർക്കായി. ഞങ്ങൾ പരിഗണിക്കുന്നു
ട്രെയ്‌സിംഗ് സിസ്റ്റം വളരെ പ്രധാനപ്പെട്ട ഭാഗമാണ് ns-3 അതിനാൽ പരിചയപ്പെടാൻ ശുപാർശ ചെയ്യുക
അതു കൊണ്ട് സാധ്യമാണ്. ബാക്കിയുള്ളവ മനസിലാക്കുന്നത് ഒരുപക്ഷേ അങ്ങനെയാണ് ns-3 സിസ്റ്റം
നിങ്ങൾ ട്രെയ്‌സിംഗ് സിസ്റ്റത്തിൽ പ്രാവീണ്യം നേടിക്കഴിഞ്ഞാൽ വളരെ ലളിതമായിരിക്കും

ഡാറ്റ ശേഖരണം

ഞങ്ങളുടെ അവസാന ട്യൂട്ടോറിയൽ അധ്യായത്തിൽ ചേർത്ത ചില ഘടകങ്ങൾ പരിചയപ്പെടുത്തുന്നു ns-3 പതിപ്പിൽ
3.18, അത് ഇപ്പോഴും വികസനത്തിലാണ്. ഈ ട്യൂട്ടോറിയൽ വിഭാഗവും എ
ജോലി പുരോഗമിക്കുന്നു.

പ്രചോദനം
സിമുലേഷനുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന്റെ പ്രധാന പോയിന്റുകളിലൊന്ന് ഔട്ട്പുട്ട് ഡാറ്റ സൃഷ്ടിക്കുക എന്നതാണ്
ഗവേഷണ ഉദ്ദേശ്യങ്ങൾ അല്ലെങ്കിൽ സിസ്റ്റത്തെക്കുറിച്ച് പഠിക്കാൻ. മുൻ അധ്യായത്തിൽ, ഞങ്ങൾ
ട്രേസിംഗ് സബ്സിസ്റ്റവും ഉദാഹരണവും അവതരിപ്പിച്ചു ആറാം. സി.സി. അതിൽ നിന്ന് PCAP അല്ലെങ്കിൽ ASCII ട്രെയ്സ്
ഫയലുകൾ സൃഷ്ടിക്കപ്പെടുന്നു. വൈവിധ്യമാർന്നവ ഉപയോഗിച്ച് ഡാറ്റ വിശകലനത്തിന് ഈ ട്രെയ്‌സുകൾ വിലപ്പെട്ടതാണ്
ബാഹ്യ ഉപകരണങ്ങൾ, കൂടാതെ പല ഉപയോക്താക്കൾക്കും, അത്തരം ഔട്ട്‌പുട്ട് ഡാറ്റ ശേഖരിക്കുന്നതിനുള്ള ഒരു മുൻഗണനാ മാർഗമാണ്
ഡാറ്റ (ബാഹ്യ ഉപകരണങ്ങൾ വിശകലനം ചെയ്യാൻ).

എന്നിരുന്നാലും, ട്രെയ്‌സ് ഫയൽ സൃഷ്ടിക്കുന്നതിനേക്കാൾ കൂടുതൽ ഉപയോഗ കേസുകളും ഉണ്ട്
താഴെ:

· നോൺ-പാക്കറ്റ് പോലെയുള്ള PCAP അല്ലെങ്കിൽ ASCII ട്രെയ്സുകളിലേക്ക് നന്നായി മാപ്പ് ചെയ്യാത്ത ഡാറ്റയുടെ ജനറേഷൻ
ഡാറ്റ (ഉദാ. പ്രോട്ടോക്കോൾ സ്റ്റേറ്റ് മെഷീൻ ട്രാൻസിഷനുകൾ),

· ട്രേസ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഡിസ്ക് I/O ആവശ്യകതകൾക്കുള്ള വലിയ സിമുലേഷനുകൾ
നിരോധിതമോ ബുദ്ധിമുട്ടുള്ളതോ, ഒപ്പം

· ആവശ്യം ഓൺലൈൻ സിമുലേഷൻ സമയത്ത് ഡാറ്റ റിഡക്ഷൻ അല്ലെങ്കിൽ കണക്കുകൂട്ടൽ.
സിമുലേഷനായി ഒരു ടെർമിനേഷൻ അവസ്ഥ നിർവചിക്കുക എന്നതാണ് ഇതിന്റെ നല്ലൊരു ഉദാഹരണം
ഒരു ഇടുങ്ങിയ ആത്മവിശ്വാസം രൂപപ്പെടുത്തുന്നതിന് ആവശ്യമായ ഡാറ്റ ലഭിച്ചപ്പോൾ അത് എപ്പോൾ നിർത്തണം
ചില പരാമീറ്ററിന്റെ എസ്റ്റിമേറ്റിന് ചുറ്റുമുള്ള ഇടവേള.

ദി ns-3 ഈ അധിക കഴിവുകൾ ലഭ്യമാക്കുന്നതിനാണ് വിവരശേഖരണ ചട്ടക്കൂട് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്
ട്രെയ്സ്-ബേസ്ഡ് ഔട്ട്പുട്ടിനുമപ്പുറം. ഈ വിഷയത്തിൽ താൽപ്പര്യമുള്ള വായനക്കാരോട് കൂടിയാലോചിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു
The ns-3 ഈ ചട്ടക്കൂടിന്റെ കൂടുതൽ വിശദമായ ചികിത്സയ്ക്കുള്ള മാനുവൽ; ഇവിടെ, ഞങ്ങൾ സംഗ്രഹിക്കുന്നു
വികസിപ്പിക്കുന്ന ചില കഴിവുകളുടെ ഒരു ഉദാഹരണ പ്രോഗ്രാം.

ഉദാഹരണം കോഡ്
ട്യൂട്ടോറിയൽ ഉദാഹരണം ഉദാഹരണങ്ങൾ/tutorial/seventh.cc സമാനമാണ് ആറാം. സി.സി ഉദാഹരണം ഞങ്ങൾ
കുറച്ച് മാറ്റങ്ങൾ ഒഴികെ മുമ്പ് അവലോകനം ചെയ്തത്. ആദ്യം, ഇത് IPv6-നായി പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു
ഒരു കമാൻഡ്-ലൈൻ ഓപ്ഷനുള്ള പിന്തുണ:

കമാൻഡ് ലൈൻ cmd;
cmd.AddValue ("useIpv6", "Use Ipv6", useV6);
cmd.Parse (argc, argv);

ഉപയോക്താവ് വ്യക്തമാക്കിയാൽ Ipv6 ഉപയോഗിക്കുക, ഓപ്ഷൻ, IPv6-ന് പകരം IPv4 ഉപയോഗിച്ച് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കും.
ദി സഹായിക്കൂ ഓപ്ഷൻ, എല്ലാവർക്കും ലഭ്യമാണ് ns-3 കമാൻഡ് ലൈൻ ഒബ്ജക്റ്റിനെ പിന്തുണയ്ക്കുന്ന പ്രോഗ്രാമുകൾ
മുകളിൽ കാണിച്ചിരിക്കുന്നത്, ഇനിപ്പറയുന്ന രീതിയിൽ അഭ്യർത്ഥിക്കാം (ദയവായി ഇരട്ട ഉദ്ധരണികളുടെ ഉപയോഗം ശ്രദ്ധിക്കുക):

./waf --റൺ "ഏഴാം --സഹായം"

ഉൽപ്പാദിപ്പിക്കുന്നത്:

ns3-dev-seventh-debug [പ്രോഗ്രാം ആർഗ്യുമെന്റുകൾ] [പൊതുവായ വാദങ്ങൾ]

പ്രോഗ്രാം വാദങ്ങൾ:
--useIpv6: Ipv6 ഉപയോഗിക്കുക [false]

പൊതുവായ വാദങ്ങൾ:
--PrintGlobals: ഗ്ലോബലുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.
--PrintGroups: ഗ്രൂപ്പുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.
--PrintGroup=[group]: ഗ്രൂപ്പിന്റെ എല്ലാ TypeId-കളും പ്രിന്റ് ചെയ്യുക.
--PrintTypeIds: എല്ലാ ടൈപ്പ് ഐഡുകളും പ്രിന്റ് ചെയ്യുക.
--PrintAttributes=[typeid]: ടൈപ്പിഡിന്റെ എല്ലാ ആട്രിബ്യൂട്ടുകളും പ്രിന്റ് ചെയ്യുക.
--PrintHelp: ഈ സഹായ സന്ദേശം അച്ചടിക്കുക.

ബൂളിയൻ ടോഗിൾ ചെയ്തുകൊണ്ട് ഈ ഡിഫോൾട്ട് (IPv4 ന്റെ ഉപയോഗം, useIpv6 തെറ്റായതിനാൽ) മാറ്റാവുന്നതാണ്.
മൂല്യം ഇപ്രകാരമാണ്:

./waf --റൺ "ഏഴാം --useIpv6=1"

കൂടാതെ ജനറേറ്റുചെയ്‌ത pcap നോക്കുക, ഉദാഹരണത്തിന് tcpdump:

tcpdump -r ഏഴാം.pcap -nn -tt

ഇത് IPv6 പിന്തുണയിലേക്കും കമാൻഡ് ലൈനിലേക്കും ഒരു ചെറിയ വ്യതിചലനമാണ്
ഈ ട്യൂട്ടോറിയലിൽ നേരത്തെ അവതരിപ്പിച്ചു. കമാൻഡ് ലൈൻ ഉപയോഗത്തിന്റെ ഒരു സമർപ്പിത ഉദാഹരണത്തിനായി,
ദയവായി കാണുക src/core/examples/command-line-example.cc.

ഇപ്പോൾ ഡാറ്റ ശേഖരണത്തിലേക്ക് മടങ്ങുക. ൽ ഉദാഹരണങ്ങൾ/ട്യൂട്ടോറിയൽ/ ഡയറക്ടറി, ഇനിപ്പറയുന്നത് ടൈപ്പ് ചെയ്യുക
കമാൻഡ്: ഡിഫ്എഫ് -u ആറാം. സി.സി ഏഴാം.സി.സി, ഈ വ്യത്യാസത്തിന്റെ ചില പുതിയ വരികൾ പരിശോധിക്കുക:

+ std::string probeType;
+ std::സ്ട്രിംഗ് ട്രേസ്പാത്ത്;
+ എങ്കിൽ (useV6 == തെറ്റ്)
+ {
...
+ probeType = "ns3::Ipv4PacketProbe";
+ ട്രേസ്പാത്ത് = "/നോഡ് ലിസ്റ്റ്/*/$ns3::Ipv4L3Protocol/Tx";
+}
+ വേറെ
+ {
...
+ probeType = "ns3::Ipv6PacketProbe";
+ ട്രേസ്പാത്ത് = "/നോഡ് ലിസ്റ്റ്/*/$ns3::Ipv6L3Protocol/Tx";
+}
...
+ // കാലക്രമേണ പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് പ്ലോട്ട് ചെയ്യാൻ GnuplotHelper ഉപയോഗിക്കുക
+ ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ പ്ലോട്ട് ഹെൽപ്പർ;
+
+ // പ്ലോട്ട് കോൺഫിഗർ ചെയ്യുക. ആദ്യത്തെ ആർഗ്യുമെന്റ് ഫയൽ നെയിം പ്രിഫിക്സാണ്
സൃഷ്‌ടിച്ച ഔട്ട്‌പുട്ട് ഫയലുകൾക്കായി + //. രണ്ടാമത്തേതും മൂന്നാമത്തേതും നാലാമത്തേതും
+ // ആർഗ്യുമെന്റുകൾ യഥാക്രമം, പ്ലോട്ടിന്റെ ശീർഷകം, x-axis, y-axis ലേബലുകൾ എന്നിവയാണ്
+ plotHelper.ConfigurePlot ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
+ "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് vs. സമയം",
+ "സമയം (സെക്കൻഡ്)",
+ "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്");
+
+ // പ്രോബ് തരം വ്യക്തമാക്കുക, ഉറവിട പാത കണ്ടെത്തുക (കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ), കൂടാതെ
പ്ലോട്ട് ചെയ്യാൻ + // ഔട്ട്‌പുട്ട് ട്രെയ്‌സ് ഉറവിടം ("ഔട്ട്‌പുട്ട് ബൈറ്റുകൾ") അന്വേഷിക്കുക. നാലാമത്തെ വാദം
+ // പ്ലോട്ടിലെ ഡാറ്റ സീരീസ് ലേബലിന്റെ പേര് വ്യക്തമാക്കുന്നു. അവസാനത്തെ
+ // ആർഗ്യുമെന്റ് കീ എവിടെ സ്ഥാപിക്കണമെന്ന് വ്യക്തമാക്കി പ്ലോട്ടിനെ ഫോർമാറ്റ് ചെയ്യുന്നു.
+ plotHelper.PlotProbe (probeType,
+ ട്രെയ്സ്പാത്ത്,
+ "ഔട്ട്‌പുട്ട് ബൈറ്റുകൾ",
+ "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്",
+ GnuplotAggregator :: KEY_BELOW);
+
+ // കാലക്രമേണ പാക്കറ്റ് ബൈറ്റ് എണ്ണം എഴുതാൻ FileHelper ഉപയോഗിക്കുക
+ ഫയൽഹെൽപ്പർ ഫയൽഹെൽപ്പർ;
+
+ // എഴുതേണ്ട ഫയലും ഔട്ട്‌പുട്ട് ഡാറ്റയുടെ ഫോർമാറ്റിംഗും കോൺഫിഗർ ചെയ്യുക.
+ fileHelper.ConfigureFile ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
+ ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);
+
+ // ഈ ഫോർമാറ്റ് ചെയ്ത ഔട്ട്‌പുട്ട് ഫയലിനായി ലേബലുകൾ സജ്ജമാക്കുക.
+ fileHelper.Set2dFormat ("സമയം (സെക്കൻഡ്) = %.3e\tപാക്കറ്റ് ബൈറ്റ് കൗണ്ട് = %.0f");
+
+ // പ്രോബ് തരം, പ്രോബ് പാത്ത് (കോൺഫിഗറേഷൻ നെയിംസ്‌പെയ്‌സിൽ) എന്നിവ വ്യക്തമാക്കുക
+ // എഴുതാൻ ഔട്ട്പുട്ട് ട്രെയ്സ് സോഴ്സ് ("ഔട്ട്പുട്ട് ബൈറ്റുകൾ") അന്വേഷിക്കുക.
+ fileHelper.WriteProbe (probeType,
+ ട്രെയ്സ്പാത്ത്,
+ "ഔട്ട്പുട്ട്ബൈറ്റുകൾ");
+
സിമുലേറ്റർ:: നിർത്തുക (സെക്കൻഡ് (20));
സിമുലേറ്റർ:: റൺ ();
സിമുലേറ്റർ:: നശിപ്പിക്കുക ();

മുകളിലുള്ള IPv6 കമാൻഡ് ലൈൻ ആട്രിബ്യൂട്ട് പരിശോധിക്കുമ്പോൾ, ശ്രദ്ധാപൂർവം വായിക്കുന്നവർ ശ്രദ്ധിച്ചിട്ടുണ്ടാകും,
ആ ഏഴാം.സി.സി നിരവധി പുതിയ ഔട്ട്പുട്ട് ഫയലുകൾ സൃഷ്ടിച്ചു:

ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം-0.txt
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം-1.txt
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.dat
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.plt
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-കൗണ്ട്.png
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.sh

മുകളിൽ അവതരിപ്പിച്ച അധിക പ്രസ്താവനകൾ കൊണ്ടാണ് ഇവ സൃഷ്ടിച്ചത്; പ്രത്യേകിച്ചും, എ
ഗ്നുപ്ലോട്ട് ഹെൽപ്പറും ഒരു ഫയൽ ഹെൽപ്പറും. ഡാറ്റാ ശേഖരണം ബന്ധിപ്പിച്ചാണ് ഈ ഡാറ്റ നിർമ്മിച്ചത്
എന്നതിലേക്കുള്ള ഘടകങ്ങൾ ns-3 ഉറവിടങ്ങൾ കണ്ടെത്തുകയും ഫോർമാറ്റ് ചെയ്ത ഡാറ്റയിലേക്ക് മാർഷൽ ചെയ്യുകയും ചെയ്യുന്നു ഗ്നുപ്ലോട്ട് ഒപ്പം
ഫോർമാറ്റ് ചെയ്ത ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക്. അടുത്ത വിഭാഗങ്ങളിൽ, ഇവ ഓരോന്നും ഞങ്ങൾ അവലോകനം ചെയ്യും.

ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ
GnuplotHelper ആണ് ns-3 ഉത്പാദനം ലക്ഷ്യമിട്ടുള്ള സഹായ വസ്തു ഗ്നുപ്ലോട്ട് കൂടെ പ്ലോട്ടുകൾ
സാധാരണ കേസുകളിൽ കഴിയുന്നത്ര കുറച്ച് പ്രസ്താവനകൾ. അത് കൊളുത്തുന്നു ns-3 ഡാറ്റ ഉപയോഗിച്ച് ഉറവിടങ്ങൾ കണ്ടെത്തുക
ഡാറ്റ ശേഖരണ സംവിധാനം പിന്തുണയ്ക്കുന്ന തരങ്ങൾ. എല്ലാം അല്ല ns-3 ട്രേസ് ഉറവിടങ്ങളുടെ ഡാറ്റ തരങ്ങളാണ്
പിന്തുണയ്‌ക്കുന്നു, പക്ഷേ സാധാരണമായ ട്രെയ്സ് തരങ്ങളിൽ പലതും, പ്ലെയിൻ ഓൾഡുള്ള TracedValues ​​ഉൾപ്പെടെയുള്ളവയാണ്
ഡാറ്റ (POD) തരങ്ങൾ.

ഈ സഹായി ഉൽപ്പാദിപ്പിക്കുന്ന ഔട്ട്പുട്ട് നോക്കാം:

ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.dat
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.plt
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.sh

ആദ്യത്തേത് സ്‌പെയ്‌സ്-ഡിലിമിറ്റഡ് ടൈംസ്റ്റാമ്പുകളുടെയും പാക്കറ്റിന്റെയും ഒരു ശ്രേണിയുള്ള ഗ്‌നപ്‌ലോട്ട് ഡാറ്റാ ഫയലാണ്
ബൈറ്റ് എണ്ണങ്ങൾ. ഈ പ്രത്യേക ഡാറ്റ ഔട്ട്‌പുട്ട് എങ്ങനെ കോൺഫിഗർ ചെയ്‌തുവെന്നത് ഞങ്ങൾ ചുവടെ വിവരിക്കും, പക്ഷേ നമുക്ക് നോക്കാം
ഔട്ട്പുട്ട് ഫയലുകളുമായി തുടരുക. ഫയല് ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.plt ഒരു gnuplot പ്ലോട്ടാണ്
ഫയൽ, gnuplot ഉള്ളിൽ നിന്ന് തുറക്കാൻ കഴിയും. gnuplot വാക്യഘടന മനസ്സിലാക്കുന്ന വായനക്കാർക്ക് കഴിയും
ഇത് ഫോർമാറ്റ് ചെയ്‌ത ഔട്ട്‌പുട്ട് PNG ഫയൽ നിർമ്മിക്കുമെന്ന് കാണുക
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-കൗണ്ട്.png. ഒടുവിൽ, ഒരു ചെറിയ ഷെൽ സ്ക്രിപ്റ്റ്
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.sh ആവശ്യമുള്ളത് നിർമ്മിക്കുന്നതിന് gnuplot വഴി ഈ പ്ലോട്ട് ഫയൽ പ്രവർത്തിപ്പിക്കുന്നു
PNG (ഇത് ഒരു ഇമേജ് എഡിറ്ററിൽ കാണാൻ കഴിയും); അതായത്, കമാൻഡ്:

sh ഏഴാം-പാക്കറ്റ്-ബൈറ്റ്-count.sh

വഴങ്ങും ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-കൗണ്ട്.png. എന്തുകൊണ്ടാണ് ഈ PNG ആദ്യം ഉൽപ്പാദിപ്പിച്ചില്ല
സ്ഥലം? plt ഫയൽ നൽകുന്നതിലൂടെ, ഉപയോക്താവിന് കൈകൊണ്ട് കോൺഫിഗർ ചെയ്യാൻ കഴിയും എന്നതാണ് ഉത്തരം
PNG ഉൽപ്പാദിപ്പിക്കുന്നതിന് മുമ്പ്, വേണമെങ്കിൽ ഫലം.

ഈ പ്ലോട്ട് "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് വേഴ്സസ് ടൈം" എന്നതിന്റെ പ്ലോട്ടാണെന്ന് PNG ചിത്ര ശീർഷകം പറയുന്നു, കൂടാതെ
ട്രെയ്‌സ് സോഴ്‌സ് പാത്തിന് അനുയോജ്യമായ പ്രോബ്ഡ് ഡാറ്റയാണ് ഇത് പ്ലോട്ട് ചെയ്യുന്നത്:

/NodeList/*/$ns3::Ipv6L3Protocol/Tx

ട്രെയ്സ് പാതയിലെ വൈൽഡ് കാർഡ് ശ്രദ്ധിക്കുക. ചുരുക്കത്തിൽ, ഈ പ്ലോട്ട് പിടിച്ചെടുക്കുന്നത് പ്ലോട്ട് ആണ്
Ipv6L3Protocol ഒബ്ജക്റ്റിന്റെ ട്രാൻസ്മിറ്റ് ട്രെയ്സ് ഉറവിടത്തിൽ നിരീക്ഷിച്ച പാക്കറ്റ് ബൈറ്റുകളുടെ;
ഒരു ദിശയിൽ 596-ബൈറ്റ് ടിസിപി സെഗ്‌മെന്റുകളും മറ്റൊന്നിൽ 60-ബൈറ്റ് ടിസിപി ആക്കുകളും (രണ്ട്
നോഡ് ട്രെയ്സ് ഉറവിടങ്ങൾ ഈ ട്രേസ് ഉറവിടവുമായി പൊരുത്തപ്പെട്ടു).

ഇത് എങ്ങനെയാണ് ക്രമീകരിച്ചത്? കുറച്ച് പ്രസ്താവനകൾ നൽകേണ്ടതുണ്ട്. ആദ്യം, GnuplotHelper
ഒബ്ജക്റ്റ് പ്രഖ്യാപിക്കുകയും കോൺഫിഗർ ചെയ്യുകയും വേണം:

+ // കാലക്രമേണ പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് പ്ലോട്ട് ചെയ്യാൻ GnuplotHelper ഉപയോഗിക്കുക
+ ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ പ്ലോട്ട് ഹെൽപ്പർ;
+
+ // പ്ലോട്ട് കോൺഫിഗർ ചെയ്യുക. ആദ്യത്തെ ആർഗ്യുമെന്റ് ഫയൽ നെയിം പ്രിഫിക്സാണ്
സൃഷ്‌ടിച്ച ഔട്ട്‌പുട്ട് ഫയലുകൾക്കായി + //. രണ്ടാമത്തേതും മൂന്നാമത്തേതും നാലാമത്തേതും
+ // ആർഗ്യുമെന്റുകൾ യഥാക്രമം, പ്ലോട്ടിന്റെ ശീർഷകം, x-axis, y-axis ലേബലുകൾ എന്നിവയാണ്
+ plotHelper.ConfigurePlot ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
+ "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് vs. സമയം",
+ "സമയം (സെക്കൻഡ്)",
+ "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്");

ഈ ഘട്ടത്തിൽ, ഒരു ശൂന്യമായ പ്ലോട്ട് ക്രമീകരിച്ചിരിക്കുന്നു. ഫയൽനാമം പ്രിഫിക്സ് ആണ് ആദ്യത്തേത്
വാദം, പ്ലോട്ടിന്റെ ശീർഷകം രണ്ടാമത്തേതും, x-ആക്സിസ് ലേബൽ മൂന്നാമത്തേതും, y-ആക്സിസ് ലേബലുമാണ്
നാലാമത്തെ വാദം.

അടുത്ത ഘട്ടം ഡാറ്റ കോൺഫിഗർ ചെയ്യുകയാണ്, ഇവിടെയാണ് ട്രെയ്സ് ഉറവിടം ഹുക്ക് ചെയ്തിരിക്കുന്നത്.
ആദ്യം, പ്രോഗ്രാമിൽ മുകളിൽ ശ്രദ്ധിക്കുക, പിന്നീടുള്ള ഉപയോഗത്തിനായി ഞങ്ങൾ കുറച്ച് വേരിയബിളുകൾ പ്രഖ്യാപിച്ചു:

+ std::string probeType;
+ std::സ്ട്രിംഗ് ട്രേസ്പാത്ത്;
+ probeType = "ns3::Ipv6PacketProbe";
+ ട്രേസ്പാത്ത് = "/നോഡ് ലിസ്റ്റ്/*/$ns3::Ipv6L3Protocol/Tx";

ഞങ്ങൾ അവ ഇവിടെ ഉപയോഗിക്കുന്നു:

+ // പ്രോബ് തരം വ്യക്തമാക്കുക, ഉറവിട പാത കണ്ടെത്തുക (കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ), കൂടാതെ
പ്ലോട്ട് ചെയ്യാൻ + // ഔട്ട്‌പുട്ട് ട്രെയ്‌സ് ഉറവിടം ("ഔട്ട്‌പുട്ട് ബൈറ്റുകൾ") അന്വേഷിക്കുക. നാലാമത്തെ വാദം
+ // പ്ലോട്ടിലെ ഡാറ്റ സീരീസ് ലേബലിന്റെ പേര് വ്യക്തമാക്കുന്നു. അവസാനത്തെ
+ // ആർഗ്യുമെന്റ് കീ എവിടെ സ്ഥാപിക്കണമെന്ന് വ്യക്തമാക്കി പ്ലോട്ടിനെ ഫോർമാറ്റ് ചെയ്യുന്നു.
+ plotHelper.PlotProbe (probeType,
+ ട്രെയ്സ്പാത്ത്,
+ "ഔട്ട്‌പുട്ട് ബൈറ്റുകൾ",
+ "പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്",
+ GnuplotAggregator :: KEY_BELOW);

ആദ്യത്തെ രണ്ട് ആർഗ്യുമെന്റുകൾ പ്രോബ് തരത്തിന്റെ പേരും ട്രെയ്സ് സോഴ്സ് പാത്തും ആണ്. ഇവ
ഈ ചട്ടക്കൂട് ഉപയോഗിച്ച് മറ്റൊന്ന് പ്ലോട്ട് ചെയ്യാൻ നിങ്ങൾ ശ്രമിക്കുമ്പോൾ നിർണ്ണയിക്കാൻ ഏറ്റവും പ്രയാസമുള്ളത് രണ്ടാണ്
അടയാളങ്ങൾ. ഇവിടെയുള്ള പ്രോബ് ട്രെയ്സ് ആണ് Tx ക്ലാസിന്റെ ഉറവിടം കണ്ടെത്തുക Ipv6L3പ്രോട്ടോക്കോൾ. ഞങ്ങൾ എപ്പോൾ
ഈ ക്ലാസ് നടപ്പിലാക്കൽ പരിശോധിക്കുക (src/internet/model/ipv6-l3-protocol.cc) നമുക്ക് നിരീക്ഷിക്കാൻ കഴിയും:

.AddTraceSource ("Tx", "ഔട്ട്‌ഗോയിംഗ് ഇന്റർഫേസിലേക്ക് IPv6 പാക്കറ്റ് അയയ്‌ക്കുക.",
MakeTraceSourceAccessor (&Ipv6L3Protocol::m_txTrace))

ഇത് പറയുന്നു Tx വേരിയബിളിന്റെ പേരാണ് m_txTrace, ഇതിൽ ഒരു പ്രഖ്യാപനമുണ്ട്:

/ **
* TX (ട്രാൻസ്മിഷൻ) പാക്കറ്റുകൾ കണ്ടെത്തുന്നതിന് സംക്ഷിപ്തമായി വിളിക്കുക.
*/
TracedCallback , Ptr , uint6_t> m_txTrace;

ഈ നിർദ്ദിഷ്ട ട്രെയ്സ് സോഴ്സ് സിഗ്നേച്ചറിനെ ഒരു പ്രോബ് ക്ലാസ് പിന്തുണയ്ക്കുന്നുവെന്ന് ഇത് മാറുന്നു (എന്ത്
ഞങ്ങൾക്ക് ഇവിടെ ആവശ്യമാണ്) Ipv6PacketProbe ക്ലാസ്സ്. ഫയലുകൾ കാണുക
src/internet/model/ipv6-packet-probe.{h,cc}.

അതിനാൽ, മുകളിലുള്ള പ്ലോട്ട്പ്രോബ് പ്രസ്താവനയിൽ, പ്രസ്താവന ട്രെയ്‌സിനെ ആകർഷിക്കുന്നതായി ഞങ്ങൾ കാണുന്നു
പൊരുത്തമുള്ള ഉറവിടം (പാത്ത് സ്ട്രിംഗ് വഴി തിരിച്ചറിഞ്ഞു). ns-3 പ്രോബ് തരം Ipv6PacketProbe. എങ്കിൽ
ഞങ്ങൾ ഈ അന്വേഷണ തരത്തെ പിന്തുണച്ചില്ല (പൊരുത്തമുള്ള ട്രെയ്സ് സോഴ്സ് സിഗ്നേച്ചർ), ഞങ്ങൾക്ക് കഴിഞ്ഞില്ല
ഈ പ്രസ്താവന ഉപയോഗിച്ചു (കൂടുതൽ സങ്കീർണ്ണമായ ചില താഴ്ന്ന നിലയിലുള്ള പ്രസ്താവനകൾ ആകാമായിരുന്നു
മാനുവലിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ).

Ipv6PacketProbe കയറ്റുമതി ചെയ്യുന്നു, അതിൽ നിന്ന് ഡാറ്റ വേർതിരിച്ചെടുക്കുന്ന ചില ഉറവിടങ്ങൾ കണ്ടെത്തുന്നു.
പരിശോധിച്ച പാക്കറ്റ് ഒബ്‌ജക്റ്റ്:

ടൈപ്പ് ഐഡി
Ipv6PacketProbe::GetTypeId ()
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::Ipv6PacketProbe")
.SetParent ()
.AddConstructor ()
.AddTraceSource ("ഔട്ട്പുട്ട്",
"പാക്കറ്റും അതിന്റെ IPv6 ഒബ്‌ജക്‌റ്റും ഇന്റർഫേസും ഈ അന്വേഷണത്തിന്റെ ഔട്ട്‌പുട്ടായി വർത്തിക്കുന്നു",
MakeTraceSourceAccessor (&Ipv6PacketProbe::m_output))
.AddTraceSource ("OutputBytes",
"പാക്കറ്റിലെ ബൈറ്റുകളുടെ എണ്ണം",
MakeTraceSourceAccessor (&Ipv6PacketProbe::m_outputBytes))
;
റിട്ടേൺ ടിഡ്;
}

ഞങ്ങളുടെ PlotProbe പ്രസ്താവനയുടെ മൂന്നാമത്തെ വാദം ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെന്ന് വ്യക്തമാക്കുന്നു
ഈ പാക്കറ്റിലെ ബൈറ്റുകളുടെ എണ്ണം; പ്രത്യേകമായി, "ഔട്ട്‌പുട്ട്ബൈറ്റുകൾ" ട്രെയ്സ് ഉറവിടം
Ipv6PacketProbe. അവസാനമായി, പ്രസ്താവനയുടെ അവസാന രണ്ട് വാദങ്ങൾ ഇതിവൃത്തം നൽകുന്നു
ഈ ഡാറ്റാ സീരീസിനായി ("പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്"), കൂടാതെ ഒരു ഓപ്ഷണൽ ഗ്നപ്ലോട്ട് ഫോർമാറ്റിംഗ് പ്രസ്താവനയും
(GnuplotAggregator::KEY_BELOW) പ്ലോട്ടിന് താഴെ പ്ലോട്ട് കീ ചേർക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
മറ്റ് ഓപ്ഷനുകളിൽ NO_KEY, KEY_INSIDE, KEY_ABOVE എന്നിവ ഉൾപ്പെടുന്നു.

പിന്തുണയുള്ള ട്രെയ്സ് തരത്തിലുള്ളവ
ഇനിപ്പറയുന്ന ട്രേസ്ഡ് മൂല്യങ്ങൾ ഈ രചനയിൽ പ്രോബ്സ് ഉപയോഗിച്ച് പിന്തുണയ്ക്കുന്നു:

പതനം ───────────────────┐
│ട്രേസ്ഡ് വാല്യൂ തരം │ പ്രോബ് തരം │ ഫയൽ │
പതനം ───────────────────┤
│ഇരട്ട │ DoubleProbe │ stats/model/double-probe.h │
പതനം ───────────────────┤
│uint8_t │ Uinteger8Probe │ stats/model/uinteger-8-probe.h │
പതനം ───────────────────┤
│uint16_t │ Uinteger16Probe │ stats/model/uinteger-16-probe.h │
പതനം ───────────────────┤
│uint32_t │ Uinteger32Probe │ stats/model/uinteger-32-probe.h │
പതനം ───────────────────┤
│bool │ BooleanProbe │ stats/model/uinteger-16-probe.h │
പതനം ───────────────────┤
│ns3::സമയം │ TimeProbe │ stats/model/time-probe.h │
പതനം ────────────────────┘

ഇനിപ്പറയുന്ന ട്രേസ് സോഴ്‌സ് തരങ്ങളെ ഈ എഴുത്ത് പ്രകാരം പ്രോബ്സ് പിന്തുണയ്ക്കുന്നു:

പതനം പതനം ──────────┐
പതനം പതനം ──────────┤
പതനം പതനം ──────────┤
പതനം പതനം ──────────┤
പതനം പതനം ──────────┤
പതനം പതനം ──────────┤
പതനം പതനം ──────────┘

കാണാനാകുന്നതുപോലെ, ചില ട്രെയ്സ് ഉറവിടങ്ങൾ മാത്രമേ പിന്തുണയ്ക്കുന്നുള്ളൂ, അവയെല്ലാം ലക്ഷ്യമാക്കിയുള്ളവയാണ്
പാക്കറ്റ് വലുപ്പം ഔട്ട്പുട്ട് ചെയ്യുന്നു (ബൈറ്റുകളിൽ). എന്നിരുന്നാലും, മിക്ക അടിസ്ഥാന ഡാറ്റാ തരങ്ങളും
ഈ സഹായികൾക്കൊപ്പം TracedValues ​​പിന്തുണയ്‌ക്കാവുന്നതിനാൽ ലഭ്യമാണ്.

ഫയൽഹെൽപ്പർ
FileHelper ക്ലാസ് മുമ്പത്തെ GnuplotHelper ഉദാഹരണത്തിന്റെ ഒരു വ്യതിയാനം മാത്രമാണ്. ദി
ഉദാഹരണം പ്രോഗ്രാം താഴെപ്പറയുന്നതുപോലെ, അതേ ടൈംസ്റ്റാമ്പ് ചെയ്ത ഡാറ്റയുടെ ഫോർമാറ്റ് ചെയ്ത ഔട്ട്പുട്ട് നൽകുന്നു:

സമയം (സെക്കൻഡ്) = 9.312e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 596
സമയം (സെക്കൻഡ്) = 9.312e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 564

രണ്ട് ഫയലുകൾ നൽകിയിരിക്കുന്നു, ഒന്ന് നോഡ് "0" നും ഒന്ന് "1" നോഡിനും കാണാവുന്നതാണ്
ഫയൽനാമങ്ങൾ. നമുക്ക് കോഡ് ഓരോന്നായി നോക്കാം:

+ // കാലക്രമേണ പാക്കറ്റ് ബൈറ്റ് എണ്ണം എഴുതാൻ FileHelper ഉപയോഗിക്കുക
+ ഫയൽഹെൽപ്പർ ഫയൽഹെൽപ്പർ;
+
+ // എഴുതേണ്ട ഫയലും ഔട്ട്‌പുട്ട് ഡാറ്റയുടെ ഫോർമാറ്റിംഗും കോൺഫിഗർ ചെയ്യുക.
+ fileHelper.ConfigureFile ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
+ ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);

ഫയൽ ഹെൽപ്പർ ഫയൽ പ്രിഫിക്സാണ് ആദ്യ ആർഗ്യുമെന്റ്, അടുത്തത് ഫോർമാറ്റ് സ്പെസിഫയർ ആണ്. ചിലത്
ഫോർമാറ്റിംഗിനുള്ള മറ്റ് ഓപ്ഷനുകളിൽ SPACE_SEPARATED, COMMA_SEPARATED, TAB_SEPARATED എന്നിവ ഉൾപ്പെടുന്നു.
ഒരു ഫോർമാറ്റ് സ്ട്രിംഗ് ഉപയോഗിച്ച് ഉപയോക്താക്കൾക്ക് ഫോർമാറ്റിംഗ് മാറ്റാൻ കഴിയും (ഫോർമാറ്റ് ചെയ്തതാണെങ്കിൽ)
ഇനിപ്പറയുന്നവ പോലെ:

+
+ // ഈ ഫോർമാറ്റ് ചെയ്ത ഔട്ട്‌പുട്ട് ഫയലിനായി ലേബലുകൾ സജ്ജമാക്കുക.
+ fileHelper.Set2dFormat ("സമയം (സെക്കൻഡ്) = %.3e\tപാക്കറ്റ് ബൈറ്റ് കൗണ്ട് = %.0f");

അവസാനമായി, താൽപ്പര്യത്തിന്റെ ഉറവിടം ഹുക്ക് ചെയ്യണം. വീണ്ടും, പ്രോബ് ടൈപ്പും ട്രേസ്പാത്തും
ഈ ഉദാഹരണത്തിലെ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു, കൂടാതെ പ്രോബിന്റെ ഔട്ട്പുട്ട് ട്രെയ്സ് ഉറവിടം "ഔട്ട്പുട്ട്ബൈറ്റുകൾ" ആണ്
കൊളുത്തി:

+
+ // പ്രോബ് തരം വ്യക്തമാക്കുക, ഉറവിട പാത കണ്ടെത്തുക (കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ), കൂടാതെ
+ // എഴുതാൻ ഔട്ട്പുട്ട് ട്രെയ്സ് സോഴ്സ് ("ഔട്ട്പുട്ട് ബൈറ്റുകൾ") അന്വേഷിക്കുക.
+ fileHelper.WriteProbe (probeType,
+ ട്രെയ്സ്പാത്ത്,
+ "ഔട്ട്പുട്ട്ബൈറ്റുകൾ");
+

ഈ ട്രെയ്സ് സോഴ്സ് സ്പെസിഫയറിലെ വൈൽഡ്കാർഡ് ഫീൽഡുകൾ രണ്ട് ട്രെയ്സ് ഉറവിടങ്ങളുമായി പൊരുത്തപ്പെടുന്നു. പോലെയല്ല
GnuplotHelper ഉദാഹരണം, ഒരേ പ്ലോട്ടിൽ രണ്ട് ഡാറ്റ സീരീസ് ഓവർലേ ചെയ്തിരിക്കുന്നു, ഇവിടെ രണ്ട്
പ്രത്യേക ഫയലുകൾ ഡിസ്കിൽ എഴുതിയിരിക്കുന്നു.

ചുരുക്കം
ns-3.18-ലെ ഡാറ്റാ ശേഖരണ പിന്തുണ പുതിയതാണ്, കൂടാതെ സമയ ശ്രേണി നൽകുന്നതിനുള്ള അടിസ്ഥാന പിന്തുണയും
ഔട്ട്പുട്ട് ചേർത്തു. മുകളിൽ വിവരിച്ച അടിസ്ഥാന പാറ്റേൺ അതിനുള്ളിൽ ആവർത്തിക്കാം
നിലവിലുള്ള പേടകങ്ങളുടെയും ട്രേസ് സ്രോതസ്സുകളുടെയും പിന്തുണയുടെ വ്യാപ്തി. ഉൾപ്പെടെ കൂടുതൽ കഴിവുകൾ
ഭാവി റിലീസുകളിൽ സ്ഥിതിവിവരക്കണക്ക് പ്രോസസ്സിംഗ് ചേർക്കും.

ഉപസംഹാരം

ഫ്യൂച്ചേഴ്സ്
ഈ പ്രമാണം ഒരു ജീവനുള്ള പ്രമാണമായി ഉദ്ദേശിച്ചുള്ളതാണ്. കാലക്രമേണ അത് വളരുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുകയും പ്രതീക്ഷിക്കുകയും ചെയ്യുന്നു
കൂടുതൽ കൂടുതൽ നട്ടുകളും ബോൾട്ടുകളും മറയ്ക്കാൻ ns-3.

മാനുവൽ, ട്യൂട്ടോറിയൽ അധ്യായങ്ങൾ എഴുതുന്നത് നാമെല്ലാവരും ആവേശഭരിതരാകുന്ന ഒന്നല്ല, പക്ഷേ അത്
പദ്ധതിക്ക് വളരെ പ്രധാനമാണ്. നിങ്ങൾ ഈ മേഖലകളിലൊന്നിൽ വിദഗ്ദ്ധനാണെങ്കിൽ, ദയവായി
സംഭാവന ചെയ്യുന്നത് പരിഗണിക്കുക ns-3 ഈ അധ്യായങ്ങളിലൊന്ന് നൽകിക്കൊണ്ട്; അല്ലെങ്കിൽ മറ്റേതെങ്കിലും അധ്യായം നിങ്ങൾ
പ്രധാനമാണെന്ന് കരുതാം.

അടയ്ക്കുന്നതിൽ
ns-3 വലുതും സങ്കീർണ്ണവുമായ ഒരു സംവിധാനമാണ്. നിങ്ങളുടെ എല്ലാ കാര്യങ്ങളും മറയ്ക്കുക അസാധ്യമാണ്
ഒരു ചെറിയ ട്യൂട്ടോറിയലിൽ അറിയേണ്ടതുണ്ട്. കൂടുതലറിയാൻ ആഗ്രഹിക്കുന്ന വായനക്കാരെ പ്രോത്സാഹിപ്പിക്കുന്നു
ഇനിപ്പറയുന്ന അധിക ഡോക്യുമെന്റേഷൻ വായിക്കുക:

· ദി ns-3 കൈകൊണ്ടുള്ള

· ദി ns-3 മാതൃകാ ലൈബ്രറി ഡോക്യുമെന്റേഷൻ

· ദി ns-3 ഡോക്സിജൻ (API ഡോക്യുമെന്റേഷൻ)

· ദി ns-3 വിക്കി

-- ദി ns-3 വികസന സംഘം.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ns-3-ട്യൂട്ടോറിയൽ ഓൺലൈനായി ഉപയോഗിക്കുക