ns-3-മാനുവൽ - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

ns-3-മാനുവൽ - ns-3 മാനുവൽ

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

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

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

· ns-3 വിക്കി

ഉള്ളടക്കം

സംഘടന
ഈ അധ്യായം മൊത്തത്തിൽ വിവരിക്കുന്നു ns-3 സോഫ്റ്റ്വെയർ ഓർഗനൈസേഷനും അനുബന്ധവും
ഈ മാനുവലിന്റെ ഓർഗനൈസേഷൻ.

ns-3 സിമുലേഷൻ കോറും മോഡലുകളും ഉള്ള ഒരു വ്യതിരിക്ത-ഇവന്റ് നെറ്റ്‌വർക്ക് സിമുലേറ്ററാണ്
C++ ൽ നടപ്പിലാക്കി. ns-3 സ്ഥിരമായോ ചലനാത്മകമോ ആയ ഒരു ലൈബ്രറിയായാണ് നിർമ്മിച്ചിരിക്കുന്നത്
സിമുലേഷൻ ടോപ്പോളജി നിർവചിക്കുകയും ആരംഭിക്കുകയും ചെയ്യുന്ന ഒരു C++ പ്രധാന പ്രോഗ്രാമിലേക്ക് ലിങ്ക് ചെയ്‌തിരിക്കുന്നു
സിമുലേറ്റർ. ns-3 പൈത്തണിലേക്ക് അതിന്റെ മിക്കവാറും എല്ലാ API-യും കയറ്റുമതി ചെയ്യുന്നു, ഇത് പൈത്തൺ പ്രോഗ്രാമുകളെ അനുവദിക്കുന്നു
ഒരു "ns3" മൊഡ്യൂൾ ഇമ്പോർട്ടുചെയ്യുന്നത് പോലെ തന്നെ ns-3 എക്സിക്യൂട്ടബിളുകൾ വഴി ലൈബ്രറി ബന്ധിപ്പിച്ചിരിക്കുന്നു
C++ ൽ.
[image] സോഫ്റ്റ്‌വെയർ ഓർഗനൈസേഷൻ ns-3.അൺഇൻഡന്റ്

എന്നതിനായുള്ള ഉറവിട കോഡ് ns-3 കൂടുതലും സംഘടിപ്പിക്കുന്നത് ഉറവിട ഡയറക്ടറിയും വിവരിക്കാവുന്നതുമാണ്
ലെ ഡയഗ്രം പ്രകാരം സോഫ്റ്റ്വെയർ സംഘടന of ns-3. ഞങ്ങൾ താഴെ നിന്ന് ഞങ്ങളുടെ വഴി പ്രവർത്തിക്കും
മുകളിലേക്ക്; മൊഡ്യൂളുകൾക്ക് മൊഡ്യൂളുകൾക്ക് താഴെയുള്ള മൊഡ്യൂളുകളുടെ ആശ്രിതത്വം മാത്രമേ ചിത്രത്തിൽ ഉള്ളൂ.

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

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

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

പ്രോജക്‌റ്റ് പരിശോധനയ്‌ക്കും മൂല്യനിർണ്ണയത്തിനുമായി നീക്കിവച്ചിരിക്കുന്ന ഒരു പ്രത്യേക മാനുവൽ പരിപാലിക്കുന്നു ns-3 കോഡ്
(കാണാൻ ns-3 ടെസ്റ്റിംഗ് ഒപ്പം മൂല്യനിർണ്ണയം കൈകൊണ്ടുള്ള).

വികലമായ വേരിയബിളുകൾ
ns-3 ഒരു അന്തർനിർമ്മിത കപട-റാൻഡം നമ്പർ ജനറേറ്റർ (PRNG) അടങ്ങിയിരിക്കുന്നു. എന്നതിന് പ്രധാനമാണ്
പ്രവർത്തനക്ഷമത, കോൺഫിഗറേഷൻ, ഉപയോഗം എന്നിവ മനസ്സിലാക്കാൻ സിമുലേറ്ററിന്റെ ഗുരുതരമായ ഉപയോക്താക്കൾ
ഈ PRNG-യുടെ, അവന്റെ അല്ലെങ്കിൽ അവളുടെ ഗവേഷണ ഉപയോഗത്തിന് ഇത് മതിയോ എന്ന് തീരുമാനിക്കാൻ.

ദ്രുത പൊതു അവലോകനം
ns-3 റാൻഡം നമ്പറുകൾ ഉദാഹരണങ്ങളിലൂടെയാണ് നൽകിയിരിക്കുന്നത് ns3::RandomVariableStream.

· സ്ഥിരസ്ഥിതിയായി, ns-3 സിമുലേഷനുകൾ ഒരു നിശ്ചിത വിത്ത് ഉപയോഗിക്കുന്നു; അതിൽ എന്തെങ്കിലും ക്രമരഹിതതയുണ്ടെങ്കിൽ
സിമുലേഷൻ, വിത്ത് കൂടാതെ/അല്ലെങ്കിൽ പ്രോഗ്രാമിന്റെ ഓരോ ഓട്ടവും സമാനമായ ഫലങ്ങൾ നൽകും
റൺ നമ്പർ മാറ്റി.

· ഇൻ ns-3.3 മുമ്പും, ns-3 സിമുലേഷനുകൾ സ്വതവേ ക്രമരഹിതമായ വിത്ത് ഉപയോഗിച്ചു; ഇത് a അടയാളപ്പെടുത്തുന്നു
തുടങ്ങി നയത്തിൽ മാറ്റം ns-3.4.

· ഇൻ ns-3.14 മുമ്പും, ns-3 സിമുലേഷനുകൾ ഒരു വ്യത്യസ്ത റാപ്പർ ക്ലാസ് ഉപയോഗിച്ചു
ns3::റാൻഡം വേരിയബിൾ. പ്രകാരം ns-3.15, ഈ ക്ലാസ് മാറ്റിസ്ഥാപിച്ചു
ns3::RandomVariableStream; അന്തർലീനമായ വ്യാജ-റാൻഡം നമ്പർ ജനറേറ്റർ ഇല്ല
മാറി.

ഒന്നിലധികം സിമുലേഷൻ റണ്ണുകളിലുടനീളം ക്രമരഹിതത ലഭിക്കുന്നതിന്, നിങ്ങൾ ഒന്നുകിൽ വിത്ത് സജ്ജീകരിക്കണം
വ്യത്യസ്തമായി അല്ലെങ്കിൽ റൺ നമ്പർ വ്യത്യസ്തമായി സജ്ജമാക്കുക. ഒരു വിത്ത് സജ്ജമാക്കാൻ, വിളിക്കുക
ns3::RngSeedManager::SetSeed() പരിപാടിയുടെ തുടക്കത്തിൽ; ഉപയോഗിച്ച് ഒരു റൺ നമ്പർ സജ്ജീകരിക്കാൻ
അതേ വിത്ത്, വിളിക്കൂ ns3::RngSeedManager::SetRun() പരിപാടിയുടെ തുടക്കത്തിൽ; കാണുക
ഉണ്ടാക്കുന്നു ക്രമരഹിതം വേരിയബിളുകൾ.

· ഓരോ റാൻഡം വേരിയബിൾ സ്ട്രീമും ഉപയോഗിക്കുന്നു ns-3 ഒരു വെർച്വൽ റാൻഡം നമ്പർ ജനറേറ്റർ ബന്ധപ്പെട്ടിരിക്കുന്നു
അതിന്റെ കൂടെ; എല്ലാ റാൻഡം വേരിയബിളുകളും ഉപയോഗത്തെ അടിസ്ഥാനമാക്കി ഒരു നിശ്ചിത അല്ലെങ്കിൽ ക്രമരഹിതമായ വിത്ത് ഉപയോഗിക്കുന്നു
ആഗോള വിത്ത് (മുമ്പത്തെ ബുള്ളറ്റ്);

· ഒരേ സാഹചര്യത്തിൽ, വ്യത്യസ്ത ക്രമരഹിതമായ ഒന്നിലധികം റണ്ണുകൾ നടത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
അക്കങ്ങൾ, സ്വതന്ത്രമായ പകർപ്പുകൾ എങ്ങനെ നടത്താം എന്നതിനെക്കുറിച്ചുള്ള വിഭാഗം വായിക്കുന്നത് ഉറപ്പാക്കുക:
ഉണ്ടാക്കുന്നു ക്രമരഹിതം വേരിയബിളുകൾ.

റാൻഡം നമ്പർ സൗകര്യത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിശദീകരണത്തിന് കൂടുതൽ വായിക്കുക ns-3.

പശ്ചാത്തലം
സിമുലേഷനുകൾ ധാരാളം റാൻഡം നമ്പറുകൾ ഉപയോഗിക്കുന്നു; മിക്ക നെറ്റ്‌വർക്ക് സിമുലേഷനുകളും ഉണ്ടെന്ന് ഒരു പഠനം കണ്ടെത്തി
റാൻഡം നമ്പറുകൾ സൃഷ്ടിക്കുന്നതിനായി CPU-യുടെ 50% വരെ ചെലവഴിക്കുക. സിമുലേഷൻ ഉപയോക്താക്കൾ ആയിരിക്കണം
(കപട) ക്രമരഹിത സംഖ്യകളുടെ ഗുണനിലവാരവും അവയ്ക്കിടയിലുള്ള സ്വാതന്ത്ര്യവും സംബന്ധിച്ചു
ക്രമരഹിത സംഖ്യകളുടെ വ്യത്യസ്ത സ്ട്രീമുകൾ.

ഇനിപ്പറയുന്നതുപോലുള്ള ചില പ്രശ്‌നങ്ങളിൽ ഉപയോക്താക്കൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്:

· റാൻഡം നമ്പർ ജനറേറ്ററിന്റെ സീഡിംഗും ഒരു സിമുലേഷൻ ഫലമാണോ എന്നതും
നിർണ്ണായകമാണോ അല്ലയോ

· ഒന്നിൽ നിന്ന് സ്വതന്ത്രമായ റാൻഡം നമ്പറുകളുടെ വ്യത്യസ്ത സ്ട്രീമുകൾ എങ്ങനെ നേടാം
മറ്റൊന്ന്, ഒപ്പം

· സ്ട്രീമുകൾ സൈക്കിൾ ചെയ്യാൻ എത്ര സമയമെടുക്കും

ഞങ്ങൾ ഇവിടെ കുറച്ച് നിബന്ധനകൾ അവതരിപ്പിക്കും: ഒരു RNG (കപട) ക്രമരഹിതമായ ഒരു നീണ്ട ശ്രേണി നൽകുന്നു
സംഖ്യകൾ. ഈ ശ്രേണിയുടെ ദൈർഘ്യത്തെ വിളിക്കുന്നു സൈക്കിൾ നീളം or കാലഘട്ടം, അതിനു ശേഷം
RNG സ്വയം ആവർത്തിക്കും. ഈ ക്രമം വിഭജനമായി വിഭജിക്കാം തോടുകൾ. ഒരു
ഒരു RNG-യുടെ സ്ട്രീം എന്നത് RNG സീക്വൻസിൻറെ തുടർച്ചയായ ഉപസെറ്റ് അല്ലെങ്കിൽ ബ്ലോക്കാണ്. ഉദാഹരണത്തിന്, എങ്കിൽ
RNG കാലയളവ് N ദൈർഘ്യമുള്ളതാണ്, ഈ RNG-ൽ നിന്ന് രണ്ട് സ്ട്രീമുകൾ നൽകിയിരിക്കുന്നു, തുടർന്ന് ആദ്യത്തേത്
സ്ട്രീം ആദ്യത്തെ N/2 മൂല്യങ്ങൾ ഉപയോഗിച്ചേക്കാം, രണ്ടാമത്തെ സ്ട്രീം രണ്ടാമത്തെ N/2 ഉണ്ടാക്കിയേക്കാം
മൂല്യങ്ങൾ. രണ്ട് സ്ട്രീമുകളും പരസ്പര ബന്ധമില്ലാത്തതാണ് ഇവിടെ ഒരു പ്രധാന സ്വത്ത്. അതുപോലെ,
ഓരോ സ്ട്രീമും പരസ്പരം ബന്ധമില്ലാത്ത നിരവധി ഭാഗങ്ങളിലേക്ക് വിഭജിക്കാം സബ്സ്ട്രീമുകൾ. ദി
അടിവരയിടുന്ന RNG വളരെ ദൈർഘ്യമേറിയ സംഖ്യകളുടെ കപട-റാൻഡം സീക്വൻസ് ഉണ്ടാക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു
സൈക്കിൾ ദൈർഘ്യം, ഇത് കാര്യക്ഷമമായ രീതിയിൽ സ്ട്രീമുകളിലേക്കും സബ്സ്ട്രീമുകളിലേക്കും പാർട്ടീഷൻ ചെയ്യുന്നു.

ns-3 ചെയ്യുന്നത് പോലെ തന്നെ അടിസ്ഥാന റാൻഡം നമ്പർ ജനറേറ്റർ ഉപയോഗിക്കുന്നു ns-2: MRG32k3a
Pierre L'Ecuyer-ൽ നിന്നുള്ള ജനറേറ്റർ. വിശദമായ വിവരണം ഇതിൽ കാണാം
http://www.iro.umontreal.ca/~lecuyer/myftp/papers/streams00.pdf. MRG32k3a ജനറേറ്റർ
ക്രമരഹിത സംഖ്യകളുടെ 1.8x10^{19} സ്വതന്ത്ര സ്ട്രീമുകൾ നൽകുന്നു, അവയിൽ ഓരോന്നിനും ഇവ ഉൾപ്പെടുന്നു
2.3x10^{15} സബ്‌സ്ട്രീമുകൾ. ഓരോ സബ്‌സ്ട്രീമിനും ഒരു കാലഘട്ടമുണ്ട് (അതായത്, ക്രമരഹിത സംഖ്യകളുടെ എണ്ണം
ഓവർലാപ്പിന് മുമ്പ്) 7.6x10^{22}. മുഴുവൻ ജനറേറ്ററിന്റെയും കാലയളവ് 3.1x10^{57} ആണ്.

ക്ലാസ് ns3::RandomVariableStream ഈ അടിസ്ഥാന റാൻഡം നമ്പറിന്റെ പൊതു ഇന്റർഫേസ് ആണ്
ജനറേറ്റർ. ഉപയോക്താക്കൾ പുതിയ റാൻഡം വേരിയബിളുകൾ സൃഷ്ടിക്കുമ്പോൾ (ഉദാ ns3::യൂണിഫോം റാൻഡം വേരിയബിൾ,
ns3::ExponentialRandomVariableമുതലായവ), അവയിലൊന്ന് ഉപയോഗിക്കുന്ന ഒരു ഒബ്ജക്റ്റ് അവർ സൃഷ്ടിക്കുന്നു
റാൻഡം നമ്പർ ജനറേറ്ററിന്റെ വ്യത്യസ്തവും സ്വതന്ത്രവുമായ സ്ട്രീമുകൾ. അതിനാൽ, ഓരോ വസ്തുവിന്റെയും
ടൈപ്പ് ചെയ്യുക ns3::RandomVariableStream ആശയപരമായി, അതിന്റേതായ "വെർച്വൽ" RNG ഉണ്ട്. കൂടാതെ,
ഓരോന്നും ns3::RandomVariableStream വരച്ച സബ്‌സ്ട്രീമുകളിൽ ഒന്ന് ഉപയോഗിക്കുന്നതിന് കോൺഫിഗർ ചെയ്യാൻ കഴിയും
പ്രധാന സ്ട്രീമിൽ നിന്ന്.

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

ഉണ്ടാക്കുന്നു ക്രമരഹിതം വേരിയബിളുകൾ
ns-3 അടിസ്ഥാന ക്ലാസിൽ നിന്ന് നിരവധി റാൻഡം വേരിയബിൾ ഒബ്ജക്റ്റുകളെ പിന്തുണയ്ക്കുന്നു
റാൻഡം വേരിയബിൾ സ്ട്രീം. ഈ വസ്തുക്കൾ ഉരുത്തിരിഞ്ഞത് ns3::ഒബ്ജക്റ്റ് സ്മാർട്ടാണ് കൈകാര്യം ചെയ്യുന്നത്
സൂചികൾ.

ഈ ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കാനുള്ള ശരിയായ മാർഗം ടെംപ്ലേറ്റ് ചെയ്‌തത് ഉപയോഗിക്കുക എന്നതാണ് CreateObject<> രീതി,
അതുപോലെ:

Ptr x = CreateObject ();

തുടർന്ന് ഒബ്‌ജക്‌റ്റിലെ രീതികൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് മൂല്യങ്ങൾ ആക്‌സസ് ചെയ്യാൻ കഴിയും:

myRandomNo = x->GetInteger ();

പകരം ഇതുപോലെ എന്തെങ്കിലും ചെയ്യാൻ നിങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ:

myRandomNo = UniformRandomVariable().GetInteger ();

നിങ്ങളുടെ പ്രോഗ്രാം ഒരു സെഗ്മെന്റേഷൻ തകരാർ നേരിടും, കാരണം നടപ്പിലാക്കൽ ആശ്രയിക്കുന്നു
എപ്പോൾ മാത്രം സംഭവിക്കുന്ന ചില ആട്രിബ്യൂട്ട് നിർമ്മാണം ക്രിയേറ്റ് ഒബ്ജക്റ്റ് വിളിച്ചു.

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

വിത്ത് ഒപ്പം സ്വതന്ത്രമായ പകർപ്പുകൾ
ns-3 നിർണ്ണായകമായ അല്ലെങ്കിൽ ക്രമരഹിതമായ ഫലങ്ങൾ ഉണ്ടാക്കുന്നതിനായി അനുകരണങ്ങൾ ക്രമീകരിക്കാവുന്നതാണ്. എങ്കിൽ
ns-3 ഒരേ റൺ നമ്പറുള്ള സ്ഥിരവും നിർണ്ണായകവുമായ വിത്ത് ഉപയോഗിക്കുന്നതിന് സിമുലേഷൻ ക്രമീകരിച്ചിരിക്കുന്നു,
ഓരോ തവണ പ്രവർത്തിപ്പിക്കുമ്പോഴും ഒരേ ഔട്ട്പുട്ട് നൽകണം.

സ്ഥിരസ്ഥിതിയായി, ns-3 സിമുലേഷനുകൾ ഒരു നിശ്ചിത സീഡും റൺ നമ്പറും ഉപയോഗിക്കുന്നു. ഈ മൂല്യങ്ങൾ സംഭരിച്ചിരിക്കുന്നു
രണ്ട് ns3:: ഗ്ലോബൽ വാല്യൂ സന്ദർഭങ്ങൾ: g_rngവിത്ത് ഒപ്പം g_rngRun.

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

ഒരു ക്ലാസ് ns3::RngSeedManager സീഡിംഗും റൺ നമ്പറും നിയന്ത്രിക്കാൻ ഒരു API നൽകുന്നു
പെരുമാറ്റം. ഈ സീഡിംഗും സബ്‌സ്ട്രീം അവസ്ഥയും ക്രമരഹിതമായി വിളിക്കപ്പെടുന്നതിന് മുമ്പ് വിളിക്കേണ്ടതാണ്
വേരിയബിളുകൾ സൃഷ്ടിക്കപ്പെടുന്നു; ഉദാ:

RngSeedManager::SetSeed (3); // വിത്ത് ഡിഫോൾട്ടായി 1-ൽ നിന്ന് 3-ലേക്ക് മാറ്റുന്നു
RngSeedManager::SetRun (7); // റൺ നമ്പർ ഡിഫോൾട്ട് 1 മുതൽ 7 വരെ മാറ്റുന്നു
// ഇപ്പോൾ, റാൻഡം വേരിയബിളുകൾ സൃഷ്ടിക്കുക
Ptr x = CreateObject ();
Ptr y = CreateObject ();
...

ഏതാണ് മികച്ചത്, ഒരു പുതിയ വിത്ത് സജ്ജീകരിക്കുകയോ സബ്‌സ്ട്രീം നില മെച്ചപ്പെടുത്തുകയോ? അവിടെ ഇല്ല
ക്രമരഹിതമായ രണ്ട് വിത്തുകൾ നിർമ്മിക്കുന്ന സ്ട്രീമുകൾ ഓവർലാപ്പ് ചെയ്യില്ലെന്ന് ഉറപ്പ് നൽകുന്നു. ഒരേയൊരു വഴി
രണ്ട് സ്ട്രീമുകൾ ഓവർലാപ്പ് ചെയ്യുന്നില്ലെന്ന് ഉറപ്പുനൽകുന്നത് നൽകിയിരിക്കുന്ന സബ്സ്ട്രീം കഴിവ് ഉപയോഗിക്കുക എന്നതാണ്
RNG നടപ്പിലാക്കൽ. അതുകൊണ്ടു, ഉപയോഗം The സബ്സ്ട്രീം കഴിവ് ലേക്ക് ഉൽപ്പാദിപ്പിക്കുക ഒന്നിലധികം
സ്വതന്ത്രമായ റൺസ് of The ഒരേ സിമുലേഷൻ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, സ്ഥിതിവിവരക്കണക്ക് കൂടുതൽ കർശനമാണ്
ഒന്നിലധികം സ്വതന്ത്രമായ പകർപ്പുകൾ ക്രമീകരിക്കുന്നതിനുള്ള മാർഗ്ഗം ഒരു നിശ്ചിത വിത്ത് ഉപയോഗിക്കുകയും മുന്നേറുകയും ചെയ്യുക എന്നതാണ്
റൺ നമ്പർ. ഈ നടപ്പാക്കൽ പരമാവധി 2.3x10^{15} സ്വതന്ത്രമായി അനുവദിക്കുന്നു
സബ്സ്ട്രീമുകൾ ഉപയോഗിച്ചുള്ള പകർപ്പുകൾ.

ഉപയോഗത്തിന്റെ എളുപ്പത്തിനായി, അതിനുള്ളിൽ നിന്ന് വിത്തും റൺ നമ്പറും നിയന്ത്രിക്കേണ്ട ആവശ്യമില്ല
പ്രോഗ്രാം; ഉപയോക്താവിന് സജ്ജമാക്കാൻ കഴിയും NS_GLOBAL_VALUE പരിസ്ഥിതി വേരിയബിൾ ഇനിപ്പറയുന്ന രീതിയിൽ:

$ NS_GLOBAL_VALUE="RngRun=3" ./waf --run program-name

ഇത് നിയന്ത്രിക്കാനുള്ള മറ്റൊരു മാർഗ്ഗം ഒരു കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റ് പാസാക്കുക എന്നതാണ്; കാരണം ഇത് ഒരു ആണ് ns-3
GlobalValue ഉദാഹരണം, ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ തുല്യമായി ചെയ്യുന്നു:

$ ./waf --command-template="%s --RngRun=3" --run program-name

അല്ലെങ്കിൽ, നിങ്ങൾ വാഫിന് പുറത്ത് നേരിട്ട് പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ:

$ ./build/optimized/scrach/program-name --RngRun=3

മുകളിലെ കമാൻഡ്-ലൈൻ വേരിയന്റുകൾ ഒരു ഷെല്ലിൽ നിന്ന് നിരവധി വ്യത്യസ്ത റണ്ണുകൾ പ്രവർത്തിപ്പിക്കുന്നത് എളുപ്പമാക്കുന്നു
മറ്റൊരു RngRun സൂചിക പാസ്സാക്കി സ്ക്രിപ്റ്റ് ചെയ്യുക.

ക്ലാസ് റാൻഡം വേരിയബിൾ സ്ട്രീം
എല്ലാ റാൻഡം വേരിയബിളുകളും ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞിരിക്കണം റാൻഡം വേരിയബിൾ. ഈ അടിസ്ഥാന ക്ലാസ് എ
റാൻഡം നമ്പർ ജനറേറ്ററിന്റെ സ്വഭാവം ആഗോളതലത്തിൽ ക്രമീകരിക്കുന്നതിനുള്ള ചില രീതികൾ. ഉരുത്തിരിഞ്ഞത്
പ്രത്യേക വിതരണത്തിൽ നിന്ന് ക്രമരഹിതമായ വ്യത്യാസങ്ങൾ വരയ്ക്കുന്നതിന് ക്ലാസുകൾ API നൽകുന്നു
പിന്തുണയ്‌ക്കുന്നു.

സിമുലേഷനിൽ സൃഷ്ടിച്ച ഓരോ RandomVariableStream-നും ഒരു പുതിയ ജനറേറ്റർ നൽകിയിരിക്കുന്നു
അടിസ്ഥാന PRNG-യിൽ നിന്ന് RNG സ്ട്രീം. ഈ രീതിയിൽ ഉപയോഗിക്കുന്നു, L'Ecuyer നടപ്പിലാക്കൽ
പരമാവധി 1.8x10^19 റാൻഡം വേരിയബിളുകൾ അനുവദിക്കുന്നു. ഓരോ റാൻഡം വേരിയബിളും ഒറ്റത്തവണയിൽ
ഓവർലാപ്പുചെയ്യുന്നതിന് മുമ്പ് 7.6x10^22 ക്രമരഹിത സംഖ്യകൾ വരെ പകർത്താൻ കഴിയും.

അടിത്തറ ക്ലാസ് പൊതു എപിഐ
ക്ലാസ്സിന്റെ ചില പൊതു രീതികൾ താഴെ ഉദ്ധരിക്കുന്നു റാൻഡം വേരിയബിൾ സ്ട്രീം അത് ആക്സസ് ചെയ്യുക
സബ്സ്ട്രീമിലെ അടുത്ത മൂല്യം.

/ **
* \brief അടിസ്ഥാന വിതരണത്തിൽ നിന്ന് ക്രമരഹിതമായ ഇരട്ടി നൽകുന്നു
* \ഒരു ഫ്ലോട്ടിംഗ് പോയിന്റ് റാൻഡം മൂല്യം തിരികെ നൽകുക
*/
ഇരട്ട GetValue (അസാധു) കോൺസ്റ്റ്;

/ **
* \brief അടിസ്ഥാന വിതരണത്തിൽ നിന്ന് ഒരു റാൻഡം പൂർണ്ണസംഖ്യ നൽകുന്നു
* \return integer cast ::GetValue()
*/
uint32_t GetInteger (അസാധു) const;

മുകളിൽ സീഡിംഗ് കോൺഫിഗറേഷൻ ഞങ്ങൾ ഇതിനകം വിവരിച്ചിട്ടുണ്ട്. വ്യത്യസ്ത റാൻഡം വേരിയബിൾ
ഉപവിഭാഗങ്ങൾക്ക് അധിക API ഉണ്ടായിരിക്കാം.

തരത്തിലുള്ളവ of റാൻഡം വേരിയബിളുകൾ
ഇനിപ്പറയുന്ന തരത്തിലുള്ള റാൻഡം വേരിയബിളുകൾ നൽകിയിരിക്കുന്നു, അവയിൽ രേഖപ്പെടുത്തിയിരിക്കുന്നു ns-3
ഡോക്സിജൻ അല്ലെങ്കിൽ വായനയിലൂടെ src/core/model/random-variable-stream.h. ഉപയോക്താക്കൾക്കും സൃഷ്ടിക്കാൻ കഴിയും
ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ് അവരുടെ സ്വന്തം ഇഷ്‌ടാനുസൃത റാൻഡം വേരിയബിളുകൾ റാൻഡം വേരിയബിൾ സ്ട്രീം.

· ക്ലാസ് യൂണിഫോം റാൻഡം വേരിയബിൾ

· ക്ലാസ് കോൺസ്റ്റന്റ് റാൻഡം വേരിയബിൾ

· ക്ലാസ് സീക്വൻഷ്യൽ റാൻഡം വേരിയബിൾ

· ക്ലാസ് എക്സ്പോണൻഷ്യൽ റാൻഡം വേരിയബിൾ

· ക്ലാസ് ParetoRandomVariable

· ക്ലാസ് വെയ്ബുൾ റാൻഡം വേരിയബിൾ

· ക്ലാസ് സാധാരണ റാൻഡം വേരിയബിൾ

· ക്ലാസ് ലോഗ് നോർമൽ റാൻഡം വേരിയബിൾ

· ക്ലാസ് ഗാമറാൻഡം വേരിയബിൾ

· ക്ലാസ് എർലാങ് റാൻഡം വേരിയബിൾ

· ക്ലാസ് ത്രികോണ ക്രമരഹിത വേരിയബിൾ

· ക്ലാസ് ZipfRandomVariable

· ക്ലാസ് ZetaRandomVariable

· ക്ലാസ് ഡിറ്റർമിനിസ്റ്റിക് റാൻഡം വേരിയബിൾ

· ക്ലാസ് അനുഭാവപരമായ റാൻഡം വേരിയബിൾ

സെമാന്റിക്സ് of റാൻഡം വേരിയബിൾ സ്ട്രീം വസ്തുക്കൾ
RandomVariableStream ഒബ്‌ജക്‌റ്റുകൾ ഉരുത്തിരിഞ്ഞത് ns3::ഒബ്ജക്റ്റ് കൂടാതെ സ്മാർട്ട് പോയിന്ററുകൾ കൈകാര്യം ചെയ്യുന്നു.

RandomVariableStream സംഭവങ്ങളും ഉപയോഗിക്കാവുന്നതാണ് ns-3 ആട്രിബ്യൂട്ടുകൾ, അതായത്
വഴി അവർക്ക് മൂല്യങ്ങൾ സജ്ജമാക്കാൻ കഴിയും ns-3 ആട്രിബ്യൂട്ട് സിസ്റ്റം. എന്നതിൽ ഒരു ഉദാഹരണമുണ്ട്
WifiNetDevice-നുള്ള പ്രചരണ മോഡലുകൾ:

ടൈപ്പ് ഐഡി
ക്രമരഹിതമായ പ്രചരണ കാലതാമസം മോഡൽ::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് ടിഡ് = ടൈപ്പ് ഐഡ് ("ns3::RandomPropagationDelayModel")
.SetParent ()
.AddConstructor ()
.AddAtribute ("വേരിയബിൾ",
"റാൻഡം കാലതാമസം (കൾ) സൃഷ്ടിക്കുന്ന റാൻഡം വേരിയബിൾ.",
StringValue ("ns3::UniformRandomVariable"),
MakePointerAccessor (&RandomPropagationDelayModel::m_variable),
MakePointerChecker ())
;
റിട്ടേൺ ടിഡ്;
}

ഇവിടെ, ദി ns-3 ഈ കാലതാമസം മോഡലിനായി ഉപയോക്താവിന് സ്ഥിരസ്ഥിതി റാൻഡം വേരിയബിൾ മാറ്റാൻ കഴിയും (അതായത്
ആട്രിബ്യൂട്ട് സിസ്റ്റം വഴി 0 മുതൽ 1 വരെ) ഒരു യൂണിഫോം റാൻഡം വേരിയബിൾ.

ഉപയോഗിക്കുന്നു മറ്റ് PRNG
വ്യത്യസ്‌തമായ ഒരു റാൻഡം നമ്പർ മാറ്റിസ്ഥാപിക്കുന്നതിന് നിലവിൽ പിന്തുണയില്ല
ജനറേറ്റർ (ഉദാ, GNU സയന്റിഫിക് ലൈബ്രറി അല്ലെങ്കിൽ Akaroa പാക്കേജ്). പാച്ചുകൾ സ്വാഗതം ചെയ്യുന്നു.

ക്രമീകരണം The സ്ട്രീം അക്കം
അന്തർലീനമായ MRG32k3a ജനറേറ്റർ 2^64 സ്വതന്ത്ര സ്ട്രീമുകൾ നൽകുന്നു. ns-3-ൽ, ഇവയാണ്
പുതിയ റാൻഡം വേരിയബിൾ സ്ട്രീം സംഭവങ്ങളായി ആദ്യ സ്ട്രീം മുതൽ തുടർച്ചയായി അസൈൻ ചെയ്‌തു
GetValue() എന്നതിലേക്ക് അവരുടെ ആദ്യ കോൾ ചെയ്യുക.

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

ഒരു വ്യക്തമായ ഉദാഹരണമെന്ന നിലയിൽ, റൂട്ടിംഗ് പ്രോട്ടോക്കോളുകൾക്കിടയിൽ ഒരു താരതമ്യ പഠനം നടത്തുന്ന ഉപയോക്താവ്
ഒരു റൂട്ടിംഗ് പ്രോട്ടോക്കോൾ മറ്റൊന്നിനായി മാറ്റുന്നത് ശ്രദ്ധിക്കുമെന്ന് കണ്ടെത്തുക
അടിസ്ഥാന മൊബിലിറ്റി പാറ്റേണും മാറി.

ns-3.15 മുതൽ, ഉപയോക്താക്കളെ അനുവദിക്കുന്നതിന് ഉപയോക്താക്കൾക്ക് ചില നിയന്ത്രണം നൽകിയിട്ടുണ്ട്
തിരഞ്ഞെടുത്ത RandomVariableStream ഒബ്‌ജക്‌റ്റുകളുടെ അസൈൻമെന്റ് ഐച്ഛികമായി പരിഹരിക്കുക
അരുവികൾ. ഇതാണ് സ്ട്രീം ആട്രിബ്യൂട്ട്, റാൻഡം വേരിയബിൾ സ്ട്രീമിന്റെ അടിസ്ഥാന ക്ലാസിന്റെ ഭാഗം.

മുമ്പത്തെ സ്ട്രീമുകളുടെ നിലവിലുള്ള ക്രമം വിഭജിക്കുന്നതിലൂടെ:

<------------------------------------------------ ------------------------->
സ്ട്രീം 0 സ്ട്രീം (2^64 - 1)

രണ്ട് തുല്യ വലിപ്പത്തിലുള്ള സെറ്റുകളായി:

<------------------------------------------------ ------------------------->
^^^^
| || |
സ്ട്രീം 0 സ്ട്രീം (2^63 - 1) സ്ട്രീം 2^63 സ്ട്രീം (2^64 - 1)
<- സ്വയമേവ അസൈൻ ചെയ്‌ത ------------> ഉപയോക്താവ് നിയോഗിച്ചത് ---------------->

ആദ്യത്തെ 2^63 സ്ട്രീമുകൾ സ്വയമേവ അസൈൻ ചെയ്യുന്നത് തുടരുന്നു, അവസാനത്തെ 2^63
നൽകിയിരിക്കുന്ന സ്ട്രീം സൂചികകൾ പൂജ്യത്തിൽ തുടങ്ങി 2^63-1 വരെ.

ഒരു നിശ്ചിത സ്ട്രീം നമ്പറിലേക്ക് സ്ട്രീമുകളുടെ അസൈൻമെന്റ് ഓപ്ഷണലാണ്; ഉദാഹരണങ്ങൾ
അസൈൻ ചെയ്‌ത സ്ട്രീം മൂല്യം ഇല്ലാത്ത RandomVariableStream അടുത്തത് അസൈൻ ചെയ്യും
ഓട്ടോമാറ്റിക് സ്ട്രീമുകളുടെ കുളത്തിൽ നിന്ന് ഒന്ന്.

ഒരു പ്രത്യേക അണ്ടർലൈയിംഗ് സ്ട്രീമിലേക്ക് ഒരു RandomVariableStream ശരിയാക്കാൻ, അത് നിയോഗിക്കുക സ്ട്രീം
ഒരു നോൺ-നെഗറ്റീവ് പൂർണ്ണസംഖ്യയിലേക്ക് ആട്രിബ്യൂട്ട് ചെയ്യുക (-1 ന്റെ സ്ഥിര മൂല്യം അർത്ഥമാക്കുന്നത് ഒരു മൂല്യം ആയിരിക്കും എന്നാണ്
സ്വയമേവ അനുവദിച്ചു).

പസിദ്ധീകരിക്കുന്ന നിങ്ങളുടെ ഫലം
നിങ്ങൾ സിമുലേഷൻ ഫലങ്ങൾ പ്രസിദ്ധീകരിക്കുമ്പോൾ, നിങ്ങൾക്കുള്ള കോൺഫിഗറേഷൻ വിവരങ്ങളുടെ ഒരു പ്രധാന ഭാഗം
നിങ്ങൾ റാൻഡം നമ്പർ ജനറേറ്റർ എങ്ങനെ ഉപയോഗിച്ചുവെന്ന് എപ്പോഴും പ്രസ്താവിക്കേണ്ടതാണ്.

· നിങ്ങൾ ഉപയോഗിച്ച വിത്തുകൾ,

ഡിഫോൾട്ടല്ലെങ്കിൽ നിങ്ങൾ എന്ത് RNG ഉപയോഗിച്ചു,

സ്വതന്ത്ര റണ്ണുകൾ എങ്ങനെയാണ് നടത്തിയത്,

· വലിയ സിമുലേഷനുകൾക്കായി, നിങ്ങൾ സൈക്കിൾ ചവിട്ടിയില്ലെന്ന് നിങ്ങൾ എങ്ങനെ പരിശോധിച്ചു.

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

ചുരുക്കം
ഒരു സിമുലേഷൻ സൃഷ്ടിക്കുമ്പോൾ നിങ്ങൾ ചെയ്യേണ്ട കാര്യങ്ങൾ എന്തൊക്കെയാണെന്ന് നമുക്ക് അവലോകനം ചെയ്യാം.

· നിങ്ങൾ ഒരു നിശ്ചിത വിത്ത് ഉപയോഗിച്ചാണോ അതോ ക്രമരഹിതമായ വിത്തുമായാണോ ഓടുന്നത് എന്ന് തീരുമാനിക്കുക; ഒരു നിശ്ചിത വിത്താണ്
സ്ഥിരസ്ഥിതി,

· ബാധകമെങ്കിൽ, നിങ്ങൾ സ്വതന്ത്രമായ പകർപ്പുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് തീരുമാനിക്കുക,

· സൈക്കിൾ ദൈർഘ്യത്തേക്കാൾ കൂടുതൽ ക്രമരഹിതമായ മൂല്യങ്ങൾ നിങ്ങൾ വരയ്ക്കുന്നില്ലെന്ന് സ്വയം ബോധ്യപ്പെടുത്തുക
നിങ്ങൾ വളരെ ദൈർഘ്യമേറിയ ഒരു സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുന്നു, ഒപ്പം

· നിങ്ങൾ പ്രസിദ്ധീകരിക്കുമ്പോൾ, ക്രമരഹിതമായ നിങ്ങളുടെ ഉപയോഗം ഡോക്യുമെന്റ് ചെയ്യുന്നതിനെക്കുറിച്ചുള്ള മുകളിലെ മാർഗ്ഗനിർദ്ദേശങ്ങൾ പാലിക്കുക
നമ്പർ ജനറേറ്റർ.

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

ഇതര ഹാഷ് ചേർക്കുന്നതിന് (അല്ലെങ്കിൽ റൺ സമയത്ത് നൽകുന്നതിന്) ഒരു നേർരേഖ സംവിധാനം ഉണ്ട്
ഫംഗ്ഷൻ നടപ്പിലാക്കലുകൾ.

അടിസ്ഥാനപരമായ ഉപയോഗം
ഒരു ഡാറ്റ ബഫറിന്റെയോ സ്‌ട്രിംഗിന്റെയോ ഹാഷ് മൂല്യം നേടുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഇതാണ്:

#ഉൾപ്പെടുത്തുക "ns3/hash.h"

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

ചാർ * ബഫർ =...
size_t buffer_size = ...

uint32_t buffer_hash = Hash32 (ബഫർ, ബഫർ_സൈസ്);

std::സ്ട്രിംഗ് എസ്;
uint32_t string_hash = Hash32 (s);

64-ബിറ്റ് ഹാഷ് മൂല്യങ്ങൾക്ക് തുല്യമായ ഫംഗ്ഷനുകൾ നിർവചിച്ചിരിക്കുന്നു.

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

ഇത് ആദ്യ ഉദാഹരണം പോലെ തന്നെ നേരായതാണ്:

#ഉൾപ്പെടുത്തുക "ns3/hash.h"

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

ചാർ * ബഫർ;
വലിപ്പം_t ബഫർ_സൈസ്;

ഹാഷർ ഹാഷർ; // ഡിഫോൾട്ട് ഹാഷ് ഫംഗ്ഷൻ ഉപയോഗിക്കുക

വേണ്ടി ( )
{
ബഫർ = get_next_buffer ();
ഹാഷർ (ബഫർ, ബഫർ_സൈസ്);
}
uint32_t compound_hash = hasher.GetHash32 ();

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

hasher.clear ().GetHash32 (ബഫർ, ബഫർ_സൈസ്);

ബഫർ ഹാഷ് ചെയ്യുന്നതിന് മുമ്പ് ഇത് ആന്തരിക അവസ്ഥയെ പുനരാരംഭിക്കുന്നു.

ഉപയോഗിക്കുന്നു an ബദൽ ഹാഷ് ഫംഗ്ഷൻ
ഡിഫോൾട്ട് ഹാഷ് ഫംഗ്ഷൻ ആണ് പിറുപിറുപ്പ്3. FNV1a എന്നിവയും ലഭ്യമാണ്. ഹാഷ് വ്യക്തമാക്കാൻ
വ്യക്തമായി പ്രവർത്തിക്കുക, ഈ കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കുക:

ഹാഷർ ഹാഷർ = ഹാഷർ (സൃഷ്ടിക്കുക () );

ചേർക്കുന്നു പുതിയ ഹാഷ് ഫംഗ്ഷൻ നടപ്പാക്കലുകൾ
ഹാഷ് ഫംഗ്ഷൻ ചേർക്കാൻ ഫൂ, പിന്തുടരുക hash-murmur3.h/.cc പാറ്റേൺ:

ഒരു ക്ലാസ് ഡിക്ലറേഷൻ സൃഷ്ടിക്കുക (.h) കൂടാതെ നിർവചനം (.cc) പാരമ്പര്യമായി ലഭിക്കുന്നത്
ഹാഷ്:: നടപ്പാക്കൽ.

· ഉൾപ്പെടുന്നു പ്രഖ്യാപനം hash.h (ആ സ്ഥലത്ത് hash-murmur3.h ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

· നിങ്ങളുടെ സ്വന്തം കോഡിൽ, തൽക്ഷണം a ഹാഷർ കൺസ്ട്രക്റ്റർ വഴി ഒബ്ജക്റ്റ് ഹാഷർ
(Ptr ())

നിങ്ങളുടെ ഹാഷ് ഫംഗ്‌ഷൻ ഒരൊറ്റ ഫംഗ്‌ഷൻ ആണെങ്കിൽ, ഉദാ ഹാഷ്ഫ്, നിങ്ങൾ ഒരു സൃഷ്ടിക്കാൻ പോലും ആവശ്യമില്ല
ഹാഷ് ഇംപ്ലിമെന്റേഷനിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ പുതിയ ക്ലാസ്:

ഹാഷർ ഹാഷർ =
ഹാഷർ (സൃഷ്ടിക്കുക (&hashf) );

ഇത് സമാഹരിക്കാൻ, നിങ്ങളുടെ ഹാഷ്ഫ് ഫംഗ്‌ഷൻ പോയിന്റർ സിഗ്‌നേച്ചറുകളിലൊന്നുമായി പൊരുത്തപ്പെടണം:

typedef uint32_t (*Hash32Function_ptr) (const char *, const size_t);
typedef uint64_t (*Hash64Function_ptr) (const char *, const size_t);

ഉറവിടങ്ങൾ വേണ്ടി ഹാഷ് പ്രവർത്തനങ്ങൾ
മറ്റ് ഹാഷ് ഫംഗ്‌ഷൻ നടപ്പിലാക്കുന്നതിനുള്ള ഉറവിടങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:

പീറ്റർ കാങ്കോവ്സ്കി: http://www.strchr.com

· അരാഷ് പാർട്ടോവ്: http://www.partow.net/programming/hashfunctions/index.html

എസ്.എം.ഹാഷർ: http://code.google.com/p/smhasher/

· സാൻമെയ്‌സ്: http://www.sanmayce.com/Fastest_Hash/index.html

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

ഇതെല്ലാം സംഭവിക്കുന്നതിന്, സിമുലേറ്ററിന് കുറച്ച് കാര്യങ്ങൾ ആവശ്യമാണ്:

1. ഇവന്റുകൾ സംഭരിച്ചിരിക്കുന്ന ഒരു ഇവന്റ് ക്യൂ ആക്‌സസ് ചെയ്യാൻ കഴിയുന്ന ഒരു സിമുലേറ്റർ ഒബ്‌ജക്റ്റ്
ഇവന്റുകളുടെ നിർവ്വഹണം നിയന്ത്രിക്കുക

2. ക്യൂവിൽ നിന്ന് ഇവന്റുകൾ ചേർക്കുന്നതിനും നീക്കം ചെയ്യുന്നതിനും ഉത്തരവാദിത്തമുള്ള ഒരു ഷെഡ്യൂളർ

3. സിമുലേഷൻ സമയത്തെ പ്രതിനിധീകരിക്കുന്നതിനുള്ള ഒരു മാർഗം

4. സംഭവങ്ങൾ തന്നെ

മാനുവലിന്റെ ഈ അധ്യായം ഈ അടിസ്ഥാന വസ്തുക്കളെ വിവരിക്കുന്നു (സിമുലേറ്റർ, ഷെഡ്യൂളർ,
സമയം, ഇവന്റ്) കൂടാതെ അവ എങ്ങനെ ഉപയോഗിക്കുന്നു.

സംഭവം
ലേക്ക് be പൂർത്തിയായി

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

സിമുലേറ്റർ മെയിൻ ലൂപ്പ് ഉപയോഗിച്ച് നിർവ്വഹണത്തിനായി ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യാൻ, സിമുലേറ്റർ ക്ലാസ് നൽകുന്നു
സിമുലേറ്റർ::ഷെഡ്യൂൾ* ഫാമിലി ഓഫ് ഫംഗ്‌ഷനുകൾ.

1. വ്യത്യസ്ത ഒപ്പുകളുള്ള ഇവന്റ് ഹാൻഡ്‌ലറുകൾ കൈകാര്യം ചെയ്യുന്നു

ഈ പ്രവർത്തനങ്ങൾ സ്വയമേവ കൈകാര്യം ചെയ്യുന്നതിനായി C++ ടെംപ്ലേറ്റുകളായി പ്രഖ്യാപിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു
കാട്ടിൽ ഉപയോഗിക്കുന്ന വൈവിധ്യമാർന്ന C++ ഇവന്റ് ഹാൻഡ്‌ലർ ഒപ്പുകൾ. ഉദാഹരണത്തിന്, ഒരു ഷെഡ്യൂൾ ചെയ്യാൻ
ഭാവിയിൽ 10 സെക്കൻഡ് എക്സിക്യൂട്ട് ചെയ്യാനുള്ള ഇവന്റ്, കൂടാതെ ഒരു C++ രീതി അല്ലെങ്കിൽ ഫംഗ്‌ഷൻ അഭ്യർത്ഥിക്കുക
നിർദ്ദിഷ്ട വാദങ്ങൾ, നിങ്ങൾക്ക് ഇത് എഴുതാം:

അസാധുവായ ഹാൻഡ്‌ലർ (int arg0, int arg1)
{
std::cout << "ആർഗ്യുമെന്റ് arg0=" << arg0 << " ഒപ്പം
arg1=" << arg1 << std::endl;
}

സിമുലേറ്റർ:: ഷെഡ്യൂൾ(സെക്കൻഡ്(10), & ഹാൻഡ്‌ലർ, 10, 5);

ഏത് ഔട്ട്പുട്ട് ചെയ്യും:

ആർഗ്യുമെന്റ് arg0=10, arg1=5 എന്നിവ ഉപയോഗിച്ച് ഹാൻഡ്‌ലർ വിളിച്ചു

തീർച്ചയായും, ഈ C++ ടെംപ്ലേറ്റുകൾക്ക് C++-ൽ അംഗത്വ രീതികൾ സുതാര്യമായി കൈകാര്യം ചെയ്യാൻ കഴിയും
വസ്തുക്കൾ:

ലേക്ക് be പൂർത്തിയായി: അംഗം രീതി ഉദാഹരണം

കുറിപ്പുകൾ:

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

· 'പൂർണ്ണമായി ബന്ധിപ്പിച്ച ഫംഗ്‌ടറുകൾ' എന്ന പദം പരിചയമുള്ള വായനക്കാർ തിരിച്ചറിയും
സിമുലേറ്റർ ::അത്തരം ഒബ്‌ജക്‌റ്റുകൾ സ്വയമേവ നിർമ്മിക്കുന്നതിനുള്ള ഒരു മാർഗമായി രീതികൾ ഷെഡ്യൂൾ ചെയ്യുക.

2. സാധാരണ ഷെഡ്യൂളിംഗ് പ്രവർത്തനങ്ങൾ

മിക്ക ഇവന്റുകളും ഷെഡ്യൂൾ ചെയ്യുന്നത് വളരെ ലളിതമാക്കുന്നതിനാണ് സിമുലേറ്റർ API രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. അത്
അതിനായി മൂന്ന് വകഭേദങ്ങൾ നൽകുന്നു (ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്നതിൽ നിന്ന് കുറഞ്ഞത് സാധാരണയായി ഉപയോഗിക്കുന്നവയിലേക്ക് ക്രമീകരിച്ചത്):

ഭാവിയിൽ ഒരു ഇവന്റ് ഷെഡ്യൂൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന രീതികൾ ഷെഡ്യൂൾ ചെയ്യുക
ടാർഗെറ്റ് ഇവന്റിന്റെ നിലവിലെ സിമുലേഷൻ സമയവും കാലഹരണപ്പെടുന്ന തീയതിയും തമ്മിലുള്ള കാലതാമസം.

നിലവിലെ സിമുലേഷനായി ഒരു ഇവന്റ് ഷെഡ്യൂൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ScheduleNow രീതികൾ
സമയം: നിലവിലെ ഇവന്റ് നിർവഹിച്ചുകഴിഞ്ഞാൽ_ അവർ എക്സിക്യൂട്ട് ചെയ്യും, പക്ഷേ _മുമ്പ്_
അടുത്ത ഇവന്റിനായി സിമുലേഷൻ സമയം മാറ്റി.

സിമുലേറ്ററിന്റെ ഷട്ട്ഡൗൺ പ്രക്രിയയിൽ ഹുക്ക് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഷെഡ്യൂൾഡെസ്ട്രോയ് രീതികൾ
സിമുലേഷൻ ഉറവിടങ്ങൾ വൃത്തിയാക്കാൻ: ഉപയോക്താവ് വിളിക്കുമ്പോൾ എല്ലാ 'നശിപ്പിക്കുക' ഇവന്റുകളും നടപ്പിലാക്കുന്നു
സിമുലേറ്റർ:: നശിപ്പിക്കുന്ന രീതി.

3. സിമുലേഷൻ സന്ദർഭം നിലനിർത്തൽ

ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യാൻ രണ്ട് അടിസ്ഥാന മാർഗങ്ങളുണ്ട്, കൂടെയും അല്ലാതെയും സന്ദർഭം. ഇത് എന്താണ് ചെയ്യുന്നത്
അർത്ഥമാക്കുന്നത്?

സിമുലേറ്റർ:: ഷെഡ്യൂൾ (സമയ കോൺസ്റ്റ് & സമയം, MEM mem_ptr, OBJ obj);

വേഴ്സസ്

സിമുലേറ്റർ::ScheduleWithContext (uint32_t സന്ദർഭം, സമയ കോൺസ്റ്റ് &സമയം, MEM mem_ptr, OBJ obj);

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

നിലവിൽ പ്രവർത്തിക്കുന്ന നെറ്റ്‌വർക്ക് നോഡിന്റെ നോഡ് ഐഡി യഥാർത്ഥത്തിൽ സിമുലേറ്റർ ട്രാക്ക് ചെയ്യുന്നു
ക്ലാസ്. ഇത് റിട്ടേൺ ചെയ്യുന്ന സിമുലേറ്റർ ::GetContext രീതി ഉപയോഗിച്ച് ആക്സസ് ചെയ്യാൻ കഴിയും
'സന്ദർഭം' (ഒരു 32-ബിറ്റ് പൂർണ്ണസംഖ്യ) നിലവിൽ നടപ്പിലാക്കുന്ന ഇവന്റുമായി ബന്ധിപ്പിച്ച് സംഭരിച്ചിരിക്കുന്നു. ഇൻ
ചില അപൂർവ സന്ദർഭങ്ങളിൽ, ഒരു ഇവന്റ് ഒരു നിർദ്ദിഷ്ട നെറ്റ്‌വർക്ക് നോഡുമായി ബന്ധപ്പെടുത്തിയിട്ടില്ലെങ്കിൽ, അത്
'സന്ദർഭം' 0xffffffff ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

ഓരോ ഇവന്റുമായി ഒരു സന്ദർഭം ബന്ധപ്പെടുത്തുന്നതിന്, ഷെഡ്യൂൾ, ഷെഡ്യൂൾ നൗ രീതികൾ സ്വയമേവ
ഷെഡ്യൂൾ ചെയ്‌ത ഇവന്റിന്റെ സന്ദർഭമായി നിലവിൽ നടപ്പിലാക്കുന്ന ഇവന്റിന്റെ സന്ദർഭം വീണ്ടും ഉപയോഗിക്കുക
പിന്നീട് നടപ്പിലാക്കുന്നതിനായി.

ചില സന്ദർഭങ്ങളിൽ, ഒരു നോഡിൽ നിന്ന് ഒരു പാക്കറ്റിന്റെ കൈമാറ്റം അനുകരിക്കുമ്പോൾ പ്രത്യേകിച്ചും
മറ്റൊന്ന്, സ്വീകരണ പരിപാടിയുടെ പ്രതീക്ഷിത സന്ദർഭമായതിനാൽ ഈ സ്വഭാവം അഭികാമ്യമല്ല
സ്വീകരിക്കുന്ന നോഡിന്റേതാണ്, അയയ്ക്കുന്ന നോഡല്ല. ഈ പ്രശ്നം ഒഴിവാക്കാൻ, സിമുലേറ്റർ
ക്ലാസ് ഒരു നിർദ്ദിഷ്‌ട ഷെഡ്യൂൾ രീതി നൽകുന്നു: ScheduleWithContext ഇത് നൽകാൻ ഒരാളെ അനുവദിക്കുന്നു
സ്വീകരിക്കുന്ന ഇവന്റുമായി ബന്ധപ്പെട്ട സ്വീകരിക്കുന്ന നോഡിന്റെ നോഡ് ഐഡി വ്യക്തമായി.

XXX: കോഡ് ഉദാഹരണം

വളരെ അപൂർവമായ ചില സന്ദർഭങ്ങളിൽ, ഡെവലപ്പർമാർക്ക് സന്ദർഭം എങ്ങനെ പരിഷ്കരിക്കുകയോ മനസ്സിലാക്കുകയോ ചെയ്യേണ്ടതായി വന്നേക്കാം
ആദ്യ ഇവന്റിന്റെ (നോഡ് ഐഡി) അതിന്റെ അനുബന്ധ നോഡിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു. ഇത് പൂർത്തീകരിച്ചു
നോഡ്‌ലിസ്റ്റ് ക്ലാസ് പ്രകാരം: ഒരു പുതിയ നോഡ് സൃഷ്ടിക്കുമ്പോഴെല്ലാം, നോഡ്‌ലിസ്റ്റ് ക്ലാസ് ഉപയോഗിക്കുന്നു
ഈ നോഡിനായി ഒരു 'ഇനീഷ്യലൈസ്' ഇവന്റ് ഷെഡ്യൂൾ ചെയ്യുന്നതിനായി, ContextWithContext. 'ഇനിഷ്യലൈസ്' ഇവന്റ്
അങ്ങനെ നോഡ് ഐഡിയുടെ ഒരു സന്ദർഭം സജ്ജീകരിച്ച് എക്സിക്യൂട്ട് ചെയ്യുന്നു കൂടാതെ സാധാരണ വൈവിധ്യം ഉപയോഗിക്കാം
ഷെഡ്യൂൾ രീതികൾ. ഇത് 'ഇനീഷ്യലൈസ്' പ്രചരിപ്പിക്കുന്ന നോഡ്::ഇനിഷ്യലൈസ് രീതിയെ അഭ്യർത്ഥിക്കുന്നു
നോഡുമായി ബന്ധപ്പെട്ട ഓരോ ഒബ്ജക്റ്റിനും DoInitialize രീതി വിളിക്കുന്നതിലൂടെ ഇവന്റ്. ദി
ഈ ഒബ്‌ജക്‌റ്റുകളിൽ ചിലത് (പ്രത്യേകിച്ച് അപ്ലിക്കേഷനിൽ) അസാധുവാക്കപ്പെട്ട രീതി DoInitialize
അടിസ്ഥാന ക്ലാസ്) ചില ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യും (പ്രത്യേകിച്ച് ആപ്ലിക്കേഷൻ :: സ്റ്റാർട്ട്ആപ്ലിക്കേഷൻ).
ട്രാഫിക് ജനറേഷൻ ഇവന്റുകൾ ഷെഡ്യൂൾ ചെയ്യും, അത് ഷെഡ്യൂൾ ചെയ്യും
നെറ്റ്‌വർക്ക്-ലെവൽ ഇവന്റുകൾ.

കുറിപ്പുകൾ:

· വിളിക്കുന്നതിലൂടെ ഒബ്‌ജക്‌റ്റുകളിലുടനീളം DoInitialize രീതികൾ പ്രചരിപ്പിക്കാൻ ഉപയോക്താക്കൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്
അവരുടെ അംഗ വസ്‌തുക്കളിൽ വ്യക്തമായി ആരംഭിക്കുക

· ഓരോ ScheduleWithContext രീതിയുമായി ബന്ധപ്പെട്ട സന്ദർഭ ഐഡിക്ക് അതിനപ്പുറം മറ്റ് ഉപയോഗങ്ങളുണ്ട്
ലോഗിംഗ്: സമാന്തര സിമുലേഷൻ നടത്താൻ ns-3 ന്റെ ഒരു പരീക്ഷണ ശാഖയാണ് ഇത് ഉപയോഗിക്കുന്നത്
മൾട്ടി ത്രെഡിംഗ് ഉപയോഗിക്കുന്ന മൾട്ടികോർ സിസ്റ്റങ്ങൾ.

സിമുലേറ്റർ::* ഫംഗ്‌ഷനുകൾക്ക് സന്ദർഭം എന്താണെന്ന് അറിയില്ല: അവ അത് ഉറപ്പാക്കുക മാത്രമാണ് ചെയ്യുന്നത്
ScheduleWithContext ഉപയോഗിച്ച് നിങ്ങൾ വ്യക്തമാക്കുന്ന ഏത് സന്ദർഭവും അനുബന്ധമായിരിക്കുമ്പോൾ ലഭ്യമാണ്
::GetContext ഉപയോഗിച്ച് ഇവന്റ് നടപ്പിലാക്കുന്നു.

സന്ദർഭ മൂല്യം വ്യാഖ്യാനിക്കുന്നത് സിമുലേറ്ററിന് മുകളിൽ നടപ്പിലാക്കിയ മോഡലുകൾക്കാണ്::*.
ns-3-ൽ, നെറ്റ്‌വർക്ക് മോഡലുകൾ സന്ദർഭത്തെ നോഡിന്റെ നോഡ് ഐഡിയായി വ്യാഖ്യാനിക്കുന്നു
ഒരു ഇവന്റ് സൃഷ്ടിച്ചു. അതുകൊണ്ടാണ് ScheduleWithContext-ലേക്ക് വിളിക്കേണ്ടത് പ്രധാനമായത്
ns3::ചാനൽ സബ്ക്ലാസ്സുകൾ കാരണം ഞങ്ങൾ നോഡ് i മുതൽ നോഡ് j ലേക്ക് ഒരു ഇവന്റ് സൃഷ്ടിക്കുന്നു, ഞങ്ങൾ
നോഡ് j-ൽ പ്രവർത്തിക്കുന്ന ഇവന്റിന് ശരിയായ സന്ദർഭമുണ്ടെന്ന് ഉറപ്പാക്കാൻ ആഗ്രഹിക്കുന്നു.

കാലം
ലേക്ക് be പൂർത്തിയായി

ഷെഡ്യൂളർ
ലേക്ക് be പൂർത്തിയായി

കോൾബാക്കുകൾ
ചില പുതിയ ഉപയോക്താക്കൾ ns-3 വ്യാപകമായി ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാമിംഗ് ഐഡിയം പരിചിതമല്ല
കോഡിലുടനീളം: the ns-3 തിരിച്ചു വിളിക്കുക. ഈ അധ്യായം ചില പ്രചോദനങ്ങൾ നൽകുന്നു
കോൾബാക്ക്, അത് എങ്ങനെ ഉപയോഗിക്കണം എന്നതിനെക്കുറിച്ചുള്ള മാർഗ്ഗനിർദ്ദേശം, അത് നടപ്പിലാക്കുന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ.

കോൾബാക്കുകൾ പ്രചോദനം
നിങ്ങൾക്ക് എ, ബി എന്നീ രണ്ട് സിമുലേഷൻ മോഡലുകൾ ഉണ്ടെന്നും അവ പാസാകാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്നും പരിഗണിക്കുക
സിമുലേഷൻ സമയത്ത് അവർ തമ്മിലുള്ള വിവരങ്ങൾ. നിങ്ങൾക്ക് അത് ചെയ്യാൻ കഴിയുന്ന ഒരു മാർഗം നിങ്ങളാണ്
A, B എന്നിവയെ പരസ്പരം വ്യക്തമായി മനസ്സിലാക്കാൻ കഴിയും, അതുവഴി അവർക്ക് അഭ്യർത്ഥിക്കാൻ കഴിയും
പരസ്പരം രീതികൾ:

ക്ലാസ് എ {
പൊതുവായത്:
റിസീവ്ഇൻപുട്ട് അസാധുവാണ് (// പരാമീറ്ററുകൾ);
...
}

(മറ്റൊരു സോഴ്സ് ഫയലിൽ :)

ക്ലാസ് ബി {
പൊതുവായത്:
അസാധുവായ DoSomething (ശൂന്യം);
...

സ്വകാര്യം:
A* a_instance; // ഒരു എയിലേക്കുള്ള പോയിന്റർ
}

ശൂന്യം
ബി::എന്തെങ്കിലും ചെയ്യുക()
{
// എന്തെങ്കിലും സംഭവിച്ചുവെന്ന് a_instance പറയുക
a_instance->ReceiveInput ( // parameters);
...
}

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

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

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

----------------------
| TCP | | TCP |
----------------------
| മാറുന്നു -> |
-------------------------
| IP | | IPsec |
-------------------------
|
----------
| IP |
----------

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

കോൾബാക്കുകൾ പശ്ചാത്തലം
ശ്രദ്ധിക്കുക:
പ്രോഗ്രാമിംഗ് കോൾബാക്കുകൾ പരിചയമുള്ള വായനക്കാർക്ക് ഈ ട്യൂട്ടോറിയൽ വിഭാഗം ഒഴിവാക്കാം.

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

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

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

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

ഇതിൽ നിന്ന് നിങ്ങൾക്ക് ലഭിക്കുന്നത് ലളിതമായി പേരിട്ടിരിക്കുന്ന ഒരു വേരിയബിളാണ് pfi അത് 0 എന്ന മൂല്യത്തിലേക്ക് ആരംഭിക്കുന്നു.
നിങ്ങൾക്ക് ഈ പോയിന്റർ അർത്ഥവത്തായ ഒന്നിലേക്ക് ആരംഭിക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ഉണ്ടായിരിക്കണം
പൊരുത്തപ്പെടുന്ന ഒപ്പോടുകൂടിയ പ്രവർത്തനം. ഈ സാഹചര്യത്തിൽ:

int MyFunction (int arg) {}

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

pfi = MyFunction;

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

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

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

int ഫലം = pfi (1234);

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

C++ ൽ നിങ്ങൾക്ക് ഒബ്‌ജക്‌റ്റുകളുടെ സങ്കീർണ്ണത കൂടുതലാണ്. മുകളിലുള്ള PFI യുമായുള്ള സാമ്യം അർത്ഥമാക്കുന്നത് നിങ്ങളെയാണ്
ഒരു അംഗ ഫംഗ്‌ഷനിലേക്ക് പോയിന്ററിന് പകരം ഒരു int (PMI) തിരികെ നൽകുന്ന ഒരു പോയിന്റർ ഉണ്ടായിരിക്കുക
ഒരു int (PFI) തിരികെ നൽകുന്ന പ്രവർത്തനം.

പരോക്ഷം നൽകുന്ന വേരിയബിളിന്റെ പ്രഖ്യാപനം അല്പം വ്യത്യസ്തമായി കാണപ്പെടുന്നു:

int (MyClass::*pmi) (int arg) = 0;

ഇത് പേരുള്ള ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു pmi മുമ്പത്തെ ഉദാഹരണം പേരുള്ള ഒരു വേരിയബിൾ പ്രഖ്യാപിച്ചു
pfi. ഒരു പ്രത്യേക ക്ലാസിന്റെ ഒരു ഉദാഹരണത്തിന്റെ രീതിയെ വിളിക്കേണ്ടത് ഇച്ഛാശക്തിയായതിനാൽ, ഒരാൾ നിർബന്ധമായും
ഒരു ക്ലാസ്സിൽ ആ രീതി പ്രഖ്യാപിക്കുക:

ക്ലാസ് മൈക്ലാസ് {
പൊതുവായത്:
int MyMethod (int arg);
};

ഈ ക്ലാസ് ഡിക്ലറേഷൻ നൽകിയാൽ, ഒരാൾ ആ വേരിയബിളിനെ ഇതുപോലെ ആരംഭിക്കും:

pmi = &MyClass::MyMethod;

ഇത് വേരിയബിളിലേക്ക് രീതി നടപ്പിലാക്കുന്ന കോഡിന്റെ വിലാസം നൽകുന്നു, പൂർത്തിയാക്കുന്നു
പരോക്ഷം. ഒരു രീതിയെ വിളിക്കുന്നതിന്, കോഡിന് ഒരു ആവശ്യമാണ് ഈ സൂചിക. ഇതാകട്ടെ,
സൂചിപ്പിക്കാൻ MyClass ന്റെ ഒരു ഒബ്ജക്റ്റ് ഉണ്ടായിരിക്കണം എന്നാണ് അർത്ഥമാക്കുന്നത്. ഇതിന് ഒരു ലളിതമായ ഉദാഹരണം ന്യായമാണ്
ഒരു രീതിയെ പരോക്ഷമായി വിളിക്കുന്നു (വെർച്വൽ ഫംഗ്‌ഷൻ ചിന്തിക്കുക):

int (MyClass::*pmi) (int arg) = 0; // ഒരു പിഎംഐ പ്രഖ്യാപിക്കുക
pmi = &MyClass::MyMethod; // നടപ്പാക്കൽ കോഡിലേക്ക് പോയിന്റ് ചെയ്യുക

MyClass myClass; // ക്ലാസ്സിന്റെ ഒരു ഉദാഹരണം വേണം
(myClass.*pmi) (1234); // ഒരു ഒബ്ജക്റ്റ് ptr ഉപയോഗിച്ച് രീതി വിളിക്കുക

സി ഉദാഹരണത്തിലെന്നപോലെ, നിങ്ങൾക്ക് ഇത് മറ്റൊരു മൊഡ്യൂളിലേക്കുള്ള അസിൻക്രണസ് കോളിൽ ഉപയോഗിക്കാം
അത് ചെയ്യും വിളി തിരികെ ഒരു രീതിയും ഒരു ഒബ്ജക്റ്റ് പോയിന്ററും ഉപയോഗിക്കുന്നു. നേരായ വിപുലീകരണം
ഒബ്‌ജക്‌റ്റിലേയ്‌ക്കും പിഎംഐ വേരിയബിളിലേക്കും ഒരു പോയിന്റർ കൈമാറുന്നത് പരിഗണിക്കാം. മൊഡ്യൂൾ
വെറുതെ ചെയ്യും:

(*objectPtr.*pmi) (1234);

ആവശ്യമുള്ള ഒബ്ജക്റ്റിൽ കോൾബാക്ക് എക്സിക്യൂട്ട് ചെയ്യാൻ.

ഈ സമയത്ത് ഒരാൾ ചോദിച്ചേക്കാം, എന്താണ് The ബിന്ദു? വിളിച്ച മൊഡ്യൂൾ മനസ്സിലാക്കേണ്ടതുണ്ട്
കോൾബാക്ക് ശരിയായി നടത്തുന്നതിന് കോളിംഗ് ഒബ്‌ജക്റ്റിന്റെ കോൺക്രീറ്റ് തരം. എന്തുകൊണ്ട്
ഇത് അംഗീകരിക്കുക, ശരിയായി ടൈപ്പ് ചെയ്‌ത ഒബ്‌ജക്‌റ്റ് പോയിന്റർ കടത്തിവിട്ട് ചെയ്യുക ഒബ്ജക്റ്റ്->രീതി(1234) in
കോൾബാക്കിന് പകരം കോഡ്? മുകളിൽ വിവരിച്ച പ്രശ്നം ഇതാണ്. എന്താണ്
കോൾ ചെയ്ത ക്ലാസിൽ നിന്ന് കോളിംഗ് ഫംഗ്‌ഷൻ പൂർണ്ണമായും ഡീകൂപ്പിൾ ചെയ്യാനുള്ള ഒരു മാർഗമാണ് ആവശ്യം. ഈ
ആവശ്യകത വികസനത്തിലേക്ക് നയിച്ചു ഫംക്റ്റർ.

1960-കളിൽ കണ്ടുപിടിച്ച ക്ലോഷർ എന്ന് വിളിക്കപ്പെടുന്ന ഒന്നിന്റെ വളർച്ചയാണ് ഫങ്‌റ്റർ. അത്
അടിസ്ഥാനപരമായി ഒരു പാക്കേജ്-അപ്പ് ഫംഗ്‌ഷൻ കോൾ, ഒരുപക്ഷേ ഏതെങ്കിലും സംസ്ഥാനത്തോടൊപ്പമായിരിക്കാം.

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

നിർദ്ദിഷ്ട ഫംഗ്‌ടറും അതിന്റെ ഓവർലോഡും ഉപയോഗിച്ച് ഓപ്പറേറ്റർ () സൃഷ്ടിച്ചു, അപ്പോൾ വിളിക്കപ്പെടുന്ന കോഡ്
കോൾബാക്ക് (കോളിംഗ്) നടപ്പിലാക്കുന്ന മൊഡ്യൂളിന് പ്രത്യേക കോഡ് നൽകുന്നു
കോഡ്).

കോളിംഗ് കോഡ് ഒരു ജനറിക് ഫംഗ്‌ടറിനെ ഒരു പാരാമീറ്ററായി എടുക്കും, അതിനാൽ ഒരു പരോക്ഷമായ കാസ്റ്റ് ചെയ്യപ്പെടും
ഫംഗ്‌ഷൻ കോളിൽ നിർദിഷ്ട ഫങ്‌ടറിനെ ഒരു ജനറിക് ഫങ്‌ടറാക്കി മാറ്റുക. ഇതിനർത്ഥം
കോളിംഗ് മൊഡ്യൂളിന് ജനറിക് ഫംഗ്‌റ്റർ തരം മനസ്സിലാക്കേണ്ടതുണ്ട്. ഇത് വേർപെടുത്തിയതാണ്
പൂർണ്ണമായും കോളിംഗ് കോഡിൽ നിന്ന്.

ഒരു നിർദ്ദിഷ്‌ട ഫങ്‌ടർ ഉണ്ടാക്കാൻ ഒരാൾക്ക് ആവശ്യമായ വിവരങ്ങൾ ഒബ്‌ജക്റ്റ് പോയിന്ററും ദിയുമാണ്
പോയിന്റർ-ടു-മെത്തേഡ് വിലാസം.

എന്താണ് സംഭവിക്കേണ്ടതെന്നതിന്റെ സാരാംശം, സിസ്റ്റം അതിന്റെ പൊതുവായ ഭാഗം പ്രഖ്യാപിക്കുന്നു എന്നതാണ്
ഘടകം:

ടെംപ്ലേറ്റ്
ക്ലാസ് ഫങ്‌റ്റർ
{
പൊതുവായത്:
virtual int operator() (T arg) = 0;
};

ഫംഗ്‌ടറിന്റെ ഒരു പ്രത്യേക ഭാഗം വിളിക്കുന്നയാൾ നിർവചിക്കുന്നു, അത് നടപ്പിലാക്കാൻ മാത്രമേയുള്ളൂ
നിർദ്ദിഷ്ട ഓപ്പറേറ്റർ() രീതി:

ടെംപ്ലേറ്റ്
ക്ലാസ് സ്‌പെസിഫിക് ഫങ്‌റ്റർ: പബ്ലിക് ഫങ്‌റ്റർ
{
പൊതുവായത്:
നിർദ്ദിഷ്ട പ്രവർത്തനം(T* p, int (T::*_pmi)(ARG arg))
{
m_p = p;
m_pmi = _pmi;
}

വെർച്വൽ ഇന്റ് ഓപ്പറേറ്റർ() (ARG arg)
{
(*m_p.*m_pmi)(arg);
}
സ്വകാര്യം:
int (T::*m_pmi)(ARG arg);
T* m_p;
};

ഉപയോഗത്തിന്റെ ഒരു ഉദാഹരണം ഇതാ:

ക്ലാസ് എ
{
പൊതുവായത്:
A (int a0) : a (a0) {}
int ഹലോ (int b0)
{
std::cout << "A-ൽ നിന്നുള്ള ഹലോ, a = " << a << " b0 = " << b0 << std::endl;
}
int a;
};

int main ()
{
A a(10);
സ്പെസിഫിക് ഫംക്റ്റർ sf(&a, &A::ഹലോ);
sf(5);
}

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

മുകളിലുള്ള ക്ലാസ്സിൽ രണ്ട് വേരിയബിളുകൾ നിർവചിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക. m_p വേരിയബിൾ ആണ്
ഒബ്‌ജക്റ്റ് പോയിന്ററും m_pmi എന്നത് ഫംഗ്‌ഷന്റെ വിലാസം അടങ്ങുന്ന വേരിയബിളാണ്
നടപ്പിലാക്കുക.

എപ്പോൾ എന്ന് ശ്രദ്ധിക്കുക ഓപ്പറേറ്റർ() എന്ന് വിളിക്കുന്നു, അത് അതോടൊപ്പം നൽകിയിരിക്കുന്ന രീതിയെ വിളിക്കുന്നു
C++ PMI വാക്യഘടന ഉപയോഗിക്കുന്ന ഒബ്‌ജക്റ്റ് പോയിന്റർ.

ഇത് ഉപയോഗിക്കുന്നതിന്, ഒരു ജനറിക് ഫങ്‌ടറിനെ a ആയി എടുക്കുന്ന ചില മോഡൽ കോഡ് പ്രഖ്യാപിക്കാം
പാരാമീറ്റർ:

അസാധുവായ ലൈബ്രറി ഫംഗ്ഷൻ (ഫങ്‌റ്റർ ഫംഗ്‌റ്റർ);

മോഡലുമായി സംസാരിക്കുന്ന കോഡ് ഒരു നിർദ്ദിഷ്ട ഫംഗ്‌റ്റർ നിർമ്മിച്ച് അത് കൈമാറും
ലൈബ്രറി പ്രവർത്തനം:

MyClass myClass;
സ്പെസിഫിക് ഫംക്റ്റർ ഫങ്ക്ടർ (&myclass, MyClass ::MyMethod);

എപ്പോൾ ലൈബ്രറി പ്രവർത്തനം ചെയ്തു, ഇത് ഉപയോഗിച്ച് കോൾബാക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നു ഓപ്പറേറ്റർ() ജനറിക് ന്
ഫംഗ്‌റ്റർ അത് പാസ്സാക്കി, ഈ പ്രത്യേക സാഹചര്യത്തിൽ, പൂർണ്ണസംഖ്യ ആർഗ്യുമെന്റ് നൽകുന്നു:

ശൂന്യം
ലൈബ്രറി പ്രവർത്തനം (ഫങ്‌റ്റർ ഫംഗ്‌റ്റർ)
{
// ലൈബ്രറി ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുക
ഫംക്റ്റർ(1234);
}

അത് ശ്രദ്ധിക്കുക ലൈബ്രറി പ്രവർത്തനം ക്ലയന്റിന്റെ പ്രത്യേക തരത്തിൽ നിന്ന് പൂർണ്ണമായും വേർപെടുത്തിയിരിക്കുന്നു.
ഫങ്‌റ്റർ പോളിമോർഫിസത്തിലൂടെയാണ് കണക്ഷൻ നിർമ്മിച്ചിരിക്കുന്നത്.

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

ഉപയോഗിക്കുന്നു The തിരിച്ചുവിളിക്കുക എപിഐ
കോൾബാക്ക് API വളരെ കുറവാണ്, രണ്ട് സേവനങ്ങൾ മാത്രം നൽകുന്നു:

1. കോൾബാക്ക് തരം ഡിക്ലറേഷൻ: തന്നിരിക്കുന്ന ഒപ്പ് ഉപയോഗിച്ച് ഒരു തരം കോൾബാക്ക് പ്രഖ്യാപിക്കുന്നതിനുള്ള ഒരു മാർഗം,
ഒപ്പം,

2. കോൾബാക്ക് തൽക്ഷണം: ടെംപ്ലേറ്റ് സൃഷ്ടിച്ച ഫോർവേഡിംഗ് കോൾബാക്ക് തൽക്ഷണം ചെയ്യാനുള്ള ഒരു മാർഗം
ഏത് കോളുകളും മറ്റൊരു C++ ക്ലാസ് അംഗ രീതിയിലേക്കോ C++ ഫംഗ്‌ഷനിലേക്കോ ഫോർവേഡ് ചെയ്യാം.

അടിസ്ഥാനമാക്കിയുള്ള ഒരു ഉദാഹരണത്തിലൂടെ നടക്കുന്നതിലൂടെ ഇത് നന്നായി നിരീക്ഷിക്കപ്പെടുന്നു സാമ്പിളുകൾ/main-callback.cc.

ഉപയോഗിക്കുന്നു The തിരിച്ചുവിളിക്കുക എപിഐ കൂടെ സ്റ്റാറ്റിക്ക് ഫംഗ്ഷനുകളും
ഒരു ഫംഗ്ഷൻ പരിഗണിക്കുക:

സ്റ്റാറ്റിക് ഡബിൾ
CbOne (ഡബിൾ എ, ഡബിൾ ബി)
{
std::cout << "cbOne a=" << a << ", b=" << b << std::endl;
തിരികെ എ;
}

ഇനിപ്പറയുന്ന പ്രധാന പ്രോഗ്രാം സ്‌നിപ്പറ്റും പരിഗണിക്കുക:

int main (int argc, char *argv[])
{
// റിട്ടേൺ തരം: ഇരട്ട
// ആദ്യ arg തരം: ഇരട്ട
// second arg തരം: ഇരട്ട
തിരിച്ചു വിളിക്കുക ഒന്ന്;
}

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

ശ്രദ്ധിക്കുക:
C++ ടെംപ്ലേറ്റുകൾ പരിചയമില്ലാത്ത വായനക്കാർക്ക് കൂടിയാലോചിക്കാം
http://www.cplusplus.com/doc/tutorial/templates/.

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

അതിനാൽ മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾക്ക് "ഒന്ന്" എന്ന പേരിൽ ഒരു കോൾബാക്ക് പ്രഖ്യാപിച്ചു, അത് ഒടുവിൽ സംഭവിക്കും
ഒരു ഫംഗ്ഷൻ പോയിന്റർ പിടിക്കുക. അത് കൈവശം വയ്ക്കുന്ന ഫംഗ്‌ഷന്റെ ഒപ്പ് തിരികെ നൽകണം
ഇരട്ട, രണ്ട് ഇരട്ട വാദങ്ങളെ പിന്തുണയ്ക്കണം. ഒരാൾ ഒരു ഫംഗ്‌ഷൻ പാസാക്കാൻ ശ്രമിക്കുകയാണെങ്കിൽ
പ്രഖ്യാപിത കോൾബാക്കുമായി ഒപ്പ് പൊരുത്തപ്പെടുന്നില്ല, ഒരു സമാഹാര പിശക് സംഭവിക്കും. കൂടാതെ, എങ്കിൽ
ഒരു കോൾബാക്കിലേക്ക് പൊരുത്തമില്ലാത്ത ഒന്ന് അസൈൻ ചെയ്യാൻ ശ്രമിക്കുന്നു, സമാഹാരം വിജയിക്കും എന്നാൽ a
റൺ-ടൈം NS_FATAL_ERROR ഉയർത്തും. സാമ്പിൾ പ്രോഗ്രാം
src/core/examples/main-callback.cc ഈ രണ്ട് പിശക് കേസുകളും അവസാനം കാണിക്കുന്നു
The പ്രധാന () പ്രോഗ്രാം.

ഇപ്പോൾ, നമുക്ക് ഈ കോൾബാക്ക് സംഭവവും യഥാർത്ഥ ടാർഗെറ്റ് ഫംഗ്‌ഷനും ഒരുമിച്ച് ബന്ധിപ്പിക്കേണ്ടതുണ്ട്
(CbOne). CbOne-ന് കോൾബാക്കിന്റെ അതേ ഫംഗ്ഷൻ സിഗ്നേച്ചർ തരങ്ങളുണ്ടെന്ന് മുകളിൽ ശ്രദ്ധിക്കുക--
ഇത് പ്രധാനപ്പെട്ടതാണ്. ഈ കോൾബാക്കിലേക്ക് ശരിയായി ടൈപ്പ് ചെയ്‌ത ഏത് ഫംഗ്‌ഷനും നമുക്ക് കൈമാറാനാകും.
നമുക്ക് ഇത് കൂടുതൽ വിശദമായി നോക്കാം:

സ്റ്റാറ്റിക് ഡബിൾ CbOne (ഡബിൾ എ, ഡബിൾ ബി) {}
^^^
| | |
| | |
തിരിച്ചു വിളിക്കുക ഒന്ന്;

പൊരുത്തപ്പെടുന്ന ഒപ്പ് ഉണ്ടെങ്കിൽ മാത്രമേ നിങ്ങൾക്ക് ഒരു കോൾബാക്കിലേക്ക് ഒരു ഫംഗ്‌ഷൻ ബന്ധിപ്പിക്കാൻ കഴിയൂ. ആദ്യത്തേത്
ടെംപ്ലേറ്റ് ആർഗ്യുമെന്റ് റിട്ടേൺ തരമാണ്, കൂടാതെ അധിക ടെംപ്ലേറ്റ് ആർഗ്യുമെന്റുകൾ തരങ്ങളാണ്
ഫംഗ്ഷൻ സിഗ്നേച്ചറിന്റെ ആർഗ്യുമെന്റുകളുടെ.

ഇപ്പോൾ, നമ്മുടെ കോൾബാക്ക് "ഒന്ന്" അതിന്റെ ഒപ്പുമായി പൊരുത്തപ്പെടുന്ന ഫംഗ്‌ഷനിലേക്ക് ബന്ധിപ്പിക്കാം:

// cbOne ഫംഗ്‌ഷനെ ചൂണ്ടിക്കാണിക്കുന്ന കോൾബാക്ക് ഉദാഹരണം നിർമ്മിക്കുക
ഒന്ന് = MakeCallback (&CbOne);

ഈ കോൾ തിരികെ വിളിക്കുക സാരാംശത്തിൽ, പ്രത്യേക ഫംഗ്ഷനുകളിലൊന്ന് സൃഷ്ടിക്കുന്നു
മുകളിൽ സൂചിപ്പിച്ച. ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച വേരിയബിൾ തിരിച്ചുവിളിക്കുക ടെംപ്ലേറ്റ് ഫംഗ്‌ഷൻ പോകുന്നു
ജനറിക് ഫംഗ്‌ടറിന്റെ പങ്ക് വഹിക്കുക. നിയമനം ഒന്ന് = തിരികെ വിളിക്കുക (&CbOne) is
വിളിക്കുന്നയാൾക്ക് അറിയാവുന്ന സ്പെഷ്യലൈസ്ഡ് ഫംഗ്‌ടറിനെ ഒരു ജനറിക് ഫങ്‌ടറാക്കി മാറ്റുന്ന കാസ്റ്റ്
വിളിക്കുന്നയാൾക്ക് അറിയാം.

പിന്നീട്, പ്രോഗ്രാമിൽ, കോൾബാക്ക് ആവശ്യമെങ്കിൽ, അത് ഇനിപ്പറയുന്ന രീതിയിൽ ഉപയോഗിക്കാം:

NS_ASSERT (! one.IsNull ());

// കോൾബാക്ക് ഉദാഹരണത്തിലൂടെ cbOne ഫംഗ്‌ഷൻ അഭ്യർത്ഥിക്കുക
ഇരട്ട retOne;
retOne = ഒന്ന് (10.0, 20.0);

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

ഉപയോഗിക്കുന്നു The തിരിച്ചുവിളിക്കുക എപിഐ കൂടെ അംഗം ഫംഗ്ഷനുകളും
സാധാരണയായി, നിങ്ങൾ സ്റ്റാറ്റിക് ഫംഗ്‌ഷനുകളല്ല, പകരം പൊതു അംഗങ്ങളുടെ ഫംഗ്‌ഷനുകളെയാണ് വിളിക്കുന്നത്
ഒരു വസ്തു. ഈ സാഹചര്യത്തിൽ, MakeCallback ഫംഗ്‌ഷനിലേക്ക് ഒരു അധിക ആർഗ്യുമെന്റ് ആവശ്യമാണ്
ഏത് ഒബ്‌ജക്റ്റിലാണ് ഫംഗ്‌ഷൻ അഭ്യർത്ഥിക്കേണ്ടതെന്ന് സിസ്റ്റത്തോട് പറയുക. ഈ ഉദാഹരണം പരിഗണിക്കുക,
main-callback.cc-ൽ നിന്നും:

ക്ലാസ് MyCb {
പൊതുവായത്:
int CbTwo (ഇരട്ട a) {
std::cout << "cbTwo a=" << a << std::endl;
മടക്കം -5;
}
};

int മെയിൻ ()
{
...
// റിട്ടേൺ തരം: int
// ആദ്യ arg തരം: ഇരട്ട
തിരിച്ചു വിളിക്കുക രണ്ട്;
MyCb cb;
// MyCb ::cbTwo ലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന കോൾബാക്ക് ഉദാഹരണം നിർമ്മിക്കുക
രണ്ട് = MakeCallback (&MyCb::CbTwo, &cb);
...
}

ഇവിടെ, ഞങ്ങൾ ഒരു അധിക ഒബ്ജക്റ്റ് പോയിന്റർ കൈമാറുന്നു വിളിക്കുക<> പ്രവർത്തനം. നിന്ന് തിരിച്ചുവിളിക്കുക
അതിനു മുകളിലുള്ള പശ്ചാത്തല വിഭാഗം ഓപ്പറേറ്റർ() അംഗ വാക്യഘടനയിലേക്ക് പോയിന്റർ ഉപയോഗിക്കുമ്പോൾ അത് ഉപയോഗിക്കും
ഒരു വസ്തുവിൽ നടപ്പിലാക്കുന്നു:

വെർച്വൽ ഇന്റ് ഓപ്പറേറ്റർ() (ARG arg)
{
(*m_p.*m_pmi)(arg);
}

അതിനാൽ ഞങ്ങൾക്ക് രണ്ട് വേരിയബിളുകൾ നൽകേണ്ടതുണ്ട് (m_p ഒപ്പം m_pmi) ഞങ്ങൾ നിർദ്ദിഷ്ടമാക്കിയപ്പോൾ
ഫംക്റ്റർ. വര:

രണ്ട് = MakeCallback (&MyCb::CbTwo, &cb);

അത് കൃത്യമായി ചെയ്യുന്നു. ഈ സാഹചര്യത്തിൽ, എപ്പോൾ രണ്ട് () അഭ്യർത്ഥിക്കുന്നു:

int ഫലം = രണ്ട് (1.0);

ഒരു കോളിന് കാരണമാകും CbTwo ചൂണ്ടിക്കാണിച്ച ഒബ്‌ജക്‌റ്റിലെ അംഗ പ്രവർത്തനം (രീതി).
&cb.

കെട്ടിടം ശൂന്യം കോൾബാക്കുകൾ
കോൾബാക്കുകൾ അസാധുവാകാൻ സാധ്യതയുണ്ട്; അതിനാൽ അവ ഉപയോഗിക്കുന്നതിന് മുമ്പ് പരിശോധിക്കുന്നത് ബുദ്ധിയായിരിക്കാം.
ഒരു നൾ കോൾബാക്കിനായി ഒരു പ്രത്യേക നിർമ്മാണമുണ്ട്, അത് ലളിതമായി കടന്നുപോകുന്നതിനേക്കാൾ നല്ലതാണ്
"0" ഒരു വാദമായി; അത് MakeNullCallback<> നിർമ്മിക്കുക:

രണ്ട് = MakeNullCallback ();
NS_ASSERT (രണ്ട്.IsNull ());

ഒരു നൾ കോൾബാക്ക് അഭ്യർത്ഥിക്കുന്നത് ഒരു നൾ ഫംഗ്ഷൻ പോയിന്റർ അഭ്യർത്ഥിക്കുന്നതുപോലെയാണ്: ഇത് ക്രാഷ് ചെയ്യും
റൺടൈം.

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

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

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

സ്റ്റാറ്റിക് ശൂന്യമായ DefaultSink (Ptr ഫയൽ, Ptr പി);

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

m_promiscSnifferTrace (m_currentPkt);

നമ്മൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്നത് ബന്ധിക്കുക The Ptr ഫയല് നിർദ്ദിഷ്ട കോൾബാക്കിലേക്ക്
അത് സൃഷ്ടിക്കുമ്പോൾ നടപ്പിലാക്കുകയും ക്രമീകരിക്കുകയും ചെയ്യുന്നു ഓപ്പറേറ്റർ() എന്നതിലേക്കുള്ള കോൾബാക്ക്
ആ പാരാമീറ്റർ സൗജന്യമായി നൽകുക.

ഞങ്ങൾ നൽകുന്നു MakeBoundCallback അതിനായി ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ. അതുതന്നെ എടുക്കുന്നു
എന്ന നിലയിൽ പരാമീറ്ററുകൾ തിരികെ വിളിക്കുക ടെംപ്ലേറ്റ് ഫംഗ്‌ഷൻ മാത്രമല്ല പാരാമീറ്ററുകളും എടുക്കുന്നു
ബന്ധിക്കപ്പെട്ടിരിക്കുന്നു. മുകളിലുള്ള ഉദാഹരണത്തിന്റെ കാര്യത്തിൽ:

MakeBoundCallback (&DefaultSink, ഫയൽ);

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

ടെംപ്ലേറ്റ്
ക്ലാസ് സ്‌പെസിഫിക് ഫങ്‌റ്റർ: പബ്ലിക് ഫങ്‌റ്റർ
{
പൊതുവായത്:
നിർദ്ദിഷ്ട പ്രവർത്തനം(T* p, int (T::*_pmi)(ARG arg), BOUND_ARG boundArg)
{
m_p = p;
m_pmi = pmi;
m_boundArg = boundArg;
}

വെർച്വൽ ഇന്റ് ഓപ്പറേറ്റർ() (ARG arg)
{
(*m_p.*m_pmi)(m_boundArg, arg);
}
സ്വകാര്യം:
ശൂന്യമായ (T::*m_pmi)(ARG arg);
T* m_p;
BOUND_ARG m_boundArg;
};

നിർദ്ദിഷ്ട ഫങ്‌റ്റർ സൃഷ്‌ടിക്കുമ്പോൾ, ബൗണ്ട് ആർഗ്യുമെന്റ് ഇതിൽ സേവ് ചെയ്യപ്പെടുന്നത് നിങ്ങൾക്ക് കാണാൻ കഴിയും
ഫംഗ്‌റ്റർ / കോൾബാക്ക് ഒബ്‌ജക്റ്റ് തന്നെ. എപ്പോൾ ഓപ്പറേറ്റർ() സിംഗിൾ ഉപയോഗിച്ച് വിളിക്കപ്പെടുന്നു
പരാമീറ്റർ, ഇതുപോലെ:

m_promiscSnifferTrace (m_currentPkt);

നടപ്പാക്കൽ ഓപ്പറേറ്റർ() യഥാർത്ഥ ഫംഗ്‌ഷൻ കോളിലേക്ക് ബൗണ്ട് പാരാമീറ്റർ ചേർക്കുന്നു:

(*m_p.*m_pmi)(m_boundArg, arg);

രണ്ടോ മൂന്നോ വാദങ്ങൾ കെട്ടാനും സാധ്യതയുണ്ട്. ഞങ്ങൾക്ക് ഒരു ഫംഗ്‌ഷൻ ഉണ്ടെന്ന് പറയുക
കയ്യൊപ്പ്:

സ്റ്റാറ്റിക് ശൂന്യമായ NotifyEvent (Ptr a, Ptr b, MyEventType e);

ഒരാൾക്ക് ബൗണ്ട് കോൾബാക്ക് ബൈൻഡിംഗ് ആദ്യ രണ്ട് ആർഗ്യുമെന്റുകൾ സൃഷ്ടിക്കാൻ കഴിയും:

MakeBoundCallback (&NotifyEvent, a1, b1);

അനുമാനിക്കുന്നു a1 ഒപ്പം b1 തരം വസ്തുക്കളാണ് A ഒപ്പം B യഥാക്രമം. അതുപോലെ മൂന്നിനും
ആർഗ്യുമെന്റുകൾ ഒരാൾക്ക് ഒരു ഒപ്പ് ഉപയോഗിച്ച് പ്രവർത്തിക്കും:

സ്റ്റാറ്റിക് ശൂന്യമായ NotifyEvent (Ptr a, Ptr b, MyEventType e);

മൂന്ന് ആർഗ്യുമെന്റുകൾ ബൈൻഡ് ചെയ്യുന്നത് ഇതുപയോഗിച്ച് ചെയ്തു:

MakeBoundCallback (&NotifyEvent, a1, b1, c1);

വീണ്ടും അനുമാനിക്കുന്നു a1, b1 ഒപ്പം c1 തരം വസ്തുക്കളാണ് A, B ഒപ്പം C യഥാക്രമം.

സിമുലേഷനിൽ ഒബ്‌ജക്റ്റുകൾക്കിടയിൽ വിവരങ്ങൾ കൈമാറുന്നതിന് ഇത്തരത്തിലുള്ള ബൈൻഡിംഗ് ഉപയോഗിക്കാം;
പ്രത്യേകമായി, ബൗണ്ട് കോൾബാക്കുകൾ ട്രെയ്‌സ്ഡ് കോൾബാക്കുകളായി ഉപയോഗിക്കാം, അതിൽ വിവരിക്കും
അടുത്ത വിഭാഗം.

കണ്ടെത്തി കോൾബാക്കുകൾ
പ്ലെയ്സ്ഹോൾഡർ ഉപവിഭാഗം

തിരിച്ചുവിളിക്കുക ലൊക്കേഷനുകൾ in ns-3
എവിടെയാണ് കോൾബാക്കുകൾ പതിവായി ഉപയോഗിക്കുന്നത് ns-3? കൂടുതൽ ദൃശ്യമായവയിൽ ചിലത് ഇതാ
സാധാരണ ഉപയോക്താക്കൾ:

· സോക്കറ്റ് API

· ലെയർ-2/ലെയർ-3 എപിഐ

· ട്രേസിംഗ് സബ്സിസ്റ്റം

· IP, റൂട്ടിംഗ് സബ്സിസ്റ്റങ്ങൾ തമ്മിലുള്ള API

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

വിവരിച്ച സാങ്കേതികതകളെ അടിസ്ഥാനമാക്കിയാണ് കോഡ് ആദ്യം എഴുതിയത്
http://www.codeproject.com/cpp/TTLFunction.asp. പിന്നീട് അത് പിന്തുടരാനായി മാറ്റിയെഴുതി
വാസ്തുവിദ്യയിൽ വിവരിച്ചിരിക്കുന്നു ആധുനികമായ സി ++ രൂപകൽപ്പന, സാമാന്യ പ്രോഗ്രാമിംഗ് ഒപ്പം ഡിസൈൻ പാറ്റേണുകൾ
പ്രയോഗിച്ചു, അലക്സാണ്ടർസ്കു, അധ്യായം 5, സാമാന്യവൽക്കരിച്ചു പ്രവർത്തനങ്ങൾ.

ഈ കോഡ് ഉപയോഗിക്കുന്നത്:

· സ്ഥിരസ്ഥിതി ടെംപ്ലേറ്റ് പാരാമീറ്ററുകൾ എപ്പോൾ ശൂന്യമായ പാരാമീറ്ററുകൾ വ്യക്തമാക്കുന്നതിൽ നിന്ന് ഉപയോക്താക്കളെ രക്ഷിക്കുന്നു
പരാമീറ്ററുകളുടെ എണ്ണം പരമാവധി പിന്തുണയ്ക്കുന്ന സംഖ്യയേക്കാൾ ചെറുതാണ്

· പിംപ്ൾ ഐഡിയം: കോൾബാക്ക് ക്ലാസ് മൂല്യമനുസരിച്ച് കടന്നുപോകുകയും അതിന്റെ പ്രധാനം നിയോഗിക്കുകയും ചെയ്യുന്നു
ജോലി അതിന്റെ പിംപ്ൽ പോയിന്ററിലേക്ക്.

CallbackImpl FunctorCallbackImpl-ൽ നിന്ന് ഉരുത്തിരിഞ്ഞ രണ്ട് pimpl നടപ്പിലാക്കലുകൾ ഉപയോഗിക്കാം
അംഗങ്ങൾക്കുള്ള പോയിന്ററുകൾക്കൊപ്പം MemPtrCallbackImpl ഉപയോഗിക്കാനാകുമ്പോൾ ഏതെങ്കിലും ഫംഗ്‌ടർ-തരം
പ്രവർത്തനങ്ങൾ.

· കോൾബാക്കിന്റെ മൂല്യം സെമാന്റിക്സ് നടപ്പിലാക്കുന്നതിനുള്ള ഒരു റഫറൻസ് ലിസ്റ്റ് നടപ്പിലാക്കൽ.

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

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

ഈ വിഭാഗം C++ ക്ലാസ് ഡിസൈൻ വിവരിക്കുന്നു ns-3 വസ്തുക്കൾ. ചുരുക്കത്തിൽ, നിരവധി ഡിസൈൻ
ഉപയോഗത്തിലുള്ള പാറ്റേണുകളിൽ ക്ലാസിക് ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ഡിസൈൻ ഉൾപ്പെടുന്നു (പോളിമോർഫിക് ഇന്റർഫേസുകളും
നടപ്പാക്കലുകൾ), ഇന്റർഫേസിന്റെ വേർതിരിവും നടപ്പിലാക്കലും, നോൺ-വെർച്വൽ പബ്ലിക്
ഇന്റർഫേസ് ഡിസൈൻ പാറ്റേൺ, ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ സൗകര്യം, റഫറൻസ് കൗണ്ടിംഗ്
മെമ്മറി മാനേജ്മെന്റ്. COM അല്ലെങ്കിൽ Bonobo പോലുള്ള ഘടക മോഡലുകളുമായി പരിചയമുള്ളവർ
ഡിസൈനിലെ ഘടകങ്ങൾ തിരിച്ചറിയുക ns-3 ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ മോഡൽ, എന്നിരുന്നാലും ns-3
ഡിസൈൻ കർശനമായി രണ്ടിനും അനുസൃതമല്ല.

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

ക്ലാസ് വിലാസം
{
പൊതുവായത്:
വിലാസം ();
വിലാസം (uint8_t തരം, const uint8_t *buffer, uint8_t len);
വിലാസം (വിലാസവും വിലാസവും);
വിലാസം & ഓപ്പറേറ്റർ = (const വിലാസം & വിലാസം);
...
സ്വകാര്യം:
uint8_t m_type;
uint8_t m_len;
...
};

വസ്തു അടിസ്ഥാനം ക്ലാസുകൾ
മൂന്ന് പ്രത്യേക അടിസ്ഥാന ക്ലാസുകൾ ഉപയോഗിക്കുന്നു ns-3. ഈ അടിത്തറയിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ക്ലാസുകൾ
ക്ലാസുകൾക്ക് പ്രത്യേക ഗുണങ്ങളുള്ള വസ്തുക്കളെ തൽക്ഷണം ചെയ്യാൻ കഴിയും. ഈ അടിസ്ഥാന ക്ലാസുകൾ ഇവയാണ്:

· ക്ലാസ് വസ്തു

· ക്ലാസ് ഒബ്ജക്റ്റ്ബേസ്

· ക്ലാസ് SimpleRefCount

അത് ആവശ്യമില്ല ns-3 ഈ വർഗ്ഗത്തിൽ നിന്നുള്ള വസ്തുക്കൾ പാരമ്പര്യമായി ലഭിക്കുന്നു, എന്നാൽ ലഭിക്കുന്നവ
പ്രത്യേക പ്രോപ്പർട്ടികൾ. ക്ലാസിൽ നിന്ന് ലഭിക്കുന്ന ക്ലാസുകൾ വസ്തു ഇനിപ്പറയുന്ന പ്രോപ്പർട്ടികൾ നേടുക.

· ദി ns-3 ടൈപ്പും ആട്രിബ്യൂട്ടും സിസ്റ്റം (ആട്രിബ്യൂട്ടുകൾ കാണുക)

· ഒരു ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ സിസ്റ്റം

ഒരു സ്മാർട്ട് പോയിന്റർ റഫറൻസ് കൗണ്ടിംഗ് സിസ്റ്റം (ക്ലാസ് പിടിആർ)

ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ക്ലാസുകൾ ഒബ്ജക്റ്റ്ബേസ് മുകളിലുള്ള ആദ്യത്തെ രണ്ട് ഗുണങ്ങൾ നേടുക, പക്ഷേ ചെയ്യരുത്
സ്മാർട്ട് പോയിന്ററുകൾ നേടുക. ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ക്ലാസുകൾ SimpleRefCount: മാത്രം നേടുക
സ്മാർട്ട് പോയിന്റർ റഫറൻസ് കൗണ്ടിംഗ് സിസ്റ്റം.

പ്രായോഗികമായി, ക്ലാസ് വസ്തു അതിനു മുകളിലുള്ള മൂന്നിന്റെ വകഭേദമാണ് ns-3 ഡെവലപ്പർ ചെയ്യും
ഏറ്റവും സാധാരണയായി കണ്ടുമുട്ടുന്നത്.

മെമ്മറി മാനേജ്മെന്റ് ഒപ്പം ക്ലാസ് Ptr
ഒരു C++ പ്രോഗ്രാമിലെ മെമ്മറി മാനേജ്മെന്റ് ഒരു സങ്കീർണ്ണമായ പ്രക്രിയയാണ്, അത് പലപ്പോഴും തെറ്റായി അല്ലെങ്കിൽ ചെയ്യപ്പെടുന്നു
അസ്ഥിരമായി. ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിച്ചിരിക്കുന്ന ഒരു റഫറൻസ് കൗണ്ടിംഗ് ഡിസൈനിൽ ഞങ്ങൾ സ്ഥിരതാമസമാക്കിയിട്ടുണ്ട്.

റഫറൻസ് കൗണ്ടിംഗ് ഉപയോഗിക്കുന്ന എല്ലാ വസ്തുക്കളും നിർണ്ണയിക്കാൻ ഒരു ആന്തരിക റഫറൻസ് എണ്ണം നിലനിർത്തുന്നു
ഒരു വസ്തുവിന് സ്വയം സുരക്ഷിതമായി ഇല്ലാതാക്കാൻ കഴിയുമ്പോൾ. ഓരോ തവണയും ഒരു പോയിന്റർ ലഭിക്കുന്നു
ഇന്റർഫേസ്, കോളിംഗ് വഴി ഒബ്‌ജക്റ്റിന്റെ റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കുന്നു റഫർ(). അത്
പോയിന്ററിന്റെ ഉപയോക്താവിന്റെ ബാധ്യത വ്യക്തമായി Unref() പൂർത്തിയാകുമ്പോൾ പോയിന്റർ. എപ്പോൾ
റഫറൻസ് എണ്ണം പൂജ്യത്തിലേക്ക് വീണു, ഒബ്ജക്റ്റ് ഇല്ലാതാക്കി.

· ക്ലയന്റ് കോഡ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിയിലൂടെ ഒബ്‌ജക്റ്റിൽ നിന്ന് തന്നെ ഒരു പോയിന്റർ നേടുമ്പോൾ,
അല്ലെങ്കിൽ GetObject വഴി, ഇതിന് റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കേണ്ടതില്ല.

· ക്ലയന്റ് കോഡിന് മറ്റൊരു ഉറവിടത്തിൽ നിന്ന് ഒരു പോയിന്റർ ലഭിക്കുമ്പോൾ (ഉദാ, ഒരു പോയിന്റർ പകർത്തൽ) അത് ആവശ്യമാണ്
വിളി റഫർ() റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കുന്നതിന്.

· ഒബ്ജക്റ്റ് പോയിന്ററിന്റെ എല്ലാ ഉപയോക്താക്കളും വിളിക്കേണ്ടതാണ് Unref() റഫറൻസ് റിലീസ് ചെയ്യാൻ.

വിളിക്കാനുള്ള ഭാരം Unref() റഫറൻസ് കൗണ്ടിംഗ് ഉപയോഗിക്കുന്നതിലൂടെ ഒരു പരിധിവരെ ആശ്വാസം ലഭിക്കും
താഴെ വിവരിച്ചിരിക്കുന്ന സ്മാർട്ട് പോയിന്റർ ക്ലാസ്.

റഫറൻസ്-കൌണ്ട് ചെയ്യാത്ത ഒബ്‌ജക്റ്റുകൾ വ്യക്തമായി വിനിയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു ലോ-ലെവൽ API ഉപയോഗിക്കുന്ന ഉപയോക്താക്കൾ
ഹീപ്പിൽ, പുതിയ ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നത്, അത്തരം ഒബ്‌ജക്റ്റുകൾ ഇല്ലാതാക്കുന്നതിന് ഉത്തരവാദികളാണ്.

അവലംബം കണക്കാക്കുന്നു സ്മാർട്ട് പോയിന്റർ (പിടിആർ)
വിളിക്കുന്നു റഫർ() ഒപ്പം Unref() എല്ലാ സമയവും ബുദ്ധിമുട്ടായിരിക്കും, അതിനാൽ ns-3 ഒരു സ്മാർട്ട് നൽകുന്നു
പോയിന്റർ ക്ലാസ് Ptr ഇതുപോലെയാണ് Boost::intrusive_ptr. ഈ സ്മാർട്ട് പോയിന്റർ ക്ലാസ് അത് അനുമാനിക്കുന്നു
അടിസ്ഥാന തരം ഒരു ജോടി നൽകുന്നു Ref ഒപ്പം Unref പ്രതീക്ഷിക്കുന്ന രീതികൾ
ഒബ്ജക്റ്റ് സംഭവത്തിന്റെ ആന്തരിക റീകൌണ്ട് വർദ്ധിപ്പിക്കുകയും കുറയ്ക്കുകയും ചെയ്യുക.

സ്മാർട്ട് പോയിന്റർ സാധാരണ പോലെ കൈകാര്യം ചെയ്യാൻ ഈ നടപ്പിലാക്കൽ നിങ്ങളെ അനുവദിക്കുന്നു
പോയിന്റർ: നിങ്ങൾക്ക് ഇത് പൂജ്യവുമായി താരതമ്യം ചെയ്യാം, മറ്റ് പോയിന്ററുകളുമായി താരതമ്യം ചെയ്യാം, പൂജ്യം നൽകാം
അത് മുതലായവ.

ഈ സ്മാർട്ട് പോയിന്ററിൽ നിന്ന് റോ പോയിന്റർ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യാൻ കഴിയും GetPointer()
ഒപ്പം PeekPointer() രീതികൾ.

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

ക്രിയേറ്റ് ഒബ്ജക്റ്റ് ഒപ്പം സൃഷ്ടിക്കാൻ
C++ ലെ ഒബ്‌ജക്‌റ്റുകൾ സ്ഥിരമായി, ചലനാത്മകമായി അല്ലെങ്കിൽ സ്വയമേവ സൃഷ്‌ടിച്ചതാകാം. ഇത് സത്യമാണ്
വേണ്ടി ns-3 കൂടാതെ, സിസ്റ്റത്തിലെ ചില ഒബ്ജക്റ്റുകൾക്ക് ചില അധിക ചട്ടക്കൂടുകൾ ലഭ്യമാണ്.
പ്രത്യേകമായി, റഫറൻസ് എണ്ണപ്പെട്ട ഒബ്‌ജക്‌റ്റുകൾ സാധാരണയായി ഒരു ടെംപ്ലേറ്റ് ചെയ്‌ത സൃഷ്‌ടിക്കുക അല്ലെങ്കിൽ
CreateObject രീതി, ഇനിപ്പറയുന്നത് പോലെ.

ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ വസ്തുക്കൾക്ക് വസ്തു:

Ptr ഉപകരണം = CreateObject ();

ദയവായി ഇത്തരം വസ്തുക്കൾ ഉപയോഗിച്ച് നിർമ്മിക്കരുത് ഓപ്പറേറ്റർ പുതിയ; ഉപയോഗിച്ച് അവ സൃഷ്ടിക്കുക CreateObject()
പകരം.

ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ വസ്തുക്കൾക്ക് SimpleRefCount, അല്ലെങ്കിൽ ഉപയോഗത്തെ പിന്തുണയ്ക്കുന്ന മറ്റ് വസ്തുക്കൾ
സ്മാർട്ട് പോയിന്റർ ക്ലാസ്, ഒരു ടെംപ്ലേറ്റഡ് ഹെൽപ്പർ ഫംഗ്ഷൻ ലഭ്യമാണ്, ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു:

Ptr b = സൃഷ്ടിക്കുക ();

റഫറൻസ് കൗണ്ടിംഗ് ശരിയായി കൈകാര്യം ചെയ്യുന്ന പുതിയ ഓപ്പറേറ്ററെ ചുറ്റിപ്പറ്റിയുള്ള ഒരു റാപ്പർ മാത്രമാണിത്
സിസ്റ്റം.

ചുരുക്കത്തിൽ, ഉപയോഗിക്കുക സൃഷ്ടിക്കാൻ ബി ഒരു ഒബ്ജക്റ്റ് അല്ലെങ്കിലും റഫറൻസ് കൗണ്ടിംഗ് ഉപയോഗിക്കുന്നുവെങ്കിൽ (ഉദാ
പാക്കറ്റ്), ഉപയോഗവും ക്രിയേറ്റ് ഒബ്ജക്റ്റ് ബിയിൽ നിന്ന് ഉരുത്തിരിഞ്ഞാൽ ns3::ഒബ്ജക്റ്റ്.

സംഗ്രഹം
ദി ns-3 a
സാധാരണ ഉപയോഗ കേസ് ns-2 വിപുലീകരിക്കാൻ പാരമ്പര്യത്തിന്റെയും ബഹുരൂപത്തിന്റെയും ഉപയോഗമാണ്
പ്രോട്ടോക്കോൾ മോഡലുകൾ. ഉദാഹരണത്തിന്, RenoTcpAgent പോലുള്ള TCP-യുടെ പ്രത്യേക പതിപ്പുകൾ ഉരുത്തിരിഞ്ഞതാണ്
TcpAgent ക്ലാസിൽ നിന്ന് (ഒപ്പം ഫംഗ്‌ഷനുകൾ അസാധുവാക്കുക)

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

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

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

സ്റ്റാറ്റിക് അസാധുവാണ്
AddIpv4Stack(Ptr നോഡ്)
{
Ptr ipv4 = CreateObject ();
ipv4->SetNode (നോഡ്);
നോഡ്->അഗ്രഗേറ്റ് ഒബ്ജക്റ്റ് (ipv4);
Ptr ipv4Impl = CreateObject ();
ipv4Impl->SetIpv4 (ipv4);
node->AggregateObject (ipv4Impl);
}

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

ഒരേ തരത്തിലുള്ള ഒന്നിലധികം ഒബ്‌ജക്‌റ്റുകൾ സമാഹരിക്കുന്നത് പ്രോഗ്രാമിംഗ് പിശകാണെന്ന് ശ്രദ്ധിക്കുക
an ns3::ഒബ്ജക്റ്റ്. അതിനാൽ, ഉദാഹരണത്തിന്, അഗ്രഗേഷൻ എല്ലാം സംഭരിക്കുന്നതിനുള്ള ഒരു ഓപ്ഷനല്ല
ഒരു നോഡിന്റെ സജീവ സോക്കറ്റുകൾ.

GetObject ഉദാഹരണം
സുരക്ഷിതമായ ഡൗൺകാസ്റ്റിംഗ് നേടുന്നതിനും ഇന്റർഫേസ് അനുവദിക്കുന്നതിനുമുള്ള ടൈപ്പ്-സേഫ് മാർഗമാണ് GetObject
ഒരു വസ്തുവിൽ കണ്ടെത്തി.

ഒരു നോഡ് പോയിന്റർ പരിഗണിക്കുക m_node ഇത് നടപ്പിലാക്കുന്ന ഒരു നോഡ് ഒബ്‌ജക്റ്റിലേക്ക് വിരൽ ചൂണ്ടുന്നു
IPv4 മുമ്പ് ഇതിലേക്ക് സമാഹരിച്ചിരിക്കുന്നു. ക്ലയന്റ് കോഡ് ഒരു ഡിഫോൾട്ട് റൂട്ട് കോൺഫിഗർ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു. ലേക്ക്
അങ്ങനെ ചെയ്യുകയാണെങ്കിൽ, IP ഫോർവേഡിംഗിന് ഒരു ഇന്റർഫേസ് ഉള്ള നോഡിനുള്ളിൽ ഒരു ഒബ്ജക്റ്റ് ആക്സസ് ചെയ്യണം
കോൺഫിഗറേഷൻ. ഇത് ഇനിപ്പറയുന്നവ നിർവഹിക്കുന്നു:

Ptr ipv4 = m_node->GetObject ();

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

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

ഈ പ്രോഗ്രാമിംഗ് മോഡ് പരിഷ്‌ക്കരിക്കുന്നതിന് ഡവലപ്പർമാരുടെ ആവശ്യം വളരെ കുറവായിരിക്കുമെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു
അടിസ്ഥാന ക്ലാസുകൾ.

വസ്തു ഫാക്ടറികൾ
സമാനമായി ക്രമീകരിച്ച ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കുക എന്നതാണ് ഒരു സാധാരണ ഉപയോഗ കേസ്. ഒരാൾക്ക് ആവർത്തിച്ച് കഴിയും
വിളി CreateObject() എന്നാൽ ഒരു ഫാക്ടറി ഡിസൈൻ പാറ്റേണും ഉപയോഗത്തിലുണ്ട് ns-3 സിസ്റ്റം.
ഇത് "ഹെൽപ്പർ" API-യിൽ വളരെയധികം ഉപയോഗിക്കുന്നു.

ക്ലാസ് ഒബ്ജക്റ്റ് ഫാക്ടറി ഒബ്‌ജക്‌റ്റുകൾ തൽക്ഷണം ചെയ്യുന്നതിനും ആട്രിബ്യൂട്ടുകൾ കോൺഫിഗർ ചെയ്യുന്നതിനും ഉപയോഗിക്കാം
ആ വസ്തുക്കൾ:

അസാധുവായ SetTypeId (TypeId tid);
അസാധുവായ സെറ്റ് (std::string name, const ആട്രിബ്യൂട്ട് മൂല്യം &മൂല്യം);
Ptr സൃഷ്ടിക്കുക (അസാധു) കോൺസ്റ്റ്;

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

ഉദാഹരണത്തിന്:

ഒബ്ജക്റ്റ് ഫാക്ടറി ഫാക്ടറി;
// ഈ ഫാക്ടറിയിൽ FriisPropagationLossModel എന്ന തരത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കുക
factory.SetTypeId ("ns3::FriisPropagationLossModel")
// ഈ ഫാക്ടറി ഒബ്ജക്റ്റ് മാറ്റാൻ ഒരു ആട്രിബ്യൂട്ടിന്റെ ഡിഫോൾട്ട് മൂല്യമാക്കുക
// പിന്നീട് വസ്തുക്കൾ സൃഷ്ടിച്ചു
ഫാക്ടറി.സെറ്റ് ("സിസ്റ്റം ലോസ്", ഡബിൾ വാല്യൂ (2.0));
// അത്തരത്തിലുള്ള ഒരു വസ്തു സൃഷ്ടിക്കുക
Ptr വസ്തു = ഫാക്ടറി.സൃഷ്ടിക്കുക ();
ഫാക്ടറി.സെറ്റ് ("സിസ്റ്റം ലോസ്", ഡബിൾ വാല്യൂ (3.0));
// മറ്റൊരു സിസ്റ്റം ലോസ് ഉള്ള മറ്റൊരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുക
Ptr വസ്തു = ഫാക്ടറി.സൃഷ്ടിക്കുക ();

ഡൗൺകാസ്റ്റിംഗ്
നിരവധി തവണ ഉയർന്നുവന്ന ഒരു ചോദ്യം ഇതാണ്, "എനിക്ക് ഒരു അടിസ്ഥാന ക്ലാസ് പോയിന്റർ (Ptr) ഉണ്ടെങ്കിൽ
ഒബ്‌ജക്‌റ്റ്, എനിക്ക് ഡെറൈവ് ചെയ്‌ത ക്ലാസ് പോയിന്റർ വേണം, ഞാൻ താഴേക്ക് (C++ ഡൈനാമിക് കാസ്റ്റ് വഴി)
ഉരുത്തിരിഞ്ഞ പോയിന്റർ നേടുക, അല്ലെങ്കിൽ ഞാൻ ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ സിസ്റ്റം ഉപയോഗിക്കണോ GetObject<> ()
സബ്ക്ലാസ് API-യിലേക്കുള്ള ഇന്റർഫേസിലേക്ക് ഒരു Ptr കണ്ടെത്താൻ?"

പല സാഹചര്യങ്ങളിലും രണ്ട് ടെക്നിക്കുകളും പ്രവർത്തിക്കും എന്നതാണ് ഇതിനുള്ള ഉത്തരം. ns-3 ഒരു നൽകുന്നു
ഒബ്ജക്റ്റ് ഡൈനാമിക് കാസ്റ്റിംഗിന്റെ വാക്യഘടനയെ കൂടുതൽ ഉപയോക്താവാക്കുന്നതിനുള്ള ടെംപ്ലേറ്റഡ് ഫംഗ്ഷൻ
സൗഹൃദ:

ടെംപ്ലേറ്റ്
Ptr
DynamicCast (Ptr const&p)
{
തിരികെ Ptr (dynamic_cast (PeekPointer (p)));
}

പ്രോഗ്രാമർക്ക് ഒരു അടിസ്ഥാന ടൈപ്പ് പോയിന്റർ ഉള്ളപ്പോൾ ഡൈനാമിക്കാസ്റ്റ് പ്രവർത്തിക്കുന്നു, കൂടാതെ a യ്‌ക്കെതിരെ പരീക്ഷിക്കുമ്പോൾ
സബ്ക്ലാസ് പോയിന്റർ. വ്യത്യസ്‌ത ഒബ്‌ജക്‌റ്റുകൾ സമാഹരിച്ച് തിരയുമ്പോൾ GetObject പ്രവർത്തിക്കുന്നു, മാത്രമല്ല
DynamicCast പോലെ തന്നെ സബ്ക്ലാസ്സുകളിലും പ്രവർത്തിക്കുന്നു. ഉറപ്പില്ലെങ്കിൽ, പ്രോഗ്രാമർ ചെയ്യണം
എല്ലാ സാഹചര്യങ്ങളിലും പ്രവർത്തിക്കുന്നതിനാൽ GetObject ഉപയോഗിക്കുക. പ്രോഗ്രാമർക്ക് ക്ലാസ് ശ്രേണി അറിയാമെങ്കിൽ
പരിഗണനയിലുള്ള ഒബ്ജക്റ്റ്, ഡൈനാമിക്കാസ്റ്റ് ഉപയോഗിക്കുന്നത് കൂടുതൽ നേരിട്ടുള്ളതാണ്.

കോൺഫിഗറേഷൻ ഒപ്പം ഗുണവിശേഷങ്ങൾ
In ns-3 സിമുലേഷനുകൾ, കോൺഫിഗറേഷന് രണ്ട് പ്രധാന വശങ്ങളുണ്ട്:

സിമുലേഷൻ ടോപ്പോളജിയും ഒബ്‌ജക്‌റ്റുകൾ എങ്ങനെ ബന്ധിപ്പിച്ചിരിക്കുന്നു എന്നതും.

· ടോപ്പോളജിയിൽ ഇൻസ്റ്റൻഷ്യേറ്റ് ചെയ്ത മോഡലുകൾ ഉപയോഗിക്കുന്ന മൂല്യങ്ങൾ.

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

ഈ അധ്യായത്തിൽ മൂല്യങ്ങൾ ക്രമീകരിക്കുന്നതിനോ പരിഷ്ക്കരിക്കുന്നതിനോ ഉള്ള വിവിധ വഴികൾ ഞങ്ങൾ ചർച്ച ചെയ്യും
ഉപയോഗിച്ചത് ns-3 മാതൃകാ വസ്തുക്കൾ. നിർദ്ദിഷ്ട ക്രമത്തിൽ, ഇവയാണ്:

┌─────────────────────────────────┬─────────────── ───────────────────┐
│രീതി │ സ്കോപ്പ് │
├─────────────────────────────────┼─────────────── ───────────────────┤
│ഡിഫോൾട്ട് ആട്രിബ്യൂട്ട് മൂല്യങ്ങൾ സജ്ജീകരിച്ചു │ │ ന്റെ എല്ലാ സന്ദർഭങ്ങളെയും ബാധിക്കുന്നു
│ക്ലാസിൽ ആട്രിബ്യൂട്ടുകൾ നിർവചിക്കുമ്പോൾ. │
│GetTypeId (). │ │
└─────────────────────────────────┴─────────────── ───────────────────┘

│കമാൻഡ് ലൈൻ │ ഭാവിയിലെ എല്ലാ സംഭവങ്ങളെയും ബാധിക്കുക. │
│കോൺഫിഗർ::SetDefault() │ │
│കോൺഫിഗറേഷൻ സ്റ്റോർ │ │
├─────────────────────────────────┼─────────────── ───────────────────┤
│ഒബ്ജക്റ്റ് ഫാക്ടറി │ സൃഷ്ടിച്ച എല്ലാ സംഭവങ്ങളെയും ബാധിക്കുന്നു │
│ │ ഫാക്ടറിയോടൊപ്പം. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│XHelperSetAtribute () │ സൃഷ്ടിച്ച എല്ലാ സംഭവങ്ങളെയും ബാധിക്കുന്നു
│ │ സഹായി. │
├─────────────────────────────────┼─────────────── ───────────────────┤
│MyClass ::SetX () │ ഈ പ്രത്യേക സന്ദർഭം മാറ്റുന്നു. │
│ഒബ്ജക്റ്റ്::സെറ്റ് ആട്രിബ്യൂട്ട് () │ പൊതുവെ ഇത് മാത്രമാണ് ഫോം │
│കോൺഫിഗറേഷൻ::സെറ്റ്() │ മാറ്റാൻ ഷെഡ്യൂൾ ചെയ്യാവുന്നത് │
│ │ ഒരു ഉദാഹരണം ഒരിക്കൽ സിമുലേഷൻ │
│ │ പ്രവർത്തിക്കുന്നു. │
└─────────────────────────────────┴─────────────── ───────────────────┘

"പ്രത്യേകത" എന്നതുകൊണ്ട് ഞങ്ങൾ അർത്ഥമാക്കുന്നത് പട്ടികയിലെ പിന്നീടുള്ള വരികളിലെ രീതികൾ സെറ്റ് ചെയ്ത മൂല്യങ്ങളെ അസാധുവാക്കുന്നു എന്നാണ്
മുമ്പത്തെ രീതികളെ അപേക്ഷിച്ച്, സാധാരണഗതിയിൽ കുറച്ച് സന്ദർഭങ്ങളെ ബാധിക്കും.

ആട്രിബ്യൂട്ട് മൂല്യ വ്യവസ്ഥയുടെ വിശദാംശങ്ങളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, ചിലത് അവലോകനം ചെയ്യാൻ ഇത് സഹായിക്കും
ക്ലാസിന്റെ അടിസ്ഥാന സവിശേഷതകൾ വസ്തു.

വസ്തു പൊതു അവലോകനം
ns-3 അടിസ്ഥാനപരമായി ഒരു C++ ഒബ്ജക്റ്റ് അധിഷ്ഠിത സംവിധാനമാണ്. പുതിയ C++ ക്ലാസുകൾ എന്നാണ് ഇതിനർത്ഥം
(തരം) സാധാരണപോലെ പ്രഖ്യാപിക്കാനും നിർവചിക്കാനും ഉപവിഭാഗം നൽകാനും കഴിയും.

വളരെ ns-3 വസ്തുക്കൾ പാരമ്പര്യമായി ലഭിക്കുന്നു വസ്തു അടിസ്ഥാന ക്ലാസ്. ഈ വസ്തുക്കൾക്ക് ചില അധികമുണ്ട്
സിസ്റ്റം ഓർഗനൈസുചെയ്യുന്നതിനും മെമ്മറി മാനേജുമെന്റ് മെച്ചപ്പെടുത്തുന്നതിനും ഞങ്ങൾ ചൂഷണം ചെയ്യുന്ന സവിശേഷതകൾ
ഞങ്ങളുടെ വസ്തുക്കളുടെ:

· "മെറ്റാഡാറ്റ" സിസ്റ്റം ക്ലാസിന്റെ പേരിനെ കുറിച്ചുള്ള ധാരാളം മെറ്റാ വിവരങ്ങളുമായി ബന്ധിപ്പിക്കുന്നു
വസ്തു, ഉൾപ്പെടെ:

ഉപവർഗ്ഗത്തിന്റെ അടിസ്ഥാന ക്ലാസ്,

സബ്ക്ലാസിലെ ആക്സസ് ചെയ്യാവുന്ന കൺസ്ട്രക്റ്ററുകളുടെ സെറ്റ്,

ഉപവർഗ്ഗത്തിന്റെ "ആട്രിബ്യൂട്ടുകളുടെ" സെറ്റ്,

· ഓരോ ആട്രിബ്യൂട്ടും സജ്ജീകരിക്കാൻ കഴിയുമോ, അതോ വായിക്കാൻ മാത്രമുള്ളതാണോ,

· ഓരോ ആട്രിബ്യൂട്ടിനും അനുവദനീയമായ മൂല്യങ്ങളുടെ പരിധി.

· മെമ്മറി മാനേജ്മെന്റിനായി റഫറൻസ് കൗണ്ടിംഗ് സ്മാർട്ട് പോയിന്റർ നടപ്പിലാക്കൽ.

ns-3 ആട്രിബ്യൂട്ട് സിസ്റ്റം ഉപയോഗിക്കുന്ന ഒബ്‌ജക്റ്റുകൾ രണ്ടിൽ നിന്നും ഉരുത്തിരിഞ്ഞതാണ് വസ്തു or ഒബ്ജക്റ്റ്ബേസ്. മിക്കതും
ns-3 നമ്മൾ ചർച്ച ചെയ്യുന്ന വസ്തുക്കളിൽ നിന്ന് ഉരുത്തിരിഞ്ഞു വസ്തു, എന്നാൽ സ്മാർട്ടിനു പുറത്തുള്ള ചിലത്
പോയിന്റർ മെമ്മറി മാനേജ്‌മെന്റ് ചട്ടക്കൂട് ഇതിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണ് ഒബ്ജക്റ്റ്ബേസ്.

ഈ ഒബ്‌ജക്‌റ്റുകളുടെ രണ്ട് ഗുണങ്ങൾ നമുക്ക് അവലോകനം ചെയ്യാം.

സ്മാർട്ട് പോയിന്ററുകൾ
ൽ അവതരിപ്പിച്ചത് പോലെ ns-3 ട്യൂട്ടോറിയൽ, ns-3 ഒബ്ജക്റ്റുകൾ മെമ്മറി നിയന്ത്രിക്കുന്നത് a സൂചന
കണക്കാക്കുന്നു സ്മാർട്ട് പോയിന്റർ നടപ്പാക്കൽ, ക്ലാസ് Ptr.

സ്മാർട്ട് പോയിന്ററുകൾ വ്യാപകമായി ഉപയോഗിക്കുന്നു ns-3 എപിഐകൾ, റഫറൻസുകൾ കൈമാറുന്നത് ഒഴിവാക്കാൻ
മെമ്മറി ചോർച്ചയ്ക്ക് കാരണമായേക്കാവുന്ന കൂമ്പാരം അനുവദിച്ച വസ്തുക്കൾ. ഏറ്റവും അടിസ്ഥാനപരമായ ഉപയോഗത്തിന് (വാക്യഘടന), കൈകാര്യം ചെയ്യുക
ഒരു സാധാരണ പോയിന്റർ പോലെയുള്ള ഒരു സ്മാർട്ട് പോയിന്റർ:

Ptr nd = ...;
nd->CallSomeFunction ();
// തുടങ്ങിയവ.

ഈ ഉദാഹരണത്തിന്റെ ആദ്യ വരിയിലെന്നപോലെ, ഒരു ഒബ്‌ജക്‌റ്റിലേക്ക് നിങ്ങൾക്ക് എങ്ങനെ ഒരു സ്മാർട്ട് പോയിന്റർ ലഭിക്കും?

ക്രിയേറ്റ് ഒബ്ജക്റ്റ്
Memory-management-and-class-Ptr-ൽ ഞങ്ങൾ മുകളിൽ ചർച്ച ചെയ്തതുപോലെ, ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള API-ൽ, ഒബ്ജക്റ്റുകൾ
തരം വസ്തു ഉപയോഗിച്ച് ഉടനടി അല്ല ഓപ്പറേറ്റർ പുതിയ പതിവുപോലെ പകരം ഒരു ടെംപ്ലേറ്റഡ് വഴി
ഫംഗ്ഷൻ വിളിക്കുന്നു ക്രിയേറ്റ് ഒബ്ജക്റ്റ് ().

അത്തരമൊരു വസ്തു സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു സാധാരണ മാർഗം ഇപ്രകാരമാണ്:

Ptr nd = CreateObject ();

ഇത് പ്രവർത്തനപരമായി ഇതിന് തുല്യമാണെന്ന് നിങ്ങൾക്ക് ചിന്തിക്കാം:

WifiNetDevice* nd = പുതിയ WifiNetDevice ();

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

ചില സ്ക്രിപ്റ്റുകളിൽ, നിങ്ങൾ പലതും കാണാനിടയില്ല ക്രിയേറ്റ് ഒബ്ജക്റ്റ് () കോഡിലെ കോളുകൾ; ഇതാണ്
കാരണം ഫലത്തിൽ ചില സഹായ വസ്തുക്കളുണ്ട് ക്രിയേറ്റ് ഒബ്ജക്റ്റ് () കോളുകൾ
നിനക്കായ്.

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

· ക്ലാസ് തിരിച്ചറിയുന്ന ഒരു അദ്വിതീയ സ്ട്രിംഗ്.

· മെറ്റാഡാറ്റ സിസ്റ്റത്തിനുള്ളിലെ സബ്ക്ലാസിന്റെ അടിസ്ഥാന ക്ലാസ്.

· സബ്ക്ലാസിലെ ആക്സസ് ചെയ്യാവുന്ന കൺസ്ട്രക്റ്ററുകളുടെ സെറ്റ്.

ക്ലാസിന്റെ പൊതുവായി ആക്‌സസ് ചെയ്യാവുന്ന പ്രോപ്പർട്ടികളുടെ ("ആട്രിബ്യൂട്ടുകൾ") ഒരു ലിസ്റ്റ്.

വസ്തു ചുരുക്കം
ഈ ആശയങ്ങളെല്ലാം ഒരുമിച്ച് ചേർത്തുകൊണ്ട്, നമുക്ക് ഒരു പ്രത്യേക ഉദാഹരണം നോക്കാം: ക്ലാസ് നോഡ്.

പൊതു തലക്കെട്ട് ഫയൽ node.h ഒരു സ്റ്റാറ്റിക് ഉൾപ്പെടുന്ന ഒരു പ്രഖ്യാപനമുണ്ട് GetTypeId ()
ഫംഗ്ഷൻ കോൾ:

ക്ലാസ് നോഡ്: പൊതു വസ്തു
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);
...

ഇത് നിർവചിച്ചിരിക്കുന്നത് node.cc ഇനിപ്പറയുന്ന രീതിയിൽ ഫയൽ:

ടൈപ്പ് ഐഡി
നോഡ്::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::നോഡ്")
.SetParent ()
.AddConstructor ()
.AddAtribute ("DeviceList",
"ഈ നോഡുമായി ബന്ധപ്പെട്ട ഉപകരണങ്ങളുടെ ലിസ്റ്റ്.",
ObjectVectorValue (),
MakeObjectVectorAccessor (&Node::m_devices),
MakeObjectVectorChecker ())
.AddAtribute ("ApplicationList",
"ഈ നോഡുമായി ബന്ധപ്പെട്ട ആപ്ലിക്കേഷനുകളുടെ ലിസ്റ്റ്.",
ObjectVectorValue (),
MakeObjectVectorAccessor (&Node::m_applications),
MakeObjectVectorChecker ())
.AddAtribute ("Id",
"ഈ നോഡിന്റെ ഐഡി (അതുല്യ പൂർണ്ണസംഖ്യ).",
TypeId::ATTR_GET, // ലഭിക്കാൻ മാത്രം അനുവദിക്കുക.
UintegerValue (0),
MakeUintegerAccessor (&Node::m_id),
MakeUintegerChecker ())
;
റിട്ടേൺ ടിഡ്;
}

പരിഗണിക്കുക ടൈപ്പ് ഐഡി എന്ന ns-3 വസ്തു റൺ ടൈം തരത്തിന്റെ വിപുലീകൃത രൂപമായി ക്ലാസ്
വിവരങ്ങൾ (RTTI). പിന്തുണയ്‌ക്കുന്നതിനായി സി++ ഭാഷയിൽ ലളിതമായ ഒരു തരം RTTI ഉൾപ്പെടുന്നു
ഡൈനാമിക്_കാസ്റ്റ് ഒപ്പം ടൈപ്പിഡ് ഓപ്പറേറ്റർമാർ.

ദി സെറ്റ്പാരന്റ് () മുകളിലെ നിർവചനത്തിലെ കോൾ ഞങ്ങളുടെ കൂടെ ചേർന്ന് ഉപയോഗിക്കുന്നു
പൈതൃക മരങ്ങളിൽ സുരക്ഷിതമായി മുകളിലേക്കും താഴേക്കും കാസ്റ്റിംഗ് അനുവദിക്കുന്നതിനുള്ള ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ മെക്കാനിസങ്ങൾ
സമയത്ത് GetObject (). ഉപവിഭാഗങ്ങളെ അവരുടെ രക്ഷിതാവിന്റെ ആട്രിബ്യൂട്ടുകൾ അവകാശമാക്കാനും ഇത് പ്രാപ്തമാക്കുന്നു
ക്ലാസ്.

ദി ആഡ് കൺസ്ട്രക്റ്റർ () ഞങ്ങളുടെ അബ്‌സ്‌ട്രാക്റ്റ് ഒബ്‌ജക്റ്റ് ഫാക്ടറിയുമായി ചേർന്നാണ് കോൾ ഉപയോഗിക്കുന്നത്
ഒരു ഉപയോക്താവിനെ അറിയാൻ നിർബന്ധിക്കാതെ C++ ഒബ്‌ജക്‌റ്റുകൾ നിർമ്മിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്ന മെക്കാനിസങ്ങൾ
അവൾ നിർമ്മിക്കുന്ന വസ്തുവിന്റെ കോൺക്രീറ്റ് ക്ലാസ്.

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

ഉപയോക്താക്കൾ നോഡുകൾ സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ, അവർ സാധാരണയായി ഏതെങ്കിലും രൂപത്തിൽ വിളിക്കും ക്രിയേറ്റ് ഒബ്ജക്റ്റ് (),:

Ptr n = CreateObject ();

അല്ലെങ്കിൽ കൂടുതൽ അമൂർത്തമായി, ഒരു ഒബ്ജക്റ്റ് ഫാക്ടറി ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഒരു സൃഷ്ടിക്കാൻ കഴിയും നോഡ് പോലും ഇല്ലാത്ത വസ്തു
കോൺക്രീറ്റ് C++ തരം അറിയുന്നത്:

ഒബ്ജക്റ്റ് ഫാക്ടറി ഫാക്ടറി;
const std::string typeId = "ns3::നോഡ്'';
factory.SetTypeId (typeId);
Ptr നോഡ് = ഫാക്ടറി.സൃഷ്ടിക്കുക ();

ഈ രണ്ട് രീതികളും പൂർണ്ണമായി സമാരംഭിച്ച ആട്രിബ്യൂട്ടുകളിൽ ലഭ്യമാണ്
ഫലമായി വസ്തു സന്ദർഭങ്ങൾ.

ആട്രിബ്യൂട്ടുകൾ (അംഗ വേരിയബിളുകളുമായോ പ്രവർത്തനങ്ങളുമായോ ബന്ധപ്പെട്ട മൂല്യങ്ങൾ
ക്ലാസ്) മുകളിൽ പറഞ്ഞവയിലേക്ക് പ്ലംബ് ചെയ്തിരിക്കുന്നു ടൈപ്പ് ഐഡി.

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

· "I ആഗ്രഹിക്കുന്നു ലേക്ക് പിന്തുടരുക The പാക്കറ്റുകൾ on The വയർലെസ് ഇന്റർഫേസ് മാത്രം on The ആദ്യം പ്രവേശനം പോയിന്റ്."

· "I ആഗ്രഹിക്കുന്നു ലേക്ക് പിന്തുടരുക The മൂല്യം of The TCP തിരക്ക് ജാലകം (ഓരോ കാലം it മാറ്റങ്ങൾ) on a
പ്രത്യേക TCP സോക്കറ്റ്."

· "I ആഗ്രഹിക്കുന്നു a ഡംബ് of എല്ലാം മൂല്യങ്ങൾ ആ ആയിരുന്നു ഉപയോഗിച്ച in my അനുകരണം."

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

നിർവ്വചനത്തിൽ ഗുണവിശേഷങ്ങൾ
ഉപയോക്താക്കൾക്ക് പ്ലംബ് ചെയ്യാതെ തന്നെ സിസ്റ്റത്തിൽ ആഴത്തിലുള്ള മൂല്യങ്ങൾ ആക്‌സസ് ചെയ്യാൻ ഞങ്ങൾ ഒരു മാർഗം നൽകുന്നു
സിസ്റ്റത്തിലൂടെയുള്ള ആക്‌സസറുകൾ (പോയിന്ററുകൾ), അവയിലേക്ക് പോകുന്നതിന് പോയിന്റർ ചെയിനുകൾ നടത്തുക. എ പരിഗണിക്കുക
ക്ലാസ് DropTailQueue ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യയായ ഒരു അംഗ വേരിയബിളുണ്ട് m_maxPackets;
ഈ അംഗ വേരിയബിൾ ക്യൂവിന്റെ ആഴം നിയന്ത്രിക്കുന്നു.

യുടെ പ്രഖ്യാപനം നോക്കിയാൽ DropTailQueue, ഞങ്ങൾ ഇനിപ്പറയുന്നവ കാണുന്നു:

ക്ലാസ് DropTailQueue : പൊതു ക്യൂ {
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);
...

സ്വകാര്യം:
std::ക്യൂ > m_packets;
uint32_t m_maxPackets;
};

മൂല്യം ഉപയോഗിച്ച് ഒരു ഉപയോക്താവ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കാര്യങ്ങൾ നമുക്ക് പരിഗണിക്കാം m_maxPackets:

പുതിയത് എപ്പോഴെങ്കിലും സിസ്റ്റത്തിനായി സ്ഥിരസ്ഥിതി മൂല്യം സജ്ജമാക്കുക DropTailQueue സൃഷ്ടിക്കപ്പെട്ടത്,
ഈ അംഗം ആ ഡിഫോൾട്ടിലേക്ക് ഇനീഷ്യലൈസ് ചെയ്തിരിക്കുന്നു.

· ഇതിനകം തൽക്ഷണ ക്യൂവിൽ മൂല്യം സജ്ജമാക്കുക അല്ലെങ്കിൽ നേടുക.

മുകളിൽ പറഞ്ഞ കാര്യങ്ങൾക്ക് സാധാരണയായി നൽകേണ്ടതുണ്ട് ഗണം () ഒപ്പം നേടുക () ഫംഗ്ഷനുകൾ, കൂടാതെ ചില തരം
ആഗോള സ്ഥിരസ്ഥിതി മൂല്യം.

ൽ ns-3 ആട്രിബ്യൂട്ട് സിസ്റ്റം, ഈ മൂല്യ നിർവചനങ്ങളും ആക്‌സസർ ഫംഗ്‌ഷൻ രജിസ്‌ട്രേഷനുകളും
എന്നതിലേക്ക് മാറ്റുന്നു ടൈപ്പ് ഐഡി ക്ലാസ്; ഉദാ.:

NS_OBJECT_ENSURE_REGISTERED (DropTailQueue);

ടൈപ്പ് ഐഡി
DropTailQueue::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::DropTailQueue")
.SetParent ()
.AddConstructor ()
.AddAttribute ("MaxPackets",
"ഈ DropTailQueue സ്വീകരിച്ച പരമാവധി എണ്ണം പാക്കറ്റുകൾ.",
UintegerValue (100),
MakeUintegerAccessor (&DropTailQueue::m_maxPackets),
MakeUintegerChecker ())
;

റിട്ടേൺ ടിഡ്;
}

ദി ആട്രിബ്യൂട്ട് ചേർക്കുക () ഇതിനായി നിരവധി കാര്യങ്ങൾ ചെയ്യുന്ന രീതിയാണ് m_maxPackets മൂല്യം:

· (സാധാരണയായി സ്വകാര്യ) അംഗ വേരിയബിളിനെ ബന്ധിപ്പിക്കുന്നു m_maxPackets ഒരു പൊതു സ്ട്രിംഗിലേക്ക്
"മാക്സ്പാക്കറ്റുകൾ".

· ഒരു സ്ഥിര മൂല്യം (100 പാക്കറ്റുകൾ) നൽകുന്നു.

· മൂല്യത്തിന്റെ അർത്ഥം നിർവചിക്കുന്ന ചില സഹായ വാചകം നൽകുന്നു.

· പരിധികൾ സജ്ജമാക്കാൻ ഉപയോഗിക്കാവുന്ന ഒരു "ചെക്കർ" (ഈ ഉദാഹരണത്തിൽ ഉപയോഗിച്ചിട്ടില്ല) നൽകുന്നു
മൂല്യങ്ങളുടെ അനുവദനീയമായ ശ്രേണി.

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

ആട്രിബ്യൂട്ടിന്റെ സമാരംഭം മാക്രോയെ ആശ്രയിച്ചിരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക NS_OBJECT_ENSURE_REGISTERED
(DropTailQueue) വിളിക്കപ്പെടുന്നു; നിങ്ങളുടെ പുതിയ ക്ലാസ് നടപ്പാക്കലിൽ നിന്ന് ഇത് ഉപേക്ഷിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ
ആട്രിബ്യൂട്ടുകൾ ശരിയായി ആരംഭിക്കില്ല.

ആട്രിബ്യൂട്ടുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ഞങ്ങൾ വിവരിച്ചിട്ടുണ്ടെങ്കിലും, എങ്ങനെ ആക്‌സസ് ചെയ്യാമെന്ന് ഞങ്ങൾ വിവരിച്ചിട്ടില്ല
ഈ മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യുക. ഉദാഹരണത്തിന്, ഇല്ല ഗ്ലോബൽസ്.എച്ച് ഇവ എവിടെയാണ് ഹെഡ്ഡർ ഫയൽ
സംഭരിച്ചു; ആട്രിബ്യൂട്ടുകൾ അവയുടെ ക്ലാസുകളിൽ സംഭരിച്ചിരിക്കുന്നു. എങ്ങനെ എന്ന ചോദ്യങ്ങളാണ് സ്വാഭാവികമായും ഉയരുന്നത്
ഉപയോക്താക്കൾ അവരുടെ മോഡലുകളുടെ എല്ലാ ആട്രിബ്യൂട്ടുകളെക്കുറിച്ചും എളുപ്പത്തിൽ പഠിക്കുന്നുണ്ടോ, ഒരു ഉപയോക്താവ് എങ്ങനെ ചെയ്യുന്നു
ഈ ആട്രിബ്യൂട്ടുകൾ ആക്‌സസ് ചെയ്യുക, അല്ലെങ്കിൽ അവയുടെ റെക്കോർഡിന്റെ ഭാഗമായി അവയുടെ മൂല്യങ്ങൾ രേഖപ്പെടുത്തുക
അനുകരണം?

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

ക്രമീകരണം സ്വതേ മൂല്യങ്ങൾ
കോൺഫിഗറേഷൻ::സെറ്റ് ഡിഫോൾട്ട് ഒപ്പം കമാൻഡ് ലൈൻ
ഒരു ഉപയോക്തൃ സ്ക്രിപ്റ്റ് ഒരു നിർദ്ദിഷ്ട ആട്രിബ്യൂട്ട് മൂല്യം ആക്സസ് ചെയ്യുന്നതെങ്ങനെയെന്ന് നോക്കാം. ഞങ്ങൾ പോകുന്നു
ഉപയോഗിക്കുക src/point-to-point/examples/main-attribute-value.cc ചിത്രീകരണത്തിനുള്ള സ്ക്രിപ്റ്റ്, കൂടെ
ചില വിശദാംശങ്ങൾ നീക്കം ചെയ്തു. ദി പ്രധാന പ്രവർത്തനം ആരംഭിക്കുന്നു:

// ആട്രിബ്യൂട്ട് സിസ്റ്റം എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ അടിസ്ഥാന ഉദാഹരണമാണിത്
// അടിസ്ഥാന സിസ്റ്റത്തിൽ ഒരു മൂല്യം സജ്ജമാക്കി നേടുക; അതായത്, ഒപ്പിടാത്തത്
// ഒരു ക്യൂവിലെ പരമാവധി പാക്കറ്റുകളുടെ പൂർണ്ണസംഖ്യ
//

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

// സ്ഥിരസ്ഥിതിയായി, MaxPackets ആട്രിബ്യൂട്ടിന് 100 പാക്കറ്റുകളുടെ മൂല്യമുണ്ട്
// (DropTailQueue::GetTypeId എന്ന ഫംഗ്‌ഷനിൽ ഈ സ്ഥിരസ്ഥിതി നിരീക്ഷിക്കാവുന്നതാണ്)
//
// ഇവിടെ, ഞങ്ങൾ ഇത് 80 പാക്കറ്റുകളായി സജ്ജമാക്കി. നമുക്ക് രണ്ട് മൂല്യ തരങ്ങളിൽ ഒന്ന് ഉപയോഗിക്കാം:
// ഒരു സ്ട്രിംഗ് അടിസ്ഥാനമാക്കിയുള്ള മൂല്യം അല്ലെങ്കിൽ ഒരു Uinteger മൂല്യം
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3::DropTailQueue::MaxPackets", StringValue ("80"));
// താഴെയുള്ള ഫംഗ്‌ഷൻ കോൾ അനാവശ്യമാണ്
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3::DropTailQueue::MaxPackets", UintegerValue (80));

// ഡിഫോൾട്ടുകളും മുകളിലുള്ളവയും അസാധുവാക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുക
// SetDefaults () റൺ-ടൈമിൽ, കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ വഴി
// ഉദാഹരണത്തിന്, "--ns3::DropTailQueue::MaxPackets=80" വഴി
കമാൻഡ് ലൈൻ cmd;
// കമാൻഡ് ലൈനിൽ നിന്ന് മൂല്യം സജ്ജീകരിക്കുന്നതിനുള്ള മറ്റൊരു മാർഗം ഇത് നൽകുന്നു:
cmd.AddValue ("maxPackets", "ns3::DropTailQueue::MaxPackets");
cmd.Parse (argc, argv);

മേൽപ്പറഞ്ഞവയിൽ ശ്രദ്ധിക്കേണ്ട പ്രധാന കാര്യം തുല്യമായ രണ്ട് കോളുകളാണ് കോൺഫിഗറേഷൻ::സെറ്റ് ഡിഫോൾട്ട്
(). തുടർന്നുള്ള എല്ലാത്തിനും ഞങ്ങൾ ഡിഫോൾട്ട് മൂല്യം സജ്ജമാക്കുന്നത് ഇങ്ങനെയാണ്
DropTailQueueഎസ്. ഞങ്ങൾ രണ്ട് തരം ചിത്രീകരിക്കുന്നു വില ക്ലാസുകൾ, എ സ്ട്രിംഗ് മൂല്യം ഒരു
UintegerValue class, എന്ന ആട്രിബ്യൂട്ടിന് മൂല്യം നൽകുന്നതിന് ഉപയോഗിക്കാം
"ns3::DropTailQueue::MaxPackets".

ഇത് ഉപയോഗിച്ച് ആട്രിബ്യൂട്ടുകൾ കൈകാര്യം ചെയ്യാനും സാധിക്കും കമാൻഡ് ലൈൻ; ഞങ്ങൾ ചില ഉദാഹരണങ്ങൾ കണ്ടു
ട്യൂട്ടോറിയലിന്റെ തുടക്കത്തിൽ. പ്രത്യേകിച്ച്, ചുരുക്കെഴുത്ത് വാദം ചേർക്കുന്നത് നേരായ കാര്യമാണ്
പേര്, പോലുള്ളവ --maxPackets, നിങ്ങളുടെ മോഡലിന് പ്രത്യേകമായി പ്രസക്തമായ ഒരു ആട്രിബ്യൂട്ടിനായി,
ഈ സാഹചര്യത്തിൽ "ns3::DropTailQueue::MaxPackets". ഇതിന് അധിക സവിശേഷതയുണ്ട്
സ്ക്രിപ്റ്റിനായുള്ള ഉപയോഗ സന്ദേശത്തിന്റെ ഭാഗമായി ആട്രിബ്യൂട്ടിനായുള്ള സഹായ സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യപ്പെടും.
കൂടുതൽ വിവരങ്ങൾക്ക് ഇത് കാണുക കമാൻഡ് ലൈൻ API ഡോക്യുമെന്റേഷൻ.

ഇപ്പോൾ, ലോ-ലെവൽ API ഉപയോഗിച്ച് ഞങ്ങൾ കുറച്ച് ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കും. ഞങ്ങളുടെ പുതുതായി സൃഷ്ടിച്ച ക്യൂകൾ
ഇല്ല m_maxPackets നിർവചിച്ചിരിക്കുന്നതുപോലെ, 100 പാക്കറ്റുകളായി ആരംഭിച്ചു
DropTailQueue::GetTypeId () ഫംഗ്‌ഷൻ, പക്ഷേ 80 പാക്കറ്റുകളിലേക്ക്, ഞങ്ങൾ മുകളിൽ ചെയ്തത് കാരണം
സ്ഥിര മൂല്യങ്ങൾ:

Ptr n0 = CreateObject ();

Ptr net0 = CreateObject ();
n0->AddDevice (net0);

Ptr q = CreateObject ();
net0->AddQueue(q);

ഈ സമയത്ത്, ഞങ്ങൾ ഒരു സിംഗിൾ സൃഷ്ടിച്ചു നോഡ് (n0) ഒരു സിംഗിൾ PointToPointNetDevice
(നെത്ക്സനുമ്ക്സ), കൂടാതെ a ചേർത്തു DropTailQueue (q) ലേക്ക് നെത്ക്സനുമ്ക്സ.

കൺസ്ട്രക്‌ടർമാർ, സഹായികൾ ഒപ്പം ഒബ്ജക്റ്റ് ഫാക്ടറി
ആട്രിബ്യൂട്ടുകളുടെ അനിയന്ത്രിതമായ കോമ്പിനേഷനുകൾ സജ്ജീകരിക്കാനും സഹായിയിൽ നിന്നും താഴ്ന്ന നിലയിലുള്ളവരിൽ നിന്നും നേടാനും കഴിയും
API-കൾ; ഒന്നുകിൽ കൺസ്ട്രക്റ്റർമാരിൽ നിന്ന് തന്നെ:

Ptr p =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് വിത്ത് ആട്രിബ്യൂട്ടുകൾ
("MinX", DoubleValue (-100.0),
"MinY", ഇരട്ടമൂല്യം (-100.0),
"DeltaX", DoubleValue (5.0),
"DeltaY", DoubleValue (20.0),
"ഗ്രിഡ് വിഡ്ത്ത്", UintegerValue (20),
"ലേഔട്ട് ടൈപ്പ്", സ്ട്രിംഗ്വാല്യൂ ("റോഫസ്റ്റ്"));

അല്ലെങ്കിൽ ഉയർന്ന തലത്തിലുള്ള ഹെൽപ്പർ API-കളിൽ നിന്ന്:

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

ഞങ്ങൾ അത് ഇവിടെ ചിത്രീകരിക്കുന്നില്ല, എന്നാൽ നിങ്ങൾക്ക് ഒരു കോൺഫിഗർ ചെയ്യാനും കഴിയും ഒബ്ജക്റ്റ് ഫാക്ടറി പുതിയ മൂല്യങ്ങളോടെ
നിർദ്ദിഷ്ട ആട്രിബ്യൂട്ടുകൾക്കായി. സൃഷ്ടിച്ച സന്ദർഭങ്ങൾ ഒബ്ജക്റ്റ് ഫാക്ടറി അവ ഉണ്ടായിരിക്കും
നിർമ്മാണ സമയത്ത് സജ്ജീകരിച്ച ആട്രിബ്യൂട്ടുകൾ. ഇത് ഹെൽപ്പർ API-കളിൽ ഒന്ന് ഉപയോഗിക്കുന്നതിന് സമാനമാണ്
ക്ലാസിനായി.

അവലോകനം ചെയ്യുന്നതിന്, ക്ലാസ് സന്ദർഭങ്ങൾക്കായി ആട്രിബ്യൂട്ടുകൾക്കായി മൂല്യങ്ങൾ സജ്ജീകരിക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട് ലേക്ക് be
സൃഷ്ടിച്ചു in The ഭാവി:

· കോൺഫിഗറേഷൻ::സെറ്റ് ഡിഫോൾട്ട് ()

· കമാൻഡ് ലൈൻ::AddValue ()

· CreateObjectWithAttributes<> ()

· വിവിധ സഹായ API-കൾ

എന്നാൽ നിങ്ങൾ ഇതിനകം ഒരു ഉദാഹരണം സൃഷ്‌ടിച്ചിട്ടുണ്ടെങ്കിൽ, അതിന്റെ മൂല്യം മാറ്റാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ആട്രിബ്യൂട്ട്? ഈ ഉദാഹരണത്തിൽ, നമുക്ക് എങ്ങനെ കൈകാര്യം ചെയ്യാം m_maxPackets ഇതിനകം മൂല്യം
തൽക്ഷണം DropTailQueue? അതിനുള്ള വിവിധ വഴികൾ ഇതാ.

മാറ്റുന്നതിൽ മൂല്യങ്ങൾ
SmartPointer
ഒരു സ്മാർട്ട് പോയിന്റർ എന്ന് കരുതുക (Ptr) പ്രസക്തമായ ഒരു നെറ്റ്‌വർക്ക് ഉപകരണം കൈയിലുണ്ട്; കറണ്ടിൽ
ഉദാഹരണത്തിന്, അത് നെത്ക്സനുമ്ക്സ പോയിന്റർ.

മൂല്യം മാറ്റുന്നതിനുള്ള ഒരു മാർഗ്ഗം, അടിസ്ഥാന ക്യൂവിലേക്ക് ഒരു പോയിന്റർ ആക്സസ് ചെയ്യുകയും അത് പരിഷ്ക്കരിക്കുകയും ചെയ്യുക എന്നതാണ്
ആട്രിബ്യൂട്ട്.

ആദ്യം, നമുക്ക് (അടിസ്ഥാന ക്ലാസ്) ഒരു പോയിന്റർ ലഭിക്കുമെന്ന് ഞങ്ങൾ നിരീക്ഷിക്കുന്നു. വരി വഴി The
PointToPointNetDevice ആട്രിബ്യൂട്ടുകൾ, എവിടെയാണ് വിളിക്കുന്നത് "TxQueue":

PointerValue tmp;
net0->GetAttribute ("TxQueue", tmp);
Ptr txQueue = tmp.GetObject ();

ഉപയോഗിച്ച് GetObject () ഫംഗ്‌ഷൻ, നമുക്ക് ഒരു സുരക്ഷിതമായി താഴ്ത്താൻ കഴിയും DropTailQueueഎവിടെ
"മാക്സ്പാക്കറ്റുകൾ" ഒരു ആട്രിബ്യൂട്ട് ആണ്:

Ptr dtq = txQueue->GetObject ();
NS_ASSERT (dtq != 0);

അടുത്തതായി, ഈ ക്യൂവിൽ ഒരു ആട്രിബ്യൂട്ടിന്റെ മൂല്യം നമുക്ക് ലഭിക്കും. ഞങ്ങൾ റാപ്പർ അവതരിപ്പിച്ചു
വില ഈ തരങ്ങൾക്ക് ചുറ്റുമുള്ള ജാവ റാപ്പറുകൾക്ക് സമാനമായ അടിസ്ഥാന ഡാറ്റാ തരങ്ങൾക്കുള്ള ക്ലാസുകൾ,
ആട്രിബ്യൂട്ട് സിസ്റ്റം സംഭരിക്കുന്ന മൂല്യങ്ങൾ സ്ട്രിംഗുകളായി ക്രമീകരിച്ചിരിക്കുന്നതിനാൽ, വ്യത്യസ്ത തരങ്ങളല്ല.
ഇവിടെ, ആട്രിബ്യൂട്ട് മൂല്യം a-യ്ക്ക് നൽകിയിരിക്കുന്നു UintegerValueഎന്നാൽ നേടുക () ഇതിനെക്കുറിച്ചുള്ള രീതി
മൂല്യം ഉത്പാദിപ്പിക്കുന്നു (പൊതിഞ്ഞത്) uint32_t.:

UintegerValue പരിധി;
dtq->GetAttribute ("MaxPackets", പരിധി);
NS_LOG_INFO ("1. dtq പരിധി: " << പരിധി. നേടുക () << "പാക്കറ്റുകൾ");

മേൽപ്പറഞ്ഞ താഴ്ച്ച ശരിക്കും ആവശ്യമില്ലെന്ന കാര്യം ശ്രദ്ധിക്കുക; നമുക്ക് ആട്രിബ്യൂട്ട് ലഭിക്കുമായിരുന്നു
നേരിട്ട് മൂല്യം txQueue, ഇത് ഒരു വസ്തു:

txQueue->GetAttribute ("MaxPackets", പരിധി);
NS_LOG_INFO ("2. txQueue പരിധി: " << പരിധി. നേടുക () << "പാക്കറ്റുകൾ");

ഇനി, നമുക്ക് അതിനെ മറ്റൊരു മൂല്യത്തിലേക്ക് (60 പാക്കറ്റുകൾ) സജ്ജമാക്കാം:

txQueue->SetAttribute("MaxPackets", UintegerValue (60));
txQueue->GetAttribute ("MaxPackets", പരിധി);
NS_LOG_INFO ("3. txQueue പരിധി മാറ്റി: " << പരിധി. നേടുക () << "പാക്കറ്റുകൾ");

കോൺഫിഗറേഷൻ നെയിംസ്പെയ്സ് പാത
കോൺഫിഗറേഷൻ നെയിംസ്പേസ് ഉപയോഗിക്കുക എന്നതാണ് ആട്രിബ്യൂട്ട് ലഭിക്കുന്നതിനുള്ള ഒരു ഇതര മാർഗം. ഇവിടെ,
ഈ ആട്രിബ്യൂട്ട് ഈ നെയിംസ്പേസിൽ അറിയപ്പെടുന്ന ഒരു പാതയിൽ വസിക്കുന്നു; എങ്കിൽ ഈ സമീപനം ഉപയോഗപ്രദമാണ്
അടിസ്ഥാന പോയിന്ററുകളിലേക്ക് ആക്സസ് ഇല്ല കൂടാതെ ഒരു നിർദ്ദിഷ്ട കോൺഫിഗർ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു
ഒരൊറ്റ പ്രസ്താവനയുള്ള ആട്രിബ്യൂട്ട്.:

കോൺഫിഗറേഷൻ::സെറ്റ് ("/നോഡ് ലിസ്റ്റ്/0/ഉപകരണ ലിസ്റ്റ്/0/TxQueue/MaxPackets",
UintegerValue (25));
txQueue->GetAttribute ("MaxPackets", പരിധി);
NS_LOG_INFO ("4. txQueue പരിധി നെയിംസ്പേസിലൂടെ മാറ്റി: "
<< പരിധി. നേടുക () << "പാക്കറ്റുകൾ");

കോൺഫിഗറേഷൻ പാതയ്ക്ക് പലപ്പോഴും രൂപമുണ്ട് ".../
പേര്>/ /.../ / " ഒരു സൂചിക പ്രകാരം ഒരു നിർദ്ദിഷ്ട ഉദാഹരണം സൂചിപ്പിക്കാൻ
കണ്ടെയ്നറിലെ വസ്തു. ഈ സാഹചര്യത്തിൽ ആദ്യ കണ്ടെയ്നർ എല്ലാവരുടെയും പട്ടികയാണ് നോഡ്എസ്; ദി
രണ്ടാമത്തെ കണ്ടെയ്നർ എല്ലാവരുടെയും പട്ടികയാണ് നെറ്റ് ഡിവൈസ്തിരഞ്ഞെടുത്തവയിൽ എസ് നോഡ്. അവസാനമായി, ദി
കോൺഫിഗറേഷൻ പാത സാധാരണയായി അംഗങ്ങളുടെ ആട്രിബ്യൂട്ടുകളുടെ തുടർച്ചയായി അവസാനിക്കുന്നു, ഈ സാഹചര്യത്തിൽ
"മാക്സ്പാക്കറ്റുകൾ" എന്ന ആട്രിബ്യൂട്ട് "TxQueue" തിരഞ്ഞെടുത്തവയുടെ നെറ്റ് ഡിവൈസ്.

എല്ലാ നോഡുകൾക്കും എല്ലാ നെറ്റ് ഉപകരണങ്ങൾക്കും ഈ മൂല്യം സജ്ജീകരിക്കാൻ നമുക്ക് വൈൽഡ്കാർഡുകൾ ഉപയോഗിക്കാമായിരുന്നു
(ഈ ലളിതമായ ഉദാഹരണത്തിൽ മുമ്പത്തേതിന് സമാനമായ ഫലമുണ്ട് കോൺഫിഗറേഷൻ::സെറ്റ് ()):

കോൺഫിഗറേഷൻ::സെറ്റ് ("/നോഡ്‌ലിസ്റ്റ്/*/ഡിവൈസ്‌ലിസ്റ്റ്/*/TxQueue/MaxPackets",
UintegerValue (15));
txQueue->GetAttribute ("MaxPackets", പരിധി);
NS_LOG_INFO ("5. txQueue പരിധി വൈൽഡ്കാർഡ് നെയിംസ്പേസിലൂടെ മാറ്റി: "
<< പരിധി. നേടുക () << "പാക്കറ്റുകൾ");

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

പേരുകൾ:: ചേർക്കുക ("സെർവർ", n0);
പേരുകൾ::ചേർക്കുക ("സെർവർ/eth0", net0);

...

കോൺഫിഗറേഷൻ::സെറ്റ് ("/പേരുകൾ/സെർവർ/eth0/TxQueue/MaxPackets", UintegerValue (25));

ഇവിടെ ഞങ്ങൾ പാത്ത് ഘടകങ്ങൾ ചേർത്തു "സെർവർ" ഒപ്പം "eth0" കീഴെ "/പേരുകൾ/" നെയിംസ്പേസ്, പിന്നെ
ആട്രിബ്യൂട്ട് സജ്ജമാക്കാൻ തത്ഫലമായുണ്ടാകുന്ന കോൺഫിഗറേഷൻ പാത്ത് ഉപയോഗിച്ചു.

പൂർണ്ണമായ ചികിത്സയ്ക്കായി ഒബ്ജക്റ്റ്-നാമങ്ങൾ കാണുക ns-3 കോൺഫിഗറേഷൻ നെയിംസ്പേസ്.

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

p->Set ("cwnd", StringValue ("100")); // സ്ട്രിംഗ് അടിസ്ഥാനമാക്കിയുള്ള സെറ്റർ
p->Set ("cwnd", IntegerValue (100)); // പൂർണ്ണസംഖ്യ അടിസ്ഥാനമാക്കിയുള്ള സെറ്റർ

പുതിയ ആട്രിബ്യൂട്ട് മൂല്യം പ്രഖ്യാപിക്കാനും നിർവചിക്കാനും ഉപയോക്താക്കളെ സഹായിക്കുന്ന ചില മാക്രോകൾ സിസ്റ്റം നൽകുന്നു
ആട്രിബ്യൂട്ട് സിസ്റ്റത്തിലേക്ക് അവർ അവതരിപ്പിക്കാൻ ആഗ്രഹിക്കുന്ന പുതിയ തരങ്ങൾക്കായുള്ള ഉപവിഭാഗങ്ങൾ:

· ATTRIBUTE_HELPER_HEADER

· ATTRIBUTE_HELPER_CPP

കൂടുതൽ വിവരങ്ങൾക്ക് ഈ നിർമ്മിതികൾക്കായുള്ള API ഡോക്യുമെന്റേഷൻ കാണുക.

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

ഈ നോൺ-സ്പെസിഫിക് ഓർഡറിംഗ് കാരണം, സിസ്റ്റത്തിലെ ഒരു ആട്രിബ്യൂട്ടിനും ആശ്രിതത്വം ഉണ്ടാകണമെന്നില്ല
മറ്റേതെങ്കിലും ആട്രിബ്യൂട്ടിൽ. ഒരു അനന്തരഫലമെന്ന നിലയിൽ, ആട്രിബ്യൂട്ട് സെറ്ററുകൾ ഒരിക്കലും സംസ്ഥാനം കാരണം പരാജയപ്പെടരുത്
മറ്റൊരു ആട്രിബ്യൂട്ടിന്റെ. ഒരു ആട്രിബ്യൂട്ട് സെറ്ററും മറ്റേതെങ്കിലും ആട്രിബ്യൂട്ട് മൂല്യം മാറ്റാൻ (സജ്ജീകരിക്കാൻ) പാടില്ല
അതിന്റെ മൂല്യം മാറ്റുന്നതിന്റെ ഫലം.

ഇത് വളരെ ശക്തമായ നിയന്ത്രണമാണ്, ആട്രിബ്യൂട്ടുകൾ സജ്ജീകരിക്കേണ്ട സാഹചര്യങ്ങളുണ്ട്
ശരിയായ പ്രവർത്തനം അനുവദിക്കുന്നതിന് സ്ഥിരമായി. ഇതിനായി ഞങ്ങൾ സ്ഥിരത പരിശോധിക്കാൻ അനുവദിക്കുന്നു
എപ്പോൾ The ആട്രിബ്യൂട്ട് is ഉപയോഗിച്ച (cf. NS_ASSERT_MSG or NS_ABORT_MSG).

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

ConfigStore::ConfigStore ()
{
ഒബ്ജക്റ്റ്ബേസ്::കൺസ്ട്രക്റ്റ്സെൽഫ് (ആട്രിബ്യൂട്ട് കൺസ്ട്രക്ഷൻ ലിസ്റ്റ് ());
// കൺസ്ട്രക്റ്ററുമായി തുടരുക.
}

ഒബ്ജക്റ്റും അതിന്റെ എല്ലാ ഡിറൈവ്ഡ് ക്ലാസുകളും കൂടി നടപ്പിലാക്കണം എന്ന് സൂക്ഷിക്കുക a GetInstanceTypeId
() രീതി. അല്ലാത്തപക്ഷം ദി ഒബ്ജക്റ്റ്ബേസ്::കൺസ്ട്രക്റ്റ്സെൽഫ് () വായിക്കാൻ കഴിയില്ല
ഗുണവിശേഷങ്ങൾ.

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

മൂന്ന് സാധാരണ ഉപയോഗ കേസുകളുണ്ട്:

· നിലവിലുള്ള ക്ലാസ് ഡാറ്റ അംഗത്തെ ഒരു ആട്രിബ്യൂട്ട് ആയി ആക്‌സസ് ചെയ്യാവുന്നതാക്കുന്നു, അത് ഇതിനകം അല്ലാത്തപ്പോൾ.

· ഒരു പുതിയ ക്ലാസിന് ഒരു ടൈപ്പ് ഐഡി നൽകിക്കൊണ്ട് ചില ഡാറ്റ അംഗങ്ങളെ ആട്രിബ്യൂട്ടുകളായി വെളിപ്പെടുത്താൻ പ്രാപ്തമാക്കുന്നു.

· ഒരു സൃഷ്ടിക്കുന്നു ആട്രിബ്യൂട്ട് മൂല്യം ഒരു പുതിയ ക്ലാസിനുള്ള സബ്ക്ലാസ് അങ്ങനെ ആക്സസ് ചെയ്യാൻ കഴിയും
ആട്രിബ്യൂട്ട്.

നിലവിലുള്ള അംഗം വേരിയബിൾ
ഈ വേരിയബിൾ പരിഗണിക്കുക TcpSocket:

uint32_t m_cWnd; // തിരക്കുള്ള ജാലകം

ടിസിപിയിൽ പ്രവർത്തിക്കുന്ന ഒരാൾക്ക് ആ വേരിയബിളിന്റെ മൂല്യം നേടാനോ സജ്ജീകരിക്കാനോ താൽപ്പര്യമുണ്ടെന്ന് കരുതുക
മെറ്റാഡാറ്റ സിസ്റ്റം ഉപയോഗിച്ച്. ഇത് ഇതിനകം നൽകിയിട്ടില്ലെങ്കിൽ ns-3, ഉപയോക്താവിന് പ്രഖ്യാപിക്കാൻ കഴിയും
റൺടൈം മെറ്റാഡാറ്റ സിസ്റ്റത്തിൽ ഇനിപ്പറയുന്ന കൂട്ടിച്ചേർക്കൽ (ഇതിലേക്ക് GetTypeId() എന്നതിനുള്ള നിർവ്വചനം
TcpSocket):

.AddAttribute ("തിരക്ക് ജാലകം",
"ടിസിപി കൺജഷൻ വിൻഡോ (ബൈറ്റുകൾ)",
UintegerValue (1),
MakeUintegerAccessor (&TcpSocket::m_cWnd),
MakeUintegerChecker ())

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

പുതിയ ക്ലാസ് ടൈപ്പ് ഐഡി
ഒരു പുതിയ ക്ലാസ് ചേർക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു ഉപയോക്താവിന്മേലുള്ള ആഘാതം ഞങ്ങൾ ഇവിടെ ചർച്ചചെയ്യുന്നു ns-3. എന്ത്
ആട്രിബ്യൂട്ടുകൾ കൈവശം വയ്ക്കാൻ ഇത് പ്രാപ്തമാക്കാൻ കൂടുതൽ കാര്യങ്ങൾ ചെയ്യേണ്ടതുണ്ടോ?

നമ്മുടെ പുതിയ ക്ലാസ്സ് എന്ന് നമുക്ക് ഊഹിക്കാം ns3::MyMobility, ഒരു തരം മൊബിലിറ്റി മോഡലാണ്. ആദ്യം,
ക്ലാസ് അതിന്റെ പാരന്റ് ക്ലാസിൽ നിന്ന് അവകാശമാക്കണം, ns3::മൊബിലിറ്റി മോഡൽ. എസ് my-mobility.h
തലക്കെട്ട് ഫയൽ:

നെയിംസ്പേസ് ns3 {

ക്ലാസ് MyClass : പൊതു മൊബിലിറ്റി മോഡൽ
{

ഇത് ഞങ്ങൾ പ്രഖ്യാപിക്കേണ്ടതുണ്ട് GetTypeId () പ്രവർത്തനം. ഇതൊരു ഒറ്റവരി പൊതു ചടങ്ങാണ്
പ്രഖ്യാപനം:

പൊതുവായത്:
/ **
* ഈ തരം രജിസ്റ്റർ ചെയ്യുക.
* ഒബ്ജക്റ്റ് TypeId തിരികെ നൽകുക.
*/
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);

എന്താണെന്ന് ഞങ്ങൾ ഇതിനകം അവതരിപ്പിച്ചു ടൈപ്പ് ഐഡി നിർവചനം പോലെ കാണപ്പെടും my-mobility.cc
നടപ്പിലാക്കൽ ഫയൽ:

NS_OBJECT_ENSURE_REGISTERED (MyMobility);

ടൈപ്പ് ഐഡി
MyMobility::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::MyMobility")
.SetParent ()
.SetGroupName ("മൊബിലിറ്റി")
.AddConstructor ()
.AddAtribute ("അതിരുകൾ",
"കപ്പൽ യാത്രയ്ക്കുള്ള പ്രദേശത്തിന്റെ അതിരുകൾ.",
ദീർഘചതുരം മൂല്യം (ദീർഘചതുരം (0.0, 0.0, 100.0, 100.0)),
Make RectangleAccessor (&MyMobility::m_bounds),
Make RectangleChecker ())
.AddAtribute ("സമയം",
"ഈ കാലതാമസത്തിനായി നീങ്ങിയ ശേഷം നിലവിലെ ദിശയും വേഗതയും മാറ്റുക.",
സമയമൂല്യം (സെക്കൻഡ് (1.0)),
MakeTimeAccessor (&MyMobility::m_modeTime),
MakeTimeChecker ())
// തുടങ്ങിയവ (കൂടുതൽ പാരാമീറ്ററുകൾ).
;
റിട്ടേൺ ടിഡ്;
}

നിലവിലുള്ള ഒരു ക്ലാസിൽ നിന്ന് സബ്ക്ലാസ് ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, ഹെഡർ ഫയലിൽ നമുക്ക് അവകാശമുണ്ട്
നിന്ന് ns3::ഒബ്ജക്റ്റ്, കൂടാതെ ഒബ്ജക്റ്റ് ഫയലിൽ ഞങ്ങൾ പാരന്റ് ക്ലാസ് സജ്ജമാക്കി ns3::ഒബ്ജക്റ്റ് കൂടെ
.SetParent ().

ഇവിടെ സാധാരണ തെറ്റുകൾ ഉൾപ്പെടുന്നു:

· വിളിക്കുന്നില്ല NS_OBJECT_ENSURE_REGISTERED ()

· വിളിക്കുന്നില്ല സെറ്റ്പാരന്റ് () രീതി, അല്ലെങ്കിൽ തെറ്റായ തരത്തിൽ വിളിക്കുന്നു.

· വിളിക്കുന്നില്ല ആഡ് കൺസ്ട്രക്റ്റർ () രീതി, അല്ലെങ്കിൽ തെറ്റായ തരത്തിൽ വിളിക്കുന്നു.

യുടെ പേരിൽ ഒരു ടൈപ്പോഗ്രാഫിക്കൽ പിശക് അവതരിപ്പിക്കുന്നു ടൈപ്പ് ഐഡി അതിന്റെ കൺസ്ട്രക്റ്ററിൽ.

സി++ ക്ലാസിന്റെ പൂർണ്ണ യോഗ്യതയുള്ള C++ ടൈപ്പ്‌നെയിം അതിന്റെ പേരായി ഉപയോഗിക്കുന്നില്ല.
ടൈപ്പ് ഐഡി. അതല്ല "ns3::" ആവശ്യമാണ്.

ഈ പിഴവുകളൊന്നും കണ്ടെത്താൻ കഴിയില്ല ns-3 കോഡ്ബേസ്, അതിനാൽ ഉപയോക്താക്കൾ പരിശോധിക്കാൻ നിർദ്ദേശിക്കുന്നു
ശ്രദ്ധാപൂർവം ഒന്നിലധികം തവണ അവർ ഇത് ശരിയാക്കി.

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

ഹെഡ്ഡർ ഫയല്
/ **
* \ഒരു 2d ദീർഘചതുരം ചുരുക്കുക
*/
ക്ലാസ് ദീർഘചതുരം
{
...

ഇരട്ട xMin;
ഇരട്ട xMax;
ഇരട്ട yMin;
ഇരട്ട yMax;
};

ഒരു മാക്രോ കോളും രണ്ട് ഓപ്പറേറ്റർമാരും, ക്ലാസ് ഡിക്ലറേഷന് താഴെ ചേർക്കണം
ഒരു ദീർഘചതുരം ഉപയോഗിക്കാവുന്ന മൂല്യമാക്കി മാറ്റുക ഗുണങ്ങളെ സിസ്റ്റം:

std::ostream &ഓപ്പറേറ്റർ << (std::ostream &os, const ദീർഘചതുരം &ദീർഘചതുരം);
std::istream & ഓപ്പറേറ്റർ >> (std:: istream &is, ദീർഘചതുരം & ദീർഘചതുരം);

ATTRIBUTE_HELPER_HEADER (ദീർഘചതുരം);

നടപ്പിലാക്കൽ ഫയല്
ക്ലാസ് നിർവചനത്തിൽ (.cc ഫയൽ), കോഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

ATTRIBUTE_HELPER_CPP (ദീർഘചതുരം);

std::ostream &
ഓപ്പറേറ്റർ << (std::ostream &os, const ദീർഘചതുരം & ദീർഘചതുരം)
{
os << rectangle.xMin << "|" << rectangle.xMax << "|" << rectangle.yMin << "|"
<< rectangle.yMax;
റിട്ടേൺ ഒഎസ്;
}
std::istream &
ഓപ്പറേറ്റർ >> (std::istream &is, ദീർഘചതുരം & ദീർഘചതുരം)
{
ചാർ c1, c2, c3;
ആണ് >> rectangle.xMin >> c1 >> rectangle.xMax >> c2 >> rectangle.yMin >> c3
>> rectangle.yMax;
എങ്കിൽ (c1 != '|' ||
c2 != '|' ||
c3 != '|')
{
is.setstate (std::ios_base::failbit);
}
മടക്കം ആണ്;
}

ഈ സ്ട്രീം ഓപ്പറേറ്റർമാർ ദീർഘചതുരത്തിന്റെ ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യത്തിൽ നിന്ന് പരിവർത്തനം ചെയ്യുന്നു
("xMin|xMax|yMin|yMax") കീഴിലുള്ള ദീർഘചതുരത്തിലേക്ക്. മോഡലർ ഇവ വ്യക്തമാക്കണം
ഓപ്പറേറ്റർമാരും പുതിയ ക്ലാസിന്റെ ഒരു ഉദാഹരണത്തിന്റെ സ്ട്രിംഗ് വാക്യഘടനയും.

കോൺഫിഗറേഷൻ സ്റ്റോർ
എന്നതിനായുള്ള മൂല്യങ്ങൾ ns-3 ആട്രിബ്യൂട്ടുകൾ ഒരു ASCII അല്ലെങ്കിൽ XML ടെക്സ്റ്റ് ഫയലിൽ സംഭരിച്ച് a-ലേക്ക് ലോഡ് ചെയ്യാം
ഭാവി സിമുലേഷൻ റൺ. ഈ സവിശേഷത അറിയപ്പെടുന്നത് ns-3 ConfigStore. ദി കോൺഫിഗറേഷൻ സ്റ്റോർ is
ആട്രിബ്യൂട്ട് മൂല്യങ്ങൾക്കും ഡിഫോൾട്ട് മൂല്യങ്ങൾക്കുമായി ഒരു പ്രത്യേക ഡാറ്റാബേസ്.

ഇത് പ്രത്യേകമായി പരിപാലിക്കുന്ന മൊഡ്യൂളാണെങ്കിലും src/config-store/ ഡയറക്ടറി, ഞങ്ങൾ
അതിന്റെ ഏക ആശ്രയമായതിനാൽ അത് ഇവിടെ രേഖപ്പെടുത്തുക ns-3 കോർ മൊഡ്യൂളും ആട്രിബ്യൂട്ടുകളും.

എന്നതിൽ നിന്നുള്ള ഒരു ഉദാഹരണം ഉപയോഗിച്ച് നമുക്ക് ഈ സിസ്റ്റം പര്യവേക്ഷണം ചെയ്യാം
src/config-store/examples/config-store-save.cc.

ആദ്യം, ഇതിന്റെ എല്ലാ ഉപയോക്താക്കളും കോൺഫിഗറേഷൻ സ്റ്റോർ ഇനിപ്പറയുന്ന പ്രസ്താവന ഉൾപ്പെടുത്തണം:

#ഉൾപ്പെടുത്തുക "ns3/config-store-module.h"

അടുത്തതായി, ഈ പ്രോഗ്രാം ഒരു സാമ്പിൾ ഒബ്ജക്റ്റ് ചേർക്കുന്നു കോൺഫിഗറേഷൻ ഉദാഹരണം സിസ്റ്റം വിപുലീകരിക്കുന്നത് എങ്ങനെയെന്ന് കാണിക്കാൻ:

class ConfigExample : പൊതു വസ്തു
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു) {
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::A")
.SetParent ()
.AddAttribute ("TestInt16", "സഹായ വാചകം",
പൂർണ്ണ മൂല്യം (-2),
MakeIntegerAccessor (&A::m_int16),
MakeIntegerChecker ())
;
റിട്ടേൺ ടിഡ്;
}
int16_t m_int16;
};

NS_OBJECT_ENSURE_REGISTERED (ConfigExample);

അടുത്തതായി, സ്ഥിരസ്ഥിതികളെ രണ്ട് വഴികളിലൂടെ മറികടക്കാൻ ഞങ്ങൾ കോൺഫിഗറേഷൻ സബ്സിസ്റ്റം ഉപയോഗിക്കുന്നു:

കോൺഫിഗറേഷൻ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigExample::TestInt16", IntegerValue (-5));

Ptr a_obj = CreateObject ();
NS_ABORT_MSG_UNLESS (a_obj->m_int16 == -5,
"Config::SetDefault വഴി ConfigExample-ന്റെ പൂർണ്ണസംഖ്യ ആട്രിബ്യൂട്ട് സജ്ജമാക്കാൻ കഴിയില്ല");

Ptr a2_obj = CreateObject ();
a2_obj->SetAtribute ("TestInt16", IntegerValue (-3));
IntegerValue iv;
a2_obj->GetAtribute ("TestInt16", iv);
NS_ABORT_MSG_UNLESS (iv.Get () == -3,
"SetAttribute വഴി ConfigExample-ന്റെ പൂർണ്ണസംഖ്യ ആട്രിബ്യൂട്ട് സജ്ജമാക്കാൻ കഴിയില്ല");

സൃഷ്ടിച്ച ഒബ്‌ജക്‌റ്റുകളിൽ ഒന്ന് വേരൂന്നിയതാണെന്ന് ഉറപ്പാക്കാൻ അടുത്ത പ്രസ്താവന ആവശ്യമാണ്
കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ ഒരു ഒബ്ജക്റ്റ് ഉദാഹരണമായി. നിങ്ങൾ ചെയ്യുമ്പോൾ ഇത് സാധാരണയായി സംഭവിക്കുന്നു
ഒബ്ജക്റ്റുകൾ a ലേക്ക് സമാഹരിക്കുക ns3::നോഡ് or ns3::ചാനൽ ഉദാഹരണത്തിന്, എന്നാൽ ഇവിടെ, ഞങ്ങൾ ജോലി ചെയ്യുന്നതിനാൽ
പ്രധാന തലത്തിൽ, നമുക്ക് ഒരു പുതിയ റൂട്ട് നെയിംസ്പേസ് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കേണ്ടതുണ്ട്:

കോൺഫിഗറേഷൻ::RegisterRootNamespaceObject (a2_obj);

എഴുത്തു
അടുത്തതായി, കോൺഫിഗറേഷൻ സ്റ്റോർ ഔട്ട്പുട്ട് ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഇത് രണ്ടായി എങ്ങനെ ചെയ്യാമെന്ന് ഉദാഹരണങ്ങൾ കാണിക്കുന്നു
ഫോർമാറ്റുകൾ, XML, റോ ടെക്സ്റ്റ്. പ്രായോഗികമായി, വിളിക്കുന്നതിന് തൊട്ടുമുമ്പ് ഒരാൾ ഈ ഘട്ടം ചെയ്യണം
സിമുലേറ്റർ:: റൺ () സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് തൊട്ടുമുമ്പ് അന്തിമ കോൺഫിഗറേഷൻ സംരക്ഷിക്കാൻ.

ConfigStore-ന്റെ സ്വഭാവത്തെ നിയന്ത്രിക്കുന്ന മൂന്ന് ആട്രിബ്യൂട്ടുകൾ ഉണ്ട്: "മോഡ്",
"ഫയലിന്റെ പേര്", ഒപ്പം "ഫയൽ ഫോർമാറ്റ്". മോഡ് (സ്ഥിരസ്ഥിതി "ഒന്നുമില്ല") എന്ന് കോൺഫിഗർ ചെയ്യുന്നു ns-3 വേണം
മുമ്പ് സംരക്ഷിച്ച ഫയലിൽ നിന്ന് കോൺഫിഗറേഷൻ ലോഡ് ചെയ്യുക (വ്യക്തമാക്കുക "മോഡ്=ലോഡ്") അല്ലെങ്കിൽ ഒരു ഫയലിൽ സേവ് ചെയ്യുക
(വ്യക്തമാക്കുക "മോഡ്=സംരക്ഷിക്കുക"). ഫയലിന്റെ പേര് (സ്ഥിരസ്ഥിതി "") എവിടെയാണ് കോൺഫിഗ്‌സ്റ്റോർ വായിക്കേണ്ടത് അല്ലെങ്കിൽ
അതിന്റെ ഡാറ്റ എഴുതുക. ഫയൽ ഫോർമാറ്റ് (സ്ഥിരസ്ഥിതി "റോ ടെക്സ്റ്റ്") ConfigStore ഫോർമാറ്റ് ആണോ എന്ന് നിയന്ത്രിക്കുന്നു
പ്ലെയിൻ ടെക്സ്റ്റ് അല്ലെങ്കിൽ Xml ആണ് ("ഫയൽ ഫോർമാറ്റ്=എക്സ്എംഎൽ")

ഉദാഹരണം കാണിക്കുന്നു:

കോൺഫിഗറേഷൻ ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore::Filename", StringValue ("output-attributes.xml"));
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3 :: കോൺഫിഗ് സ്റ്റോർ :: ഫയൽ ഫോർമാറ്റ്", സ്ട്രിംഗ് വാല്യൂ ("എക്സ്എംഎൽ"));
കോൺഫിഗറേഷൻ ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore :: Mode", StringValue ("സംരക്ഷിക്കുക"));
ConfigStore outputConfig;
outputConfig.ConfigureDefaults ();
outputConfig.ConfigureAttributes ();

// ഔട്ട്‌പുട്ട് കോൺഫിഗർ സ്റ്റോർ txt ഫോർമാറ്റിലേക്ക്
കോൺഫിഗറേഷൻ ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore::Filename", StringValue ("output-attributes.txt"));
Config ::SetDefault ("ns3 ::ConfigStore ::FileFormat", StringValue ("RawText"));
കോൺഫിഗറേഷൻ ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore :: Mode", StringValue ("സംരക്ഷിക്കുക"));
ConfigStore outputConfig2;
outputConfig2.ConfigureDefaults ();
outputConfig2.ConfigureAttributes ();

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

സിമുലേറ്റർ:: നശിപ്പിക്കുക ();

ഇതിന് തൊട്ടുമുമ്പ് ഈ പ്രസ്താവനകളുടെ സ്ഥാനം ശ്രദ്ധിക്കുക സിമുലേറ്റർ:: റൺ () പ്രസ്താവന.
സിമുലേഷൻ ആരംഭിക്കുന്നതിന് തൊട്ടുമുമ്പ് ഈ ഔട്ട്പുട്ട് എല്ലാ മൂല്യങ്ങളും ലോഗ് ചെയ്യുന്നു (അതായത്.
എല്ലാ കോൺഫിഗറേഷനും നടന്നതിന് ശേഷം).

പ്രവർത്തിപ്പിച്ചതിന് ശേഷം, നിങ്ങൾക്ക് തുറക്കാൻ കഴിയും output-attributes.txt ഫയൽ ചെയ്ത് കാണുക:

ഡിഫോൾട്ട് ns3::RealtimeSimulatorImpl::SynchronizationMode "BestEffort"
default ns3::RealtimeSimulatorImpl::HardLimit "+100000000.0ns"
ഡിഫോൾട്ട് ns3 ::PcapFileWrapper ::CaptureSize "65535"
ഡിഫോൾട്ട് ns3 ::PacketSocket ::RcvBufSize "131072"
default ns3 ::ErrorModel ::IsEnabled "true"
സ്ഥിരസ്ഥിതി ns3::RateErrorModel::ErrorUnit "EU_BYTE"
സ്ഥിരസ്ഥിതി ns3 :: RateErrorModel ::ErrorRate "0"
default ns3 :: RateErrorModel ::RanVar "യൂണിഫോം:0:1"
സ്ഥിരസ്ഥിതി ns3 ::DropTailQueue ::മോഡ് "പാക്കറ്റുകൾ"
ഡിഫോൾട്ട് ns3 ::DropTailQueue ::MaxPackets "100"
സ്ഥിരസ്ഥിതി ns3 ::DropTailQueue ::MaxBytes "6553500"
ഡിഫോൾട്ട് ns3 ::അപ്ലിക്കേഷൻ ::StartTime "+0.0ns"
ഡിഫോൾട്ട് ns3 ::അപ്ലിക്കേഷൻ ::StopTime "+0.0ns"
സ്ഥിരസ്ഥിതി ns3::ConfigStore::മോഡ് "സംരക്ഷിക്കുക"
default ns3 ::ConfigStore ::ഫയലിന്റെ പേര് "output-attributes.txt"
default ns3 ::ConfigStore ::FileFormat "RawText"
default ns3 ::ConfigExample ::TestInt16 "-5"
ആഗോള RngSeed "1"
ആഗോള RngRun "1"
ആഗോള സിമുലേറ്റർ ഇംപ്ലിമെന്റേഷൻ തരം "ns3::DefaultSimulatorImpl"
ആഗോള ഷെഡ്യൂളർ തരം "ns3::MapScheduler"
ആഗോള ചെക്ക്‌സം പ്രവർത്തനക്ഷമമാക്കിയ "തെറ്റ്"
മൂല്യം /$ns3::ConfigExample/TestInt16 "-3"

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

ഒരു XML പതിപ്പും നിലവിലുണ്ട് output-attributes.xml:




























നിങ്ങളുടെ സിമുലേഷൻ സ്‌ക്രിപ്‌റ്റും ഔട്ട്‌പുട്ട് ഡാറ്റയും ഉപയോഗിച്ച് ഈ ഫയൽ ആർക്കൈവ് ചെയ്യാനാകും.

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

കോൺഫിഗറേഷൻ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore::Filename", StringValue ("input-defaults.xml"));
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3 :: കോൺഫിഗ്സ്റ്റോർ :: മോഡ്", സ്ട്രിംഗ് വാല്യൂ ("ലോഡ്"));
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3 :: കോൺഫിഗ് സ്റ്റോർ :: ഫയൽ ഫോർമാറ്റ്", സ്ട്രിംഗ് വാല്യൂ ("എക്സ്എംഎൽ"));
ConfigStore inputConfig;
inputConfig.ConfigureDefaults ();

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

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

എപ്പോഴാണ് കോൺഫിഗറേഷൻ സ്റ്റോർ വസ്തു തൽക്ഷണം, അതിന്റെ ഗുണവിശേഷതകൾ "ഫയലിന്റെ പേര്", "മോഡ്", ഒപ്പം
"ഫയൽ ഫോർമാറ്റ്" ഒന്നുകിൽ സജ്ജീകരിക്കണം വഴി കമാൻഡ്-ലൈൻ അല്ലെങ്കിൽ വഴി പ്രോഗ്രാം പ്രസ്താവനകൾ.

വായന/എഴുത്ത് ഉദാഹരണം
കൂടുതൽ സങ്കീർണ്ണമായ ഒരു ഉദാഹരണം എന്ന നിലയിൽ, നമുക്ക് ഒരു കോൺഫിഗറേഷനിൽ വായിക്കണമെന്ന് അനുമാനിക്കാം
എന്ന പേരിലുള്ള ഒരു ഇൻപുട്ട് ഫയലിൽ നിന്നുള്ള ഡിഫോൾട്ടുകൾ input-defaults.xml, ഫലമായുണ്ടാകുന്നത് എഴുതുക
എന്ന പ്രത്യേക ഫയലിലേക്ക് ആട്രിബ്യൂട്ടുകൾ output-attributes.xml.:

#ഉൾപ്പെടുത്തുക "ns3/config-store-module.h"
...
ഇൻറ്റ് മെയിൻ (...)
{

കോൺഫിഗറേഷൻ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore::Filename", StringValue ("input-defaults.xml"));
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3 :: കോൺഫിഗ്സ്റ്റോർ :: മോഡ്", സ്ട്രിംഗ് വാല്യൂ ("ലോഡ്"));
കോൺഫിഗറേഷൻ :: സെറ്റ് ഡിഫോൾട്ട് ("ns3 :: കോൺഫിഗ് സ്റ്റോർ :: ഫയൽ ഫോർമാറ്റ്", സ്ട്രിംഗ് വാല്യൂ ("എക്സ്എംഎൽ"));
ConfigStore inputConfig;
inputConfig.ConfigureDefaults ();

//
// ഏതെങ്കിലും ഡിഫോൾട്ടുകളും മുകളിലുള്ള ബൈൻഡ് () അറ്റ് അസാധുവാക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുക
// റൺ-ടൈം, കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ വഴി
//
കമാൻഡ് ലൈൻ cmd;
cmd.Parse (argc, argv);

// ടോപ്പോളജി സജ്ജീകരിക്കുക
...

// സിമുലേറ്ററിൽ പ്രവേശിക്കുന്നതിന് തൊട്ടുമുമ്പ് വിളിക്കുക ::റൺ ()
കോൺഫിഗറേഷൻ ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore::Filename", StringValue ("output-attributes.xml"));
കോൺഫിഗറേഷൻ ::സെറ്റ് ഡിഫോൾട്ട് ("ns3::ConfigStore :: Mode", StringValue ("സംരക്ഷിക്കുക"));
ConfigStore outputConfig;
outputConfig.ConfigureAttributes ();
സിമുലേറ്റർ:: റൺ ();
}

കോൺഫിഗറേഷൻ സ്റ്റോർ GUI
ConfigStore-ന് GTK അടിസ്ഥാനമാക്കിയുള്ള ഒരു ഫ്രണ്ട് എൻഡ് ഉണ്ട്. ഇത് ഒരു GUI ഉപയോഗിക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്നു
വേരിയബിളുകൾ ആക്സസ് ചെയ്യുകയും മാറ്റുകയും ചെയ്യുക. ഈ സവിശേഷതയുടെ സ്ക്രീൻഷോട്ടുകൾ ലഭ്യമാണ് |ns3|
പൊതു അവലോകനം അവതരണം.

ഈ സവിശേഷത ഉപയോഗിക്കുന്നതിന്, ഒരാൾ ഇൻസ്റ്റാൾ ചെയ്യണം libgtk ഒപ്പം libgtk-dev; ഒരു ഉദാഹരണം ഉബുണ്ടു
ഇൻസ്റ്റലേഷൻ കമാൻഡ് ഇതാണ്:

$ sudo apt-get install libgtk2.0-0 libgtk2.0-dev

ഇത് കോൺഫിഗർ ചെയ്‌തിട്ടുണ്ടോ ഇല്ലയോ എന്ന് പരിശോധിക്കാൻ, ഘട്ടത്തിന്റെ ഔട്ട്പുട്ട് പരിശോധിക്കുക:

$ ./waf കോൺഫിഗർ --enable-examples --enable-tests

---- ഓപ്ഷണൽ NS-3 സവിശേഷതകളുടെ സംഗ്രഹം:
പൈത്തൺ ബൈൻഡിംഗുകൾ: പ്രവർത്തനക്ഷമമാക്കി
പൈത്തൺ API സ്കാനിംഗ് പിന്തുണ: പ്രവർത്തനക്ഷമമാക്കി
NS-3 ക്ലിക്ക് ഇന്റഗ്രേഷൻ : പ്രവർത്തനക്ഷമമാക്കി
GtkConfigStore : പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല (ലൈബ്രറി 'gtk+-2.0 >= 2.12' കണ്ടെത്തിയില്ല)

മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഇത് പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല, അതിനാൽ അനുയോജ്യമായ പതിപ്പ് ഉണ്ടാകുന്നതുവരെ ഇത് ഉപയോഗിക്കാൻ കഴിയില്ല
ഇൻസ്റ്റാൾ ചെയ്തതും:

$ ./waf കോൺഫിഗർ --enable-examples --enable-tests
$ ./waf

വീണ്ടും പ്രക്ഷേപണം ചെയ്യുന്നു.

GTK-അധിഷ്‌ഠിതമല്ലാത്ത പതിപ്പിന്റെ ഉപയോഗം ഏതാണ്ട് സമാനമാണ്, പക്ഷേ ഇല്ല കോൺഫിഗറേഷൻ സ്റ്റോർ
ഉൾപ്പെട്ടിരിക്കുന്ന ആട്രിബ്യൂട്ടുകൾ:

// സിമുലേറ്ററിൽ പ്രവേശിക്കുന്നതിന് തൊട്ടുമുമ്പ് വിളിക്കുക ::റൺ ()
GtkConfigStore കോൺഫിഗറേഷൻ;
config.ConfigureDefaults ();
config.ConfigureAtributes ();

ഇപ്പോൾ, നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, മെനുകൾ തുറക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു GUI പോപ്പ് അപ്പ് ചെയ്യണം
വ്യത്യസ്‌ത നോഡുകൾ/ഒബ്‌ജക്‌റ്റുകളിലെ ആട്രിബ്യൂട്ടുകൾ, തുടർന്ന് നിങ്ങൾ ചെയ്യുമ്പോൾ സിമുലേഷൻ എക്‌സിക്യൂഷൻ സമാരംഭിക്കുക
ചെയ്തിരിക്കുന്നു.

ഭാവി വേല
സാധ്യമായ രണ്ട് മെച്ചപ്പെടുത്തലുകൾ ഉണ്ട്:

ഫയലിന്റെ ആരംഭത്തിൽ തീയതിയും സമയവും സഹിതമുള്ള ഒരു അദ്വിതീയ പതിപ്പ് നമ്പർ സംരക്ഷിക്കുക.

· പ്രാരംഭ വിത്ത് എവിടെയെങ്കിലും സൂക്ഷിക്കുക.

· ഓരോ റാൻഡം വേരിയബിളും അതിന്റേതായ പ്രാരംഭ വിത്ത് സീരിയലൈസ് ചെയ്യുകയും പിന്നീട് വീണ്ടും വായിക്കുകയും ചെയ്യുക.

വസ്തു പേരുകൾ
പ്ലെയ്സ്ഹോൾഡർ അധ്യായം

ലോഗ് ചെയ്യുന്നു
ദി ns-3 സിമുലേഷന്റെ പുരോഗതി നിരീക്ഷിക്കുന്നതിനോ ഡീബഗ് ചെയ്യുന്നതിനോ ലോഗിംഗ് സൗകര്യം ഉപയോഗിക്കാം
പ്രോഗ്രാമുകൾ. നിങ്ങളിലെ പ്രോഗ്രാം പ്രസ്താവനകൾ വഴി ലോഗിംഗ് ഔട്ട്പുട്ട് പ്രവർത്തനക്ഷമമാക്കാം പ്രധാന () പ്രോഗ്രാം അല്ലെങ്കിൽ
ഉപയോഗിച്ച് NS_LOG എൻവയോൺമെന്റ് വേരിയബിൾ.

ലോഗിംഗ് സ്റ്റേറ്റ്‌മെന്റുകൾ ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡുകളിലേക്ക് കംപൈൽ ചെയ്തിട്ടില്ല ns-3. ലോഗിംഗ് ഉപയോഗിക്കുന്നതിന്, ഒന്ന്
യുടെ (സ്ഥിരസ്ഥിതി) ഡീബഗ് ബിൽഡ് നിർമ്മിക്കണം ns-3.

ലോഗിംഗ് ഔട്ട്‌പുട്ട് അതേപടി തുടരുമോ എന്നതിനെക്കുറിച്ച് പ്രോജക്റ്റ് യാതൊരു ഉറപ്പും നൽകുന്നില്ല
സമയം. ലോഗിംഗിന് മുകളിൽ സിമുലേഷൻ ഔട്ട്പുട്ട് ചട്ടക്കൂടുകൾ നിർമ്മിക്കുന്നതിനെതിരെ ഉപയോക്താക്കൾക്ക് മുന്നറിയിപ്പ് നൽകുന്നു
കോഡ്, ഔട്ട്പുട്ടും ഔട്ട്പുട്ട് പ്രവർത്തനക്ഷമമാക്കുന്ന രീതിയും കാലക്രമേണ മാറിയേക്കാം.

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

ഉദാഹരണത്തിന്, ഈ കോഡ് സ്നിപ്പറ്റ് ഇതിൽ നിന്നുള്ളതാണ് Ipv4L3Protocol ::IsDestinationAddress():

എങ്കിൽ (വിലാസം == iaddr.GetBroadcast ())
{
NS_LOG_LOGIC ("എനിക്ക് (ഇന്റർഫേസ് പ്രക്ഷേപണ വിലാസം)");
സത്യമായി മടങ്ങുക;
}

ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ Ipv4L3പ്രോട്ടോക്കോൾ ഒരു തീവ്രതയിൽ ഘടകം LOGIC or
മുകളിൽ (ലോഗിൻ്റെ തീവ്രതയെക്കുറിച്ച് താഴെ കാണുക), പ്രസ്താവന പ്രിന്റ് ഔട്ട് ചെയ്യും; അല്ലെങ്കിൽ, അത്
അടിച്ചമർത്തപ്പെടും.

പ്രാപ്തമാക്കുന്നു ഔട്ട്പുട്ട്
ഉപയോക്താക്കൾ സാധാരണയായി ലോഗ് ഔട്ട്പുട്ട് നിയന്ത്രിക്കുന്ന രണ്ട് വഴികളുണ്ട്. ആദ്യത്തേത് സജ്ജീകരിക്കുന്നതിലൂടെയാണ്
NS_LOG പരിസ്ഥിതി വേരിയബിൾ; ഉദാ:

$ NS_LOG="*" ./waf --ആദ്യം റൺ ചെയ്യുക

പ്രവർത്തിപ്പിക്കും ആദ്യം എല്ലാ ലോഗിംഗ് ഔട്ട്പുട്ടും ഉള്ള ട്യൂട്ടോറിയൽ പ്രോഗ്രാം. (ഇതിന്റെ പ്രത്യേകതകൾ NS_LOG
ഫോർമാറ്റ് ചുവടെ ചർച്ചചെയ്യും.)

വ്യക്തിഗത ഘടകങ്ങൾ തിരഞ്ഞെടുത്ത് ഇത് കൂടുതൽ ഗ്രാനുലാർ ആക്കാം:

$ NS_LOG="Ipv4L3Protocol" ./waf --ആദ്യം റൺ ചെയ്യുക

പ്രിഫിക്‌സ് ഓപ്‌ഷനുകൾ ഉപയോഗിച്ച് ഔട്ട്‌പുട്ട് കൂടുതൽ ക്രമീകരിക്കാവുന്നതാണ്.

ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നതിനുള്ള രണ്ടാമത്തെ മാർഗ്ഗം, നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഇൻ പോലുള്ള വ്യക്തമായ പ്രസ്താവനകൾ ഉപയോഗിക്കുക എന്നതാണ്
The ആദ്യം ട്യൂട്ടോറിയൽ പ്രോഗ്രാം:

int
പ്രധാനം (int argc, char *argv[])
{
LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
...

(ഇതിന്റെ അർത്ഥം LOG_LEVEL_INFO, മറ്റ് സാധ്യമായ മൂല്യങ്ങൾ എന്നിവ ചുവടെ ചർച്ചചെയ്യും.)

NS_LOG പദവിന്യാസം
ദി NS_LOG എൻവയോൺമെന്റ് വേരിയബിളിൽ ലോഗ് ഘടകങ്ങളുടെയും ഓപ്ഷനുകളുടെയും ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു. ലോഗ്
ഘടകങ്ങളെ `:' പ്രതീകങ്ങളാൽ വേർതിരിക്കുന്നു:

$ NS_LOG=" : ..."

ഓരോ ലോഗ് ഘടകത്തിനുമുള്ള ഓപ്ഷനുകൾ ഓരോ ലോഗ് ഘടകത്തിനും ശേഷം ഫ്ലാഗുകളായി നൽകിയിരിക്കുന്നു:

$ NS_LOG=" = | ...: ..."

ഓപ്‌ഷനുകൾ ആ ഘടകത്തിന്റെ തീവ്രതയും നിലയും നിയന്ത്രിക്കുന്നു, കൂടാതെ ഓപ്‌ഷണൽ ആണെങ്കിലും
സിമുലേഷൻ സമയം, സിമുലേഷൻ നോഡ്, പ്രവർത്തനം തുടങ്ങിയ വിവരങ്ങൾ ഉൾപ്പെടുത്തണം
പേര്, പ്രതീകാത്മക തീവ്രത.

ലോഗ് ഘടകങ്ങൾ
സാധാരണയായി ഒരു ലോഗ് ഘടകം ഒരൊറ്റ സോഴ്സ് കോഡിനെ സൂചിപ്പിക്കുന്നു .cc ഫയൽ, എന്നിവ ഉൾക്കൊള്ളുന്നു
മുഴുവൻ ഫയലും.

ഒരു മൊഡ്യൂളിലെ എല്ലാ ഘടകങ്ങളുടെയും ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കാൻ ചില സഹായികൾക്ക് പ്രത്യേക രീതികളുണ്ട്,
വ്യത്യസ്‌ത കംപൈലേഷൻ യൂണിറ്റുകളിൽ വ്യാപിച്ചുകിടക്കുന്നു, എന്നാൽ ലോജിക്കലായി ഒരുമിച്ച് ഗ്രൂപ്പുചെയ്‌തിരിക്കുന്നു ns-3
വൈഫൈ കോഡ്:

WifiHelper wifiHelper;
wifiHelper.EnableLogComponents ();

ദി NS_LOG ലോഗ് ഘടകം വൈൽഡ്കാർഡ് `*' എല്ലാ ഘടകങ്ങളെയും പ്രവർത്തനക്ഷമമാക്കും.

ലോഗ് ഘടകങ്ങൾ നിർവചിച്ചിരിക്കുന്നത് കാണുന്നതിന്, ഇവയിലേതെങ്കിലും പ്രവർത്തിക്കും:

$ NS_LOG="print-list" ./waf --run ...

$ NS_LOG="foo" # ഒരു ലോഗ്-ഘടകവുമായി പൊരുത്തപ്പെടാത്ത ഒരു ടോക്കൺ

ആദ്യ ഫോം എല്ലാ ലോഗ് ഘടകങ്ങൾക്കും പേരും പ്രവർത്തനക്ഷമമാക്കിയ ഫ്ലാഗുകളും പ്രിന്റ് ചെയ്യും
ലിങ്ക് ചെയ്‌തു; കൂടെ പരീക്ഷിക്കുക സ്ക്രാച്ച്-സിമുലേറ്റർ. രണ്ടാമത്തെ ഫോം രജിസ്റ്റർ ചെയ്ത എല്ലാ ലോഗുകളും പ്രിന്റ് ചെയ്യുന്നു
ഘടകങ്ങൾ, തുടർന്ന് ഒരു പിശക് ഉപയോഗിച്ച് പുറത്തുകടക്കുക.

തീവ്രത ഒപ്പം ലെവൽ ഓപ്ഷനുകൾ
വ്യക്തിഗത സന്ദേശങ്ങൾ മാക്രോ സൃഷ്‌ടിക്കുന്ന ഒരൊറ്റ "തീവ്രത ക്ലാസിൽ" പെടുന്നു
സന്ദേശം. മുകളിലെ ഉദാഹരണത്തിൽ, NS_LOG_LOGIC(..) എന്നതിൽ സന്ദേശം സൃഷ്ടിക്കുന്നു LOG_LOGIC
തീവ്രത ക്ലാസ്.

ഇനിപ്പറയുന്ന തീവ്രത ക്ലാസുകൾ ഇങ്ങനെ നിർവചിച്ചിരിക്കുന്നു enum സ്ഥിരാങ്കങ്ങൾ:

പതനം ─┐
│തീവ്രത ക്ലാസ് │ അർത്ഥം │
പതനം ─┤
│LOG_NONE │ ഡിഫോൾട്ട്, ലോഗിംഗ് ഇല്ല │
പതനം ─┤
│LOG_ERROR │ ഗുരുതരമായ പിശക് സന്ദേശങ്ങൾ മാത്രം │
പതനം ─┤
│LOG_WARN │ മുന്നറിയിപ്പ് സന്ദേശങ്ങൾ │
പതനം ─┤
│LOG_DEBUG │ ഡീബഗ്ഗിംഗിൽ ഉപയോഗിക്കുന്നതിന് │
പതനം ─┤
│LOG_INFO │ വിവരങ്ങൾ │
പതനം ─┤
│LOG_FUNCTION │ ഫംഗ്‌ഷൻ ട്രെയ്‌സിംഗ് │
പതനം ─┤
│LOG_LOGIC │ ഉള്ളിൽ ഫ്ലോ ട്രെയ്‌സിംഗ് നിയന്ത്രിക്കുക
│ │ ഫംഗ്ഷനുകൾ │
പതനം ─┘

ഒരു നിശ്ചിത തീവ്രത ക്ലാസിൽ സന്ദേശങ്ങൾ കാണാൻ സാധാരണയായി ഒരാൾ ആഗ്രഹിക്കുന്നു ഒപ്പം കൂടുതൽ. ഇത് ചെയ്യുന്നത്
ഉൾപ്പെടുന്ന ലോഗിംഗ് "ലെവലുകൾ" നിർവചിക്കുന്നു:

┌───────────────────┬───────────────────────────── ─────┐
│ലെവൽ │ അർത്ഥം │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_ERROR │ മാത്രം LOG_ERROR തീവ്രത ക്ലാസ് │
│ │ സന്ദേശങ്ങൾ. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_WARN │ LOG_WARN മുകളിൽ. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_DEBUG │ LOG_DEBUG മുകളിൽ. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_INFO │ LOG_INFO മുകളിൽ. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_FUNCTION │ LOG_FUNCTION മുകളിൽ. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_LOGIC │ LOG_LOGIC മുകളിൽ. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_LEVEL_ALL │ എല്ലാ തീവ്രത ക്ലാസുകളും. │
├───────────────────┼───────────────────────────── ─────┤
│LOG_ALL │ എന്നതിന്റെ പര്യായപദം LOG_LEVEL_ALL │
└───────────────────┴───────────────────────────── ─────┘

തീവ്രത ക്ലാസും ലെവൽ ഓപ്ഷനുകളും ഇതിൽ നൽകാം NS_LOG പരിസ്ഥിതി വേരിയബിൾ വഴി
ഈ ടോക്കണുകൾ:

┌─────────┬───────────────┐
│ക്ലാസ് │ ലെവൽ │
├─────────┼───────────────┤
│പിശക് │ ലെവൽ_പിശക് │
├─────────┼───────────────┤
│മുന്നറിയിപ്പ് │ level_warn │
├─────────┼───────────────┤
│ഡീബഗ് │ ലെവൽ_ഡീബഗ് │
├─────────┼───────────────┤
│വിവരം │ level_info │
├─────────┼───────────────┤
│ഫംഗ്ഷൻ │ ലെവൽ_ഫംഗ്ഷൻ │
├─────────┼───────────────┤
│തര്ക്കശാസ്തം │ level_logic │
├─────────┼───────────────┤
│ │ ലെവൽ_എല്ലാം │
│ │ എല്ലാം │
│ │ * │
└─────────┴───────────────┘

ഒരു തീവ്രത ക്ലാസ് ടോക്കൺ ഉപയോഗിക്കുന്നത് ആ തീവ്രതയിൽ മാത്രം ലോഗ് സന്ദേശങ്ങൾ പ്രവർത്തനക്ഷമമാക്കുന്നു. ഉദാഹരണത്തിന്,
NS_LOG="*=മുന്നറിയിപ്പ്" സന്ദേശങ്ങൾ തീവ്രതയോടെ ഔട്ട്പുട്ട് ചെയ്യില്ല പിശക്. NS_LOG="*=level_debug" ഉദ്ദേശിക്കുന്ന
തീവ്രത തലത്തിൽ സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ഡീബഗ് മുകളിൽ.

തീവ്രത ക്ലാസുകളും ലെവലുകളും `|' എന്നതുമായി സംയോജിപ്പിക്കാം ഓപ്പറേറ്റർ:
NS_LOG="*=level_warn|logic" തീവ്രതയിൽ സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യും പിശക്, മുന്നറിയിപ്പ് ഒപ്പം തര്ക്കശാസ്തം.

ദി NS_LOG തീവ്രത ലെവൽ വൈൽഡ്കാർഡ് `*' ഒപ്പം എല്ലാം എന്നതിന്റെ പര്യായപദങ്ങളാണ് ലെവൽ_എല്ലാം.

ഇതിൽ പരാമർശിച്ചിരിക്കുന്ന ലോഗ് ഘടകങ്ങൾക്ക് NS_LOG

$ NS_LOG=" :..."

സ്ഥിരസ്ഥിതി തീവ്രത LOG_LEVEL_ALL.

പ്രിഫിക്സ് ഓപ്ഷനുകൾ
ഒരു സന്ദേശം എവിടെ, എപ്പോൾ ഉത്ഭവിച്ചു, എന്തിന് എന്ന് തിരിച്ചറിയാൻ നിരവധി പ്രിഫിക്സുകൾക്ക് കഴിയും
തീവ്രത.

ലഭ്യമായ പ്രിഫിക്‌സ് ഓപ്‌ഷനുകൾ (അതുപോലെ enum സ്ഥിരാങ്കങ്ങൾ) ആകുന്നു

പതനം ───┐
│പ്രിഫിക്സ് ചിഹ്നം │ അർത്ഥം │
പതനം ───┤
│LOG_PREFIX_FUNC │ കോളിന്റെ പേര് പ്രിഫിക്സ് ചെയ്യുക │
│ │ ഫംഗ്ഷൻ. │
പതനം ───┤
│LOG_PREFIX_TIME │ സിമുലേഷൻ സമയം പ്രിഫിക്സ് ചെയ്യുക. │
പതനം ───┤
│LOG_PREFIX_NODE │ നോഡ് ഐഡി പ്രിഫിക്സ് ചെയ്യുക. │
പതനം ───┤
│LOG_PREFIX_LEVEL │ തീവ്രത ലെവൽ പ്രിഫിക്സ് ചെയ്യുക. │
പതനം ───┤
│LOG_PREFIX_ALL │ എല്ലാ പ്രിഫിക്സുകളും പ്രവർത്തനക്ഷമമാക്കുക. │
പതനം ───┘

പ്രിഫിക്‌സ് ഓപ്ഷനുകൾ ചുരുക്കമായി ചുവടെ വിവരിച്ചിരിക്കുന്നു.

എന്നതിൽ ഓപ്ഷനുകൾ നൽകാം NS_LOG ഈ ടോക്കണുകളാൽ പരിസ്ഥിതി വേരിയബിൾ:

┌────────────┬───────────┐
│ടോക്കൺ │ ഇതര │
├────────────┼──────────┤
│പ്രിഫിക്സ്_ഫങ്ക് │ ഫങ്ക് │
├────────────┼──────────┤
│പ്രിഫിക്സ്_സമയം │ കാലം │
└────────────┴───────────┘

│പ്രിഫിക്സ്_നോഡ് │ നോഡ് │
├────────────┼──────────┤
│പ്രിഫിക്സ്_ലെവൽ │ ലെവൽ │
├────────────┼──────────┤
│പ്രിഫിക്സ്_എല്ലാം │ എല്ലാം │
│ │ * │
└────────────┴───────────┘

ഇതിൽ പരാമർശിച്ചിരിക്കുന്ന ലോഗ് ഘടകങ്ങൾക്ക് NS_LOG

$ NS_LOG=" :..."

ഡിഫോൾട്ട് പ്രിഫിക്സ് ഓപ്ഷനുകൾ LOG_PREFIX_ALL.

തീവ്രത പ്രിഫിക്സ്
ഒരു സന്ദേശത്തിന്റെ തീവ്രത ക്ലാസ് ഓപ്‌ഷനുകൾക്കൊപ്പം ഉൾപ്പെടുത്താം പ്രിഫിക്സ്_ലെവൽ or ലെവൽ.
ഉദാഹരണത്തിന്, ഈ മൂല്യം NS_LOG എല്ലാ ലോഗ് ഘടകങ്ങൾക്കും (`*') ലോഗിംഗ് പ്രാപ്തമാക്കുന്നു
തീവ്രത ക്ലാസുകൾ (=എല്ലാം), കൂടാതെ സന്ദേശത്തിന്റെ തീവ്രത ക്ലാസ് ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്യുന്നു (|പ്രിഫിക്സ്_ലെവൽ).

$ NS_LOG="*=all|prefix_level" ./waf --run scratch-simulator
സ്ക്രാച്ച് സിമുലേറ്റർ
[ERROR] പിശക് സന്ദേശം
[മുന്നറിയിപ്പ്] മുന്നറിയിപ്പ് സന്ദേശം
[ഡീബഗ്] ഡീബഗ് സന്ദേശം
[INFO] വിവര സന്ദേശം
[FUNCT] ഫംഗ്‌ഷൻ സന്ദേശം
[LOGIC] ലോജിക് സന്ദേശം

കാലം പ്രിഫിക്സ്
സിമുലേഷൻ സമയം ഓപ്ഷനുകൾക്കൊപ്പം ഉൾപ്പെടുത്താം പ്രിഫിക്സ്_സമയം or കാലം. ഇത് പ്രിന്റ് ചെയ്യുന്നു
സിമുലേഷൻ സമയം സെക്കൻഡിൽ.

നോഡ് പ്രിഫിക്സ്
സിമുലേഷൻ നോഡ് ഐഡി ഓപ്‌ഷനുകൾക്കൊപ്പം ഉൾപ്പെടുത്താം പ്രിഫിക്സ്_നോഡ് or നോഡ്.

ഫംഗ്ഷൻ പ്രിഫിക്സ്
കോളിംഗ് ഫംഗ്‌ഷന്റെ പേര് ഓപ്‌ഷനുകൾക്കൊപ്പം ഉൾപ്പെടുത്താം പ്രിഫിക്സ്_ഫങ്ക് or ഫങ്ക്.

NS_LOG വൈൽഡ്കാർഡുകൾ
ലോഗ് ഘടകം വൈൽഡ്കാർഡ് `*' എല്ലാ ഘടകങ്ങളെയും പ്രവർത്തനക്ഷമമാക്കും. എല്ലാ ഘടകങ്ങളും പ്രവർത്തനക്ഷമമാക്കാൻ a
നിർദ്ദിഷ്ട തീവ്രത ലെവൽ ഉപയോഗം *=.

തീവ്രത ലെവൽ ഓപ്ഷൻ വൈൽഡ്കാർഡ് `*' എന്നതിന്റെ പര്യായപദമാണ് എല്ലാം. ഇത് എല്ലാത്തിനുമുമ്പ് സംഭവിക്കണം
`|' പ്രതീകങ്ങൾ വേർതിരിക്കുന്ന ഓപ്ഷനുകൾ. എല്ലാ തീവ്രത ക്ലാസുകളും പ്രവർത്തനക്ഷമമാക്കാൻ, ഉപയോഗിക്കുക =*,
or =*|.

ഓപ്ഷൻ വൈൽഡ്കാർഡ് `*' അല്ലെങ്കിൽ ടോക്കൺ എല്ലാം എല്ലാ പ്രിഫിക്‌സ് ഓപ്‌ഷനുകളും പ്രാപ്‌തമാക്കുന്നു, പക്ഷേ സംഭവിക്കണം ശേഷം a
`|' സ്വഭാവം. ഒരു നിർദ്ദിഷ്‌ട തീവ്രത ക്ലാസ് അല്ലെങ്കിൽ ലെവൽ, കൂടാതെ എല്ലാ പ്രിഫിക്‌സുകളും പ്രവർത്തനക്ഷമമാക്കാൻ, ഉപയോഗിക്കുക
= |*.

സംയുക്ത ഓപ്ഷൻ വൈൽഡ്കാർഡ് ** എല്ലാ തീവ്രതകളും എല്ലാ പ്രിഫിക്സുകളും പ്രാപ്തമാക്കുന്നു; ഉദാഹരണത്തിന്,
=**.

ഉബർ-വൈൽഡ്കാർഡ് *** എല്ലാ ലോഗ് ഘടകങ്ങൾക്കും എല്ലാ തീവ്രതകളും എല്ലാ പ്രിഫിക്സുകളും പ്രാപ്തമാക്കുന്നു.
ഇവയെല്ലാം തുല്യമാണ്:

$ NS_LOG="***" ... $ NS_LOG="*=എല്ലാം|*" ... $ NS_LOG="*=*|എല്ലാം" ...
$ NS_LOG="*=**" ... $ NS_LOG="*=level_all|*" ... $ NS_LOG="*=*|prefix_all" ...
$ NS_LOG="*=*|*" ...

ഉപദേശിക്കുക: നിസ്സാരമായത് പോലും സ്ക്രാച്ച്-സിമുലേറ്റർ ഉപയോഗിച്ച് ഔട്ട്പുട്ടിന്റെ 46K-ലധികം ലൈനുകൾ ഉത്പാദിപ്പിക്കുന്നു
NS_LOG="***"!

എങ്ങനെ ലേക്ക് ചേർക്കുക ലോഗിംഗ് ലേക്ക് നിങ്ങളുടെ കോഡ്
നിങ്ങളുടെ കോഡിലേക്ക് ലോഗിംഗ് ചേർക്കുന്നത് വളരെ ലളിതമാണ്:

1. അഭ്യർത്ഥിക്കുക NS_LOG_COMPONENT_DEFINE (...); മാക്രോ ഉള്ളിൽ നെയിംസ്പേസ് ns3.
ഒരു അദ്വിതീയ സ്ട്രിംഗ് ഐഡന്റിഫയർ സൃഷ്ടിക്കുക (സാധാരണയായി ഫയലിന്റെ കൂടാതെ/അല്ലെങ്കിൽ ക്ലാസിന്റെ പേര് അടിസ്ഥാനമാക്കിയുള്ളതാണ്
ഫയലിനുള്ളിൽ നിർവചിച്ചിരിക്കുന്നത്) കൂടാതെ ഇനിപ്പറയുന്നതുപോലുള്ള ഒരു മാക്രോ കോൾ ഉപയോഗിച്ച് അത് രജിസ്റ്റർ ചെയ്യുക:

നെയിംസ്പേസ് ns3 {

NS_LOG_COMPONENT_DEFINE ("Ipv4L3Protocol");
...

ഇത് രജിസ്റ്റർ ചെയ്യുന്നു Ipv4L3പ്രോട്ടോക്കോൾ ഒരു ലോഗ് ഘടകമായി.

(അകത്തോ പുറത്തോ ഉൾപ്പെടുത്താൻ അനുവദിക്കുന്നതിനായി മാക്രോ ശ്രദ്ധാപൂർവ്വം എഴുതിയിരിക്കുന്നു
നെയിംസ്പേസ് ns3, കൂടാതെ ഉപയോഗം കോഡ്ബേസിൽ ഉടനീളം വ്യത്യാസപ്പെടും, എന്നാൽ യഥാർത്ഥ ഉദ്ദേശം ഇതായിരുന്നു
ഇത് രജിസ്റ്റർ ചെയ്യുക പുറത്ത് നെയിംസ്പേസിന്റെ ns3 ഫയൽ ആഗോള വ്യാപ്തിയിൽ.)

2. നിങ്ങളുടെ ഫംഗ്‌ഷനുകളിലേക്കും ഫംഗ്‌ഷൻ ബോഡികളിലേക്കും ലോഗിംഗ് സ്റ്റേറ്റ്‌മെന്റുകൾ (മാക്രോ കോളുകൾ) ചേർക്കുക.

ലോഗ് ചെയ്യുന്നു മാക്രോകൾ
ലോഗിംഗ് മാക്രോകളും അനുബന്ധ തീവ്രത ലെവലുകളും

┌─────────────────────────────
│തീവ്രത ക്ലാസ് │ മാക്രോ │
├──────────────┼──────────
│LOG_NONE │ (ആവശ്യമില്ല) │
├──────────────┼──────────
│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 (...); │
├──────────────┼──────────
│LOG_LOGIC │ NS_LOG_LOGIC (...); │
────────────────────────────

മാക്രോകൾ ഔട്ട്‌പുട്ട് സ്ട്രീമറായി പ്രവർത്തിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് എന്തും അയയ്‌ക്കാൻ കഴിയും std::cout, ചേർന്നു
by << ഓപ്പറേറ്റർമാർ, അനുവദനീയമാണ്:

അസാധുവായ MyClass :: ചെക്ക് (int value, char * ഇനം)
{
NS_LOG_FUNCTION (ഈ << arg << ഇനം);
എങ്കിൽ (arg > 10)
{
NS_LOG_ERROR ("മോശമായ മൂല്യം നേരിട്ടു" << മൂല്യം <
" പരിശോധിക്കുമ്പോൾ " << പേര് << "!");
}
...
}

അതല്ല NS_LOG_FUNCTION സ്വയമേവ ഒരു ` ചേർക്കുന്നു,' (കോമ-സ്പേസ്) തമ്മിലുള്ള സെപ്പറേറ്റർ
അതിന്റെ ഓരോ വാദങ്ങളും. ഇത് ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകളുടെ ലോഗിംഗ് ലളിതമാക്കുന്നു; വെറുതെ സംയോജിപ്പിക്കുക
അവരോടൊപ്പം << മുകളിലെ ഉദാഹരണത്തിലെന്നപോലെ.

തടസ്സമില്ല ലോഗ് ചെയ്യുന്നു
സൗകര്യാർത്ഥം, ദി NS_LOG_UNCOND (...); മാക്രോ എപ്പോഴും അതിന്റെ ആർഗ്യുമെന്റുകൾ ലോഗ് ചെയ്യും
അനുബന്ധ ലോഗ്-ഘടകം ഒരു തീവ്രതയിലും പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ല. ഈ മാക്രോ ഒന്നും ഉപയോഗിക്കുന്നില്ല
പ്രിഫിക്സ് ഓപ്ഷനുകളുടെ. ഡീബഗ് ബിൽഡുകളിൽ മാത്രമേ ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുള്ളൂ എന്നത് ശ്രദ്ധിക്കുക; ഈ മാക്രോ
ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡുകളിൽ ഔട്ട്പുട്ട് ഉൽപ്പാദിപ്പിക്കില്ല.

മാർഗ്ഗനിർദ്ദേശങ്ങൾ
· ഓരോ ക്ലാസ് രീതിയും ആരംഭിക്കുക NS_LOG_FUNCTION (ഈ << ആർഗ്സ്...); ഇത് എളുപ്പമാക്കുന്നു
ഫംഗ്ഷൻ കോൾ ട്രേസിംഗ്.

· ഒഴികെ: ഓപ്പറേറ്റർമാരെയോ സ്പഷ്ടമായ കോപ്പി കൺസ്ട്രക്റ്റർമാരെയോ ലോഗ് ചെയ്യരുത്, കാരണം ഇവ കാരണമാകും
അനന്തമായ ആവർത്തനവും സ്റ്റാക്ക് ഓവർഫ്ലോയും.

· ആർഗ്യുമെന്റുകളില്ലാത്ത രീതികൾക്ക് ഇതേ ഫോം ഉപയോഗിക്കുക: NS_LOG_FUNCTION (ഈ);

· സ്റ്റാറ്റിക് ഫംഗ്‌ഷനുകൾക്കായി:

· ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് NS_LOG_FUNCTION (...); സാധാരണ പോലെ.

· വാദങ്ങൾ ഉപയോഗിക്കാതെ NS_LOG_FUNCTION_NOARGS ();

· ഉപയോഗിക്കുക NS_LOG_ERROR സിമുലേഷൻ അസാധുവാക്കിയേക്കാവുന്ന ഗുരുതരമായ പിശക് അവസ്ഥകൾക്ക്
വധശിക്ഷ.

· ഉപയോഗിക്കുക NS_LOG_WARN തിരുത്താൻ കഴിയുന്ന അസാധാരണമായ അവസ്ഥകൾക്കായി. ദയവായി ചില സൂചനകൾ നൽകുക
പ്രശ്നത്തിന്റെ സ്വഭാവത്തെക്കുറിച്ചും അത് എങ്ങനെ ശരിയാക്കാം എന്നതിനെക്കുറിച്ചും.

· NS_LOG_DEBUG ഒരു സാധാരണയായി ഉപയോഗിക്കുന്നു ad ഹോക്ക് ഒരു മോഡലിന്റെ നിർവ്വഹണം മനസ്സിലാക്കാനുള്ള വഴി.

· ഉപയോഗിക്കുക NS_LOG_INFO a യുടെ വലിപ്പം പോലുള്ള നിർവ്വഹണത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്
അതിൽ നിന്ന് ചേർക്കുമ്പോൾ / നീക്കം ചെയ്യുമ്പോൾ ഡാറ്റ ഘടന.

· ഉപയോഗിക്കുക NS_LOG_LOGIC ഒരു ഫംഗ്ഷനിൽ പ്രധാനപ്പെട്ട ലോജിക് ശാഖകൾ കണ്ടെത്തുന്നതിന്.

· നിങ്ങളുടെ ലോഗിംഗ് മാറ്റങ്ങൾ കോഡ് ലംഘിക്കുന്നില്ലെന്ന് പരിശോധിക്കുക. ഉപയോഗിച്ച് ചില ഉദാഹരണ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുക
എല്ലാ ലോഗ് ഘടകങ്ങളും ഓണാക്കി (ഉദാ NS_LOG="***").

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

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു സിമുലേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന്റെ മുഴുവൻ പോയിന്റും കൂടുതൽ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുക എന്നതാണ്
പഠനം. ഇൻ ns-3, ഇത് ചെയ്യാൻ ഒരു ഗവേഷകനെ പ്രാപ്തനാക്കുന്ന ഉപസിസ്റ്റം ട്രെയ്‌സിംഗ് ആണ്
ഉപസിസ്റ്റം.

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

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

ചെറിയ പരിതസ്ഥിതികളിൽ ഇത് പ്രവർത്തിക്കാവുന്നതാണ്, എന്നാൽ നിങ്ങളുടെ സിമുലേഷനുകൾ കൂടുതൽ കൂടുതൽ ലഭിക്കുന്നു
സങ്കീർണ്ണമായ, നിങ്ങൾ കൂടുതൽ കൂടുതൽ പ്രിന്റുകളും പാഴ്‌സിംഗ് ചെയ്യാനും നിർവ്വഹിക്കാനുമുള്ള ചുമതലയിൽ അവസാനിക്കുന്നു
ഔട്ട്പുട്ടിലെ കണക്കുകൂട്ടലുകൾ കൂടുതൽ കഠിനമാകാൻ തുടങ്ങുന്നു.

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

ns-3 ലോഗിംഗ് ചെയ്യുന്നതിനും ഔട്ട്പുട്ടിൽ കുറച്ച് നിയന്ത്രണം നൽകുന്നതിനുമുള്ള ഒരു ലളിതമായ സംവിധാനം നൽകുന്നു
ലോഗ് ഘടകങ്ങൾ, എന്നാൽ നിയന്ത്രണത്തിന്റെ തോത് വളരെ മികച്ചതല്ല. മരം മുറിക്കൽ
മൊഡ്യൂൾ താരതമ്യേന മൂർച്ചയുള്ള ഉപകരണമാണ്.

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

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

പൊതു അവലോകനം
ട്രേസിംഗ് സബ്സിസ്റ്റം പ്രധാനമായും ആശ്രയിക്കുന്നത് ns-3 കോൾബാക്ക്, ആട്രിബ്യൂട്ട് മെക്കാനിസങ്ങൾ. നിങ്ങൾ
ശ്രമിക്കുന്നതിന് മുമ്പ് മാന്വലിന്റെ അനുബന്ധ ഭാഗങ്ങൾ വായിച്ച് മനസ്സിലാക്കണം
ട്രേസിംഗ് സിസ്റ്റം മനസ്സിലാക്കുക.

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

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

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

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

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

ഈ ആശയപരമായ പോയിന്റ്-ടു-മൾട്ടിപോയിന്റ് ലിങ്കിന്റെ "ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ" ഒരു ആണ് ns-3 തിരിച്ചുവിളിക്കുക.

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

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

ദി ലളിതം ഉദാഹരണം
ഞങ്ങൾ പറഞ്ഞ കാര്യങ്ങൾ ഊട്ടിയുറപ്പിക്കാൻ ഒരു ദ്രുത ഉദാഹരണത്തിലൂടെ നടക്കുന്നത് ഉപയോഗപ്രദമാകും.:

#ഉൾപ്പെടുത്തുക "ns3/object.h"
#ഉൾപ്പെടുത്തുക "ns3/uinteger.h"
#ഉൾപ്പെടുത്തുക "ns3/traced-value.h""
#ഉൾപ്പെടുത്തുക "ns3/trace-source-accessor.h"

#ഉൾപ്പെടുന്നു

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

ആദ്യം ചെയ്യേണ്ടത് ആവശ്യമായ ഫയലുകൾ ഉൾപ്പെടുത്തുക എന്നതാണ്. മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ട്രെയ്സ് സിസ്റ്റം
ഒബ്‌ജക്‌റ്റ്, ആട്രിബ്യൂട്ട് സിസ്റ്റങ്ങൾ അമിതമായി ഉപയോഗിക്കുന്നു. ആദ്യ രണ്ടിൽ കൊണ്ടുവരുന്നത് ഉൾപ്പെടുന്നു
ആ സംവിധാനങ്ങൾക്കുള്ള പ്രഖ്യാപനങ്ങൾ. ഫയല്, ട്രേസ്ഡ്-മൂല്യം.എച്ച് ആവശ്യമുള്ളത് കൊണ്ടുവരുന്നു
മൂല്യ സെമാന്റിക്‌സ് അനുസരിക്കുന്ന ഡാറ്റ കണ്ടെത്തുന്നതിനുള്ള പ്രഖ്യാപനങ്ങൾ.

പൊതുവേ, മൂല്യം അർത്ഥമാക്കുന്നത് നിങ്ങൾക്ക് ഒബ്ജക്റ്റ് കൈമാറാൻ കഴിയും എന്നാണ്, അല്ലാതെ
വിലാസം. മൂല്യം സെമാന്റിക്സ് ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒരു വസ്തു ഉണ്ടായിരിക്കണം
അനുബന്ധ കോപ്പി കൺസ്ട്രക്‌ടറും അസൈൻമെന്റ് ഓപ്പറേറ്ററും ലഭ്യമാണ്. ഞങ്ങൾ ആവശ്യകതകൾ വിപുലീകരിക്കുന്നു
പ്ലെയിൻ-ഓൾഡ്-ഡാറ്റ (പിഒഡി) തരങ്ങൾക്കായി മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുള്ള ഓപ്പറേറ്റർമാരുടെ സെറ്റിനെക്കുറിച്ച് സംസാരിക്കാൻ.
ഓപ്പറേറ്റർ=, ഓപ്പറേറ്റർ++, ഓപ്പറേറ്റർ--, ഓപ്പറേറ്റർ+, ഓപ്പറേറ്റർ==, തുടങ്ങിയവ.

ഇതെല്ലാം അർത്ഥമാക്കുന്നത്, ഉപയോഗിച്ച് ഉണ്ടാക്കിയ ഒരു ഒബ്‌ജക്‌റ്റിൽ നിങ്ങൾക്ക് മാറ്റങ്ങൾ കണ്ടെത്താനാകും എന്നതാണ്
ആ ഓപ്പറേറ്റർമാർ.:

ക്ലാസ് MyObject : പൊതു വസ്തു
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("MyObject")
.SetParent (Object::GetTypeId ())
.AddConstructor ()
.AddTraceSource ("MyInteger",
"ട്രേസ് ചെയ്യാനുള്ള ഒരു പൂർണ്ണസംഖ്യ മൂല്യം.",
MakeTraceSourceAccessor (&MyObject::m_myInt))
;
റിട്ടേൺ ടിഡ്;
}

MyObject () {}
ട്രേസ്ഡ് വാല്യൂ m_myInt;
};

ട്രെയ്‌സിംഗ് സിസ്റ്റം ആട്രിബ്യൂട്ടുകളുമായി സംയോജിപ്പിച്ചിരിക്കുന്നതിനാൽ, ആട്രിബ്യൂട്ടുകൾ ഒബ്‌ജക്റ്റുകളുമായി പ്രവർത്തിക്കുന്നു,
ഒരു ഉണ്ടായിരിക്കണം ns-3 വസ്തു ജീവിക്കാനുള്ള സ്രോതസ്സിനായി. രണ്ട് പ്രധാന വരികൾ
കോഡ് ആകുന്നു .AddTraceSource ഒപ്പം ട്രേസ്ഡ് വാല്യൂ പ്രഖ്യാപനം.

ദി .AddTraceSource എന്നതിലേക്ക് ട്രെയ്സ് സോഴ്സിനെ ബന്ധിപ്പിക്കുന്നതിന് ഉപയോഗിക്കുന്ന "ഹുക്കുകൾ" നൽകുന്നു
പുറം ലോകം. ദി ട്രേസ്ഡ് വാല്യൂ പ്രഖ്യാപനം ഓവർലോഡ് ചെയ്യുന്ന ഇൻഫ്രാസ്ട്രക്ചർ നൽകുന്നു
മുകളിൽ സൂചിപ്പിച്ച ഓപ്പറേറ്റർമാർ കോൾബാക്ക് പ്രക്രിയയെ നയിക്കുന്നു.:

ശൂന്യം
IntTrace (Int oldValue, Int newValue)
{
std::cout << "ട്രേസ് ചെയ്തു " << oldvalue << " to " << newValue << std::endl;
}

ട്രേസ് സിങ്കിന്റെ നിർവചനം ഇതാണ്. ഇത് ഒരു കോൾബാക്ക് ഫംഗ്ഷനുമായി നേരിട്ട് യോജിക്കുന്നു.
യുടെ ഓപ്പറേറ്റർമാരിൽ ഒരാൾ എപ്പോഴെങ്കിലും ഈ ഫംഗ്‌ഷൻ വിളിക്കപ്പെടും ട്രേസ്ഡ് വാല്യൂ is
നടപ്പിലാക്കി.:

int
പ്രധാനം (int argc, char *argv[])
{
Ptr myObject = CreateObject ();

myObject->TraceConnectWithoutContext ("MyInteger", MakeCallback(&IntTrace));

myObject->m_myInt = 1234;
}

ഈ സ്‌നിപ്പെറ്റിൽ, ആദ്യം ചെയ്യേണ്ടത് ഏത് വസ്തുവിലെ വസ്തുവിനെ സൃഷ്ടിക്കുക എന്നതാണ്
ട്രെയ്സ് ഉറവിടം ജീവിക്കുന്നു.

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

ഒടുവിൽ, വരി,:

myObject->m_myInt = 1234;

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

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

ഉപയോഗിക്കുന്നു The കോൺഫിഗറേഷൻ ഉപസിസ്റ്റം ലേക്ക് ബന്ധിപ്പിക്കുക ലേക്ക് ട്രെയ്സ് ഉറവിടങ്ങൾ
ദി TraceConnect WithoutContext ലളിതമായ ഉദാഹരണത്തിൽ മുകളിൽ കാണിച്ചിരിക്കുന്ന കോൾ യഥാർത്ഥത്തിൽ വളരെ ആണ്
സിസ്റ്റത്തിൽ അപൂർവ്വമായി ഉപയോഗിക്കുന്നു. കൂടുതൽ സാധാരണമായി, ദി കോൺഫിഗറേഷൻ തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്നതിന് സബ്സിസ്റ്റം ഉപയോഗിക്കുന്നു
എ എന്ന് വിളിക്കുന്നത് ഉപയോഗിച്ച് സിസ്റ്റത്തിലെ ഒരു ട്രെയ്സ് ഉറവിടം config പാത.

ഉദാഹരണത്തിന്, സിസ്റ്റത്തിൽ ഇനിപ്പറയുന്നതു പോലെ തോന്നിക്കുന്ന എന്തെങ്കിലും ഒരാൾ കണ്ടെത്തിയേക്കാം (എടുത്തത്
നിന്ന് ഉദാഹരണങ്ങൾ/tcp-large-transfer.cc):

അസാധുവായ CwndTracer (uint32_t ഓൾഡ്‌വൽ, uint32_t ന്യൂവൽ) {}

...

കോൺഫിഗറേഷൻ::ConnectWithoutContext (
"/NodeList/0/$ns3::TcpL4Protocol/SocketList/0/CongestionWindow",
MakeCallback (&CwndTracer));

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

ആദ്യം ചെയ്യേണ്ടത് പാത പിന്നിലേക്ക് വായിക്കുക എന്നതാണ്. പാതയുടെ അവസാന ഭാഗം ആയിരിക്കണം
an ഗുണങ്ങളെ ഒരു വസ്തു. വാസ്തവത്തിൽ, നിങ്ങൾക്ക് ഒരു പോയിന്റർ ഉണ്ടെങ്കിൽ വസ്തു അത് ഉണ്ട്
"തിരക്ക് ജാലകം" ഗുണങ്ങളെ സുലഭം (അതിനെ വിളിക്കുക വസ്തു), നിങ്ങൾക്ക് ഇത് പോലെ തന്നെ എഴുതാം
മുമ്പത്തെ ഉദാഹരണം:

അസാധുവായ CwndTracer (uint32_t ഓൾഡ്‌വൽ, uint32_t ന്യൂവൽ) {}

...

TheObject->TraceConnect WithoutContext ("CongestionWindow", MakeCallback (&CwndTracer));

എന്നതിനായുള്ള കോഡ് ആണെന്ന് ഇത് മാറുന്നു കോൺഫിഗറേഷൻ::കണക്ട് വിതൗട്ട് കോൺടെക്സ്റ്റ് അത് കൃത്യമായി ചെയ്യുന്നു. ഈ
ഫംഗ്‌ഷൻ ഒരു ശൃംഖലയെ പ്രതിനിധീകരിക്കുന്ന ഒരു പാത സ്വീകരിക്കുന്നു വസ്തു ചൂണ്ടിക്കാണിക്കുകയും അത് വരെ അവരെ പിന്തുടരുകയും ചെയ്യുന്നു
പാതയുടെ അവസാനം എത്തുകയും അവസാന സെഗ്‌മെന്റിനെ ഒരു ആയി വ്യാഖ്യാനിക്കുകയും ചെയ്യുന്നു ഗുണങ്ങളെ അവസാനത്തേത്
വസ്തു. എന്താണ് സംഭവിക്കുന്നതെന്ന് നമുക്ക് നടക്കാം.

പാതയിലെ പ്രധാന "/" പ്രതീകം നെയിംസ്പേസ് എന്ന് വിളിക്കപ്പെടുന്നതിനെ സൂചിപ്പിക്കുന്നു. അതിലൊന്ന്
കോൺഫിഗറേഷൻ സിസ്റ്റത്തിലെ മുൻനിർവചിക്കപ്പെട്ട നെയിംസ്‌പേസുകൾ "നോഡ്‌ലിസ്റ്റ്" ആണ്, ഇത് എല്ലാവരുടേയും പട്ടികയാണ്.
സിമുലേഷനിലെ നോഡുകൾ. ലിസ്റ്റിലെ ഇനങ്ങൾ സൂചികകളാൽ സൂചിപ്പിക്കപ്പെടുന്നു, അതിനാൽ
"/NodeList/0" എന്നത് സിമുലേഷൻ സൃഷ്ടിച്ച നോഡുകളുടെ പട്ടികയിലെ സീറോത്ത് നോഡിനെ സൂചിപ്പിക്കുന്നു.
ഈ നോഡ് യഥാർത്ഥത്തിൽ a ആണ് Ptr ഒരു ഉപവിഭാഗവും അങ്ങനെയാണ് ns3::ഒബ്ജക്റ്റ്.

ഒബ്ജക്റ്റ് മോഡൽ വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ, ns-3 ഒരു ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ മോഡലിനെ പിന്തുണയ്ക്കുന്നു. ദി
അടുത്ത പാത്ത് സെഗ്‌മെന്റ് ആരംഭിക്കുന്നത് a സൂചിപ്പിക്കുന്ന "$" അക്ഷരത്തിൽ നിന്നാണ് GetObject കോൾ ആയിരിക്കണം
ഇനിപ്പറയുന്ന തരത്തിനായി തിരയുന്നു. ഒരു നോഡ് ആരംഭിക്കുമ്പോൾ
InternetStackHelper നിരവധി ഇന്റർഫേസുകൾ നോഡിലേക്ക് സമാഹരിച്ചിരിക്കുന്നു. അതിലൊന്നാണ്
TCP ലെവൽ നാല് പ്രോട്ടോക്കോൾ. ഈ പ്രോട്ടോക്കോൾ ഒബ്ജക്റ്റിന്റെ റൺടൈം തരം ns3::TcpL4Protocol''.
എപ്പോൾ The ``GetObject എക്സിക്യൂട്ട് ചെയ്തു, ഇത് ഈ തരത്തിലുള്ള ഒബ്ജക്റ്റിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു.

ദി TcpL4 പ്രോട്ടോക്കോൾ ക്ലാസ് "സോക്കറ്റ്‌ലിസ്റ്റ്" എന്ന് വിളിക്കുന്ന ഒരു ആട്രിബ്യൂട്ട് നിർവചിക്കുന്നു
സോക്കറ്റുകൾ. ഓരോ സോക്കറ്റും യഥാർത്ഥത്തിൽ ഒരു ആണ് ns3::ഒബ്ജക്റ്റ് സ്വന്തം കൂടെ ഗുണവിശേഷങ്ങൾ. ഉള്ളിലുള്ള ഇനങ്ങൾ
നോഡ്‌ലിസ്റ്റിലെന്നപോലെ സോക്കറ്റുകളുടെ ലിസ്റ്റ് സൂചിക പ്രകാരം സൂചിപ്പിക്കപ്പെടുന്നു, അതിനാൽ "സോക്കറ്റ്‌ലിസ്റ്റ്/0"
നോഡ്‌ലിസ്റ്റിലെ സീറോത്ത് നോഡിലെ സോക്കറ്റുകളുടെ പട്ടികയിലെ സീറോത്ത് സോക്കറ്റിനെ സൂചിപ്പിക്കുന്നു --
സിമുലേഷനിൽ നിർമ്മിച്ച ആദ്യത്തെ നോഡ്.

ഈ സോക്കറ്റ്, അതിന്റെ തരം ഒരു ആയി മാറുന്നു ns3::TcpSocketImpl ഒരു ആട്രിബ്യൂട്ട് നിർവചിക്കുന്നു
"CongestionWindow" എന്ന് വിളിക്കപ്പെടുന്ന a ട്രേസ്ഡ് വാല്യൂ. ദി
കോൺഫിഗറേഷൻ::കണക്ട് വിതൗട്ട് കോൺടെക്സ്റ്റ് ഇപ്പോൾ ഒരു ചെയ്യുന്നു,:

object->TraceConnect WithoutContext ("CongestionWindow", MakeCallback (&CwndTracer));

"SocketList/0"-ൽ നിന്നുള്ള ഒബ്‌ജക്റ്റ് പോയിന്റർ ഉപയോഗിക്കുന്നു, അത് ട്രെയ്‌സ് തമ്മിലുള്ള കണക്ഷൻ ഉണ്ടാക്കുന്നു
കോൾബാക്കിലേക്ക് സോക്കറ്റിൽ നിർവചിച്ചിരിക്കുന്ന ഉറവിടം -- CwndTracer.

ഇപ്പോൾ, ഒരു മാറ്റം വരുത്തുമ്പോഴെല്ലാം ട്രേസ്ഡ് വാല്യൂ തിരക്കിനെ പ്രതിനിധീകരിക്കുന്നു
ടിസിപി സോക്കറ്റിലെ വിൻഡോ, രജിസ്റ്റർ ചെയ്ത കോൾബാക്ക് എക്സിക്യൂട്ട് ചെയ്യുകയും ഫംഗ്ഷൻ ചെയ്യുകയും ചെയ്യും
CwndTracer TCP തിരക്കിന്റെ പഴയതും പുതിയതുമായ മൂല്യങ്ങൾ പ്രിന്റ് ചെയ്യുന്നതിനെ വിളിക്കും
ജാലകം.

ഉപയോഗിക്കുന്നു The പിന്തുടരുന്നു എപിഐ
ട്രേസിംഗ് സിസ്റ്റവുമായി മൂന്ന് തലത്തിലുള്ള ഇടപെടലുകളുണ്ട്:

· തുടക്കക്കാരനായ ഉപയോക്താവിന് ട്രെയ്‌സിംഗിൽ ഏതൊക്കെ വസ്തുക്കളാണ് പങ്കെടുക്കുന്നതെന്ന് എളുപ്പത്തിൽ നിയന്ത്രിക്കാനാകും;

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

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

ഉപയോഗിക്കുന്നു ട്രെയ്സ് സഹായികൾ
ദി 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 പിന്തുടരുന്നു ഉപകരണ സഹായികൾ
ഒരു സ്ഥിരതയുള്ള pcap ട്രെയ്സ് സൗകര്യം ചേർക്കുന്നത് എളുപ്പമാക്കുക എന്നതാണ് ഈ സഹായികളുടെ ലക്ഷ്യം
ns-3 ഉപകരണം. pcap ട്രെയ്‌സിംഗിന്റെ വിവിധ ഫ്ലേവറുകളെല്ലാം ഒരേപോലെ പ്രവർത്തിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
എല്ലാ ഉപകരണങ്ങളും, അതിനാൽ ഈ സഹായികളുടെ രീതികൾ ഉപകരണ സഹായികൾക്ക് പാരമ്പര്യമായി ലഭിക്കുന്നു. ഒന്നു നോക്കൂ
at src/network/helper/trace-helper.h നോക്കുമ്പോൾ ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ്.

വര്ഗം PcapHelperForDevice ഒരു ആണ് മിക്സിൻ ഉപയോഗിക്കുന്നതിന് ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം നൽകുന്നു
pcap ട്രെയ്‌സിംഗ് ഒരു ns-3 ഉപകരണം. ഓരോ ഉപകരണവും ഒരൊറ്റ വെർച്വൽ രീതി നടപ്പിലാക്കണം
ഈ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചതാണ്:

വെർച്വൽ ശൂന്യത EnablePcapInternal (std::string prefix, Ptr nd, bool promiscuous) = 0;

ഈ രീതിയുടെ ഒപ്പ് ഈ സാഹചര്യത്തിന്റെ ഉപകരണ കേന്ദ്രീകൃത വീക്ഷണത്തെ പ്രതിഫലിപ്പിക്കുന്നു
നില. എല്ലാ പൊതു രീതികളും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചു PcapUserHelperForDevice ആയി കുറയ്ക്കുക
ഈ ഒരൊറ്റ ഉപകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള നടപ്പിലാക്കൽ രീതി എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന്, ഏറ്റവും താഴ്ന്ന നില
pcap രീതി,:

അസാധുവായ EnablePcap (std::string prefix, Ptr nd, bool promiscuous = false, bool explicitFilename = false);

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

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);
അസാധുവായ EnablePcap (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, NetDeviceContainer d,
bool promiscuous = false);
അസാധുവായ EnablePcap (std::string prefix, NodeContainer n,
bool promiscuous = false);
അസാധുവായ EnablePcap (std::string prefix, uint32_t nodeid, uint32_t deviceid,
bool promiscuous = false);
അസാധുവായ EnablePcapAll (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, bool promiscuous = false);

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

Ptr nd;
...
helper.EnablePcap ("പ്രിഫിക്സ്", nd, true);

എന്നതിൽ പ്രോമിസ്‌ക്യൂസ് മോഡ് ക്യാപ്‌ചറുകൾ പ്രവർത്തനക്ഷമമാക്കും നെറ്റ് ഡിവൈസ് വ്യക്തമാക്കിയത് nd.

ആദ്യത്തെ രണ്ട് രീതികളിൽ ഒരു സ്ഥിരസ്ഥിതി പരാമീറ്ററും ഉൾപ്പെടുന്നു വ്യക്തമായ ഫയലിന്റെ പേര് ആ ഇഷ്ടം
താഴെ ചർച്ച ചെയ്യാം.

ക്ലാസിനായി ഡോക്‌സിജൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു PcapHelperForDevice വിശദാംശങ്ങൾ കണ്ടെത്താൻ
ഈ രീതികളിൽ; എന്നാൽ സംഗ്രഹിക്കാൻ ...

ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഡിവൈസ് ജോടിയിൽ നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ptr ഒരു EnablePcap രീതി. ദി Ptr നെറ്റ് ഉപകരണം മുതൽ പരോക്ഷമാണ്
കൃത്യമായി ഒന്നിൽ പെട്ടതായിരിക്കണം നോഡ്. ഉദാഹരണത്തിന്,:

Ptr nd;
...
helper.EnablePcap ("പ്രിഫിക്സ്", nd);

ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഡിവൈസ് ജോടിയിൽ നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
std::സ്ട്രിംഗ് ഒരു ഒബ്ജക്റ്റ് നെയിം സേവന സ്ട്രിംഗ് പ്രതിനിധീകരിക്കുന്നു EnablePcap രീതി. ദി
Ptr നെയിം സ്ട്രിംഗിൽ നിന്ന് നോക്കുന്നു. വീണ്ടും, ദി മുതൽ പരോക്ഷമാണ്
പേരിട്ടിരിക്കുന്ന നെറ്റ് ഉപകരണം കൃത്യമായി ഒന്നിന്റെതായിരിക്കണം നോഡ്. ഉദാഹരണത്തിന്,:

പേരുകൾ:: ചേർക്കുക ("സെർവർ" ...);
പേരുകൾ::ചേർക്കുക ("സെർവർ/eth0" ...);
...
helper.EnablePcap ("പ്രിഫിക്സ്", "സെർവർ/അത്0");

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

NetDeviceContainer d = ...;
...
helper.EnablePcap ("പ്രിഫിക്സ്", d);

ഒരു നൽകിക്കൊണ്ട് നോഡ്/നെറ്റ്-ഡിവൈസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
നോഡ് കണ്ടെയ്നർ. ഓരോന്നിനും നോഡ് ലെ നോഡ് കണ്ടെയ്നർ അതിന്റെ ഘടിപ്പിച്ചിരിക്കുന്നു നെറ്റ് ഡിവൈസുകൾ ആവർത്തിക്കപ്പെടുന്നു.
ഓരോന്നും നെറ്റ് ഡിവൈസ് കണ്ടെയ്നറിലെ ഓരോ നോഡിലും ഘടിപ്പിച്ചിരിക്കുന്നു, ആ ഉപകരണത്തിന്റെ തരം
പരിശോധിച്ചു. ശരിയായ തരത്തിലുള്ള ഓരോ ഉപകരണത്തിനും (ഉപകരണം നിയന്ത്രിക്കുന്ന അതേ തരം
സഹായി), ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കി.:

നോഡ് കണ്ടെയ്നർ n;
...
helper.EnablePcap ("പ്രിഫിക്സ്", n);

നോഡ് ഐഡിയുടെയും ഉപകരണ ഐഡിയുടെയും അടിസ്ഥാനത്തിലും വ്യക്തമായും നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ptr. ഓരോന്നും നോഡ് സിസ്റ്റത്തിൽ ഒരു പൂർണ്ണസംഖ്യ നോഡ് ഐഡിയും ഓരോ ഉപകരണവും ഒരു നോഡുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു
ഒരു പൂർണ്ണസംഖ്യ ഉപകരണ ഐഡി ഉണ്ട്.:

helper.EnablePcap ("പ്രിഫിക്സ്", 21, 1);

അവസാനമായി, സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണങ്ങൾക്കുമായി നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
അത് ഉപകരണ സഹായിയാണ് കൈകാര്യം ചെയ്യുന്നത്.:

helper.EnablePcapAll ("പ്രിഫിക്സ്");

Pcap പിന്തുടരുന്നു ഉപകരണ സഹായി ഫയൽനാമം തിരഞ്ഞെടുക്കൽ
ഒരു സമ്പൂർണ്ണ ഫയൽ നാമത്തിന്റെ നിർമ്മാണമാണ് മുകളിലെ രീതി വിവരണങ്ങളിൽ ഉള്ളത്
നടപ്പിലാക്കൽ രീതി. കൺവെൻഷൻ പ്രകാരം, 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 ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്ന രീതികളിൽ മാത്രമേ ഈ ഓപ്ഷൻ ലഭ്യമാകൂ
ഒറ്റ ഉപകരണം.

ഉദാഹരണത്തിന്, ഒരു ഒറ്റ പ്രോമിസ്ക്യൂസ് pcap സൃഷ്ടിക്കാൻ ഒരു ഉപകരണ സഹായിയെ ക്രമീകരിക്കുന്നതിന്
ഒരു നിർദ്ദിഷ്ട പേരിന്റെ ഫയൽ ക്യാപ്‌ചർ ചെയ്യുക (my-pcap-file.pcap) നൽകിയിരിക്കുന്ന ഉപകരണത്തിൽ, ഒരാൾക്ക്:

Ptr nd;
...
helper.EnablePcap ("my-pcap-file.pcap", nd, true, true);

ആദ്യത്തേത് യഥാർഥ പരാമീറ്റർ പ്രോമിസ്ക്യൂസ് മോഡ് ട്രെയ്സ് പ്രാപ്തമാക്കുന്നു, രണ്ടാമത്തേത് സഹായിയെ അറിയിക്കുന്നു
വ്യാഖ്യാനിക്കാൻ പ്രിഫിക്‌സ് ഒരു സമ്പൂർണ്ണ ഫയൽ നാമമായി പരാമീറ്റർ.

അസ്സി പിന്തുടരുന്നു ഉപകരണ സഹായികൾ
Ascii ട്രെയ്സ് സഹായിയുടെ പെരുമാറ്റം മിക്സിൻ pcap പതിപ്പിനോട് സാമ്യമുള്ളതാണ്.
ഒന്ന് നോക്കിക്കോളു src/network/helper/trace-helper.h നിങ്ങൾക്ക് ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ് നോക്കുമ്പോൾ.

വര്ഗം AsciiTraceHelperForDevice ascii ഉപയോഗിക്കുന്നതിനുള്ള ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം ചേർക്കുന്നു
ഒരു ഉപകരണ സഹായ ക്ലാസിലേക്ക് കണ്ടെത്തുന്നു. pcap കേസിലെന്നപോലെ, എല്ലാ ഉപകരണവും നടപ്പിലാക്കണം a
ascii ട്രെയ്‌സിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച ഒറ്റ വെർച്വൽ രീതി മിക്സിൻ.:

വെർച്വൽ ശൂന്യത EnableAsciiInternal (Ptr സ്ട്രീം, std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr nd) = 0;

ഈ രീതിയുടെ ഒപ്പ് ഈ സാഹചര്യത്തിന്റെ ഉപകരണ കേന്ദ്രീകൃത വീക്ഷണത്തെ പ്രതിഫലിപ്പിക്കുന്നു
നില; കൂടാതെ, സഹായി ഒരു പങ്കിട്ട ഔട്ട്‌പുട്ട് സ്ട്രീമിലേക്ക് എഴുതുന്നുണ്ടെന്ന വസ്തുതയും. എല്ലാം
ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച പൊതു ആസ്കി-ട്രേസ്-അനുബന്ധ രീതികൾ AsciiTraceHelperForDevice
ഈ ഒരൊറ്റ ഉപകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള നടപ്പിലാക്കൽ രീതിയിലേക്ക് വിളിക്കുന്നത് കുറയ്ക്കുക. ഉദാഹരണത്തിന്, ദി
ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള ascii ട്രെയ്സ് രീതികൾ,:

അസാധുവായ EnableAscii (std::string prefix, Ptr nd);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, Ptr nd);

എന്ന ഉപകരണത്തിന്റെ നടപ്പാക്കലിനെ വിളിക്കും AsciiInternal പ്രവർത്തനക്ഷമമാക്കുക നേരിട്ട്, ഒന്നുകിൽ ഒരു നൽകുന്നു
സാധുവായ പ്രിഫിക്സ് അല്ലെങ്കിൽ സ്ട്രീം. മറ്റെല്ലാ പൊതു ആസ്കി ട്രെയ്‌സിംഗ് രീതികളും ഇവയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
അധിക ഉപയോക്തൃ-തല പ്രവർത്തനം നൽകുന്നതിന് താഴ്ന്ന നിലയിലുള്ള പ്രവർത്തനങ്ങൾ. ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്
സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണ സഹായികൾക്കും എല്ലാ ascii ട്രെയ്സ് രീതികളും ഉണ്ടായിരിക്കും എന്നതാണ് ഉപയോക്താവ്
ലഭ്യമാണ്; ഈ രീതികളെല്ലാം ഉപകരണങ്ങളിൽ ഒരേ രീതിയിൽ പ്രവർത്തിക്കും
നടപ്പിലാക്കുക EnablAsciiInternal ശരിയായി.

അസ്സി പിന്തുടരുന്നു ഉപകരണ സഹായി രീതികൾ
അസാധുവായ EnableAscii (std::string prefix, Ptr nd);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, Ptr nd);

അസാധുവായ EnableAscii (std::string prefix, std::string ndName);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, std::string ndName);

അസാധുവായ EnableAscii (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NetDeviceContainer d);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, NetDeviceContainer d);

അസാധുവായ EnableAscii (std::string prefix, NodeContainer n);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, നോഡ് കണ്ടെയ്നർ n);

അസാധുവായ EnableAscii (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, uint32_t nodeid, uint32_t deviceid);
അസാധുവായ EnableAscii (Ptr സ്ട്രീം, uint32_t nodeid, uint32_t deviceid);

അസാധുവായ EnableAsciiAll (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്);
അസാധുവായ EnableAsciiAll (Ptr ധാര);

ക്ലാസിനായി ഡോക്‌സിജൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു TraceHelperForDevice കണ്ടെത്താൻ
ഈ രീതികളുടെ വിശദാംശങ്ങൾ; എന്നാൽ സംഗ്രഹിക്കാൻ ...

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

pcap ട്രെയ്‌സിംഗിലെന്നപോലെ, ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഡിവൈസ് ജോടിയിൽ നിങ്ങൾക്ക് ascii ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
ഒരു നൽകിക്കൊണ്ട് Ptr ഒരു Ascii പ്രവർത്തനക്ഷമമാക്കുക രീതി. ദി Ptr മുതൽ പരോക്ഷമാണ്
നെറ്റ് ഉപകരണം കൃത്യമായി ഒന്നിൽ തന്നെയായിരിക്കണം നോഡ്. ഉദാഹരണത്തിന്,:

Ptr nd;
...
helper.EnableAscii ("പ്രിഫിക്സ്", nd);

ഈ സാഹചര്യത്തിൽ, ascii ട്രേസ് ഫയലിലേക്ക് ട്രെയ്സ് സന്ദർഭങ്ങളൊന്നും എഴുതപ്പെടുന്നില്ല
അനാവശ്യമായ. അതേ നിയമങ്ങൾ ഉപയോഗിച്ച് സൃഷ്ടിക്കേണ്ട ഫയലിന്റെ പേര് സിസ്റ്റം തിരഞ്ഞെടുക്കും
pcap വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നത്, ഫയലിന് പകരം ".tr" എന്ന പ്രത്യയം ഉണ്ടായിരിക്കുമെന്നതൊഴിച്ചാൽ
".pcap".

നിങ്ങൾക്ക് ഒന്നിലധികം നെറ്റ് ഉപകരണങ്ങളിൽ ascii ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാനും എല്ലാ ട്രെയ്‌സുകളും അയയ്‌ക്കാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ഒരൊറ്റ ഫയലിലേക്ക്, ഒരൊറ്റ ഫയലിലേക്ക് റഫർ ചെയ്യാൻ ഒരു ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അത് ചെയ്യാൻ കഴിയും:

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 ട്രേസ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന് കാരണമാകും, അവ ഓരോന്നും പിന്തുടരുന്നു
ദി - - .ടിആർ കൺവെൻഷൻ. എല്ലാ അടയാളങ്ങളും സംയോജിപ്പിച്ച് a
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി സിംഗിൾ ഫയൽ പൂർത്തിയാക്കി:

NetDeviceContainer d = ...;
...
Ptr സ്ട്രീം = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (സ്ട്രീം, ഡി);

ഒരു നൽകിക്കൊണ്ട് നിങ്ങൾക്ക് നോഡ്/നെറ്റ്-ഡിവൈസ് ജോഡികളുടെ ഒരു ശേഖരത്തിൽ ascii ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
നോഡ് കണ്ടെയ്നർ. ഓരോന്നിനും നോഡ് ലെ നോഡ് കണ്ടെയ്നർ അതിന്റെ ഘടിപ്പിച്ചിരിക്കുന്നു നെറ്റ് ഡിവൈസുകൾ ആവർത്തിക്കപ്പെടുന്നു.
ഓരോന്നും നെറ്റ് ഡിവൈസ് കണ്ടെയ്നറിലെ ഓരോ നോഡിലും ഘടിപ്പിച്ചിരിക്കുന്നു, ആ ഉപകരണത്തിന്റെ തരം
പരിശോധിച്ചു. ശരിയായ തരത്തിലുള്ള ഓരോ ഉപകരണത്തിനും (ഉപകരണം നിയന്ത്രിക്കുന്ന അതേ തരം
സഹായി), ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കി.:

നോഡ് കണ്ടെയ്നർ n;
...
helper.EnableAscii ("പ്രിഫിക്സ്", n);

ഇത് നിരവധി ascii ട്രേസ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന് കാരണമാകും, അവ ഓരോന്നും പിന്തുടരുന്നു
ദി - - .ടിആർ കൺവെൻഷൻ. എല്ലാ അടയാളങ്ങളും സംയോജിപ്പിച്ച് a
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി സിംഗിൾ ഫയൽ പൂർത്തിയാക്കി:

നോഡ് ഐഡിയുടെയും ഉപകരണ ഐഡിയുടെയും അടിസ്ഥാനത്തിലും വ്യക്തമായും നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ptr. ഓരോന്നും നോഡ് സിസ്റ്റത്തിൽ ഒരു പൂർണ്ണസംഖ്യ നോഡ് ഐഡിയും ഓരോ ഉപകരണവും ഒരു നോഡുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു
ഒരു പൂർണ്ണസംഖ്യ ഉപകരണ ഐഡി ഉണ്ട്.:

helper.EnableAscii ("പ്രിഫിക്സ്", 21, 1);

തീർച്ചയായും, മുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ട്രെയ്‌സുകൾ ഒരൊറ്റ ഫയലായി സംയോജിപ്പിക്കാം.

അവസാനമായി, സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണങ്ങൾക്കുമായി നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
അത് ഉപകരണ സഹായിയാണ് കൈകാര്യം ചെയ്യുന്നത്.:

helper.EnableAsciiAll ("പ്രിഫിക്സ്");

ഇത് നിരവധി ascii ട്രെയ്സ് ഫയലുകൾ സൃഷ്ടിക്കുന്നതിലേക്ക് നയിക്കും, ഓരോ ഉപകരണത്തിനും ഒന്ന്
സഹായി കൈകാര്യം ചെയ്യുന്ന തരത്തിലുള്ള സിസ്റ്റം. ഈ ഫയലുകളെല്ലാം പിന്തുടരും
- - .ടിആർ കൺവെൻഷൻ. എല്ലാ ട്രെയ്‌സുകളും ഒരു സിംഗിൾ ആയി സംയോജിപ്പിക്കുന്നു
മുകളിലുള്ള ഉദാഹരണങ്ങൾക്ക് സമാനമായി ഫയൽ നിർവ്വഹിച്ചിരിക്കുന്നു.

അസ്സി പിന്തുടരുന്നു ഉപകരണ സഹായി ഫയൽനാമം തിരഞ്ഞെടുക്കൽ
മുകളിലുള്ള പ്രിഫിക്‌സ്-സ്റ്റൈൽ രീതി വിവരണങ്ങളിൽ അന്തർലീനമായത് പൂർണ്ണമായ നിർമ്മാണമാണ്
നടപ്പിലാക്കൽ രീതി പ്രകാരം ഫയൽ നാമങ്ങൾ. കൺവെൻഷൻ പ്രകാരം, 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 പിന്തുടരുന്നു പ്രോട്ടോകോൾ സഹായികൾ
ഇവയുടെ ലക്ഷ്യം മിക്സിനുകൾ സ്ഥിരതയുള്ള pcap ട്രെയ്‌സ് സൗകര്യം ചേർക്കുന്നത് എളുപ്പമാക്കുക എന്നതാണ്
പ്രോട്ടോക്കോളുകൾ. pcap ട്രെയ്‌സിംഗിന്റെ വിവിധ ഫ്ലേവറുകൾ എല്ലായിടത്തും ഒരേപോലെ പ്രവർത്തിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
പ്രോട്ടോക്കോളുകൾ, അതിനാൽ ഈ സഹായികളുടെ രീതികൾ സ്റ്റാക്ക് ഹെൽപ്പർമാർക്ക് പാരമ്പര്യമായി ലഭിക്കുന്നു. ഒന്ന് നോക്കിക്കോളു
src/network/helper/trace-helper.h നോക്കുമ്പോൾ ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ്.

ഈ വിഭാഗത്തിൽ ഞങ്ങൾ പ്രോട്ടോക്കോളിൽ പ്രയോഗിക്കുന്ന രീതികൾ ചിത്രീകരിക്കും IPv4. ലേക്ക്
സമാന പ്രോട്ടോക്കോളുകളിൽ ട്രെയ്സ് വ്യക്തമാക്കുക, ഉചിതമായ തരം പകരം വയ്ക്കുക. ഉദാഹരണത്തിന്,
ഒരു ഉപയോഗിക്കുക Ptr പകരം a Ptr വിളിക്കുക EnablePcapIpv6 ഇതിനുപകരമായി EnablePcapIpv4.

വര്ഗം PcapHelperForIpv4 pcap ട്രെയ്‌സിംഗ് ഉപയോഗിക്കുന്നതിന് ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം നൽകുന്നു
ലെ IPv4 പ്രോട്ടോക്കോൾ. ഈ രീതികൾ പ്രാപ്തമാക്കുന്ന ഓരോ പ്രോട്ടോക്കോൾ സഹായിയും ഒരു സിംഗിൾ നടപ്പിലാക്കണം
ഈ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച വെർച്വൽ രീതി. ഇതിനായി പ്രത്യേകം നടപ്പാക്കും
IPv6, ഉദാഹരണത്തിന്, എന്നാൽ ഒരേയൊരു വ്യത്യാസം രീതിയുടെ പേരുകളിലും ഒപ്പുകളിലും ആയിരിക്കും.
ക്ലാസ് അവ്യക്തമാക്കാൻ വ്യത്യസ്ത രീതി നാമങ്ങൾ ആവശ്യമാണ് IPv4 നിന്ന് IPv6 ഇവ രണ്ടും
ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞത് വസ്തു, ഒരേ ഒപ്പ് പങ്കിടുന്ന രീതികളും.:

വെർച്വൽ ശൂന്യത EnablePcapIpv4Internal (std::string prefix, Ptr ipv4, uint4_t ഇന്റർഫേസ്) = 32;

ഈ രീതിയുടെ ഒപ്പ് പ്രോട്ടോക്കോളും ഇന്റർഫേസ് കേന്ദ്രീകൃത കാഴ്ചയും പ്രതിഫലിപ്പിക്കുന്നു
ഈ തലത്തിലുള്ള സാഹചര്യം. എല്ലാ പൊതു രീതികളും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചു PcapHelperForIpv4
ഈ ഒരൊറ്റ ഉപകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള നടപ്പിലാക്കൽ രീതിയിലേക്ക് വിളിക്കുക. ഉദാഹരണത്തിന്, ദി
ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള pcap രീതി,:

അസാധുവായ EnablePcapIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്);

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

Pcap പിന്തുടരുന്നു പ്രോട്ടോകോൾ സഹായി രീതികൾ
ഈ രീതികൾ രൂപകല്പന ചെയ്തിരിക്കുന്നത് ഒന്നു മുതൽ ഒന്ന് വരെ കത്തിടപാടുകൾ നടത്താനാണ് നോഡ്- ഒപ്പം
നെറ്റ് ഡിവൈസ്- ഉപകരണ പതിപ്പുകളുടെ കേന്ദ്രീകൃത പതിപ്പുകൾ. ഇതിനുപകരമായി നോഡ് ഒപ്പം നെറ്റ് ഡിവൈസ് ജോഡി
നിയന്ത്രണങ്ങൾ, ഞങ്ങൾ പ്രോട്ടോക്കോളും ഇന്റർഫേസ് നിയന്ത്രണങ്ങളും ഉപയോഗിക്കുന്നു.

ഉപകരണ പതിപ്പിലെന്നപോലെ, ആറ് രീതികളുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക:

അസാധുവായ EnablePcapIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്);
അസാധുവായ EnablePcapIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, std::string ipv4Name, uint32_t ഇന്റർഫേസ്);
അസാധുവായ EnablePcapIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, Ipv4InterfaceContainer c);
അസാധുവായ EnablePcapIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NodeContainer n);
അസാധുവായ EnablePcapIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, uint32_t nodeid, uint32_t ഇന്റർഫേസ്);
അസാധുവായ EnablePcapIpv4All (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്);

ക്ലാസിനായി ഡോക്‌സിജൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു PcapHelperForIpv4 വിശദാംശങ്ങൾ കണ്ടെത്താൻ
ഈ രീതികളിൽ; എന്നാൽ സംഗ്രഹിക്കാൻ ...

ഒരു പ്രത്യേക പ്രോട്ടോക്കോൾ/ഇന്റർഫേസ് ജോടിയിൽ നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
Ptr ഒപ്പം ഇന്റർഫേസ് ഒരു EnablePcap രീതി. ഉദാഹരണത്തിന്,:

Ptr ipv4 = നോഡ്->GetObject ();
...
helper.EnablePcapIpv4 ("പ്രിഫിക്സ്", ipv4, 0);

ഒരു പ്രത്യേക നോഡ്/നെറ്റ്-ഡിവൈസ് ജോടിയിൽ നിങ്ങൾക്ക് pcap ട്രെയ്‌സിംഗ് പ്രവർത്തനക്ഷമമാക്കാം
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 ("പ്രിഫിക്സ്");

Pcap പിന്തുടരുന്നു പ്രോട്ടോകോൾ സഹായി ഫയൽനാമം തിരഞ്ഞെടുക്കൽ
മുകളിലുള്ള എല്ലാ രീതി വിവരണങ്ങളിലും അന്തർലീനമായത് പൂർണ്ണമായ നിർമ്മാണമാണ്
നടപ്പിലാക്കൽ രീതി പ്രകാരം ഫയൽ നാമങ്ങൾ. കൺവെൻഷൻ പ്രകാരം, ഉപകരണങ്ങൾക്കായി എടുത്ത pcap ട്രെയ്‌സുകൾ
The ns-3 സിസ്റ്റം രൂപത്തിലാണ് - ഐഡി>- id>.pcap. ഈ സന്ദർഭത്തിൽ
പ്രോട്ടോക്കോൾ ട്രെയ്‌സുകൾ, പ്രോട്ടോക്കോളുകൾ എന്നിവയ്‌ക്കിടയിൽ ഒന്നൊന്നായി കത്തിടപാടുകൾ ഉണ്ട് നോഡുകൾ. ഇതാണ്
കാരണം പ്രോട്ടോക്കോൾ വസ്തുക്കൾ സമാഹരിച്ചിരിക്കുന്നു നോഡ് വസ്തുക്കൾ. ആഗോള പ്രോട്ടോക്കോൾ ഇല്ലാത്തതിനാൽ
സിസ്റ്റത്തിലെ ഐഡി, ഫയൽ നാമകരണത്തിൽ ഞങ്ങൾ അനുബന്ധ നോഡ് ഐഡി ഉപയോഗിക്കുന്നു. അതിനാൽ ഒരു ഉണ്ട്
സ്വയമേവ തിരഞ്ഞെടുത്ത ട്രേസ് ഫയൽ നാമങ്ങളിൽ ഫയൽ നാമം കൂട്ടിയിടിക്കുന്നതിനുള്ള സാധ്യത. ഇതിനായി
കാരണം, പ്രോട്ടോക്കോൾ ട്രെയ്‌സുകൾക്കായി ഫയലിന്റെ പേര് കൺവെൻഷൻ മാറ്റി.

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, സിസ്റ്റത്തിലെ എല്ലാ നോഡിനും ഒരു സിസ്റ്റം അസൈൻ ചെയ്ത നോഡ് ഐഡി ഉണ്ടായിരിക്കും.
പ്രോട്ടോക്കോൾ ഇൻസ്‌റ്റൻസുകളും നോഡ് ഇൻസ്‌റ്റൻസുകളും തമ്മിൽ വൺ-ടു-വൺ കത്തിടപാടുകൾ ഉള്ളതിനാൽ
ഞങ്ങൾ നോഡ് ഐഡി ഉപയോഗിക്കുന്നു. ഓരോ ഇന്റർഫേസിനും അതിന്റെ പ്രോട്ടോക്കോളുമായി ബന്ധപ്പെട്ട് ഒരു ഇന്റർഫേസ് ഐഡി ഉണ്ട്. ഞങ്ങൾ ഉപയോഗിക്കുന്നു
കൺവെൻഷൻ " -എൻ -ഐ .pcap" എന്ന ഫയലിന്റെ പേര് കണ്ടെത്തുന്നതിന്
പ്രോട്ടോക്കോൾ സഹായികൾ.

അതിനാൽ, ഡിഫോൾട്ടായി, ട്രേസിംഗ് ഓൺ പ്രവർത്തനക്ഷമമാക്കുന്നതിന്റെ ഫലമായി ഒരു pcap ട്രെയ്സ് ഫയൽ സൃഷ്ടിച്ചു
"പ്രിഫിക്സ്" എന്ന പ്രിഫിക്‌സ് ഉപയോഗിക്കുന്ന നോഡ് 1-ന്റെ Ipv4 പ്രോട്ടോക്കോളിന്റെ ഇന്റർഫേസ് 21 ആയിരിക്കും
"prefix-n21-i1.pcap".

നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം ns-3 ഇത് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഒബ്ജക്റ്റ് നെയിം സേവനം. ഉദാഹരണത്തിന്, എങ്കിൽ
Ptr-ലേക്ക് "serverIpv4" എന്ന പേര് നൽകുന്നതിന് നിങ്ങൾ ഒബ്ജക്റ്റ് നെയിം സേവനം ഉപയോഗിക്കുന്നു നോഡിൽ
21, തത്ഫലമായുണ്ടാകുന്ന pcap ട്രെയ്സ് ഫയലിന്റെ പേര് സ്വയമേവ ആയി മാറും,
"prefix-nserverIpv4-i1.pcap".

അസ്സി പിന്തുടരുന്നു പ്രോട്ടോകോൾ സഹായികൾ
ascii ട്രെയ്സ് സഹായികളുടെ പെരുമാറ്റം pcap കേസിന് സമാനമാണ്. എ എടുക്കുക
നോക്കൂ src/network/helper/trace-helper.h നിങ്ങൾക്ക് ചർച്ച പിന്തുടരണമെങ്കിൽ
യഥാർത്ഥ കോഡ് നോക്കുന്നു.

ഈ വിഭാഗത്തിൽ ഞങ്ങൾ പ്രോട്ടോക്കോളിൽ പ്രയോഗിക്കുന്ന രീതികൾ ചിത്രീകരിക്കും IPv4. ലേക്ക്
സമാന പ്രോട്ടോക്കോളുകളിൽ ട്രെയ്സ് വ്യക്തമാക്കുക, ഉചിതമായ തരം പകരം വയ്ക്കുക. ഉദാഹരണത്തിന്,
ഒരു ഉപയോഗിക്കുക Ptr പകരം a Ptr വിളിക്കുക EnableAsciiIpv6 ഇതിനുപകരമായി
EnableAsciiIpv4.

വര്ഗം AsciiTraceHelperForIpv4 ascii ഉപയോഗിക്കുന്നതിനുള്ള ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനം ചേർക്കുന്നു
ഒരു പ്രോട്ടോക്കോൾ സഹായിയെ കണ്ടെത്തുന്നു. ഈ രീതികൾ പ്രാപ്തമാക്കുന്ന ഓരോ പ്രോട്ടോക്കോളും നടപ്പിലാക്കണം
ഈ ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച ഏക വെർച്വൽ രീതി.:

വെർച്വൽ ശൂന്യത EnableAsciiIpv4Internal (Ptr സ്ട്രീം, std ::സ്ട്രിംഗ് പ്രിഫിക്സ്,
Ptr ipv4, uint4_t ഇന്റർഫേസ്) = 32;

ഈ രീതിയുടെ ഒപ്പ് പ്രോട്ടോക്കോളും ഇന്റർഫേസ് കേന്ദ്രീകൃത കാഴ്ചയും പ്രതിഫലിപ്പിക്കുന്നു
ഈ തലത്തിലുള്ള സാഹചര്യം; കൂടാതെ സഹായി ഒരു പങ്കുവയ്ക്കലിന് എഴുതുന്നുണ്ടെന്ന വസ്തുതയും
ഔട്ട്പുട്ട് സ്ട്രീം. എല്ലാ പൊതു രീതികളും ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചു
PcapAndAsciiTraceHelperForIpv4 ഈ ഒരൊറ്റ ഉപകരണത്തെ ആശ്രിതമായി വിളിക്കുന്നതിലേക്ക് ചുരുക്കുക
നടപ്പിലാക്കൽ രീതി. ഉദാഹരണത്തിന്, ഏറ്റവും താഴ്ന്ന നിലയിലുള്ള ascii ട്രെയ്സ് രീതികൾ,:

അസാധുവായ EnableAsciiIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, Ptr ipv4, uint4_t ഇന്റർഫേസ്);

എന്ന ഉപകരണത്തിന്റെ നടപ്പാക്കലിനെ വിളിക്കും EnableAsciiIpv4Internal നേരിട്ട്, ഒന്നുകിൽ നൽകുന്നു
പ്രിഫിക്സ് അല്ലെങ്കിൽ സ്ട്രീം. മറ്റെല്ലാ പൊതു ആസ്കി ട്രെയ്‌സിംഗ് രീതികളും ഇവയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്
അധിക ഉപയോക്തൃ-തല പ്രവർത്തനം നൽകുന്നതിന് താഴ്ന്ന നിലയിലുള്ള പ്രവർത്തനങ്ങൾ. ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്
സിസ്റ്റത്തിലെ എല്ലാ ഉപകരണ സഹായികൾക്കും എല്ലാ ascii ട്രെയ്സ് രീതികളും ഉണ്ടായിരിക്കും എന്നതാണ് ഉപയോക്താവ്
ലഭ്യമാണ്; എങ്കിൽ ഈ രീതികളെല്ലാം പ്രോട്ടോക്കോളുകളിലുടനീളം ഒരേ രീതിയിൽ പ്രവർത്തിക്കും
പ്രോട്ടോക്കോളുകൾ നടപ്പിലാക്കുന്നു EnablAsciiIpv4Internal ശരിയായി.

അസ്സി പിന്തുടരുന്നു ഉപകരണ സഹായി രീതികൾ
അസാധുവായ EnableAsciiIpv4 (std::സ്ട്രിംഗ് പ്രിഫിക്സ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, Ptr ipv4, uint4_t ഇന്റർഫേസ്);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, std:: string ipv4Name, uint32_t ഇന്റർഫേസ്);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, std::string ipv4Name, uint32_t ഇന്റർഫേസ്);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, Ipv4InterfaceContainer c);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, Ipv4InterfaceContainer c);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, NodeContainer n);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, നോഡ് കണ്ടെയ്നർ n);

അസാധുവായ EnableAsciiIpv4 (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്, uint32_t nodeid, uint32_t deviceid);
അസാധുവായ EnableAsciiIpv4 (Ptr സ്ട്രീം, uint32_t nodeid, uint32_t ഇന്റർഫേസ്);

അസാധുവായ EnableAsciiIpv4All (std:: സ്ട്രിംഗ് പ്രിഫിക്സ്);
അസാധുവായ EnableAsciiIpv4All (Ptr ധാര);

ക്ലാസിനായി ഡോക്‌സിജൻ പരിശോധിക്കാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു PcapAndAsciiHelperForIpv4 കണ്ടെത്താൻ
ഈ രീതികളുടെ വിശദാംശങ്ങൾ; എന്നാൽ സംഗ്രഹിക്കാൻ ...

pcap-ന് ഉണ്ടായിരുന്നതിന്റെ ഇരട്ടി രീതികൾ 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" ഉൾപ്പെടുത്തണം.

a നൽകിക്കൊണ്ട് ഒരു പ്രത്യേക പ്രോട്ടോക്കോളിൽ നിങ്ങൾക്ക് 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 ഡാറ്റ കളക്ഷൻ ഫ്രെയിംവർക്കിനെ (DCF) വിവരിക്കുന്നു, അത്
സിമുലേറ്ററിൽ മോഡലുകൾ സൃഷ്ടിച്ച ഡാറ്റ നേടാനുള്ള കഴിവുകൾ, ഓൺലൈനിൽ പ്രവർത്തിക്കാൻ
റിഡക്ഷൻ, ഡാറ്റ പ്രോസസ്സിംഗ്, കൂടാതെ മാർഷൽ റോ അല്ലെങ്കിൽ പരിവർത്തനം ചെയ്ത ഡാറ്റ വിവിധ ഔട്ട്പുട്ടിലേക്ക്
ഫോർമാറ്റുകൾ.

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

ക്ലാസുകൾക്കുള്ള സോഴ്സ് കോഡ് ഡയറക്‌ടറിയിലാണ് src/stats.

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

ഡിസൈൻ
DCF മൂന്ന് അടിസ്ഥാന ക്ലാസുകൾ ഉൾക്കൊള്ളുന്നു:

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

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

· അഗ്രഗേറ്റർ പ്രോബുകളുടെയും കളക്ടർമാരുടെയും ഒരു ശൃംഖല ശേഖരിക്കുന്ന ഡാറ്റയുടെ അവസാന പോയിന്റാണ്.
അഗ്രഗേറ്ററിന്റെ പ്രധാന ഉത്തരവാദിത്തം മാർഷൽ ഡാറ്റയും അവയുടെ അനുബന്ധവുമാണ്
മെറ്റാഡാറ്റ, പ്ലെയിൻ ടെക്‌സ്‌റ്റ് ഫയലുകൾ, സ്‌പ്രെഡ്‌ഷീറ്റ് ഫയലുകൾ അല്ലെങ്കിൽ എന്നിങ്ങനെ വ്യത്യസ്ത ഔട്ട്‌പുട്ട് ഫോർമാറ്റുകളിലേക്ക്
ഡാറ്റാബേസുകൾ.

ഈ മൂന്ന് ക്ലാസുകളും ചലനാത്മകമായി സ്വയം ഓണാക്കാനോ ഓഫാക്കാനോ ഉള്ള കഴിവ് നൽകുന്നു
ഒരു സിമുലേഷനിൽ ഉടനീളം.

ഏതെങ്കിലും ഒറ്റപ്പെട്ട ns-3 DCF ഉപയോഗിക്കുന്ന സിമുലേഷൻ റൺ സാധാരണയായി ഒരെണ്ണമെങ്കിലും സൃഷ്ടിക്കും
മുകളിലുള്ള മൂന്ന് ക്ലാസുകളിൽ ഓരോന്നിന്റെയും ഉദാഹരണം.
[image] ഡാറ്റാ ശേഖരണ ചട്ടക്കൂട് അവലോകനം.UNINDENT

ഡാറ്റ പ്രോസസ്സിംഗിന്റെ മൊത്തത്തിലുള്ള ഒഴുക്ക് ചിത്രീകരിച്ചിരിക്കുന്നു ഡാറ്റ ശേഖരണം ചട്ടക്കൂട് അവലോകനം.
ഇടതുവശത്ത്, ഒരു ഓട്ടം ns-3 സിമുലേഷൻ ചിത്രീകരിച്ചിരിക്കുന്നു. പ്രവർത്തിപ്പിക്കുന്നതിനിടയിൽ
സിമുലേഷൻ, ട്രെയ്‌സ് സ്രോതസ്സുകളിലൂടെയോ മറ്റ് മാർഗങ്ങളിലൂടെയോ മോഡലുകൾ ഡാറ്റ ലഭ്യമാക്കുന്നു.
ഡാറ്റ സ്വീകരിക്കുന്നതിന് ഈ ട്രെയ്സ് ഉറവിടങ്ങളുമായി പേടകങ്ങളെ ബന്ധിപ്പിക്കാൻ കഴിയുമെന്ന് ഡയഗ്രം ചിത്രീകരിക്കുന്നു
അസമന്വിതമായി, അല്ലെങ്കിൽ പ്രോബുകൾക്ക് ഡാറ്റയ്ക്കായി വോട്ടെടുപ്പ് നടത്താം. പിന്നീട് ഒരു കളക്ടർ ഒബ്‌ജക്‌റ്റിലേക്ക് ഡാറ്റ കൈമാറുന്നു
അത് ഡാറ്റയെ പരിവർത്തനം ചെയ്യുന്നു. അവസാനമായി, ഒരു അഗ്രഗേറ്ററിനെ ഔട്ട്പുട്ടുകളിലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിയും
കളക്ടർ, പ്ലോട്ടുകൾ, ഫയലുകൾ അല്ലെങ്കിൽ ഡാറ്റാബേസുകൾ സൃഷ്ടിക്കാൻ.
[ചിത്രം] ഡാറ്റാ ശേഖരണ ചട്ടക്കൂട് സംഗ്രഹം.UNINDENT

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

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

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

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

ഇന്നുവരെ, രണ്ട് ഡാറ്റാ ശേഖരണ സഹായികൾ നടപ്പിലാക്കിയിട്ടുണ്ട്:

· ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ

· ഫയൽഹെൽപ്പർ

ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ
ഗ്നുപ്ലോട്ടുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ഔട്ട്പുട്ട് ഫയലുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഹെൽപ്പർ ക്ലാസ്സാണ് GnuplotHelper. ദി
കയറ്റുമതി ചെയ്ത ഡാറ്റയിൽ നിന്ന് ഉപയോക്താക്കൾക്ക് വേഗത്തിൽ പ്ലോട്ടുകൾ നിർമ്മിക്കാനുള്ള കഴിവ് നൽകുക എന്നതാണ് മൊത്തത്തിലുള്ള ലക്ഷ്യം
in ns-3 ഉറവിടങ്ങൾ കണ്ടെത്തുക. സ്ഥിരസ്ഥിതിയായി, കുറഞ്ഞ അളവിലുള്ള ഡാറ്റാ പരിവർത്തനം നടത്തപ്പെടുന്നു;
കുറച്ച് (ഡിഫോൾട്ട്) കോൺഫിഗറേഷൻ സ്റ്റേറ്റ്‌മെന്റുകൾ ഉപയോഗിച്ച് പ്ലോട്ടുകൾ സൃഷ്ടിക്കുക എന്നതാണ് ലക്ഷ്യം
സാധ്യമാണ്.

ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ പൊതു അവലോകനം
സിമുലേഷന്റെ അവസാനം GnuplotHelper 3 വ്യത്യസ്ത ഫയലുകൾ സൃഷ്ടിക്കും:

· ഒരു സ്പേസ് വേർതിരിക്കുന്ന gnuplot ഡാറ്റ ഫയൽ

ഒരു gnuplot കൺട്രോൾ ഫയൽ

gnuplot സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഷെൽ സ്ക്രിപ്റ്റ്

പ്ലോട്ടുകൾ നിർമ്മിക്കുന്നതിന് രണ്ട് കോൺഫിഗറേഷൻ പ്രസ്താവനകൾ ആവശ്യമാണ്. ആദ്യത്തേത്
സ്റ്റേറ്റ്മെന്റ് പ്ലോട്ട് കോൺഫിഗർ ചെയ്യുന്നു (ഫയലിന്റെ പേര്, ശീർഷകം, ഐതിഹ്യങ്ങൾ, ഔട്ട്പുട്ട് തരം, അവിടെ ഔട്ട്പുട്ട്
വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ ഡിഫോൾട്ടുകൾ PNG-ലേക്ക് ടൈപ്പ് ചെയ്യുക):

അസാധുവായ കോൺഫിഗർപ്ലോട്ട് (const std::string &outputFileNameWithoutExtension,
const std::സ്ട്രിംഗ് & ടൈറ്റിൽ,
const std::string &xLegend,
const std::string &yLegend,
const std::string &terminalType = ".png");

രണ്ടാമത്തെ പ്രസ്താവന താൽപ്പര്യത്തിന്റെ ഉറവിടത്തെ ആകർഷിക്കുന്നു:

അസാധുവായ PlotProbe (const std::string &typeId,
const std::സ്ട്രിംഗ് &പാത്ത്,
const std::string &probeTraceSource,
const std::string &title);

വാദങ്ങൾ ഇപ്രകാരമാണ്:

· ടൈപ്പ് ഐഡി: ദി ns-3 അന്വേഷണത്തിന്റെ തരം ഐഡി

· പാത: പാതയിലെ പാത ns-3 ഒന്നോ അതിലധികമോ ട്രേസ് ഉറവിടങ്ങളിലേക്കുള്ള കോൺഫിഗറേഷൻ നെയിംസ്പേസ്

· probeTraceSource: അന്വേഷണത്തിന്റെ ഏത് ഔട്ട്‌പുട്ട് (ഒരു ട്രെയ്സ് ഉറവിടം) പ്ലോട്ട് ചെയ്യണം

· ശീർഷകം: ഡാറ്റാസെറ്റുമായി (ഗ്നപ്ലോട്ട് ലെജൻഡിൽ) ബന്ധപ്പെടുത്താനുള്ള തലക്കെട്ട്

മുകളിലെ പ്ലോട്ട്പ്രോബിലെ ഒരു വകഭേദം നിയന്ത്രിക്കുന്ന അഞ്ചാമത്തെ ഓപ്ഷണൽ ആർഗ്യുമെന്റ് വ്യക്തമാക്കുന്നതാണ്
പ്ലോട്ടിൽ താക്കോൽ (ഇതിഹാസം) എവിടെയാണ് സ്ഥാപിച്ചിരിക്കുന്നത്.

പൂർണ്ണമായും പ്രവർത്തിച്ച ഒരു ഉദാഹരണം (നിന്ന് ഏഴാം.സി.സി) താഴെ കാണിച്ചിരിക്കുന്നു:

// gnuplot സഹായിയെ സൃഷ്ടിക്കുക.
GnuplotHelper plotHelper;

// പ്ലോട്ട് കോൺഫിഗർ ചെയ്യുക.
// പ്ലോട്ട് കോൺഫിഗർ ചെയ്യുക. ആദ്യത്തെ ആർഗ്യുമെന്റ് ഫയൽ നെയിം പ്രിഫിക്സാണ്
സൃഷ്‌ടിച്ച ഔട്ട്‌പുട്ട് ഫയലുകൾക്കായി //. രണ്ടാമത്തേതും മൂന്നാമത്തേതും നാലാമത്തേതും
// ആർഗ്യുമെന്റുകൾ യഥാക്രമം, പ്ലോട്ടിന്റെ ശീർഷകം, x-ആക്സിസ്, y-ആക്സിസ് ലേബലുകൾ എന്നിവയാണ്
plotHelper.ConfigurePlot ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
"പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് vs. സമയം",
"സമയം (സെക്കൻഡ്)",
"പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്",
"png");

// പ്രോബ് തരം വ്യക്തമാക്കുക, ഉറവിട പാത കണ്ടെത്തുക (കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ), കൂടാതെ
പ്ലോട്ട് ചെയ്യാൻ ഔട്ട്പുട്ട് ട്രെയ്സ് സോഴ്സ് ("ഔട്ട്പുട്ട് ബൈറ്റുകൾ") അന്വേഷിക്കുക. നാലാമത്തെ വാദം
// പ്ലോട്ടിലെ ഡാറ്റ സീരീസ് ലേബലിന്റെ പേര് വ്യക്തമാക്കുന്നു. അവസാനത്തെ
// ആർഗ്യുമെന്റ് കീ എവിടെ സ്ഥാപിക്കണമെന്ന് വ്യക്തമാക്കി പ്ലോട്ടിനെ ഫോർമാറ്റ് ചെയ്യുന്നു.
plotHelper.PlotProbe (probeType,
ട്രെയ്സ്പാത്ത്,
"ഔട്ട്പുട്ട്ബൈറ്റുകൾ",
"പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്",
GnuplotAggregator ::KEY_BELOW);

ഈ ഉദാഹരണത്തിൽ, ദി probeType ഒപ്പം ട്രെയ്സ്പാത്ത് ഇനിപ്പറയുന്നവയാണ് (IPv4-ന്):

probeType = "ns3::Ipv4PacketProbe";
ട്രേസ്പാത്ത് = "/നോഡ് ലിസ്റ്റ്/*/$ns3::Ipv4L3Protocol/Tx";

ഈ സഹായി പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു പ്രധാന പാരാമീറ്ററാണ് പ്രോബ് ടൈപ്പ്. ഈ ടൈപ്പ് ഐഡി രജിസ്റ്റർ ചെയ്തിരിക്കണം
സിസ്റ്റത്തിൽ, പ്രോബിന്റെ ട്രേസ് സിങ്കിലെ ഒപ്പ് ട്രേസിന്റേതുമായി പൊരുത്തപ്പെടണം
ഉറവിടത്തിലേക്ക് അത് ബന്ധിപ്പിച്ചിരിക്കുന്നു. നിരവധി ഡാറ്റ തരങ്ങൾക്കായി പ്രോബ് തരങ്ങൾ മുൻകൂട്ടി നിർവചിച്ചിരിക്കുന്നു
അനുബന്ധമായി ns-3 ട്രെയ്‌സ് ചെയ്‌ത മൂല്യങ്ങൾ, കൂടാതെ മറ്റ് ചില ട്രേസ് സോഴ്‌സ് സിഗ്‌നേച്ചറുകൾക്കും
'Tx' ട്രെയ്സ് ഉറവിടം ns3::Ipv4L3പ്രോട്ടോക്കോൾ ക്ലാസ്.

വ്യക്തമാക്കിയ ഉറവിട പാതയിൽ വൈൽഡ്കാർഡുകൾ അടങ്ങിയിരിക്കാമെന്നത് ശ്രദ്ധിക്കുക. ഈ സാഹചര്യത്തിൽ, ഒന്നിലധികം
ഡാറ്റാസെറ്റുകൾ ഒരു പ്ലോട്ടിൽ പ്ലോട്ട് ചെയ്തിരിക്കുന്നു; പൊരുത്തപ്പെടുന്ന ഓരോ പാതയ്ക്കും ഒന്ന്.

ഉൽപ്പാദിപ്പിക്കുന്ന പ്രധാന ഔട്ട്പുട്ട് മൂന്ന് ഫയലുകളായിരിക്കും:

ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.dat
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.plt
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.sh

ഈ സമയത്ത്, ഉപയോക്താക്കൾക്ക് കൂടുതൽ ഇഷ്‌ടാനുസൃതമാക്കലുകൾക്കായി .plt ഫയൽ കൈകൊണ്ട് എഡിറ്റ് ചെയ്യാം, അല്ലെങ്കിൽ
gnuplot വഴി അത് പ്രവർത്തിപ്പിക്കുക. പ്രവർത്തിക്കുന്ന sh ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-count.sh ലളിതമായി പ്ലോട്ട് പ്രവർത്തിപ്പിക്കുന്നു
gnuplot വഴി, താഴെ കാണിച്ചിരിക്കുന്നത് പോലെ.
[image] 2-D Gnuplot സൃഷ്‌ടിച്ചത് ഏഴാം.സിസി ഉദാഹരണം..UNINDENT

പ്രധാന ഘടകങ്ങൾ (ഇതിഹാസം, ശീർഷകം, ലെജൻഡ് പ്ലേസ്‌മെന്റ്, xlabel, ylabel,
കൂടാതെ ഡാറ്റയ്ക്കുള്ള പാത) എല്ലാം പ്ലോട്ടിൽ സ്ഥാപിച്ചിരിക്കുന്നു. രണ്ട് മത്സരങ്ങൾ ഉള്ളതിനാൽ
കോൺഫിഗറേഷൻ പാത്ത് നൽകിയിരിക്കുന്നു, രണ്ട് ഡാറ്റ ശ്രേണികൾ കാണിച്ചിരിക്കുന്നു:

· പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്-0 /NodeList/0/$ns3::Ipv4L3Protocol/Tx

· പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്-1 /NodeList/1/$ns3::Ipv4L3Protocol/Tx

ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ കോൺഫിഗർപ്ലോട്ട്
GnuplotHelper's കോൺഫിഗർപ്ലോട്ട്() പ്ലോട്ടുകൾ ക്രമീകരിക്കുന്നതിന് ഫംഗ്ഷൻ ഉപയോഗിക്കാം.

ഇതിന് ഇനിപ്പറയുന്ന പ്രോട്ടോടൈപ്പ് ഉണ്ട്:

അസാധുവായ കോൺഫിഗർപ്ലോട്ട് (const std::string &outputFileNameWithoutExtension,
const std::സ്ട്രിംഗ് & ടൈറ്റിൽ,
const std::string &xLegend,
const std::string &yLegend,
const std::string &terminalType = ".png");

ഇതിന് ഇനിപ്പറയുന്ന വാദങ്ങളുണ്ട്:

പതനം ────────────────┐
│വാദം │ വിവരണം │
പതനം ─────────────────┤
│ outputFileNameWithoutExtension │ gnuplot ബന്ധപ്പെട്ട ഫയലുകളുടെ പേര് │
│ │ വിപുലീകരണമില്ലാതെ എഴുതുക. │
പതനം ─────────────────┤
│ശീർഷകം │ │ എന്നതിനായി ഉപയോഗിക്കേണ്ട പ്ലോട്ട് ടൈറ്റിൽ സ്ട്രിംഗ്
│ │ ഈ പ്ലോട്ട്. │
പതനം ─────────────────┤
│xLegend │ x തിരശ്ചീനത്തിനായുള്ള ഇതിഹാസം │
│ │ അക്ഷം. │
പതനം ─────────────────┤
│yLegend │ y ലംബമായ ലെജൻഡ് │
│ │ അക്ഷം. │
പതനം ─────────────────┘

│terminalType │ │ എന്നതിനായുള്ള ടെർമിനൽ തരം ക്രമീകരണ സ്ട്രിംഗ്
│ │ ഔട്ട്പുട്ട്. സ്ഥിരസ്ഥിതി ടെർമിനൽ │
│ │ തരം "png" ആണ്. │
പതനം ─────────────────┘

GnuplotHelper's കോൺഫിഗർപ്ലോട്ട്() ഫംഗ്ഷൻ ഇതിനായി പ്ലോട്ടുമായി ബന്ധപ്പെട്ട പാരാമീറ്ററുകൾ ക്രമീകരിക്കുന്നു
gnuplot സഹായി, അതുവഴി സ്‌പെയ്‌സ് വേർതിരിക്കപ്പെട്ട gnuplot ഡാറ്റ ഫയൽ എന്ന പേരിൽ അത് സൃഷ്ടിക്കും
outputFileNameWithoutExtension + ".dat", പേരുള്ള ഒരു ഗ്നപ്ലോട്ട് കൺട്രോൾ ഫയൽ
outputFileNameWithoutExtension + ".plt", കൂടാതെ gnuplot എന്ന് പേരിട്ടിരിക്കുന്ന ഒരു ഷെൽ സ്ക്രിപ്റ്റ്
outputFileNameWithoutExtension + ".sh".

ഈ ഫംഗ്ഷൻ എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ ഒരു ഉദാഹരണം ഇതിൽ കാണാം ഏഴാം.സി.സി മുകളിൽ വിവരിച്ച കോഡ്
അത് താഴെ പറയുന്ന രീതിയിൽ എവിടെ ഉപയോഗിച്ചു:

plotHelper.ConfigurePlot ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
"പാക്കറ്റ് ബൈറ്റ് കൗണ്ട് vs. സമയം",
"സമയം (സെക്കൻഡ്)",
"പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്",
"png");

ഗ്നുപ്ലോട്ട് ഹെൽപ്പർ പ്ലോട്ട്പ്രോബ്
GnuplotHelper's പ്ലോട്ട്പ്രോബ്() പ്രോബുകൾ സൃഷ്ടിക്കുന്ന മൂല്യങ്ങൾ പ്ലോട്ട് ചെയ്യാൻ ഫംഗ്ഷൻ ഉപയോഗിക്കാം.

ഇതിന് ഇനിപ്പറയുന്ന പ്രോട്ടോടൈപ്പ് ഉണ്ട്:

അസാധുവായ PlotProbe (const std::string &typeId,
const std::സ്ട്രിംഗ് &പാത്ത്,
const std::string &probeTraceSource,
const std::സ്ട്രിംഗ് & ടൈറ്റിൽ,
enum GnuplotAggregator :: KeyLocation keyLocation = GnuplotAggregator ::KEY_INSIDE);

ഇതിന് ഇനിപ്പറയുന്ന വാദങ്ങളുണ്ട്:

പതനം ───┐
│വാദം │ വിവരണം │
പതനം ───┤
│typeId │ അന്വേഷണത്തിനുള്ള തരം ഐഡി │
│ │ ഈ സഹായി സൃഷ്ടിച്ചത്. │
പതനം ───┤
│പാത്ത് │ ട്രെയ്‌സ് ആക്‌സസ് ചെയ്യുന്നതിനുള്ള കോൺഫിഗ് പാത്ത് │
│ │ ഉറവിടം. │
പതനം ───┤
│probeTraceSource │ പ്രോബ് ട്രേസ് ഉറവിടം │
│ │ പ്രവേശനം. │
പതനം ───┤
│ശീർഷകം │ എന്നതുമായി ബന്ധപ്പെടുത്തേണ്ട ശീർഷകം
│ │ ഈ ഡാറ്റാഗണം │
പതനം ───┤
│keyLocation │ │ എന്നതിലെ കീയുടെ സ്ഥാനം
│ │ പ്ലോട്ട്. സ്ഥിരസ്ഥിതി സ്ഥാനം │ ആണ്
│ │ അകത്ത്. │
പതനം ───┘

GnuplotHelper's പ്ലോട്ട്പ്രോബ്() ഫംഗ്‌ഷൻ, ഹുക്ക് ചെയ്‌ത് സൃഷ്‌ടിച്ച ഒരു ഡാറ്റാസെറ്റ് പ്ലോട്ട് ചെയ്യുന്നു ns-3
സഹായി സൃഷ്ടിച്ച ഒരു അന്വേഷണം ഉപയോഗിച്ച് ഉറവിടം കണ്ടെത്തുക, തുടർന്ന് മൂല്യങ്ങൾ പ്ലോട്ട് ചെയ്യുക
probeTraceSource. ഡാറ്റാസെറ്റിന് നൽകിയിരിക്കുന്ന ശീർഷകം ഉണ്ടായിരിക്കും, കൂടാതെ ഇവ ഉൾപ്പെടുന്നു
ഓരോ ടൈംസ്റ്റാമ്പിലും 'newValue'.

ഒരു വൈൽഡ്കാർഡ് ഉള്ളതിനാൽ കോൺഫിഗറേഷൻ പാത്തിന് സിസ്റ്റത്തിൽ ഒന്നിലധികം പൊരുത്തം ഉണ്ടെങ്കിൽ, പിന്നെ
ഓരോ മത്സരത്തിനും ഒരു ഡാറ്റാസെറ്റ് പ്ലോട്ട് ചെയ്യും. ഡാറ്റാസെറ്റ് ശീർഷകങ്ങൾ എന്നതുമായി സഫിക്സ് ചെയ്യും
കോൺഫിഗറേഷൻ പാതയിലെ ഓരോ വൈൽഡ് കാർഡുകൾക്കുമായി പൊരുത്തപ്പെടുന്ന പ്രതീകങ്ങൾ, സ്‌പെയ്‌സുകളാൽ വേർതിരിച്ചിരിക്കുന്നു. വേണ്ടി
ഉദാഹരണത്തിന്, നിർദ്ദിഷ്ട ഡാറ്റാസെറ്റ് ശീർഷകം സ്ട്രിംഗ് "ബൈറ്റുകൾ" ആണെങ്കിൽ, കൂടാതെ രണ്ട് വൈൽഡ്കാർഡുകൾ ഉണ്ട്
പാതയിൽ, "bytes-0 0" അല്ലെങ്കിൽ "bytes-12 9" പോലുള്ള ഡാറ്റാസെറ്റ് ശീർഷകങ്ങൾ സാധ്യമാകും
പ്ലോട്ട് ചെയ്ത ഡാറ്റാസെറ്റുകൾക്കുള്ള ലേബലുകൾ.

ഈ ഫംഗ്ഷൻ എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ ഒരു ഉദാഹരണം ഇതിൽ കാണാം ഏഴാം.സി.സി മുകളിൽ വിവരിച്ച കോഡ്
എവിടെയാണ് അത് ഉപയോഗിച്ചത് (വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷനോട് കൂടി) ഇനിപ്പറയുന്ന രീതിയിൽ:

plotHelper.PlotProbe ("ns3::Ipv4PacketProbe",
"/NodeList/*/$ns3::Ipv4L3Protocol/Tx",
"ഔട്ട്പുട്ട്ബൈറ്റുകൾ",
"പാക്കറ്റ് ബൈറ്റ് കൗണ്ട്",
GnuplotAggregator ::KEY_BELOW);

മറ്റു ഉദാഹരണങ്ങൾ
ഗ്നുപ്ലോട്ട് സഹായി ഉദാഹരണം
എന്നതിനേക്കാൾ അല്പം ലളിതമായ ഉദാഹരണം ഏഴാം.സി.സി ഉദാഹരണത്തിൽ കാണാം
src/stats/examples/gnuplot-helper-example.cc. ഇനിപ്പറയുന്ന 2-D gnuplot സൃഷ്ടിച്ചത് ഉപയോഗിച്ചാണ്
ഉദാഹരണം.
[image] 2-D Gnuplot സൃഷ്ടിച്ചത് gnuplot-helper-example.cc ഉദാഹരണം..UNINDENT

ഈ ഉദാഹരണത്തിൽ, a അനുസരിച്ച് അതിന്റെ കൌണ്ടർ വർദ്ധിപ്പിക്കുന്ന ഒരു എമിറ്റർ ഒബ്ജക്റ്റ് ഉണ്ട്
പോയിസൺ പ്രോസസ്സ് ചെയ്യുകയും തുടർന്ന് കൗണ്ടറിന്റെ മൂല്യം ഒരു ട്രെയ്സ് ഉറവിടമായി പുറത്തുവിടുകയും ചെയ്യുന്നു.

Ptr emitter = CreateObject ();
പേരുകൾ:: ചേർക്കുക ("/പേരുകൾ/എമിറ്റർ", എമിറ്റർ);

ചുവടെ ഉപയോഗിച്ചിരിക്കുന്ന പാതയിൽ വൈൽഡ്കാർഡുകളൊന്നും ഇല്ലാത്തതിനാൽ, 1 ഡാറ്റ സ്ട്രീം മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ എന്നത് ശ്രദ്ധിക്കുക
പ്ലോട്ടിൽ വരച്ചത്. പ്ലോട്ടിലെ ഈ ഒരൊറ്റ ഡാറ്റാ സ്ട്രീം "എമിറ്റർ കൗണ്ട്" എന്ന് ലേബൽ ചെയ്തിരിക്കുന്നു,
പാതയിൽ വൈൽഡ്കാർഡുകൾ ഉണ്ടോ എന്ന് നോക്കുന്നതുപോലെ അധിക പ്രത്യയങ്ങളൊന്നുമില്ലാതെ.

// gnuplot സഹായിയെ സൃഷ്ടിക്കുക.
GnuplotHelper plotHelper;

// പ്ലോട്ട് കോൺഫിഗർ ചെയ്യുക.
plotHelper.ConfigurePlot ("gnuplot-helper-example",
"Emitter Counts vs. Time",
"സമയം (സെക്കൻഡ്)",
"എമിറ്റർ കൗണ്ട്",
"png");

// അന്വേഷണം സൃഷ്ടിച്ച മൂല്യങ്ങൾ പ്ലോട്ട് ചെയ്യുക. ഞങ്ങൾ നൽകുന്ന പാത
// ട്രെയ്‌സിന്റെ ഉറവിടം അവ്യക്തമാക്കാൻ സഹായിക്കുന്നു.
plotHelper.PlotProbe ("ns3::Uinteger32Probe",
"/പേരുകൾ/എമിറ്റർ/കൗണ്ടർ",
"ഔട്ട്പുട്ട്",
"എമിറ്റർ കൗണ്ട്",
GnuplotAggregator ::KEY_INSIDE);

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

ഫയൽഹെൽപ്പർ പൊതു അവലോകനം
സിമുലേഷന്റെ അവസാനം ഫയൽഹെൽപ്പർ ഒന്നോ അതിലധികമോ ടെക്സ്റ്റ് ഫയലുകൾ സൃഷ്ടിക്കും.

FileHelper-ന് 4 വ്യത്യസ്ത തരം ടെക്സ്റ്റ് ഫയലുകൾ സൃഷ്ടിക്കാൻ കഴിയും:

· ഫോർമാറ്റ് ചെയ്തു

· ഇടം വേർതിരിച്ചു (സ്ഥിരസ്ഥിതി)

· കോമ വേർതിരിച്ചു

· ടാബ് വേർതിരിച്ചു

ഫോർമാറ്റ് ചെയ്‌ത ഫയലുകൾ സി-സ്റ്റൈൽ ഫോർമാറ്റ് സ്‌ട്രിംഗുകളും സ്‌പ്രിന്റ്‌എഫ്() ഫംഗ്‌ഷനും പ്രിന്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു
എഴുതുന്ന ഫയലിലെ മൂല്യങ്ങൾ.

ഫോർമാറ്റ് ചെയ്‌ത മൂല്യങ്ങളുടെ 2 കോളങ്ങളുള്ള ഇനിപ്പറയുന്ന ടെക്‌സ്‌റ്റ് ഫയൽ നാമകരണം ചെയ്‌തു
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം-0.txt എന്നതിലേക്ക് ചേർത്ത കൂടുതൽ പുതിയ കോഡ് ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്
യഥാർത്ഥ ns-3 ട്യൂട്ടോറിയൽ ഉദാഹരണ കോഡ്. ഈ ഫയലിന്റെ ആദ്യ 10 വരികൾ മാത്രമേ കാണിച്ചിട്ടുള്ളൂ
സംക്ഷിപ്തതയ്ക്കായി ഇവിടെ.

സമയം (സെക്കൻഡ്) = 1.000e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.004e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.004e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 576
സമയം (സെക്കൻഡ്) = 1.009e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 576
സമയം (സെക്കൻഡ്) = 1.009e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 576
സമയം (സെക്കൻഡ്) = 1.015e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 512
സമയം (സെക്കൻഡ്) = 1.017e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 576
സമയം (സെക്കൻഡ്) = 1.017e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 544
സമയം (സെക്കൻഡ്) = 1.025e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 576
സമയം (സെക്കൻഡ്) = 1.025e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 544

...

ഫോർമാറ്റ് ചെയ്‌ത മൂല്യങ്ങളുടെ 2 നിരകളുള്ള ഇനിപ്പറയുന്ന വ്യത്യസ്‌ത ടെക്‌സ്‌റ്റ് ഫയൽ നാമകരണം ചെയ്‌തു
ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം-1.txt ചേർത്ത അതേ പുതിയ കോഡ് ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്
യഥാർത്ഥ ns-3 ട്യൂട്ടോറിയൽ ഉദാഹരണ കോഡ്. ഈ ഫയലിന്റെ ആദ്യ 10 വരികൾ മാത്രമേ കാണിച്ചിട്ടുള്ളൂ
സംക്ഷിപ്തതയ്ക്കായി ഇവിടെ.

സമയം (സെക്കൻഡ്) = 1.002e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.007e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.013e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.020e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.028e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.036e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.045e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.053e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.061e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40
സമയം (സെക്കൻഡ്) = 1.069e+00 പാക്കറ്റ് ബൈറ്റ് എണ്ണം = 40

...

രണ്ട് ടെക്സ്റ്റ് ഫയലുകൾ നിർമ്മിക്കാൻ ചേർത്ത പുതിയ കോഡ് ചുവടെയുണ്ട്. എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ
ഈ API പിന്നീടുള്ള വിഭാഗത്തിൽ ഉൾപ്പെടുത്തും.

പാതയിൽ വൈൽഡ്കാർഡിനായി 2 പൊരുത്തങ്ങൾ ഉണ്ടായിരുന്നതിനാൽ, 2 പ്രത്യേക ടെക്സ്റ്റ് ഫയലുകൾ ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക
സൃഷ്ടിക്കപ്പെട്ടു. "seventh-packet-byte-count-0.txt" എന്ന് പേരിട്ടിരിക്കുന്ന ആദ്യത്തെ ടെക്സ്റ്റ് ഫയൽ,
വൈൽഡ്കാർഡ് പൊരുത്തവുമായി "*" മാറ്റി പകരം "0" ഉപയോഗിച്ച് പൊരുത്തപ്പെടുന്നു. രണ്ടാമത്തെ ടെക്സ്റ്റ് ഫയൽ,
"seventh-packet-byte-count-1.txt" എന്ന് പേരിട്ടിരിക്കുന്ന, വൈൽഡ്കാർഡ് പൊരുത്തവുമായി പൊരുത്തപ്പെടുന്നു
"*" മാറ്റി പകരം "1". കൂടാതെ, ഫംഗ്ഷൻ വിളിക്കുന്നത് ശ്രദ്ധിക്കുക WriteProbe() ഒരു തരും
വൈൽഡ്കാർഡുകൾ അടങ്ങിയ ഒരു പാതയ്ക്ക് പൊരുത്തമില്ലെങ്കിൽ പിശക് സന്ദേശം.

// ഫയൽ സഹായി സൃഷ്ടിക്കുക.
ഫയൽഹെൽപ്പർ ഫയൽഹെൽപ്പർ;

// എഴുതേണ്ട ഫയൽ കോൺഫിഗർ ചെയ്യുക.
fileHelper.ConfigureFile ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);

// ഈ ഫോർമാറ്റ് ചെയ്ത ഔട്ട്‌പുട്ട് ഫയലിനായി ലേബലുകൾ സജ്ജമാക്കുക.
fileHelper.Set2dFormat ("സമയം (സെക്കൻഡ്) = %.3e\tപാക്കറ്റ് ബൈറ്റ് കൗണ്ട് = %.0f");

// അന്വേഷണം സൃഷ്ടിച്ച മൂല്യങ്ങൾ എഴുതുക.
fileHelper.WriteProbe ("ns3::Ipv4PacketProbe",
"/NodeList/*/$ns3::Ipv4L3Protocol/Tx",
"ഔട്ട്പുട്ട്ബൈറ്റുകൾ");

ഫയൽഹെൽപ്പർ ഫയൽ കോൺഫിഗർ ചെയ്യുക
ഫയൽഹെൽപ്പറുടെ കോൺഫിഗർ ഫയൽ() ടെക്സ്റ്റ് ഫയലുകൾ കോൺഫിഗർ ചെയ്യാൻ ഫംഗ്ഷൻ ഉപയോഗിക്കാം.

ഇതിന് ഇനിപ്പറയുന്ന പ്രോട്ടോടൈപ്പ് ഉണ്ട്:

അസാധുവായ കോൺഫിഗർ ഫയൽ (const std::string &outputFileNameWithout Extension,
enum FileAggregator :: FileType fileType = FileAggregator ::SPACE_SEPARATED);

ഇതിന് ഇനിപ്പറയുന്ന വാദങ്ങളുണ്ട്:

പതനം ────────────────┐
│വാദം │ വിവരണം │
പതനം ─────────────────┤
│outputFileNameWithoutExtension │ എഴുതാനുള്ള ഔട്ട്‌പുട്ട് ഫയലിന്റെ പേര് │
│ │ വിപുലീകരണമില്ലാതെ. │
പതനം ─────────────────┤
│fileType │ എഴുതാനുള്ള ഫയലിന്റെ തരം. │
│ │ ഫയലിന്റെ ഡിഫോൾട്ട് തരം സ്പേസ് ആണ്
│ │ വേർതിരിച്ചു. │
പതനം ─────────────────┘

ഫയൽഹെൽപ്പറുടെ കോൺഫിഗർ ഫയൽ() ഫംഗ്ഷൻ ടെക്സ്റ്റ് ഫയലുമായി ബന്ധപ്പെട്ട പാരാമീറ്ററുകൾ കോൺഫിഗർ ചെയ്യുന്നു
ഫയൽ സഹായി, അങ്ങനെ അത് outputFileNameWithoutExtension പ്ലസ് എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കും
വൈൽഡ്കാർഡ് പൊരുത്തങ്ങളിൽ നിന്ന് സാധ്യമായ അധിക വിവരങ്ങൾ കൂടാതെ ".txt" എന്ന് അച്ചടിച്ച മൂല്യങ്ങൾ
ഫയൽടൈപ്പ് വ്യക്തമാക്കുന്നു. ഡിഫോൾട്ട് ഫയൽ തരം സ്പേസ്-വേർതിരിക്കപ്പെട്ടതാണ്.

ഈ ഫംഗ്ഷൻ എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ ഒരു ഉദാഹരണം ഇതിൽ കാണാം ഏഴാം.സി.സി മുകളിൽ വിവരിച്ച കോഡ്
അത് താഴെ പറയുന്ന രീതിയിൽ എവിടെ ഉപയോഗിച്ചു:

fileHelper.ConfigureFile ("ഏഴാമത്തെ-പാക്കറ്റ്-ബൈറ്റ്-എണ്ണം",
ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);

ഫയൽഹെൽപ്പർ WriteProbe
ഫയൽഹെൽപ്പറുടെ WriteProbe() പ്രോബുകൾ സൃഷ്ടിച്ച മൂല്യങ്ങൾ എഴുതാൻ ഫംഗ്ഷൻ ഉപയോഗിക്കാം
ടെക്സ്റ്റ് ഫയലുകൾ.

ഇതിന് ഇനിപ്പറയുന്ന പ്രോട്ടോടൈപ്പ് ഉണ്ട്:

അസാധുവായ WriteProbe (const std::string &typeId,
const std::സ്ട്രിംഗ് &പാത്ത്,
const std::string &probeTraceSource);

ഇതിന് ഇനിപ്പറയുന്ന വാദങ്ങളുണ്ട്:

പതനം ───┐
│വാദം │ വിവരണം │
പതനം ───┤
│typeId │ അന്വേഷണത്തിനുള്ള തരം ഐഡി │
│ │ സൃഷ്ടിച്ചു. │
പതനം ───┤
│പാത്ത് │ ട്രെയ്‌സ് ആക്‌സസ് ചെയ്യുന്നതിനുള്ള കോൺഫിഗ് പാത്ത് │
│ │ ഉറവിടം. │
പതനം ───┤
│probeTraceSource │ പ്രോബ് ട്രേസ് ഉറവിടം │
│ │ പ്രവേശനം. │
പതനം ───┘

ഫയൽഹെൽപ്പറുടെ WriteProbe() ഫംഗ്‌ഷൻ ഹുക്ക് ചെയ്‌ത് ജനറേറ്റുചെയ്‌ത ഔട്ട്‌പുട്ട് ടെക്‌സ്‌റ്റ് ഫയലുകൾ സൃഷ്‌ടിക്കുന്നു
സഹായി സൃഷ്ടിച്ച ഒരു അന്വേഷണം ഉപയോഗിച്ച് ns-3 ഉറവിടം കണ്ടെത്തുക, തുടർന്ന് മൂല്യങ്ങൾ എഴുതുക
probeTraceSource. ഔട്ട്‌പുട്ട് ഫയൽ പേരുകളിൽ അംഗ വേരിയബിളിൽ ടെക്‌സ്‌റ്റ് സംഭരിച്ചിരിക്കും
m_outputFileNameWithoutExtension കൂടാതെ ".txt", കൂടാതെ ഓരോന്നിലും 'newValue' അടങ്ങിയിരിക്കും
ടൈംസ്റ്റാമ്പ്.

ഒരു വൈൽഡ്കാർഡ് ഉള്ളതിനാൽ കോൺഫിഗറേഷൻ പാത്തിന് സിസ്റ്റത്തിൽ ഒന്നിലധികം പൊരുത്തം ഉണ്ടെങ്കിൽ, പിന്നെ
ഓരോ മത്സരത്തിനും ഒരു ഔട്ട്‌പുട്ട് ഫയൽ സൃഷ്‌ടിക്കും. ഔട്ട്‌പുട്ട് ഫയലിന്റെ പേരുകളിൽ ഇവ അടങ്ങിയിരിക്കും
m_outputFileNameWithoutExtension-ലെ ടെക്‌സ്‌റ്റ് കൂടാതെ ഓരോന്നിനും പൊരുത്തപ്പെടുന്ന പ്രതീകങ്ങൾ
കോൺഫിഗറേഷൻ പാതയിലെ വൈൽഡ്കാർഡുകൾ, ഡാഷുകളാൽ വേർതിരിച്ചിരിക്കുന്നു, കൂടാതെ ".txt". ഉദാഹരണത്തിന്, മൂല്യമാണെങ്കിൽ
m_outputFileNameWithoutExtension-ൽ "പാക്കറ്റ്-ബൈറ്റ്-കൌണ്ട്" എന്ന സ്ട്രിംഗ് ആണ്, രണ്ടെണ്ണം ഉണ്ട്
പാതയിലെ വൈൽഡ്കാർഡുകൾ, തുടർന്ന് "packet-byte-count-0-0.txt" അല്ലെങ്കിൽ
സൃഷ്ടിക്കപ്പെടുന്ന ഫയലുകളുടെ പേരുകളായി "packet-byte-count-12-9.txt" സാധ്യമാകും.

ഈ ഫംഗ്ഷൻ എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ ഒരു ഉദാഹരണം ഇതിൽ കാണാം ഏഴാം.സി.സി മുകളിൽ വിവരിച്ച കോഡ്
അത് താഴെ പറയുന്ന രീതിയിൽ എവിടെ ഉപയോഗിച്ചു:

fileHelper.WriteProbe ("ns3::Ipv4PacketProbe",
"/NodeList/*/$ns3::Ipv4L3Protocol/Tx",
"ഔട്ട്പുട്ട്ബൈറ്റുകൾ");

മറ്റു ഉദാഹരണങ്ങൾ
ഫയല് സഹായി ഉദാഹരണം
എന്നതിനേക്കാൾ അല്പം ലളിതമായ ഉദാഹരണം ഏഴാം.സി.സി ഉദാഹരണത്തിൽ കാണാം
src/stats/examples/file-helper-example.cc. ഈ ഉദാഹരണം FileHelper മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ.

ഫോർമാറ്റ് ചെയ്‌ത മൂല്യങ്ങളുടെ 2 കോളങ്ങളുള്ള ഇനിപ്പറയുന്ന ടെക്‌സ്‌റ്റ് ഫയൽ നാമകരണം ചെയ്‌തു file-helper-example.txt
ഉദാഹരണം ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്. ഈ ഫയലിന്റെ ആദ്യ 10 വരികൾ മാത്രമാണ് ഇവിടെ കാണിച്ചിരിക്കുന്നത്
സംക്ഷിപ്തത.

സമയം (സെക്കൻഡ്) = 0.203 എണ്ണം = 1
സമയം (സെക്കൻഡ്) = 0.702 എണ്ണം = 2
സമയം (സെക്കൻഡ്) = 1.404 എണ്ണം = 3
സമയം (സെക്കൻഡ്) = 2.368 എണ്ണം = 4
സമയം (സെക്കൻഡ്) = 3.364 എണ്ണം = 5
സമയം (സെക്കൻഡ്) = 3.579 എണ്ണം = 6
സമയം (സെക്കൻഡ്) = 5.873 എണ്ണം = 7
സമയം (സെക്കൻഡ്) = 6.410 എണ്ണം = 8
സമയം (സെക്കൻഡ്) = 6.472 എണ്ണം = 9
...

ഈ ഉദാഹരണത്തിൽ, a അനുസരിച്ച് അതിന്റെ കൌണ്ടർ വർദ്ധിപ്പിക്കുന്ന ഒരു എമിറ്റർ ഒബ്ജക്റ്റ് ഉണ്ട്
പോയിസൺ പ്രോസസ്സ് ചെയ്യുകയും തുടർന്ന് കൗണ്ടറിന്റെ മൂല്യം ഒരു ട്രെയ്സ് ഉറവിടമായി പുറത്തുവിടുകയും ചെയ്യുന്നു.

Ptr emitter = CreateObject ();
പേരുകൾ:: ചേർക്കുക ("/പേരുകൾ/എമിറ്റർ", എമിറ്റർ);

ചുവടെ ഉപയോഗിച്ചിരിക്കുന്ന പാതയിൽ വൈൽഡ്കാർഡുകളൊന്നും ഇല്ലാത്തതിനാൽ, ഒരു ടെക്സ്റ്റ് ഫയൽ മാത്രമായിരുന്നു എന്നത് ശ്രദ്ധിക്കുക
സൃഷ്ടിച്ചു. ഈ ഒരൊറ്റ ടെക്സ്റ്റ് ഫയലിന് അധികമൊന്നും കൂടാതെ "file-helper-example.txt" എന്ന് പേരിട്ടിരിക്കുന്നു
പാതയിൽ വൈൽഡ് കാർഡുകൾ ഉണ്ടെങ്കിൽ നിങ്ങൾ കാണും പോലെയുള്ള പ്രത്യയങ്ങൾ.

// ഫയൽ സഹായി സൃഷ്ടിക്കുക.
ഫയൽഹെൽപ്പർ ഫയൽഹെൽപ്പർ;

// എഴുതേണ്ട ഫയൽ കോൺഫിഗർ ചെയ്യുക.
fileHelper.ConfigureFile ("ഫയൽ-സഹായി-ഉദാഹരണം",
ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);

// ഈ ഫോർമാറ്റ് ചെയ്ത ഔട്ട്‌പുട്ട് ഫയലിനായി ലേബലുകൾ സജ്ജമാക്കുക.
fileHelper.Set2dFormat ("സമയം (സെക്കൻഡ്) = %.3e\tCount = %.0f");

// അന്വേഷണം സൃഷ്ടിച്ച മൂല്യങ്ങൾ എഴുതുക. നമ്മൾ ചെയ്ത പാത
// ട്രെയ്‌സിന്റെ ഉറവിടം അവ്യക്തമാക്കാൻ സഹായിക്കുന്നു.
fileHelper.WriteProbe ("ns3::Uinteger32Probe",
"/പേരുകൾ/എമിറ്റർ/കൗണ്ടർ",
"ഔട്ട്പുട്ട്");

സ്കോപ്പ് ഒപ്പം പരിമിതികൾ
നിലവിൽ, ഈ പ്രോബുകൾ മാത്രമേ നടപ്പിലാക്കിയിട്ടുള്ളൂ കൂടാതെ GnuplotHelper ലേക്ക് ബന്ധിപ്പിച്ചിരിക്കുന്നു
ഫയൽഹെൽപ്പറിലേക്ക്:

· ബൂളിയൻ പ്രോബ്

· ഡബിൾപ്രോബ്

· Uinteger8Probe

· Uinteger16Probe

· Uinteger32Probe

· ടൈംപ്രോബ്

· പാക്കറ്റ്പ്രോബ്

· ApplicationPacketProbe

· Ipv4PacketProbe

അതിനാൽ, ഈ പ്രോബുകൾ മാത്രമേ ഉപയോഗിക്കാനാവൂ പ്ലോട്ട്പ്രോബ്() ഒപ്പം
WriteProbe().

അടുത്ത കുറച്ച് വിഭാഗങ്ങളിൽ, ഞങ്ങൾ ഓരോ അടിസ്ഥാന ഒബ്‌ജക്റ്റ് തരങ്ങളും (പ്രോബ്, കളക്ടർ,
ഒപ്പം അഗ്രഗേറ്ററും) കൂടുതൽ വിശദമായി, അവ ഉപയോഗിച്ച് എങ്ങനെ ഒരുമിച്ച് ബന്ധിപ്പിക്കാമെന്ന് കാണിക്കുക
ലോവർ ലെവൽ API.

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

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

സാധാരണഗതിയിൽ, ഒരു പ്രോബ് ബന്ധിപ്പിച്ചിരിക്കുന്നു ns-3 ഉറവിടം കണ്ടെത്തുക. ഈ രീതിയിൽ, എപ്പോഴൊക്കെ
ട്രെയ്സ് സോഴ്സ് ഒരു പുതിയ മൂല്യം കയറ്റുമതി ചെയ്യുന്നു, പ്രോബ് മൂല്യം ഉപയോഗിക്കുന്നു (അത് താഴേക്ക് കയറ്റുമതി ചെയ്യുന്നു
സ്വന്തം ട്രെയ്സ് സോഴ്സ് വഴി മറ്റൊരു വസ്തുവിലേക്ക്).

ട്രെയ്‌സ് സ്രോതസ്സുകളിലെ ഒരു ഫിൽട്ടറായി പ്രോബിനെ കണക്കാക്കാം. പ്രധാന കാരണങ്ങൾ
ഒരു ട്രെയ്‌സ് ഉറവിടത്തിലേക്ക് നേരിട്ട് ഉപയോഗിക്കുന്നതിനുപകരം ഒരു പ്രോബിലേക്ക് ഹുക്ക് ചെയ്യുന്നത് ഇനിപ്പറയുന്നവയാണ്:

· കോളുകൾ ഉപയോഗിച്ച് സിമുലേഷൻ സമയത്ത് പ്രോബുകൾ ചലനാത്മകമായി ഓണാക്കുകയോ ഓഫാക്കുകയോ ചെയ്തേക്കാം പ്രവർത്തനക്ഷമമാക്കുക()
ഒപ്പം പ്രവർത്തനരഹിതമാക്കുക(). ഉദാഹരണത്തിന്, ഈ സമയത്ത് ഡാറ്റയുടെ ഔട്ട്പുട്ടിംഗ് ഓഫാക്കിയേക്കാം
സിമുലേഷൻ സന്നാഹ ഘട്ടം.

കൂടുതൽ സങ്കീർണ്ണമായതിൽ നിന്ന് മൂല്യങ്ങൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതിന് പ്രോബുകൾ ഡാറ്റയിൽ പ്രവർത്തനങ്ങൾ നടത്തിയേക്കാം
ഘടനകൾ; ഉദാഹരണത്തിന്, ലഭിച്ച ns3 ::പാക്കറ്റിൽ നിന്ന് പാക്കറ്റ് സൈസ് മൂല്യം ഔട്ട്പുട്ട് ചെയ്യുന്നു.

· പ്രോബുകൾ ns3::Config നെയിംസ്പേസിൽ ഒരു പേര് രജിസ്റ്റർ ചെയ്യുന്നു (ഉപയോഗിക്കുന്നത് പേരുകൾ:: ചേർക്കുക ()) അങ്ങനെ മറ്റൊന്ന്
വസ്തുക്കൾ അവരെ പരാമർശിച്ചേക്കാം.

· പേടകങ്ങൾ ഒരു സ്റ്റാറ്റിക് രീതി നൽകുന്നു, അത് പേരിനനുസരിച്ച് ഒരു പ്രോബ് കൈകാര്യം ചെയ്യാൻ ഒരാളെ അനുവദിക്കുന്നു
ns2measure ൽ എന്താണ് ചെയ്യുന്നത് [Cic06]

സ്ഥിതി::put ("my_metric", ID, സാമ്പിൾ);

മുകളിലുള്ള ns3measure കോഡിന്റെ ns-2 തത്തുല്യമാണ്, ഉദാ

DoubleProbe::SetValueByPath ("/path/to/probe", സാമ്പിൾ);

സൃഷ്ടി
ഒരു പ്രോബ് ബേസ് ക്ലാസ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കാൻ കഴിയില്ല എന്നത് ശ്രദ്ധിക്കുക, കാരണം അത് ഒരു അമൂർത്ത അടിത്തറയാണ്
ക്ലാസ്, അതായത് നടപ്പിലാക്കാത്ത ശുദ്ധമായ വെർച്വൽ ഫംഗ്‌ഷനുകൾ ഇതിന് ഉണ്ട്. ഒരു വസ്തു
DoubleProbe എന്ന് ടൈപ്പ് ചെയ്യുക, ഇത് പ്രോബ് ക്ലാസിന്റെ ഒരു ഉപവിഭാഗമാണ്, കാണിക്കാൻ ഇവിടെ സൃഷ്ടിക്കപ്പെടും
എന്താണ് ചെയ്യേണ്ടത്.

സ്‌മാർട്ട് പോയിന്റർ ക്ലാസ് (Ptr) ഉപയോഗിച്ച് ഒരാൾ ഡൈനാമിക് മെമ്മറിയിൽ ഒരു ഡബിൾ പ്രോബ് പ്രഖ്യാപിക്കുന്നു. ). ലേക്ക്
സ്മാർട്ട് പോയിന്ററുകൾ ഉപയോഗിച്ച് ഡൈനാമിക് മെമ്മറിയിൽ ഒരു DoubleProbe സൃഷ്‌ടിക്കുക, ഒരാൾ വിളിക്കേണ്ടതുണ്ട്
ns-3 രീതി CreateObject():

Ptr myprobe = CreateObject ();

മുകളിലെ പ്രഖ്യാപനം അതിന്റെ ആട്രിബ്യൂട്ടുകൾക്കായി സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ ഉപയോഗിച്ച് DoubleProbes സൃഷ്ടിക്കുന്നു.
DoubleProbe ക്ലാസിൽ നാല് ആട്രിബ്യൂട്ടുകളുണ്ട്; അടിസ്ഥാന ക്ലാസ് ഒബ്ജക്റ്റിൽ രണ്ട്
DataCollectionObject, കൂടാതെ രണ്ട് പ്രോബ് ബേസ് ക്ലാസിൽ:

· "പേര്" (ഡാറ്റ കളക്ഷൻ ഒബ്ജക്റ്റ്), ഒരു സ്ട്രിംഗ് മൂല്യം

· "പ്രാപ്തമാക്കി" (ഡാറ്റ കളക്ഷൻ ഒബ്ജക്റ്റ്), ഒരു ബൂളിയൻ മൂല്യം

· "ആരംഭിക്കുക" (പ്രോബ്), ഒരു സമയ മൂല്യം

· "നിർത്തുക" (പ്രോബ്), ഒരു സമയ മൂല്യം

ഇനിപ്പറയുന്ന രീതി ഉപയോഗിച്ച് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ ഒരാൾക്ക് അത്തരം ആട്രിബ്യൂട്ടുകൾ സജ്ജമാക്കാൻ കഴിയും:

Ptr myprobe = CreateObjectWithAttributes (
"പേര്", StringValue ("myprobe"),
"പ്രാപ്തമാക്കി", ബൂളിയൻ മൂല്യം (തെറ്റായ),
"ആരംഭിക്കുക", സമയമൂല്യം (സെക്കൻഡ് (100.0)),
"നിർത്തുക", സമയമൂല്യം (സെക്കൻഡ് (1000.0)));

പ്രോബിന്റെ പ്രവർത്തനത്തിന്റെ ഇടവേള നിർണ്ണയിക്കുന്ന സമയ വേരിയബിളുകളാണ് സ്റ്റാർട്ട്, സ്റ്റോപ്പ്. ദി
സിമുലേഷന്റെ നിലവിലെ സമയം അതിനുള്ളിലാണെങ്കിൽ മാത്രമേ പ്രോബ് ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യുകയുള്ളൂ
ഇടവേള. സ്റ്റോപ്പിനുള്ള 0 സെക്കൻഡിന്റെ പ്രത്യേക സമയ മൂല്യം ഈ ആട്രിബ്യൂട്ട് പ്രവർത്തനരഹിതമാക്കും (അതായത്
മുഴുവൻ സിമുലേഷനുമായി അന്വേഷണം തുടരുക). പ്രോബ് ഓണാക്കുന്ന ഒരു ഫ്ലാഗ് ആണ് പ്രവർത്തനക്ഷമമാക്കിയത്
ഓഫ്, കൂടാതെ ഡാറ്റ എക്‌സ്‌പോർട്ട് ചെയ്യുന്നതിന് പ്രോബിന് true ആയി സജ്ജീകരിച്ചിരിക്കണം. വസ്തുവിന്റെ പേരാണ് നാമം
DCF ചട്ടക്കൂടിൽ.

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

ഇരട്ടപ്രോബ് പൊതു അവലോകനം
DoubleProbe ഇരട്ട മൂല്യമുള്ളതിലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഉറവിടം കണ്ടെത്തുക, അത് തന്നെ കയറ്റുമതി ചെയ്യുന്നു a
വ്യത്യസ്ത ഇരട്ട മൂല്യമുള്ള ns-3 ഉറവിടം കണ്ടെത്തുക.

ഇനിപ്പറയുന്ന കോഡ്, എടുത്തത് src/stats/examples/double-probe-example.cc, അടിസ്ഥാനം കാണിക്കുന്നു
DoubleProbe ഒരു സിമുലേഷനിലേക്ക് പ്ലംബിംഗ് ചെയ്യുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ, അവിടെ അത് ഒരു കൗണ്ടർ അന്വേഷിക്കുന്നു
ഒരു എമിറ്റർ ഒബ്‌ജക്റ്റ് (ക്ലാസ് എമിറ്റർ) കയറ്റുമതി ചെയ്യുന്നു.

Ptr emitter = CreateObject ();
പേരുകൾ:: ചേർക്കുക ("/പേരുകൾ/എമിറ്റർ", എമിറ്റർ);
...

Ptr probe1 = CreateObject ();

// അന്വേഷണം എമിറ്ററിന്റെ കൗണ്ടറുമായി ബന്ധിപ്പിക്കുക
bool connected = probe1->ConnectByObject ("കൗണ്ടർ", എമിറ്റർ);

ഒരേ എമിറ്റർ ഒബ്‌ജക്‌റ്റ് എക്‌സ്‌പോർട്ട് ചെയ്‌ത അതേ കൗണ്ടറിനെയാണ് ഇനിപ്പറയുന്ന കോഡ് അന്വേഷിക്കുന്നത്. ഈ
എന്നിരുന്നാലും, DoubleProbe, കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ ഒരു പാത്ത് ഉപയോഗിക്കുന്നു
കണക്ഷൻ. ശേഷം കോൺഫിഗറേഷൻ നെയിംസ്പേസിൽ എമിറ്റർ സ്വയം രജിസ്റ്റർ ചെയ്തു എന്നത് ശ്രദ്ധിക്കുക
അത് സൃഷ്ടിക്കപ്പെട്ടു; അല്ലെങ്കിൽ, ConnectByPath പ്രവർത്തിക്കില്ല.

Ptr probe2 = CreateObject ();

// ശ്രദ്ധിക്കുക, റിട്ടേൺ മൂല്യമൊന്നും ഇവിടെ പരിശോധിച്ചിട്ടില്ല
probe2->ConnectByPath ("/പേരുകൾ/എമിറ്റർ/കൗണ്ടർ");

താഴെ കാണിച്ചിരിക്കുന്ന അടുത്ത DoubleProbe അതിന്റെ പാത്ത് ഉപയോഗിച്ച് അതിന്റെ മൂല്യം സജ്ജമാക്കും
കോൺഫിഗറേഷൻ നെയിംസ്പേസ്. ഇത്തവണ DoubleProbe സ്വയം രജിസ്റ്റർ ചെയ്തിരിക്കുന്നത് ശ്രദ്ധിക്കുക
കോൺഫിഗറേഷൻ നെയിംസ്പേസ് സൃഷ്ടിച്ചതിനുശേഷം.

Ptr probe3 = CreateObject ();
probe3->SetName ("StaticallyAccessedProbe");

// ഞങ്ങൾ ഇത് കോൺഫിഗറേഷൻ ഡാറ്റാബേസിലേക്ക് ചേർക്കണം
പേരുകൾ:: ചേർക്കുക ("/പേരുകൾ/പ്രോബ്സ്", probe3->GetName (), probe3);

എമിറ്ററിന്റെ കൗണ്ട്() ഫംഗ്‌ഷന് ഇപ്പോൾ ഈ DoubleProbe-ന്റെ മൂല്യം ഇതായി സജ്ജമാക്കാൻ കഴിയും
താഴെ:

ശൂന്യം
എമിറ്റർ::എണ്ണം (അസാധു)
{
...
m_counter += 1.0;
DoubleProbe::SetValueByPath ("/Names/StaticallyAccessedProbe", m_counter);
...
}

മുകളിലെ ഉദാഹരണം, പ്രോബിനെ വിളിക്കുന്ന കോഡിന് എങ്ങനെ വ്യക്തമായിരിക്കണമെന്നില്ല എന്ന് കാണിക്കുന്നു
പ്രോബിലേക്കുള്ള റഫറൻസ്, എന്നാൽ കോൺഫിഗ് നെയിംസ്പേസിലൂടെ മൂല്യ ക്രമീകരണം നയിക്കാനാകും.
പ്രവർത്തനത്തിൽ ഇത് സമാനമാണ് സ്ഥിതി:: ഇടുക ns2measure പേപ്പർ അവതരിപ്പിച്ച രീതി
[Cic06], കൂടാതെ ഇതുപോലുള്ള പ്രോബ് പ്രസ്താവനകൾ താൽക്കാലികമായി ചേർക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്നു printf പ്രസ്താവനകൾ
നിലവിലുള്ള ഉള്ളിൽ ns-3 മോഡലുകൾ. ഇതിൽ DoubleProbe ഉപയോഗിക്കുന്നതിന് വേണ്ടി എന്നത് ശ്രദ്ധിക്കുക
ഇതുപോലുള്ള ഉദാഹരണം, 2 കാര്യങ്ങൾ ആവശ്യമായിരുന്നു:

1. സ്റ്റാറ്റ്സ് മൊഡ്യൂൾ ഹെഡ്ഡർ ഫയൽ ഉദാഹരണം .cc ഫയലിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്

2. ഉദാഹരണം അതിന്റെ wscript ഫയലിലെ സ്ഥിതിവിവരക്കണക്കുകളുടെ മൊഡ്യൂളിനെ ആശ്രയിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്.

മറ്റ് സ്ഥലങ്ങളിൽ മറ്റ് പ്രോബുകൾ ചേർക്കുന്നതിന് സമാനമായ കാര്യങ്ങൾ ചെയ്യേണ്ടതുണ്ട് ns-3
കോഡ് അടിസ്ഥാനം.

DoubleProbe::SetValue(), എന്ന ഫംഗ്‌ഷൻ ഉപയോഗിച്ചും DoubleProbe-നുള്ള മൂല്യങ്ങൾ സജ്ജമാക്കാവുന്നതാണ്.
അതേസമയം DoubleProbe-നുള്ള മൂല്യങ്ങൾ ഫംഗ്ഷൻ ഉപയോഗിച്ച് ലഭിക്കും
DoubleProbe::GetValue().

DoubleProbe അതിന്റെ "ഔട്ട്‌പുട്ട്" ട്രെയ്സ് ഉറവിടത്തിൽ ഇരട്ട മൂല്യങ്ങൾ കയറ്റുമതി ചെയ്യുന്നു; ഒരു താഴത്തെ വസ്തു
ഇനിപ്പറയുന്ന രീതിയിൽ ഒരു ട്രെയ്സ് സിങ്ക് (NotifyViaProbe) ഹുക്ക് ചെയ്യാം:

ബന്ധിപ്പിച്ച = probe1->TraceConnect ("ഔട്ട്പുട്ട്", probe1->GetName (), MakeCallback (&NotifyViaProbe));

മറ്റു പേടകങ്ങൾ
DoubleProbe കൂടാതെ, ഇനിപ്പറയുന്ന പ്രോബുകളും ലഭ്യമാണ്:

· Uinteger8Probe ഒരു ലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഒരു uint8_t കയറ്റുമതി ചെയ്യുന്ന ഉറവിടം കണ്ടെത്തുക.

· Uinteger16Probe ഒരു ലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഒരു uint16_t കയറ്റുമതി ചെയ്യുന്ന ഉറവിടം കണ്ടെത്തുക.

· Uinteger32Probe ഒരു ലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഒരു uint32_t കയറ്റുമതി ചെയ്യുന്ന ഉറവിടം കണ്ടെത്തുക.

· PacketProbe ഒരു ലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഒരു പാക്കറ്റ് കയറ്റുമതി ചെയ്യുന്ന ഉറവിടം കണ്ടെത്തുക.

· ApplicationPacketProbe എന്നതിലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഒരു പാക്കറ്റും സോക്കറ്റും കയറ്റുമതി ചെയ്യുന്ന ഉറവിടം കണ്ടെത്തുക
വിലാസം.

· Ipv4PacketProbe എന്നതിലേക്ക് ബന്ധിപ്പിക്കുന്നു ns-3 ഒരു പാക്കറ്റ്, ഒരു IPv4 ഒബ്‌ജക്റ്റ്, കൂടാതെ കയറ്റുമതി ചെയ്യുന്ന ഉറവിടം കണ്ടെത്തുക
ഒരു ഇന്റർഫേസ്.

ഉണ്ടാക്കുന്നു പുതിയ അന്വേഷിക്കുക തരം
ഒരു പുതിയ പ്രോബ് തരം സൃഷ്ടിക്കുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ ചെയ്യേണ്ടതുണ്ട്:

· നിങ്ങളുടെ പുതിയ പ്രോബ് ക്ലാസ് പ്രോബ് ബേസ് ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണെന്ന് ഉറപ്പാക്കുക.

· നിങ്ങളുടെ പുതിയ പ്രോബ് ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ശുദ്ധമായ വെർച്വൽ ഫംഗ്‌ഷനുകൾ ഉറപ്പാക്കുക
പ്രോബ് ബേസ് ക്ലാസ് നടപ്പിലാക്കുന്നു.

· തരത്തിൽ ഏറ്റവും അടുത്തുള്ള ഒരു ട്രെയ്സ് ഉറവിടം ഉപയോഗിക്കുന്ന നിലവിലുള്ള ഒരു പ്രോബ് ക്ലാസ് കണ്ടെത്തുക
നിങ്ങളുടെ പ്രോബ് ഉപയോഗിക്കുന്ന ട്രെയ്സ് ഉറവിടത്തിന്റെ തരം.

നിലവിലുള്ള പ്രോബ് ക്ലാസിന്റെ ഹെഡർ ഫയലും (.എച്ച്) ഇംപ്ലിമെന്റേഷൻ ഫയലും (.സിസി) രണ്ടിലേക്ക് പകർത്തുക
നിങ്ങളുടെ പുതിയ അന്വേഷണവുമായി പൊരുത്തപ്പെടുന്ന പേരുകളുള്ള പുതിയ ഫയലുകൾ.

· പകർത്തിയ ഫയലുകളിലെ തരങ്ങൾ, ആർഗ്യുമെന്റുകൾ, വേരിയബിളുകൾ എന്നിവ ഉചിതമായവ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക
നിങ്ങളുടെ അന്വേഷണത്തിനായി ടൈപ്പ് ചെയ്യുക.

· കോഡ് കംപൈൽ ചെയ്യുന്നതിനും അത് നിങ്ങൾ ചെയ്യുന്നതുപോലെ പ്രവർത്തിക്കുന്നതിനും ആവശ്യമായ മാറ്റങ്ങൾ വരുത്തുക
പോലെ.

ഉദാഹരണങ്ങൾ
രണ്ട് ഉദാഹരണങ്ങൾ ഇവിടെ വിശദമായി ചർച്ച ചെയ്യും:

· ഡബിൾ പ്രോബ് ഉദാഹരണം

· IPv4 പാക്കറ്റ് പ്ലോട്ട് ഉദാഹരണം

ഇരട്ട അന്വേഷിക്കുക ഉദാഹരണം
ഇരട്ട അന്വേഷണ ഉദാഹരണം മുമ്പ് ചർച്ച ചെയ്തിട്ടുണ്ട്. ഉദാഹരണം പ്രോഗ്രാം കാണാം
in src/stats/examples/double-probe-example.cc. ഈ പ്രോഗ്രാമിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് സംഗ്രഹിക്കാൻ,
ഒരു പൊയ്‌സൺ പ്രക്രിയയ്ക്ക് അനുസൃതമായി വർദ്ധിക്കുന്ന ഒരു കൌണ്ടർ കയറ്റുമതി ചെയ്യുന്ന ഒരു എമിറ്റർ ഉണ്ട്.
പ്രത്യേകിച്ചും, ഡാറ്റ എമിറ്റുചെയ്യുന്നതിനുള്ള രണ്ട് വഴികൾ കാണിച്ചിരിക്കുന്നു:

1. ഒരു പ്രോബിലേക്ക് ഹുക്ക് ചെയ്ത ഒരു ട്രേസ്ഡ് വേരിയബിളിലൂടെ:

ട്രേസ്ഡ് വാല്യൂ m_counter; // സാധാരണയായി ഇത് പൂർണ്ണസംഖ്യയുടെ തരമായിരിക്കും

2. ഒരു കൗണ്ടറിലൂടെ അതിന്റെ മൂല്യം രണ്ടാമത്തെ പ്രോബിലേക്ക് പോസ്റ്റുചെയ്‌തു, അതിന്റെ പേരിൽ പരാമർശിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷൻ സിസ്റ്റം:

ശൂന്യം
എമിറ്റർ::എണ്ണം (അസാധു)
{
NS_LOG_FUNCTION (ഇത്);
NS_LOG_DEBUG (" << സിമുലേറ്ററിൽ:: ഇപ്പോൾ ().GetSeconds ()) എണ്ണുന്നു;
m_counter += 1.0;
DoubleProbe::SetValueByPath ("/Names/StaticallyAccessedProbe", m_counter);
സിമുലേറ്റർ:: ഷെഡ്യൂൾ (സെക്കൻഡ് (m_var->GetValue ()), &Emitter::count, this);
}

പ്രോബ് കൂടുതൽ ശ്രദ്ധയോടെ നോക്കാം. പ്രോബുകൾക്ക് അവയുടെ മൂല്യങ്ങൾ ഒന്നിലധികം തവണ ലഭിക്കും
വഴികൾ:

1. ട്രെയ്സ് സോഴ്സ് നേരിട്ട് ആക്സസ് ചെയ്ത് ഒരു ട്രെയ്സ് സിങ്ക് കണക്ട് ചെയ്ത് പ്രോബ് വഴി

2. കോൺഫിഗറേഷൻ നെയിംസ്‌പേസിലൂടെ ട്രേസ് സോഴ്‌സ് ആക്‌സസ് ചെയ്‌ത് പ്രോബ് വഴി a കണക്ട് ചെയ്യുന്നു
അതിലേക്ക് സിങ്ക് കണ്ടെത്തുക

3. കോളിംഗ് കോഡ് ഉപയോഗിച്ച് പ്രോബിനെ വ്യക്തമായി വിളിക്കുന്നു സെറ്റ്വാല്യൂ() രീതി

4. കോളിംഗ് കോഡ് ഉപയോഗിച്ച് വ്യക്തമായി വിളിക്കുന്നു മൂല്യം ബൈപാത്ത് സജ്ജമാക്കുക
("/പാത്ത്/ത്രൂ/കോൺഫിഗ്/നാംസ്പേസ്", ...)

ആദ്യത്തെ രണ്ട് ടെക്നിക്കുകൾ ഏറ്റവും സാധാരണമായിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു. കൂടാതെ ഉദാഹരണത്തിൽ, ദി
സാധാരണ ചെയ്യുന്നത് പോലെ ഒരു സാധാരണ കോൾബാക്ക് ഫംഗ്‌ഷന്റെ ഹുക്കിംഗ് കാണിക്കുന്നു ns-3. ഈ
കോൾബാക്ക് ഫംഗ്‌ഷൻ ഒരു പ്രോബ് ഒബ്‌ജക്‌റ്റുമായി ബന്ധപ്പെടുത്തിയിട്ടില്ല. ഞങ്ങൾ ഈ കേസ് 0) താഴെ വിളിക്കും.

// ഒരു റോ ഫംഗ്‌ഷൻ ട്രെയ്‌സ് സോഴ്‌സിലേക്ക് ഹുക്ക് ചെയ്യുന്നത് പരിശോധിക്കുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷനാണിത്
ശൂന്യം
NotifyViaTraceSource (std::സ്ട്രിംഗ് സന്ദർഭം, ഇരട്ട പഴയ വാൽ, ഇരട്ട ന്യൂവൽ)
{
NS_LOG_DEBUG ("സന്ദർഭം: " << സന്ദർഭം << " പഴയ " << oldVal << " പുതിയ " << newVal);
}

ആദ്യം, എമിറ്റർ സജ്ജീകരിക്കേണ്ടതുണ്ട്:

Ptr emitter = CreateObject ();
പേരുകൾ:: ചേർക്കുക ("/പേരുകൾ/എമിറ്റർ", എമിറ്റർ);

// എമിറ്റർ ഒബ്‌ജക്റ്റ് ഒരു ns-3 നോഡുമായി ബന്ധപ്പെടുത്തിയിട്ടില്ല, അതിനാൽ
// ഇത് സ്വയമേവ ആരംഭിക്കില്ല, അതിനാൽ ഞങ്ങൾ ഇത് സ്വയം ചെയ്യേണ്ടതുണ്ട്
സിമുലേറ്റർ:: ഷെഡ്യൂൾ (സെക്കൻഡ് (0.0), &എമിറ്റർ::ആരംഭിക്കുക, എമിറ്റർ);

താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ വിവിധ ഡബിൾപ്രോബുകൾ ഉദാഹരണത്തിലെ എമിറ്ററുമായി സംവദിക്കുന്നു.

കേസ് 0):

// ഒരു അന്വേഷണം ഇല്ലാതെ സാധാരണ പ്രവർത്തനം താഴെ കാണിക്കുന്നു
// (ഒരു ട്രെയ്സ് ഉറവിടത്തിലേക്ക് ഒരു സിങ്ക് ഫംഗ്ഷൻ ബന്ധിപ്പിക്കുക)
//
ബന്ധിപ്പിച്ച = എമിറ്റർ->ട്രേസ്കണക്റ്റ് ("കൗണ്ടർ", "സാമ്പിൾ സന്ദർഭം", മേക്ക് കോൾബാക്ക് (&NotifyViaTraceSource));
NS_ASSERT_MSG (കണക്‌റ്റുചെയ്‌തു, "ട്രേസ് സോഴ്‌സ് കണക്റ്റുചെയ്‌തിട്ടില്ല");

കേസ് 1):

//
// പ്രോബ്1, എമിറ്റർ ട്രെയ്സ് സോഴ്സ് ഒബ്ജക്റ്റിലേക്ക് നേരിട്ട് ഹുക്ക് ചെയ്യപ്പെടും
//

// probe1 എമിറ്റർ ട്രെയ്സ് ഉറവിടത്തിലേക്ക് ഹുക്ക് ചെയ്യപ്പെടും
Ptr probe1 = CreateObject ();
// അന്വേഷണത്തിന്റെ പേര് അതിന്റെ സന്ദർഭമായി ട്രെയ്‌സിംഗിൽ വർത്തിക്കും
probe1->SetName ("ObjectProbe");

// അന്വേഷണം എമിറ്ററിന്റെ കൗണ്ടറുമായി ബന്ധിപ്പിക്കുക
ബന്ധിപ്പിച്ച = probe1->ConnectByObject ("കൌണ്ടർ", എമിറ്റർ);
NS_ASSERT_MSG (കണക്‌റ്റുചെയ്‌തു, "ട്രേസ് സോഴ്‌സ് പ്രോബ്1-ലേക്ക് ബന്ധിപ്പിച്ചിട്ടില്ല");

കേസ് 2):

//
// പ്രോബ്2 എമിറ്റർ ട്രെയ്‌സ് സോഴ്‌സ് ഒബ്‌ജക്റ്റിലേക്ക് ഹുക്ക് ചെയ്യപ്പെടും
// കോൺഫിഗറേഷൻ ഡാറ്റാബേസിൽ പാതയുടെ പേര് ഉപയോഗിച്ച് ഇത് ആക്സസ് ചെയ്യുന്നു
//

// സമാനമായ മറ്റൊരു അന്വേഷണം സൃഷ്ടിക്കുക; ഇത് ഒരു കോൺഫിഗറേഷൻ പാത്ത് വഴി ഹുക്ക് അപ്പ് ചെയ്യും
Ptr probe2 = CreateObject ();
probe2->SetName ("PathProbe");

// ശ്രദ്ധിക്കുക, റിട്ടേൺ മൂല്യമൊന്നും ഇവിടെ പരിശോധിച്ചിട്ടില്ല
probe2->ConnectByPath ("/പേരുകൾ/എമിറ്റർ/കൗണ്ടർ");

കേസ് 4) (കേസ് 3 ഈ ഉദാഹരണത്തിൽ കാണിച്ചിട്ടില്ല):

//
// പ്രോബ്3 എമിറ്റർ മുഖേന നേരിട്ട് വിളിക്കും
// സ്റ്റാറ്റിക് രീതി SetValueByPath().
//
Ptr probe3 = CreateObject ();
probe3->SetName ("StaticallyAccessedProbe");
// ഞങ്ങൾ ഇത് കോൺഫിഗറേഷൻ ഡാറ്റാബേസിലേക്ക് ചേർക്കണം
പേരുകൾ:: ചേർക്കുക ("/പേരുകൾ/പ്രോബ്സ്", probe3->GetName (), probe3);

അവസാനമായി, ഔട്ട്‌പുട്ട് സൃഷ്ടിക്കാൻ പ്രോബുകൾ എങ്ങനെ ഹുക്ക് ചെയ്യാമെന്ന് ഉദാഹരണം കാണിക്കുന്നു:

// അന്വേഷണം തന്നെ ഔട്ട്പുട്ട് ഉണ്ടാക്കണം. ഞങ്ങൾ നൽകുന്ന സന്ദർഭം
// ഈ അന്വേഷണത്തിലേക്ക് (ഈ സാഹചര്യത്തിൽ, അന്വേഷണത്തിന്റെ പേര്) അവ്യക്തമാക്കാൻ സഹായിക്കും
// ട്രേസിന്റെ ഉറവിടം
ബന്ധിപ്പിച്ച = probe3->TraceConnect ("ഔട്ട്പുട്ട്",
"/പേരുകൾ/പ്രോബ്‌സ്/സ്റ്റാറ്റിക്കലി ആക്‌സസ്ഡ് പ്രോബ്/ഔട്ട്‌പുട്ട്",
MakeCallback (&NotifyViaProbe));
NS_ASSERT_MSG (കണക്‌റ്റുചെയ്‌തു, "സ്രോതസ്സ് കണ്ടെത്തുക അല്ല .. probe3 ഔട്ട്‌പുട്ടിലേക്ക് കണക്‌റ്റ് ചെയ്‌തിരിക്കുന്നു");

ചിത്രീകരണ ആവശ്യങ്ങൾക്കായി ഈ ഉദാഹരണത്തിലെ പ്രോബിലേക്ക് ഇനിപ്പറയുന്ന കോൾബാക്ക് ഹുക്ക് ചെയ്‌തിരിക്കുന്നു;
സാധാരണയായി, അന്വേഷണം ഒരു കളക്ടർ ഒബ്‌ജക്‌റ്റുമായി ബന്ധിപ്പിച്ചിരിക്കും.

// ഇത് പ്രോബ് ഔട്ട്പുട്ടിലേക്ക് ഹുക്ക് ചെയ്യുന്നത് പരിശോധിക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷനാണ്
ശൂന്യം
NotifyViaProbe (std::സ്ട്രിംഗ് സന്ദർഭം, ഇരട്ട പഴയ വാൽ, ഇരട്ട ന്യൂവൽ)
{
NS_LOG_DEBUG ("സന്ദർഭം: " << സന്ദർഭം << " പഴയ " << oldVal << " പുതിയ " << newVal);
}

IPv4 പാക്കറ്റ് തന്ത്രം ഉദാഹരണം
IPv4 പാക്കറ്റ് പ്ലോട്ട് ഉദാഹരണം fifth.cc ഉദാഹരണത്തിൽ നിന്നുള്ളതാണ് ns-3 ട്യൂട്ടോറിയൽ. അത്
കാണാവുന്നതാണ് src/stats/examples/ipv4-packet-plot-example.cc.

നോഡ് 0 നോഡ് 1
+------------------+ +----------------+
| ns-3 TCP | | ns-3 TCP |
+------------------+ +----------------+
| 10.1.1.1 | | 10.1.1.2 |
+------------------+ +----------------+
| പോയിന്റ്-ടു-പോയിന്റ് | | പോയിന്റ്-ടു-പോയിന്റ് |
+------------------+ +----------------+
| |
+------------------------+

പ്രോബ്‌സ് മൂല്യങ്ങൾ അൺപാക്ക് ചെയ്‌തേക്കാമെന്ന് ഇത് വ്യക്തമാക്കുന്നു, ഞങ്ങൾ പ്രോബിലേക്ക് നോക്കും.
ഘടനകൾ (ഈ സാഹചര്യത്തിൽ, പാക്കറ്റുകൾ) കൂടാതെ ആ മൂല്യങ്ങൾ ട്രെയ്സ് സോഴ്സ് ഔട്ട്പുട്ടുകളായി റിപ്പോർട്ട് ചെയ്യുക
ഒരേ തരത്തിലുള്ള ഡാറ്റയിലൂടെ കടന്നുപോകുന്നതിനേക്കാൾ.

ഈ ഉദാഹരണത്തിന്റെ മറ്റ് വശങ്ങളും ഡോക്യുമെന്റേഷനിൽ പിന്നീട് വിശദീകരിക്കും.
കയറ്റുമതി ചെയ്യുന്ന രണ്ട് തരം ഡാറ്റ പാക്കറ്റ് തന്നെയാണ് (ഔട്ട്പുട്ട്) കൂടാതെ ഒരു കണക്കും
പാക്കറ്റിലെ ബൈറ്റുകളുടെ എണ്ണം (ഔട്ട്പുട്ട്ബൈറ്റുകൾ).

ടൈപ്പ് ഐഡി
Ipv4PacketProbe::GetTypeId ()
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::Ipv4PacketProbe")
.SetParent ()
.AddConstructor ()
.AddTraceSource ("ഔട്ട്പുട്ട്",
"പാക്കറ്റും അതിന്റെ IPv4 ഒബ്‌ജക്‌റ്റും ഇന്റർഫേസും ഈ അന്വേഷണത്തിന്റെ ഔട്ട്‌പുട്ടായി വർത്തിക്കുന്നു",
MakeTraceSourceAccessor (&Ipv4PacketProbe::m_output))
.AddTraceSource ("OutputBytes",
"പാക്കറ്റിലെ ബൈറ്റുകളുടെ എണ്ണം",
MakeTraceSourceAccessor (&Ipv4PacketProbe::m_outputBytes))
;
റിട്ടേൺ ടിഡ്;
}

പ്രോബിന്റെ ട്രെയ്സ് സിങ്കിന് ഒരു പാക്കറ്റ് ലഭിക്കുമ്പോൾ, പ്രോബ് പ്രവർത്തനക്ഷമമാക്കിയാൽ, അത് ഔട്ട്പുട്ട് ചെയ്യും
അതിന്റെ പാക്കറ്റ് ഔട്ട്പുട്ട് ഉറവിടം കണ്ടെത്തുക, പക്ഷേ ഇത് ബൈറ്റുകളുടെ എണ്ണം ഔട്ട്പുട്ട് ചെയ്യും
ഔട്ട്പുട്ട്ബൈറ്റുകൾ ഉറവിടം കണ്ടെത്തുക.

ശൂന്യം
Ipv4PacketProbe::TraceSink (Ptr പാക്കറ്റ്, Ptr ipv4, uint4_t ഇന്റർഫേസ്)
{
NS_LOG_FUNCTION (ഈ << പാക്കറ്റ് << ipv4 << ഇന്റർഫേസ്);
(IsEnabled ())
{
m_packet = പാക്കറ്റ്;
m_ipv4 = ipv4;
m_interface = ഇന്റർഫേസ്;
m_output (പാക്കറ്റ്, ipv4, ഇന്റർഫേസ്);

uint32_t packetSizeNew = packet->GetSize ();
m_outputBytes (m_packetSizeOld, packetSizeNew);
m_packetSizeOld = packetSizeNew;
}
}

അവലംബം
[Cic06]
ക്ലോഡിയോ സിക്കോനെറ്റി, എൻസോ മിംഗോസി, ജിയോവാനി സ്റ്റീ, "ഇതിനായുള്ള ഒരു സംയോജിത ചട്ടക്കൂട്
ns2, വർക്ക്ഷോപ്പ് ഉപയോഗിച്ച് ഫലപ്രദമായ ഡാറ്റ ശേഖരണവും സ്റ്റാറ്റിസ്റ്റിക്കൽ അനാലിസിസും പ്രവർത്തനക്ഷമമാക്കുന്നു
ns-2 (WNS2), പിസ, ഇറ്റലി, ഒക്ടോബർ 2006.

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

കുറിപ്പ്: ns-3.18-ലെ കണക്കനുസരിച്ച്, കളക്ടർമാർ ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുന്നു, ഇതുവരെ അതിന്റെ ഭാഗമായി നൽകിയിട്ടില്ല
ചട്ടക്കൂടിന്റെ.

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

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

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

അഗ്രഗേറ്ററിനെക്കുറിച്ച് ഇനിപ്പറയുന്നവ ശ്രദ്ധിക്കുക:

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

· കോൾബാക്ക് വഴി കളക്ടർമാരിൽ നിന്ന് അഗ്രഗേറ്റർമാർ ഡാറ്റ സ്വീകരിക്കുന്നു. ഒരു കളക്ടർ ബന്ധപ്പെട്ടിരിക്കുമ്പോൾ
ഒരു അഗ്രഗേറ്ററിലേക്ക്, അഗ്രഗേറ്ററിന്റെ ട്രെയ്സ് സ്ഥാപിക്കാൻ TraceConnect-ലേക്ക് ഒരു കോൾ ചെയ്യുന്നു
ഒരു കോൾബാക്ക് ആയി സിങ്ക് രീതി.

ഇന്നുവരെ, രണ്ട് അഗ്രഗേറ്ററുകൾ നടപ്പിലാക്കിയിട്ടുണ്ട്:

· ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ

· ഫയൽ അഗ്രഗേറ്റർ

ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ
GnuplotAggregator ഗ്നുപ്ലോട്ടുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ഔട്ട്പുട്ട് ഫയലുകൾ നിർമ്മിക്കുന്നു.

സിമുലേഷന്റെ അവസാനം GnuplotAggregator 3 വ്യത്യസ്ത ഫയലുകൾ സൃഷ്ടിക്കും:

· ഒരു സ്പേസ് വേർതിരിക്കുന്ന gnuplot ഡാറ്റ ഫയൽ

ഒരു gnuplot കൺട്രോൾ ഫയൽ

gnuplot സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഷെൽ സ്ക്രിപ്റ്റ്

സൃഷ്ടി
എന്താണ് ചെയ്യേണ്ടതെന്ന് കാണിക്കാൻ GnuplotAggregator എന്ന തരത്തിലുള്ള ഒരു ഒബ്‌ജക്റ്റ് ഇവിടെ സൃഷ്‌ടിക്കും.

സ്മാർട്ട് പോയിന്റർ ക്ലാസ് ഉപയോഗിച്ച് ഡൈനാമിക് മെമ്മറിയിൽ ഒരു ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ പ്രഖ്യാപിക്കുന്നു
(Ptr ). സ്‌മാർട്ട് പോയിന്ററുകൾ ഉപയോഗിച്ച് ഡൈനാമിക് മെമ്മറിയിൽ ഒരു GnuplotAggregator സൃഷ്‌ടിക്കാൻ, ഒന്ന് മാത്രം
വിളിക്കേണ്ടതുണ്ട് ns-3 രീതി CreateObject(). ഇനിപ്പറയുന്ന കോഡ്
src/stats/examples/gnuplot-aggregator-example.cc ഇത് എങ്ങനെ ചെയ്യാമെന്ന് കാണിക്കുന്നു:

string fileNameWithoutExtension = "gnuplot-aggregator";

// ഒരു അഗ്രഗേറ്റർ സൃഷ്ടിക്കുക.
Ptr അഗ്രഗേറ്റർ =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് (fileNameWithoutExtension);

കൺസ്‌ട്രക്‌ടറിനുള്ള ആദ്യത്തെ ആർഗ്യുമെന്റ്, fileNameWithoutExtension എന്നതിന്റെ പേരാണ്
വിപുലീകരണമില്ലാതെ എഴുതാൻ ബന്ധപ്പെട്ട ഫയലുകൾ gnuplot ചെയ്യുക. ഈ GnuplotAggregator ഒരു സൃഷ്ടിക്കും
"gnuplot-aggregator.dat" എന്ന് പേരിട്ടിരിക്കുന്ന സ്പെയ്സ് വേർതിരിക്കുന്ന gnuplot ഡാറ്റ ഫയൽ, ഒരു gnuplot നിയന്ത്രണ ഫയൽ
"gnuplot-aggregator.plt" എന്ന് നാമകരണം ചെയ്യപ്പെട്ടു
"gnuplot-aggregator.sh".

സൃഷ്‌ടിക്കപ്പെട്ട ഗ്‌നപ്‌ലോട്ടിന് അതിന്റെ കീ 4 വ്യത്യസ്‌ത സ്ഥലങ്ങളിൽ ഉണ്ടായിരിക്കും:

· താക്കോൽ ഇല്ല

പ്ലോട്ടിനുള്ളിലെ കീ (സ്ഥിരസ്ഥിതി)

· പ്ലോട്ടിന് മുകളിലുള്ള താക്കോൽ

· പ്ലോട്ടിന് താഴെ താക്കോൽ

കീയുടെ സ്ഥാനം വ്യക്തമാക്കാൻ ഇനിപ്പറയുന്ന gnuplot കീ ലൊക്കേഷൻ enum മൂല്യങ്ങൾ അനുവദിച്ചിരിക്കുന്നു:

enum KeyLocation {
NO_KEY,
KEY_INSIDE,
കീ_മുകളിൽ,
കീ_താഴെ
};

ഉള്ളിലെ ഡിഫോൾട്ട് സ്ഥാനത്തേക്കാൾ താഴെ താക്കോൽ വേണമെന്നാണ് ആഗ്രഹമെങ്കിൽ, അപ്പോൾ
നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാൻ കഴിയും.

aggregator->SetKeyLocation(GnuplotAggregator::KEY_BELOW);

ഉദാഹരണങ്ങൾ
ഒരു ഉദാഹരണം ഇവിടെ വിശദമായി ചർച്ച ചെയ്യും:

· ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ ഉദാഹരണം

ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ ഉദാഹരണം
GnuplotAggregator വ്യായാമം ചെയ്യുന്ന ഒരു ഉദാഹരണം ഇതിൽ കാണാം
src/stats/examples/gnuplot-aggregator-example.cc.

ഉദാഹരണം ഉപയോഗിച്ചാണ് ഇനിപ്പറയുന്ന 2-D ഗ്നൂപ്‌ലോട്ട് സൃഷ്‌ടിച്ചത്.
[image] 2-D Gnuplot സൃഷ്ടിച്ചത് gnuplot-aggregator-example.cc ഉദാഹരണം..UNINDENT

ഉദാഹരണത്തിൽ നിന്നുള്ള ഈ കോഡ് ചർച്ച ചെയ്തതുപോലെ GnuplotAggregator എങ്ങനെ നിർമ്മിക്കാമെന്ന് കാണിക്കുന്നു
മുകളിൽ.

ശൂന്യമായ Create2dPlot ()
{
നെയിംസ്‌പെയ്‌സ് std ഉപയോഗിക്കുന്നു;

string fileNameWithoutExtension = "gnuplot-aggregator";
string plotTitle = "ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ പ്ലോട്ട്";
string plotXAxisHeading = "സമയം (സെക്കൻഡ്)";
string plotYAxisHeading = "ഇരട്ട മൂല്യങ്ങൾ";
string plotDatasetLabel = "ഡാറ്റ മൂല്യങ്ങൾ";
string datasetContext = "ഡാറ്റാസെറ്റ്/സന്ദർഭം/സ്ട്രിംഗ്";

// ഒരു അഗ്രഗേറ്റർ സൃഷ്ടിക്കുക.
Ptr അഗ്രഗേറ്റർ =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് (fileNameWithoutExtension);

2-D ഡാറ്റാസെറ്റ് ഉൾപ്പെടെ വിവിധ GnuplotAggregator ആട്രിബ്യൂട്ടുകൾ സജ്ജീകരിച്ചിരിക്കുന്നു
ഗൂഢാലോചന നടത്തി.

// അഗ്രഗേറ്ററിന്റെ പ്രോപ്പർട്ടികൾ സജ്ജമാക്കുക.
അഗ്രഗേറ്റർ->സെറ്റ് ടെർമിനൽ ("png");
അഗ്രഗേറ്റർ->സെറ്റ്ടൈറ്റിൽ (പ്ലോട്ട്ടൈറ്റിൽ);
അഗ്രഗേറ്റർ->സെറ്റ്ലെജൻഡ് (പ്ലോട്ട്എക്സ്എക്സിസ്ഹെഡിംഗ്, പ്ലോട്ട്യാക്സിസ്ഹെഡിംഗ്);

// അഗ്രഗേറ്ററിലേക്ക് ഒരു ഡാറ്റ സെറ്റ് ചേർക്കുക.
അഗ്രഗേറ്റർ->Add2dDataset (datasetContext, plotDatasetLabel);

// അഗ്രഗേറ്റർ ഓണാക്കിയിരിക്കണം
അഗ്രഗേറ്റർ-> പ്രവർത്തനക്ഷമമാക്കുക ();

അടുത്തതായി, 2-D മൂല്യങ്ങൾ കണക്കാക്കുന്നു, ഓരോന്നും വ്യക്തിഗതമായി എഴുതുന്നു
GnuplotAggregator ഉപയോഗിക്കുന്നത് Write2d() പ്രവർത്തനം.

ഇരട്ട സമയം;
ഇരട്ട മൂല്യം;

// 2-D ഡാറ്റാസെറ്റ് സൃഷ്‌ടിക്കുക.
ഇതിനായി (സമയം = -5.0; സമയം <= +5.0; സമയം += 1.0)
{
// 2-D കർവ് കണക്കാക്കുക
//
// 2
// മൂല്യം = സമയം .
//
മൂല്യം = സമയം * സമയം;

// ഈ പോയിന്റ് പ്ലോട്ടിലേക്ക് ചേർക്കുക.
അഗ്രഗേറ്റർ->Write2d (ഡാറ്റസെറ്റ് സന്ദർഭം, സമയം, മൂല്യം);
}

// അഗ്രഗേറ്ററിനായുള്ള ഡാറ്റ ലോഗിംഗ് പ്രവർത്തനരഹിതമാക്കുക.
അഗ്രഗേറ്റർ->അപ്രാപ്തമാക്കുക ();
}

ഫയൽ അഗ്രഗേറ്റർ
ഫയൽ അഗ്രഗേറ്റർ അത് സ്വീകരിക്കുന്ന മൂല്യങ്ങൾ ഒരു ഫയലിലേക്ക് അയയ്ക്കുന്നു.

ഫയൽ അഗ്രഗേറ്ററിന് 4 വ്യത്യസ്ത തരം ഫയലുകൾ സൃഷ്ടിക്കാൻ കഴിയും:

· ഫോർമാറ്റ് ചെയ്തു

· ഇടം വേർതിരിച്ചു (സ്ഥിരസ്ഥിതി)

· കോമ വേർതിരിച്ചു

· ടാബ് വേർതിരിച്ചു

ഫോർമാറ്റ് ചെയ്‌ത ഫയലുകൾ സി-സ്റ്റൈൽ ഫോർമാറ്റ് സ്‌ട്രിംഗുകളും സ്‌പ്രിന്റ്‌എഫ്() ഫംഗ്‌ഷനും പ്രിന്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു
എഴുതുന്ന ഫയലിലെ മൂല്യങ്ങൾ.

സൃഷ്ടി
എന്താണ് ചെയ്യേണ്ടതെന്ന് കാണിക്കാൻ ഫയൽ അഗ്രഗേറ്റർ എന്ന തരത്തിലുള്ള ഒരു ഒബ്‌ജക്റ്റ് ഇവിടെ സൃഷ്‌ടിക്കും.

സ്മാർട്ട് പോയിന്റർ ക്ലാസ് (Ptr) ഉപയോഗിച്ച് ഡൈനാമിക് മെമ്മറിയിൽ ഒരു ഫയൽ അഗ്രഗേറ്റർ പ്രഖ്യാപിക്കുന്നു. ).
സ്‌മാർട്ട് പോയിന്ററുകൾ ഉപയോഗിച്ച് ഡൈനാമിക് മെമ്മറിയിൽ ഒരു ഫയൽ അഗ്രഗേറ്റർ സൃഷ്‌ടിക്കുന്നതിന്, ഒരാൾ വിളിച്ചാൽ മതി
The ns-3 രീതി CreateObject. ഇനിപ്പറയുന്ന കോഡ്
src/stats/examples/file-aggregator-example.cc ഇത് എങ്ങനെ ചെയ്യാമെന്ന് കാണിക്കുന്നു:

string fileName = "file-aggregator-formatted-values.txt";

// ഫോർമാറ്റ് ചെയ്‌ത മൂല്യങ്ങളുള്ള ഒരു അഗ്രഗേറ്റർ സൃഷ്‌ടിക്കുക.
Ptr അഗ്രഗേറ്റർ =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് (ഫയലിന്റെ പേര്, ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);

കൺസ്‌ട്രക്‌ടറിനുള്ള ആദ്യത്തെ ആർഗ്യുമെന്റ്, ഫയലിന്റെ പേര്, എഴുതേണ്ട ഫയലിന്റെ പേരാണ്; ദി
രണ്ടാമത്തെ ആർഗ്യുമെന്റ്, ഫയൽ ടൈപ്പ്, എഴുതാനുള്ള ഫയലിന്റെ തരമാണ്. ഈ ഫയൽ അഗ്രഗേറ്റർ ഒരു സൃഷ്ടിക്കും
"file-aggregator-formatted-values.txt" എന്ന് പേരിട്ടിരിക്കുന്ന ഫയൽ അതിന്റെ മൂല്യങ്ങൾ വ്യക്തമാക്കിയത് പോലെ അച്ചടിച്ചിരിക്കുന്നു
fileType, അതായത്, ഈ സാഹചര്യത്തിൽ ഫോർമാറ്റ് ചെയ്തിരിക്കുന്നു.

ഇനിപ്പറയുന്ന ഫയൽ തരം enum മൂല്യങ്ങൾ അനുവദനീയമാണ്:

enum ഫയൽ തരം {
ഫോർമാറ്റ് ചെയ്ത,
SPACE_SEPARATED,
COMMA_SEPARATED,
TAB_SEPARATED
};

ഉദാഹരണങ്ങൾ
ഒരു ഉദാഹരണം ഇവിടെ വിശദമായി ചർച്ച ചെയ്യും:

· ഫയൽ അഗ്രഗേറ്റർ ഉദാഹരണം

ഫയല് അഗ്രഗേറ്റർ ഉദാഹരണം
ഫയൽ അഗ്രഗേറ്റർ പ്രവർത്തിപ്പിക്കുന്ന ഒരു ഉദാഹരണം കാണാം
src/stats/examples/file-aggregator-example.cc.

കോമകളാൽ വേർതിരിച്ച മൂല്യങ്ങളുടെ 2 നിരകളുള്ള ഇനിപ്പറയുന്ന ടെക്സ്റ്റ് ഫയൽ സൃഷ്ടിച്ചത്
ഉദാഹരണം.

-5,25
-4,16
-3,9
-2,4
-1,1
0,0
1,1
2,4
3,9
4,16
5,25

ചർച്ച ചെയ്തതുപോലെ ഫയൽ അഗ്രഗേറ്റർ എങ്ങനെ നിർമ്മിക്കാമെന്ന് ഉദാഹരണത്തിൽ നിന്നുള്ള ഈ കോഡ് കാണിക്കുന്നു
മുകളിൽ.

CreateCommaSeparatedFile അസാധുവാണ് ()
{
നെയിംസ്‌പെയ്‌സ് std ഉപയോഗിക്കുന്നു;

string fileName = "file-aggregator-comma-separated.txt";
string datasetContext = "ഡാറ്റാസെറ്റ്/സന്ദർഭം/സ്ട്രിംഗ്";

// ഒരു അഗ്രഗേറ്റർ സൃഷ്ടിക്കുക.
Ptr അഗ്രഗേറ്റർ =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് (ഫയലിന്റെ പേര്, ഫയൽ അഗ്രഗേറ്റർ::COMMA_SEPARATED);

ഫയൽ അഗ്രഗേറ്റർ ആട്രിബ്യൂട്ടുകൾ സജ്ജമാക്കി.

// അഗ്രഗേറ്റർ ഓണാക്കിയിരിക്കണം
അഗ്രഗേറ്റർ-> പ്രവർത്തനക്ഷമമാക്കുക ();

അടുത്തതായി, 2-D മൂല്യങ്ങൾ കണക്കാക്കുന്നു, ഓരോന്നും വ്യക്തിഗതമായി എഴുതുന്നു
ഫയൽ അഗ്രഗേറ്റർ ഉപയോഗിക്കുന്നത് Write2d() പ്രവർത്തനം.

ഇരട്ട സമയം;
ഇരട്ട മൂല്യം;

// 2-D ഡാറ്റാസെറ്റ് സൃഷ്‌ടിക്കുക.
ഇതിനായി (സമയം = -5.0; സമയം <= +5.0; സമയം += 1.0)
{
// 2-D കർവ് കണക്കാക്കുക
//
// 2
// മൂല്യം = സമയം .
//
മൂല്യം = സമയം * സമയം;

// ഈ പോയിന്റ് പ്ലോട്ടിലേക്ക് ചേർക്കുക.
അഗ്രഗേറ്റർ->Write2d (ഡാറ്റസെറ്റ് സന്ദർഭം, സമയം, മൂല്യം);
}

// അഗ്രഗേറ്ററിനായുള്ള ഡാറ്റ ലോഗിംഗ് പ്രവർത്തനരഹിതമാക്കുക.
അഗ്രഗേറ്റർ->അപ്രാപ്തമാക്കുക ();
}

ഫോർമാറ്റ് ചെയ്‌ത മൂല്യങ്ങളുടെ 2 കോളങ്ങളുള്ള ഇനിപ്പറയുന്ന ടെക്‌സ്‌റ്റ് ഫയലും ഇത് ഉപയോഗിച്ച് സൃഷ്‌ടിച്ചതാണ്
ഉദാഹരണം.

സമയം = -5.000e+00 മൂല്യം = 25
സമയം = -4.000e+00 മൂല്യം = 16
സമയം = -3.000e+00 മൂല്യം = 9
സമയം = -2.000e+00 മൂല്യം = 4
സമയം = -1.000e+00 മൂല്യം = 1
സമയം = 0.000e+00 മൂല്യം = 0
സമയം = 1.000e+00 മൂല്യം = 1
സമയം = 2.000e+00 മൂല്യം = 4
സമയം = 3.000e+00 മൂല്യം = 9
സമയം = 4.000e+00 മൂല്യം = 16
സമയം = 5.000e+00 മൂല്യം = 25

ചർച്ച ചെയ്തതുപോലെ ഫയൽ അഗ്രഗേറ്റർ എങ്ങനെ നിർമ്മിക്കാമെന്ന് ഉദാഹരണത്തിൽ നിന്നുള്ള ഈ കോഡ് കാണിക്കുന്നു
മുകളിൽ.

ശൂന്യമായ CreateFormattedFile ()
{
നെയിംസ്‌പെയ്‌സ് std ഉപയോഗിക്കുന്നു;

string fileName = "file-aggregator-formatted-values.txt";
string datasetContext = "ഡാറ്റാസെറ്റ്/സന്ദർഭം/സ്ട്രിംഗ്";

// ഫോർമാറ്റ് ചെയ്‌ത മൂല്യങ്ങളുള്ള ഒരു അഗ്രഗേറ്റർ സൃഷ്‌ടിക്കുക.
Ptr അഗ്രഗേറ്റർ =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് (ഫയലിന്റെ പേര്, ഫയൽ അഗ്രഗേറ്റർ:: ഫോർമാറ്റഡ്);

ഉപയോഗിക്കാനുള്ള സി-സ്റ്റൈൽ ഫോർമാറ്റ് സ്ട്രിംഗ് ഉൾപ്പെടെ ഫയൽ അഗ്രഗേറ്റർ ആട്രിബ്യൂട്ടുകൾ സജ്ജീകരിച്ചിരിക്കുന്നു.

// മൂല്യങ്ങൾക്കായി ഫോർമാറ്റ് സജ്ജമാക്കുക.
aggregator->Set2dFormat ("സമയം = %.3e\tValue = %.0f");

// അഗ്രഗേറ്റർ ഓണാക്കിയിരിക്കണം
അഗ്രഗേറ്റർ-> പ്രവർത്തനക്ഷമമാക്കുക ();

അടുത്തതായി, 2-D മൂല്യങ്ങൾ കണക്കാക്കുന്നു, ഓരോന്നും വ്യക്തിഗതമായി എഴുതുന്നു
ഫയൽ അഗ്രഗേറ്റർ ഉപയോഗിക്കുന്നത് Write2d() പ്രവർത്തനം.

ഇരട്ട സമയം;
ഇരട്ട മൂല്യം;

// 2-D ഡാറ്റാസെറ്റ് സൃഷ്‌ടിക്കുക.
ഇതിനായി (സമയം = -5.0; സമയം <= +5.0; സമയം += 1.0)
{
// 2-D കർവ് കണക്കാക്കുക
//
// 2
// മൂല്യം = സമയം .
//
മൂല്യം = സമയം * സമയം;

// ഈ പോയിന്റ് പ്ലോട്ടിലേക്ക് ചേർക്കുക.
അഗ്രഗേറ്റർ->Write2d (ഡാറ്റസെറ്റ് സന്ദർഭം, സമയം, മൂല്യം);
}

// അഗ്രഗേറ്ററിനായുള്ള ഡാറ്റ ലോഗിംഗ് പ്രവർത്തനരഹിതമാക്കുക.
അഗ്രഗേറ്റർ->അപ്രാപ്തമാക്കുക ();
}

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

ശ്രദ്ധിക്കുക: 'അഡാപ്റ്റർ' എന്ന പദത്തിന് 'അഡാപ്റ്റർ' എന്നും എഴുതാം; ഞങ്ങൾ അക്ഷരവിന്യാസം തിരഞ്ഞെടുത്തു
C++ സ്റ്റാൻഡേർഡ് ഉപയോഗിച്ച്.

അഡാപ്റ്റർ പൊതു അവലോകനം
വ്യത്യസ്ത തരം DCF ഒബ്‌ജക്റ്റുകൾക്കിടയിൽ കണക്ഷനുകൾ ഉണ്ടാക്കാൻ ഒരു അഡാപ്റ്റർ ഉപയോഗിക്കുന്നു.

ഇന്നുവരെ, ഒരു അഡാപ്റ്റർ നടപ്പിലാക്കി:

· TimeSeriesAdaptor

കാലം സീരീസ് അഡാപ്റ്റർ
ടൈംസീരീസ് അഡാപ്റ്റർ പ്രോബുകളെ അഗ്രഗേറ്ററുകളിലേക്ക് നേരിട്ട് കണക്റ്റുചെയ്യാൻ അനുവദിക്കുന്നു
ഇടയിൽ കലക്ടർ.

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

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

വ്യാപ്തി/പരിമിതികൾ
ഈ വിഭാഗം ഡാറ്റാ ശേഖരണ ചട്ടക്കൂടിന്റെ വ്യാപ്തിയും പരിമിതികളും ചർച്ച ചെയ്യുന്നു.

നിലവിൽ, ഈ പ്രോബുകൾ മാത്രമാണ് DCF-ൽ നടപ്പിലാക്കിയിരിക്കുന്നത്:

· ബൂളിയൻ പ്രോബ്

· ഡബിൾപ്രോബ്

· Uinteger8Probe

· Uinteger16Probe

· Uinteger32Probe

· ടൈംപ്രോബ്

· പാക്കറ്റ്പ്രോബ്

· ApplicationPacketProbe

· Ipv4PacketProbe

നിലവിൽ, ബേസിക് സ്റ്റാറ്റ് കളക്ടർ കീഴിലുണ്ടെങ്കിലും ഡിസിഎഫിൽ കളക്ടർമാരൊന്നും ലഭ്യമല്ല
വികസനം.

നിലവിൽ, ഈ അഗ്രഗേറ്ററുകൾ മാത്രമേ DCF-ൽ നടപ്പിലാക്കിയിട്ടുള്ളൂ:

· ഗ്നുപ്ലോട്ട് അഗ്രഗേറ്റർ

· ഫയൽ അഗ്രഗേറ്റർ

നിലവിൽ, ഈ അഡാപ്റ്റർ മാത്രമേ DCF-ൽ നടപ്പിലാക്കിയിട്ടുള്ളൂ:

ടൈം-സീരീസ് അഡാപ്റ്റർ.

ഭാവി വേല
ഡാറ്റാ ശേഖരണ ചട്ടക്കൂടിൽ ഭാവിയിൽ ചെയ്യേണ്ട ജോലികൾ ഈ വിഭാഗം ചർച്ചചെയ്യുന്നു.

ഇനിയും ചെയ്യേണ്ട ചില കാര്യങ്ങൾ ഇതാ:

· കൂടുതൽ ട്രെയ്സ് ഉറവിടങ്ങൾ ഹുക്ക് അപ്പ് ചെയ്യുക ns-3 സിമുലേറ്ററിൽ നിന്ന് കൂടുതൽ മൂല്യങ്ങൾ ലഭിക്കാൻ കോഡ്.

· നിലവിൽ ഉള്ളതിനേക്കാൾ കൂടുതൽ തരം പ്രോബുകൾ നടപ്പിലാക്കുക.

നിലവിലുള്ള 2-ഡി കളക്ടർ, BasicStatsCollector എന്നതിനേക്കാൾ കൂടുതൽ നടപ്പിലാക്കുക.

· കൂടുതൽ അഗ്രഗേറ്ററുകൾ നടപ്പിലാക്കുക.

· കേവലം അഡാപ്റ്ററുകൾ മാത്രമല്ല കൂടുതൽ നടപ്പിലാക്കുക.

സ്റ്റാറ്റിസ്റ്റിക്കൽ ചട്ടക്കൂട്
ഈ അധ്യായം സിമുലേഷൻ ഡാറ്റാ ശേഖരണത്തെക്കുറിച്ചും സ്റ്റാറ്റിസ്റ്റിക്കൽ ചട്ടക്കൂടിനെക്കുറിച്ചും ഉള്ള പ്രവർത്തനത്തിന്റെ രൂപരേഖ നൽകുന്നു
ns-3.

സ്റ്റാറ്റിസ്റ്റിക്കൽ ചട്ടക്കൂടിനുള്ള സോഴ്സ് കോഡ് ഡയറക്‌ടറിയിലാണ് src/stats.

ലക്ഷ്യങ്ങൾ
ഈ ശ്രമത്തിന്റെ പ്രാഥമിക ലക്ഷ്യങ്ങൾ ഇനിപ്പറയുന്നവയാണ്:

· വിശകലനത്തിനായി ഡാറ്റയും സ്ഥിതിവിവരക്കണക്കുകളും രേഖപ്പെടുത്തുന്നതിനും കണക്കാക്കുന്നതിനും അവതരിപ്പിക്കുന്നതിനുമുള്ള പ്രവർത്തനക്ഷമത നൽകുക
നെറ്റ്‌വർക്ക് സിമുലേഷനുകളുടെ.

· വിപുലമായ ട്രെയ്സ് ലോഗുകൾ സൃഷ്ടിക്കേണ്ടതിന്റെ ആവശ്യകത കുറച്ചുകൊണ്ട് സിമുലേഷൻ പ്രകടനം വർദ്ധിപ്പിക്കുക
ഡാറ്റ ശേഖരിക്കാൻ ഓർഡർ.

· ഓൺലൈൻ സ്ഥിതിവിവരക്കണക്കുകൾ വഴി സിമുലേഷൻ നിയന്ത്രണം പ്രവർത്തനക്ഷമമാക്കുക, ഉദാ സിമുലേഷനുകൾ അവസാനിപ്പിക്കുക അല്ലെങ്കിൽ
ആവർത്തിച്ചുള്ള പരീക്ഷണങ്ങൾ.

ഉരുത്തിരിഞ്ഞ ഉപ ലക്ഷ്യങ്ങളും മറ്റ് ലക്ഷ്യ സവിശേഷതകളും ഇനിപ്പറയുന്നവ ഉൾക്കൊള്ളുന്നു:

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

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

· ഒന്നിലധികം ട്രയലുകളിലൂടെ ഡാറ്റ സൃഷ്ടിക്കാനും സമാഹരിക്കാനും വിശകലനം ചെയ്യാനും ഉപയോക്താക്കളെ സഹായിക്കുന്നു.

· ഉപയോക്താവ് സൃഷ്ടിച്ച ഇൻസ്ട്രുമെന്റേഷനുള്ള പിന്തുണ, ഉദാ ആപ്ലിക്കേഷൻ നിർദ്ദിഷ്ട ഇവന്റുകൾ കൂടാതെ
നടപടികൾ.

· പാക്കേജ് ഉപയോഗത്തിലില്ലാത്തപ്പോൾ കുറഞ്ഞ മെമ്മറിയും CPU ഓവർഹെഡും.

നിലവിലുള്ള വിശകലനവും ഔട്ട്പുട്ട് ടൂളുകളും കഴിയുന്നത്ര പ്രയോജനപ്പെടുത്തുക. ചട്ടക്കൂട് ആകാം
ചില അടിസ്ഥാന സ്ഥിതിവിവരക്കണക്കുകൾ നൽകുക, പക്ഷേ ഡാറ്റ ശേഖരിക്കുന്നതിലും അത് നിർമ്മിക്കുന്നതിലുമാണ് ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്
സ്ഥാപിത ഉപകരണങ്ങളിൽ കൃത്രിമം നടത്തുന്നതിന് ആക്സസ് ചെയ്യാവുന്നതാണ്.

· സ്വതന്ത്രമായ പകർപ്പുകൾ വിതരണം ചെയ്യുന്നതിനുള്ള അന്തിമ പിന്തുണ പ്രധാനമാണ് എന്നാൽ ഉൾപ്പെടുത്തിയിട്ടില്ല
ഫീച്ചറുകളുടെ ആദ്യ റൗണ്ടിൽ.

പൊതു അവലോകനം
സ്റ്റാറ്റിസ്റ്റിക്സ് ചട്ടക്കൂടിൽ ഇനിപ്പറയുന്ന സവിശേഷതകൾ ഉൾപ്പെടുന്നു:

പ്രധാന ചട്ടക്കൂടും രണ്ട് അടിസ്ഥാന ഡാറ്റാ കളക്ടർമാരും: ഒരു കൗണ്ടർ, ഒരു മിനിറ്റ്/പരമാവധി/ശരാശരി/മൊത്തം
നിരീക്ഷകൻ.

· സമയങ്ങളും പാക്കറ്റുകളും ഉപയോഗിച്ച് എളുപ്പത്തിൽ പ്രവർത്തിക്കാനുള്ള വിപുലീകരണങ്ങൾ.

· പ്ലെയിൻടെക്സ്റ്റ് ഔട്ട്പുട്ട് ഫോർമാറ്റ് ചെയ്തു OMNet++.

· ഡാറ്റാബേസ് ഔട്ട്പുട്ട് ഉപയോഗിക്കുന്നു SQLite, ഒരു ഒറ്റപ്പെട്ട, ഭാരം കുറഞ്ഞ, ഉയർന്ന പ്രകടനമുള്ള SQL എഞ്ചിൻ.

· റണ്ണുകൾ വിവരിക്കുന്നതിനും പ്രവർത്തിക്കുന്നതിനും നിർബന്ധിതവും തുറന്നതുമായ മെറ്റാഡാറ്റ.

· NS-3 ന്റെ ഗുണവിശേഷതകൾ പരിശോധിക്കുന്നതിനുള്ള സാങ്കൽപ്പിക പരീക്ഷണത്തെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു ഉദാഹരണം
ഡിഫോൾട്ട് അഡ്‌ഹോക്ക് വൈഫൈ പ്രകടനം. ഇത് ഇനിപ്പറയുന്നവ ഉൾക്കൊള്ളുന്നു:

· രണ്ട് നോഡ് അഡ്‌ഹോക്ക് വൈഫൈ നെറ്റ്‌വർക്കിന്റെ നിർമ്മാണം, നോഡുകൾക്ക് ഒരു പാരാമീറ്ററൈസ്ഡ് ദൂരമുണ്ട്
വേറിട്ട്.

· UDP ട്രാഫിക് സോഴ്‌സ്, സിങ്ക് ആപ്ലിക്കേഷനുകൾ എന്നിവ അല്പം വ്യത്യസ്തമായ പെരുമാറ്റവും ഒപ്പം
സ്റ്റോക്ക് ക്ലാസുകളേക്കാൾ അളക്കൽ കൊളുത്തുകൾ.

നിലവിലുള്ള ട്രെയ്സ് സിഗ്നലുകൾ വഴി NS-3 കോറിൽ നിന്നുള്ള ഡാറ്റ ശേഖരണം, പ്രത്യേകിച്ച് ഡാറ്റ
വൈഫൈ MAC ഒബ്‌ജക്‌റ്റുകൾ കൈമാറുകയും സ്വീകരിക്കുകയും ചെയ്യുന്ന ഫ്രെയിമുകൾ.

· സ്റ്റാറ്റിലേക്ക് പുതിയ ട്രെയ്സ് സിഗ്നലുകൾ ബന്ധിപ്പിച്ചുകൊണ്ട് കസ്റ്റം ആപ്ലിക്കേഷനുകളുടെ ഇൻസ്ട്രുമെന്റേഷൻ
ചട്ടക്കൂട്, അതുപോലെ നേരിട്ടുള്ള അപ്ഡേറ്റുകൾ വഴി. മൊത്തം പാക്കറ്റുകളെ കുറിച്ചുള്ള വിവരങ്ങൾ രേഖപ്പെടുത്തിയിട്ടുണ്ട്
അയച്ചതും സ്വീകരിച്ചതും, കൈമാറ്റം ചെയ്യപ്പെട്ട ബൈറ്റുകൾ, അവസാനം മുതൽ അവസാനം വരെ വൈകും.

· എൻഡ്-ടു-എൻഡ് കാലതാമസം ട്രാക്ക് ചെയ്യുന്നതിന് പാക്കറ്റ് ടാഗുകൾ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം.

· പരീക്ഷണത്തിന്റെ അനേകം ട്രയലുകൾ വ്യത്യസ്‌തമായി പ്രവർത്തിപ്പിക്കുന്ന ഒരു ലളിതമായ നിയന്ത്രണ സ്‌ക്രിപ്റ്റ്
GNUPlot ഉപയോഗിച്ച് ഒരു ഗ്രാഫ് നിർമ്മിക്കുന്നതിന് ദൂരങ്ങൾ കണ്ടെത്തി ഫലമായുണ്ടാകുന്ന ഡാറ്റാബേസ് അന്വേഷിക്കുന്നു.

ചെയ്യാൻ
ഉയർന്ന മുൻഗണനയുള്ള ഇനങ്ങൾ ഉൾപ്പെടുന്നു:

· ഓൺലൈൻ സ്റ്റാറ്റിസ്റ്റിക്സ് കോഡ് ഉൾപ്പെടുത്തൽ, ഉദാ മെമ്മറി കാര്യക്ഷമമായ ആത്മവിശ്വാസ ഇടവേളകൾക്കായി.

· റണ്ണുകൾ അവസാനിപ്പിക്കുന്നതിനുള്ള ഡാറ്റ കളക്ടറുകളിലെ വ്യവസ്ഥകൾ, അതായത് ഒരു പരിധി അല്ലെങ്കിൽ
ആത്മവിശ്വാസം നിറവേറ്റപ്പെടുന്നു.

· കാലക്രമേണ സാമ്പിളുകൾ ലോഗ് ചെയ്യുന്നതിനുള്ള ഡാറ്റ കളക്ടർമാർ, വിവിധ ഫോർമാറ്റുകളിലേക്ക് ഔട്ട്പുട്ട്.

പതിവായി ചില മൂല്യങ്ങൾ പോൾ ചെയ്യുന്നതിനായി ലളിതമായ സൈക്ലിക് ഇവന്റ് ഗ്ലൂ എഴുതുന്നത് പ്രദർശിപ്പിക്കുക.

അവ ഓരോന്നും നിലവിലെ ചട്ടക്കൂടിൽ സംയോജിപ്പിക്കാൻ നേരായ തെളിയിക്കണം.

സമീപനം
ചട്ടക്കൂട് ഇനിപ്പറയുന്ന അടിസ്ഥാന തത്വങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്:

ഒരു സിമുലേഷൻ പ്രോഗ്രാമിന്റെ ഒരു ഉദാഹരണം ഉപയോഗിച്ചാണ് ഒരു പരീക്ഷണ ട്രയൽ നടത്തുന്നത്
സമാന്തരമായി അല്ലെങ്കിൽ സീരിയലായി.

· ഒരു കൺട്രോൾ സ്ക്രിപ്റ്റ് സിമുലേഷന്റെ സന്ദർഭങ്ങൾ നിർവ്വഹിക്കുന്നു, ആവശ്യാനുസരണം വ്യത്യസ്ത പാരാമീറ്ററുകൾ.

ബാഹ്യ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് പ്ലോട്ടിംഗിനും വിശകലനത്തിനുമായി ഡാറ്റ ശേഖരിക്കുകയും സംഭരിക്കുകയും ചെയ്യുന്നു
നിലവിലുള്ള ഉപകരണങ്ങൾ.

സ്റ്റാറ്റ് ചട്ടക്കൂടിനെ നിലവിലുള്ളതിലേക്ക് ബന്ധിപ്പിച്ച് ns-3 കോർക്കുള്ളിലെ അളവുകൾ എടുക്കുന്നു
ട്രെയ്സ് സിഗ്നലുകൾ.

ഇൻസ്ട്രുമെന്റ് ഇഷ്‌ടാനുസൃതമാക്കാൻ ട്രേസ് സിഗ്നലുകളോ ചട്ടക്കൂടിന്റെ നേരിട്ടുള്ള കൃത്രിമത്വമോ ഉപയോഗിക്കാം
സിമുലേഷൻ കോഡ്.

ചട്ടക്കൂടിന്റെ അടിസ്ഥാന ഘടകങ്ങളും അവയുടെ ഇടപെടലുകളും ചിത്രീകരിച്ചിരിക്കുന്നു
ഇനിപ്പറയുന്ന ചിത്രം. [ചിത്രം]

ഉദാഹരണം
ഈ വിഭാഗം ചട്ടക്കൂടിൽ ഒരു പരീക്ഷണം നിർമ്മിക്കുന്ന പ്രക്രിയയിലൂടെ കടന്നുപോകുന്നു
അതിൽ നിന്ന് വിശകലനത്തിനായി (ഗ്രാഫുകൾ) ഡാറ്റ നിർമ്മിക്കുന്നു, ഘടനയും എപിഐയും പ്രദർശിപ്പിക്കുന്നു
വഴി.

ചോദ്യം
''എൻഎസ്-3യുടെ വൈഫൈ നെറ്റ് ഡിവൈസുകളുടെ (ഡിഫോൾട്ട് ഉപയോഗിച്ച്) പ്രകടനം എന്താണ്?
ക്രമീകരണങ്ങൾ)? ഒരു സിമുലേഷനിൽ വയർലെസ് നോഡുകൾക്ക് കഴിയില്ല മുമ്പ് എത്ര അകലത്തിലായിരിക്കും
വിശ്വസനീയമായി ആശയവിനിമയം നടത്തണോ?''

· അനുമാനം: യഥാർത്ഥ ജീവിത പ്രകടനത്തെക്കുറിച്ചുള്ള അറിവിനെ അടിസ്ഥാനമാക്കി, നോഡുകൾ ആശയവിനിമയം നടത്തണം
കുറഞ്ഞത് 100 മീറ്റർ അകലത്തിൽ 200 മീറ്ററിൽ കൂടുതൽ ആശയവിനിമയം പാടില്ല
സാധ്യമായ.

സിമുലേഷൻ സന്ദർഭങ്ങളിൽ വളരെ സാധാരണമായ ഒരു ചോദ്യമല്ലെങ്കിലും, ഇതൊരു പ്രധാന സ്വത്താണ്
സിമുലേഷൻ ഡെവലപ്പർമാർക്ക് ഒരു അടിസ്ഥാന ധാരണ ഉണ്ടായിരിക്കണം. അതും സാധാരണമാണ്
ലൈവ് ഹാർഡ്‌വെയറിൽ നടത്തിയ പഠനം.

സിമുലേഷൻ പ്രോഗ്രാം
ഈ പരീക്ഷണം നടപ്പിലാക്കുന്നതിൽ ആദ്യം ചെയ്യേണ്ടത് സിമുലേഷൻ വികസിപ്പിക്കുക എന്നതാണ്
പ്രോഗ്രാം. ഈ ഉദാഹരണത്തിനുള്ള കോഡ് ഇതിൽ കാണാം ഉദാഹരണങ്ങൾ/സ്ഥിതിവിവരക്കണക്കുകൾ/wifi-example-sim.cc.
ഇത് ഇനിപ്പറയുന്ന പ്രധാന ഘട്ടങ്ങൾ ചെയ്യുന്നു.

പാരാമീറ്ററുകൾ പ്രഖ്യാപിക്കുകയും കമാൻഡ് ലൈൻ പാഴ്‌സുചെയ്യുകയും ചെയ്യുന്നു ns3:: കമാൻഡ് ലൈൻ.

ഇരട്ട ദൂരം = 50.0;
സ്ട്രിംഗ് ഫോർമാറ്റ് ("OMNet++");
സ്ട്രിംഗ് പരീക്ഷണം ("വൈഫൈ-ഡിസ്റ്റൻസ്-ടെസ്റ്റ്");
സ്ട്രിംഗ് സ്ട്രാറ്റജി ("വൈഫൈ-ഡിഫോൾട്ട്");
സ്ട്രിംഗ് റൺഐഡി;

കമാൻഡ് ലൈൻ cmd;
cmd.AddValue("ദൂരം", "നോഡുകൾ സ്ഥാപിക്കുന്നതിനുള്ള ദൂരം (മീറ്ററിൽ).", ദൂരം);
cmd.AddValue("ഫോർമാറ്റ്", "ഡാറ്റ ഔട്ട്പുട്ടിനായി ഉപയോഗിക്കേണ്ട ഫോർമാറ്റ്.", ഫോർമാറ്റ്);
cmd.AddValue("പരീക്ഷണം", "പരീക്ഷണത്തിനുള്ള ഐഡന്റിഫയർ.", പരീക്ഷണം);
cmd.AddValue("തന്ത്രം", "തന്ത്രത്തിനുള്ള ഐഡന്റിഫയർ.", തന്ത്രം);
cmd.AddValue("റൺ", "റണ്ണിനുള്ള ഐഡന്റിഫയർ.", runID);
cmd.Parse (argc, argv);

· ഉപയോഗിച്ച് നോഡുകളും നെറ്റ്‌വർക്ക് സ്റ്റാക്കുകളും സൃഷ്ടിക്കുന്നു ns3::നോഡ് കണ്ടെയ്നർ, ns3:: WiFiHelper, ഒപ്പം
ns3::InternetStackHelper.

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

വൈഫൈ ഹെൽപ്പർ വൈഫൈ;
wifi.SetMac("ns3::AdhocWifiMac");
wifi.SetPhy("ns3::WifiPhy");
NetDeviceContainer nodeDevices = wifi.Install(nodes);

InternetStackHelper ഇന്റർനെറ്റ്;
ഇന്റർനെറ്റ്.ഇൻസ്റ്റാൾ (നോഡുകൾ);
Ipv4AddressHelper ipAddrs;
ipAddrs.SetBase("192.168.0.0", "255.255.255.0");
ipAddrs.Assign (nodeDevices);

· ഉപയോഗിച്ച് നോഡുകൾ സ്ഥാപിക്കുന്നു ns3::മൊബിലിറ്റി ഹെൽപ്പർ. സ്ഥിരസ്ഥിതിയായി നോഡുകൾക്ക് സ്റ്റാറ്റിക് ഉണ്ട്
മൊബിലിറ്റി, ചലിക്കില്ല, എന്നാൽ തന്നിരിക്കുന്ന ദൂരം അകലത്തിൽ സ്ഥാപിക്കണം. ഇതുണ്ട്
ഇത് ചെയ്യുന്നതിന് നിരവധി വഴികൾ; ഉപയോഗിച്ചാണ് ഇവിടെ ചെയ്യുന്നത് ns3::ListPositionAllocator, ഏത് വരയ്ക്കുന്നു
തന്നിരിക്കുന്ന പട്ടികയിൽ നിന്നുള്ള സ്ഥാനങ്ങൾ.

മൊബിലിറ്റി ഹെൽപ്പർ മൊബിലിറ്റി;
Ptr പൊസിഷൻഅലോക്ക് =
ക്രിയേറ്റ് ഒബ്ജക്റ്റ് ();
positionAlloc->Add(Vector(0.0, 0.0, 0.0));
positionAlloc->Add(Vector(0.0, ദൂരം, 0.0));
mobility.SetPositionAllocator(positionAlloc);
mobility.Install(nodes);

· ഒരു ട്രാഫിക് ജനറേറ്ററും ഒരു ട്രാഫിക് സിങ്കും സ്ഥാപിക്കുന്നു. സ്റ്റോക്ക് അപ്ലിക്കേഷനുകൾ ആയിരിക്കാം
ഉപയോഗിച്ചു, എന്നാൽ ഉദാഹരണത്തിൽ ഇഷ്‌ടാനുസൃത വസ്തുക്കൾ ഉൾപ്പെടുന്നു src/test/test02-apps.(cc|h). ഇവ
ഒരു നിശ്ചിത ഇടവേളയിൽ നിശ്ചിത എണ്ണം പാക്കറ്റുകൾ സൃഷ്ടിച്ചുകൊണ്ട് ലളിതമായ ഒരു പെരുമാറ്റം ഉണ്ടായിരിക്കുക.
അവയിൽ ഒരെണ്ണം മാത്രമുള്ളതിനാൽ അവ സ്വമേധയാ ഇൻസ്റ്റാൾ ചെയ്യപ്പെടുന്നു; ഒരു വലിയ സെറ്റിനായി
ns3::അപ്ലിക്കേഷൻ ഹെൽപ്പർ ക്ലാസ് ഉപയോഗിക്കാം. കമന്റ്-ഔട്ട് കോൺഫിഗറേഷൻ::സെറ്റ് ലൈൻ മാറ്റങ്ങൾ
ഈ ഉദാഹരണത്തിൽ സ്ഥിരസ്ഥിതിയായി പ്രക്ഷേപണം ചെയ്യാൻ സജ്ജമാക്കിയിരിക്കുന്ന പാക്കറ്റുകളുടെ ലക്ഷ്യസ്ഥാനം. അതല്ല
പൊതുവേ, വൈഫൈയ്ക്ക് ബ്രോഡ്കാസ്റ്റിനും യൂണികാസ്റ്റ് ഫ്രെയിമുകൾക്കും വ്യത്യസ്ത പ്രകടനം ഉണ്ടായിരിക്കാം
വ്യത്യസ്ത നിരക്ക് നിയന്ത്രണവും MAC റീട്രാൻസ്മിഷൻ നയങ്ങളും.

Ptr appSource = NodeList::GetNode(0);
Ptr അയച്ചയാൾ = CreateObject ();
appSource->AddApplication(അയക്കുന്നയാൾ);
അയച്ചയാൾ->ആരംഭിക്കുക(സെക്കൻഡ്(1));

Ptr appSink = നോഡ്‌ലിസ്റ്റ്::GetNode(1);
Ptr റിസീവർ = CreateObject ();
appSink->AddApplication(റിസീവർ);
റിസീവർ->ആരംഭിക്കുക(സെക്കൻഡ്(0));

// കോൺഫിഗറേഷൻ::സെറ്റ്("/നോഡ്‌ലിസ്റ്റ്/*/അപ്ലിക്കേഷൻ ലിസ്റ്റ്/*/$അയക്കുന്നയാൾ/ഡെസ്റ്റിനേഷൻ",
// Ipv4AddressValue("192.168.0.2"));

· ശേഖരിക്കേണ്ട ഡാറ്റയും സ്ഥിതിവിവരക്കണക്കുകളും ക്രമീകരിക്കുന്നു. അടിസ്ഥാന മാതൃക ഒരു ആണ്
ns3::ഡാറ്റ കളക്ടർ ഈ പ്രത്യേക റണ്ണിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ സൂക്ഷിക്കുന്നതിനാണ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ചത്
യഥാർത്ഥത്തിൽ ഡാറ്റ സൃഷ്‌ടിക്കാൻ ഏത് നിരീക്ഷകരും കാൽക്കുലേറ്ററുകളും ഘടിപ്പിച്ചിരിക്കുന്നു. പ്രധാനമായി,
റൺ വിവരങ്ങളിൽ ''പരീക്ഷണങ്ങൾ'', ''തന്ത്രം'', ''ഇൻപുട്ട്'', കൂടാതെ ലേബലുകൾ ഉൾപ്പെടുന്നു
''ഓടുക''. ഒന്നിലധികം ട്രയലുകളിൽ നിന്നുള്ള ഡാറ്റ പിന്നീട് തിരിച്ചറിയുന്നതിനും എളുപ്പത്തിൽ ഗ്രൂപ്പുചെയ്യുന്നതിനും ഇവ ഉപയോഗിക്കുന്നു.

· ഈ ട്രയൽ അംഗമായിരിക്കുന്ന പഠനമാണ് പരീക്ഷണം. ഇവിടെ അത് വൈഫൈയിലാണ്
പ്രകടനവും ദൂരവും.

· ഈ ട്രയലിൽ പരിശോധിക്കപ്പെടുന്ന കോഡോ പാരാമീറ്ററുകളോ ആണ് തന്ത്രം. ഈ ഉദാഹരണത്തിൽ
ഇത് പരിഹരിച്ചിരിക്കുന്നു, എന്നാൽ വ്യക്തമായ ഒരു വിപുലീകരണം വ്യത്യസ്ത വൈഫൈ ബിറ്റ് അന്വേഷിക്കുന്നതായിരിക്കും
നിരക്കുകൾ, അവ ഓരോന്നും വ്യത്യസ്ത തന്ത്രമായിരിക്കും.

ഈ ട്രയലിന് നൽകിയിരിക്കുന്ന പ്രത്യേക പ്രശ്നമാണ് ഇൻപുട്ട്. ഇവിടെ അത് ലളിതമായി ആണ്
രണ്ട് നോഡുകൾ തമ്മിലുള്ള ദൂരം.

റൺഐഡി ഈ ട്രയലിനുള്ള ഒരു അദ്വിതീയ ഐഡന്റിഫയറാണ്, അതിന്റെ വിവരങ്ങൾ ടാഗ് ചെയ്‌തിരിക്കുന്നു
പിന്നീടുള്ള വിശകലനത്തിൽ തിരിച്ചറിയുന്നതിനായി. റൺ ഐഡി നൽകിയിട്ടില്ലെങ്കിൽ, പ്രോഗ്രാം ഉണ്ടാക്കുന്ന ഉദാഹരണം
നിലവിലെ സമയം ഉപയോഗിച്ച് ഒരു (ദുർബലമായ) റൺ ഐഡി.

മെറ്റാഡാറ്റയുടെ ആ നാല് ഭാഗങ്ങൾ ആവശ്യമാണ്, എന്നാൽ കൂടുതൽ ആവശ്യമായി വന്നേക്കാം. അവ ചേർത്തേക്കാം
ഉപയോഗിച്ച് റെക്കോർഡിലേക്ക് ns3::DataCollector::AddMetadata() രീതി.

ഡാറ്റ കളക്ടർ ഡാറ്റ;
data.DescribeRun(പരീക്ഷണം, തന്ത്രം, ഇൻപുട്ട്, റൺഐഡി);
data.AddMetadata("രചയിതാവ്", "tjkopena");

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

Ptr totalRx = CreateObject ();
totalRx->SetKey("wifi-rx-frames");
കോൺഫിഗറേഷൻ::കണക്റ്റ്("/നോഡ്‌ലിസ്റ്റ്/1/ഉപകരണ ലിസ്റ്റ്/*/$ns3::WifiNetDevice/Rx",
MakeCallback(&PacketCounterCalculator ::FrameUpdate, totalRx));
data.AddDataCalculator(totalRx);

കാൽക്കുലേറ്ററുകൾ നേരിട്ട് കൈകാര്യം ചെയ്യാവുന്നതാണ്. ഈ ഉദാഹരണത്തിൽ, ഒരു കൌണ്ടർ സൃഷ്ടിച്ചു കൂടാതെ
പാക്കറ്റുകൾ ലഭിക്കുമ്പോൾ അപ്ഡേറ്റ് ചെയ്യേണ്ട ട്രാഫിക് സിങ്ക് ആപ്ലിക്കേഷനിലേക്ക് അയച്ചു.

Ptr > appRx = CreateObject >();
appRx->SetKey("receiver-rx-packets");
റിസീവർ->SetCounter(appRx);
ഡാറ്റ.AddDataCalculator(appRx);

എണ്ണം വർദ്ധിപ്പിക്കുന്നതിന്, സിങ്കിന്റെ പാക്കറ്റ് പ്രോസസ്സിംഗ് കോഡ്, അതിലൊന്നിനെ വിളിക്കുന്നു
കാൽക്കുലേറ്ററിന്റെ അപ്ഡേറ്റ് രീതികൾ.

m_calc->അപ്‌ഡേറ്റ്();

ആദിമ രണ്ടും ഉപയോഗിച്ച് പ്രോഗ്രാമിൽ മറ്റ് നിരവധി ഉദാഹരണങ്ങളും ഉൾപ്പെടുന്നു
പോലുള്ള കാൽക്കുലേറ്ററുകൾ ns3:: കൗണ്ടർ കാൽക്കുലേറ്റർ പാക്കറ്റുകൾ നിരീക്ഷിക്കാൻ അനുയോജ്യമായവയും
തവണ. ഇൻ src/test/test02-apps.(cc|h) അത് ഉപയോഗിക്കുന്ന ഒരു ലളിതമായ ഇഷ്‌ടാനുസൃത ടാഗും ഇത് സൃഷ്ടിക്കുന്നു
ജനറേറ്റ് ചെയ്‌ത പാക്കറ്റുകളുടെ എൻഡ്-ടു-എൻഡ് കാലതാമസം ട്രാക്കുചെയ്യുന്നതിന്, ഫലങ്ങൾ റിപ്പോർട്ടുചെയ്യുന്നത് a
ns3::TimeMinMaxAvgTotalCalculator ഡാറ്റ കാൽക്കുലേറ്റർ.

സിമുലേഷൻ റൺ ചെയ്യുന്നു, ഒരിക്കൽ നിർമ്മിച്ചുകഴിഞ്ഞാൽ അത് വളരെ ലളിതമാണ്.

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

· ഒന്നുകിൽ സൃഷ്ടിക്കുന്നു OMNet++ or SQLite ഔട്ട്പുട്ട്, കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ അനുസരിച്ച്. ലേക്ക്
ഇത് ചെയ്യുക a ns3::DataOutputInterface ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുകയും ക്രമീകരിക്കുകയും ചെയ്യുന്നു. നിർദ്ദിഷ്ട തരം
ഇത് ഔട്ട്പുട്ട് ഫോർമാറ്റ് നിർണ്ണയിക്കും. ഈ വസ്തു പിന്നീട് നൽകിയിരിക്കുന്നു
ns3::ഡാറ്റ കളക്ടർ ഔട്ട്പുട്ട് ഉത്പാദിപ്പിക്കാൻ അത് ചോദ്യം ചെയ്യുന്ന ഒബ്ജക്റ്റ്.

Ptr ഔട്ട്പുട്ട്;
എങ്കിൽ (ഫോർമാറ്റ് == "OMNet++") {
NS_LOG_INFO("OMNet++ ഫോർമാറ്റ് ചെയ്ത ഡാറ്റ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നു.");
ഔട്ട്പുട്ട് = CreateObject ();
} else {
# ifdef STAT_USE_DB
NS_LOG_INFO("SQLite ഫോർമാറ്റ് ചെയ്ത ഡാറ്റ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നു.");
ഔട്ട്പുട്ട് = CreateObject ();
# endif
}

ഔട്ട്പുട്ട്->ഔട്ട്പുട്ട്(ഡാറ്റ);

· സിമുലേഷൻ ഉപയോഗിക്കുന്ന ഏത് മെമ്മറിയും സ്വതന്ത്രമാക്കുന്നു. ഇത് പ്രധാനത്തിന്റെ അവസാനം വരണം
ഉദാഹരണത്തിനായി പ്രവർത്തനം.

സിമുലേറ്റർ:: നശിപ്പിക്കുക();

ലോഗ് ചെയ്യുന്നു
ഉദാഹരണ പ്രോഗ്രാമും ആപ്ലിക്കേഷനുകളും സ്റ്റാറ്റ് ചട്ടക്കൂടും എന്താണ് ചെയ്യുന്നതെന്ന് വിശദമായി കാണുന്നതിന്, സജ്ജമാക്കുക
The NS_LOG ഉചിതമായി വേരിയബിൾ. ഇനിപ്പറയുന്നവ എല്ലാവരിൽ നിന്നും ധാരാളം ഔട്ട്പുട്ട് നൽകും
മൂന്ന്.

$ കയറ്റുമതി NS_LOG=WiFiDistanceExperiment:WiFiDistanceApps

ഇത് അനുകരണത്തെ അസാധാരണമായി മന്ദഗതിയിലാക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക.

മാതൃക ഔട്ട്പുട്ട്
ടെസ്റ്റ് പ്രോഗ്രാം കംപൈൽ ചെയ്യുകയും ലളിതമായി പ്രവർത്തിപ്പിക്കുകയും ചെയ്യും OMNet++ പോലുള്ള ഫോർമാറ്റ് ചെയ്ത ഔട്ട്പുട്ട്
ഇനിപ്പറയുന്നവയിലേക്ക് data.sca.

റൺ റൺ-1212239121

attr പരീക്ഷണം "വൈഫൈ-ദൂര-പരിശോധന"
attr തന്ത്രം "വൈഫൈ-ഡിഫോൾട്ട്"
attr ഇൻപുട്ട് "50"
attr വിവരണം ""

attr "രചയിതാവ്" "tjkopena"

സ്കെയിലർ വൈഫൈ-ടിഎക്സ് ഫ്രെയിമുകളുടെ എണ്ണം 30
സ്കെയിലർ wifi-rx-frames എണ്ണം 30
Scalar sender-tx-packets എണ്ണം 30
സ്കെലാർ റിസീവർ-ആർഎക്സ്-പാക്കറ്റുകളുടെ എണ്ണം 30
സ്കെയിലർ tx-pkt-size കൗണ്ട് 30
സ്കെയിലർ tx-pkt-size ആകെ 1920
സ്കെലാർ tx-pkt-വലിപ്പം ശരാശരി 64
സ്കെയിലർ tx-pkt-size max 64
സ്കെലാർ tx-pkt-size min 64
സ്കെയിലർ കാലതാമസത്തിന്റെ എണ്ണം 30
സ്കെയിലർ കാലതാമസം ആകെ 5884980ns
സ്കെയിലർ കാലതാമസം ശരാശരി 196166ns
സ്കെയിലർ കാലതാമസം പരമാവധി 196166ns
സ്കെയിലർ കാലതാമസം മിനിറ്റ് 196166ns

നിയന്ത്രണ സ്ക്രിപ്റ്റ്
വൈവിധ്യമാർന്ന ഇൻപുട്ടുകളിൽ (ദൂരങ്ങളിൽ) ഡാറ്റ ശേഖരണം ഓട്ടോമേറ്റ് ചെയ്യുന്നതിന്, ഒരു ലളിതമായ ബാഷ്
സിമുലേഷനുകളുടെ ഒരു പരമ്പര നടപ്പിലാക്കാൻ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു. ഇത് കണ്ടെത്താനാകും
ഉദാഹരണങ്ങൾ/stats/wifi-example-db.sh. സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ് ഉദാഹരണങ്ങൾ/ സ്ഥിതിവിവരക്കണക്കുകൾ/
ഡയറക്ടറി.

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

#!/ bin / sh

DISTANCES="25 50 75 100 125 145 147 150 152 155 157 160 162 165 167 170 172 175 177 180"
ട്രയൽസ്="1 2 3 4 5"

എക്കോ വൈഫൈ പരീക്ഷണ ഉദാഹരണം

എങ്കിൽ [-e data.db ]
അപ്പോള്
echo Kill data.db?
ANS വായിക്കുക
എങ്കിൽ [ "$ANS" = "അതെ" -o "$ANS" = "y" ]
അപ്പോള്
എക്കോ ഡാറ്റാബേസ് ഇല്ലാതാക്കുന്നു
rm data.db
fi
fi

$TRIALS-ൽ ട്രയലിനായി
do
$DISTANCES ലെ ദൂരത്തിന്
do
എക്കോ ട്രയൽ $ട്രയൽ, ദൂരം $ദൂരം
./bin/test02 --format=db --distance=$distance --run=run-$distance-$trial
ചെയ്തു
ചെയ്തു

വിശകലനം ഒപ്പം തീരുമാനം
എല്ലാ ട്രയലുകളും നടത്തിക്കഴിഞ്ഞാൽ, സ്ക്രിപ്റ്റ് ഒരു ലളിതമായ SQL അന്വേഷണം നടപ്പിലാക്കുന്നു
ഡാറ്റാബേസ് ഉപയോഗിക്കുന്നു SQLite കമാൻഡ് ലൈൻ പ്രോഗ്രാം. ചോദ്യം ശരാശരി പാക്കറ്റ് നഷ്ടം കണക്കാക്കുന്നു
ഓരോ ദൂരവുമായി ബന്ധപ്പെട്ട ഓരോ ട്രയലുകളും. ഇത് വ്യത്യസ്തമായി കണക്കിലെടുക്കുന്നില്ല
തന്ത്രങ്ങൾ, എന്നാൽ ചില ലളിതമായ വിപുലീകരണങ്ങൾ നടത്താൻ വിവരങ്ങൾ ഡാറ്റാബേസിൽ ഉണ്ട്
അങ്ങനെ ചെയ്യുക. ശേഖരിച്ച ഡാറ്റ ഗ്രാഫിംഗിനായി GNUPlot-ലേക്ക് കൈമാറുന്നു.

CMD="ex.input തിരഞ്ഞെടുക്കുക, ശരാശരി(100-((rx.value*100)/tx.value)) \
Singletons rx, Singletons tx, Experiments exp \
ഇവിടെ rx.run = tx.run AND \
rx.run = exp.run ഒപ്പം \
rx.name='receiver-rx-packets' കൂടാതെ \
tx.name='sender-tx-packets' \
exp.input പ്രകാരം ഗ്രൂപ്പ് \
abs(exp.input) ASC വഴി ഓർഡർ ചെയ്യുക;"

sqlite3 -noheader data.db "$CMD" > wifi-default.data
sed -i "s/|/ /" wifi-default.data
gnuplot wifi-example.gnuplot

GNUPlot സ്ക്രിപ്റ്റ് ഇവിടെ കണ്ടെത്തി ഉദാഹരണങ്ങൾ/സ്ഥിതിവിവരക്കണക്കുകൾ/wifi-example.gnuplot ലളിതമായി ഔട്ട്പുട്ട് നിർവചിക്കുന്നു
ഫോർമാറ്റും ഗ്രാഫിനുള്ള ചില അടിസ്ഥാന ഫോർമാറ്റിംഗും.

ടെർമിനൽ പോസ്റ്റ്‌സ്‌ക്രിപ്റ്റ് പോർട്രെയ്‌റ്റ് മെച്ചപ്പെടുത്തി lw 2 "ഹെൽവെറ്റിക്ക" 14

സെറ്റ് സൈസ് 1.0, 0.66

#--------------------------------------------- ------
"wifi-default.eps" സജ്ജമാക്കുക
#സെറ്റ് ടൈറ്റിൽ "പാക്കറ്റ് ലോസ് ഓവർ ഡിസ്റ്റൻസ്"
xlabel സജ്ജമാക്കുക "ദൂരം (മീ) --- ഒരു പോയിന്റിന് ശരാശരി 5 ട്രയലുകൾ"
എക്സ്റേഞ്ച് സജ്ജമാക്കുക [0:200]
"% പാക്കറ്റ് നഷ്ടം" എന്ന ലേബൽ സജ്ജമാക്കുക
സെറ്റ് yrange [0:110]

പ്ലോട്ട് "wifi-default.data" എന്ന വരികൾ "വൈഫൈ ഡിഫോൾട്ടുകൾ"

അവസാനിക്കുന്നു ഫലമായി
തത്ഫലമായുണ്ടാകുന്ന ഗ്രാഫ് സ്ഥിരസ്ഥിതി വൈഫൈ മോഡലിന്റെ പ്രകടനത്തിന് തെളിവുകളൊന്നും നൽകുന്നില്ല
അനിവാര്യമായും യുക്തിരഹിതവും കുറഞ്ഞത് ഒരു ടോക്കൺ വിശ്വസ്തതയ്ക്ക് കുറച്ച് ആത്മവിശ്വാസം നൽകുന്നു
യാഥാർത്ഥ്യം. അതിലും പ്രധാനമായി, ഈ ലളിതമായ അന്വേഷണം എല്ലാ വഴികളിലൂടെയും നടത്തി
സ്റ്റാറ്റിസ്റ്റിക്കൽ ചട്ടക്കൂട് ഉപയോഗിച്ച്. വിജയം! [ചിത്രം]

തൽസമയം
ns-3 ടെസ്റ്റ്‌ബെഡിലേക്കും വെർച്വൽ മെഷീൻ പരിതസ്ഥിതികളിലേക്കും സംയോജിപ്പിക്കുന്നതിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ലേക്ക്
യഥാർത്ഥ നെറ്റ്‌വർക്ക് സ്റ്റാക്കുകളുമായി സംയോജിപ്പിച്ച് പാക്കറ്റുകൾ പുറപ്പെടുവിക്കുക/ഉപഭോഗിക്കുക, ഒരു തത്സമയ ഷെഡ്യൂളർ ആണ്
ഹാർഡ്‌വെയർ ക്ലോക്ക് ഉപയോഗിച്ച് സിമുലേഷൻ ക്ലോക്ക് ലോക്ക് ചെയ്യാൻ ശ്രമിക്കേണ്ടതുണ്ട്. ഞങ്ങൾ ഇവിടെ വിവരിക്കുന്നു a
ഇതിന്റെ ഘടകം: റിയൽടൈം ഷെഡ്യൂളർ.

തൽസമയ ഷെഡ്യൂളറിന്റെ ഉദ്ദേശ്യം സിമുലേഷൻ ക്ലോക്കിന്റെ പുരോഗതിക്ക് കാരണമാകുന്നു
ചില ബാഹ്യ സമയ അടിസ്ഥാനവുമായി ബന്ധപ്പെട്ട് സിൻക്രണസ് ആയി സംഭവിക്കുന്നത്. സാന്നിധ്യമില്ലാതെ
ഒരു ബാഹ്യ സമയ അടിസ്ഥാനം (മതിൽ ക്ലോക്ക്), സിമുലേഷൻ സമയം ഒരു സിമുലേറ്റിൽ നിന്ന് തൽക്ഷണം കുതിക്കുന്നു
അടുത്തതിലേക്കുള്ള സമയം.

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

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

സിമുലേഷൻ ഇവന്റുകളുടെ നിർവ്വഹണത്തിൽ അന്തർലീനമായ പ്രോസസ്സിംഗ് കാരണം ഇത് സംഭവിക്കാം,
സിമുലേറ്ററിന് തത്സമയം നിലനിർത്താൻ കഴിയില്ല. അത്തരമൊരു സാഹചര്യത്തിൽ, അത് ഉപയോക്താവിനെ ആശ്രയിച്ചിരിക്കുന്നു
എന്താണ് ചെയ്യേണ്ടതെന്ന് കോൺഫിഗറേഷൻ. രണ്ടെണ്ണം ഉണ്ട് ns-3 പെരുമാറ്റത്തെ നിയന്ത്രിക്കുന്ന ആട്രിബ്യൂട്ടുകൾ. ദി
ആദ്യത്തേത് ns3::RealTimeSimulatorImpl::SynchronizationMode. രണ്ട് എൻട്രികൾ സാധ്യമാണ്
ഈ ആട്രിബ്യൂട്ട് നല്ല ശ്രമം (സ്ഥിരസ്ഥിതി) അല്ലെങ്കിൽ ഹാർഡ്ലിമിറ്റ്. "BestEffort" മോഡിൽ, ദി
സിമുലേറ്റർ എയിൽ എത്തുന്നതുവരെ ഇവന്റുകൾ എക്‌സിക്യൂട്ട് ചെയ്‌ത് തത്സമയം കണ്ടെത്താൻ ശ്രമിക്കും
അടുത്ത ഇവന്റ് (തത്സമയ) ഭാവിയിൽ എവിടെയാണെന്ന് പോയിന്റ് ചെയ്യുക, അല്ലെങ്കിൽ സിമുലേഷൻ അവസാനിക്കുന്നു. ഇൻ
BestEffort മോഡ്, അപ്പോൾ, സിമുലേഷനേക്കാൾ കൂടുതൽ സമയം ചെലവഴിക്കുന്നത് സാധ്യമാണ്
മതിൽ ക്ലോക്ക് സമയം. മറ്റൊരു ഓപ്ഷൻ "HardLimit" ആണെങ്കിൽ സിമുലേഷൻ നിർത്തലാക്കും
സഹിഷ്ണുതയുടെ പരിധി കവിഞ്ഞു. ഈ ആട്രിബ്യൂട്ട് ns3::RealTimeSimulatorImpl::HardLimit
സ്ഥിരസ്ഥിതി 0.1 സെക്കൻഡ് ആണ്.

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

ഉപയോഗം
സ്‌ക്രിപ്റ്റിംഗ് വീക്ഷണകോണിൽ നിന്ന് തത്സമയ സിമുലേറ്ററിന്റെ ഉപയോഗം നേരായതാണ്.
ഉപയോക്താക്കൾ ആട്രിബ്യൂട്ട് സജ്ജമാക്കിയാൽ മതി സിമുലേറ്റർ ഇംപ്ലിമെന്റേഷൻ തരം തത്സമയത്തേക്ക്
ഇനിപ്പറയുന്നവ പോലുള്ള സിമുലേറ്റർ:

GlobalValue::Bind ("സിമുലേറ്റർ ഇംപ്ലിമെന്റേഷൻ തരം",
StringValue ("ns3::RealtimeSimulatorImpl"));

അതിൽ ഒരു സ്ക്രിപ്റ്റ് ഉണ്ട് ഉദാഹരണങ്ങൾ/realtime/realtime-udp-echo.cc അത് എങ്ങനെ എന്നതിന് ഒരു ഉദാഹരണമുണ്ട്
തത്സമയ സ്വഭാവം ക്രമീകരിക്കുക. ശ്രമിക്കുക:

$ ./waf --run realtime-udp-echo

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

നടപ്പിലാക്കൽ
നടപ്പിലാക്കൽ ഇനിപ്പറയുന്ന ഫയലുകളിൽ അടങ്ങിയിരിക്കുന്നു:

· src/core/model/realtime-simulator-impl.{cc,h}

· src/core/model/wall-clock-synchronizer.{cc,h}

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

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

സഹായി API-ക്ക് കുറച്ച് ലക്ഷ്യങ്ങളുണ്ട്:

1. ബാക്കിയുള്ളവ src / സഹായി API-യിൽ ആശ്രിതത്വമില്ല; ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയുന്ന എന്തും
ഹെൽപ്പർ API ലോ-ലെവൽ API-യിലും കോഡ് ചെയ്യാവുന്നതാണ്

2. കണ്ടെയ്‌നറുകൾ: പലപ്പോഴും സിമുലേഷനുകൾക്ക് ഗ്രൂപ്പുകൾക്ക് സമാനമായ നിരവധി പ്രവർത്തനങ്ങൾ ചെയ്യേണ്ടതുണ്ട്
വസ്തുക്കളുടെ. ഹെൽപ്പർ API സമാനമായ ഒബ്‌ജക്‌റ്റുകളുടെ കണ്ടെയ്‌നറുകൾ വളരെയധികം ഉപയോഗിക്കുന്നു
സമാനമോ സമാനമോ ആയ പ്രവർത്തനങ്ങൾ നടത്താം.

3. ഹെൽപ്പർ API ജനറിക് അല്ല; കോഡ് പുനരുപയോഗം പരമാവധിയാക്കാൻ അത് ശ്രമിക്കുന്നില്ല. അതിനാൽ,
പോളിമോർഫിസം പോലുള്ള പ്രോഗ്രാമിംഗ് നിർമ്മാണങ്ങളും കോഡ് പുനരുപയോഗം നേടുന്ന ടെംപ്ലേറ്റുകളും
പ്രബലമല്ല. ഉദാഹരണത്തിന്, പ്രത്യേക CsmaNetDevice സഹായികളും ഉണ്ട്
PointToPointNetDevice സഹായികളാണെങ്കിലും അവർ ഒരു സാധാരണ NetDevice ബേസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതല്ല
ക്ലാസ്.

4. ഹെൽപ്പർ API സാധാരണയായി സ്റ്റാക്ക്-അലോക്കേറ്റഡ് (വേഴ്സസ്. ഹീപ്പ്-അലോക്കേറ്റഡ്) ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു. വേണ്ടി
ചില പരിപാടികൾ, ns-3 ഉപയോക്താക്കൾക്ക് താഴ്ന്ന നിലയിലുള്ള ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നതിനെ കുറിച്ച് വിഷമിക്കേണ്ടതില്ല
Ptr കൈകാര്യം ചെയ്യൽ; ഒബ്‌ജക്‌റ്റുകളുടെ കണ്ടെയ്‌നറുകളും സ്റ്റാക്ക്-അലോക്കേറ്റ് ചെയ്‌ത സഹായികളും ഉപയോഗിച്ച് അവർക്ക് ചെയ്യാൻ കഴിയും
അവയിൽ പ്രവർത്തിക്കുന്നു.

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

നിർമ്മാണം പ്ലോട്ടുകൾ ഉപയോഗിച്ച് The ഗ്നുപ്ലോട്ട് ക്ലാസ്
ഒരു പ്ലോട്ട് നിർമ്മിക്കുന്നതിന് 2 പൊതു രീതികളുണ്ട് ns-3 ഒപ്പം gnuplot (-
http://www.gnuplot.info):

1. ഉപയോഗിച്ച് ഒരു gnuplot കൺട്രോൾ ഫയൽ സൃഷ്ടിക്കുക ns-3ന്റെ ഗ്നുപ്ലോട്ട് ക്ലാസ്.

2. ജനറേറ്റ് ചെയ്‌ത മൂല്യങ്ങൾ ഉപയോഗിച്ച് ഒരു gnuplot ഡാറ്റ ഫയൽ സൃഷ്‌ടിക്കുക ns-3.

ഈ വിഭാഗം രീതി 1 നെക്കുറിച്ചാണ്, അതായത് ഇത് ഉപയോഗിച്ച് ഒരു പ്ലോട്ട് എങ്ങനെ നിർമ്മിക്കാം എന്നതിനെക്കുറിച്ചാണ് ns-3ന്റെ ഗ്നുപ്ലോട്ട്
ക്ലാസ്. നിങ്ങൾക്ക് രീതി 2-ൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, ചുവടെയുള്ള "ഒരു യഥാർത്ഥ ഉദാഹരണം" ഉപവിഭാഗം കാണുക
ലെ "ട്രേസിംഗ്" വിഭാഗം ns-3 ട്യൂട്ടോറിയൽ.

ഉണ്ടാക്കുന്നു പ്ലോട്ടുകൾ ഉപയോഗിക്കുന്നു The ഗ്നുപ്ലോട്ട് ക്ലാസ്
ഉപയോഗിച്ച് ഒരു പ്ലോട്ട് സൃഷ്ടിക്കുന്നതിന് ഇനിപ്പറയുന്ന നടപടികൾ കൈക്കൊള്ളണം ns-3ന്റെ ഗ്നുപ്ലോട്ട് ക്ലാസ്:

1. നിങ്ങളുടെ കോഡ് പരിഷ്‌ക്കരിക്കുക, അതുവഴി Gnuplot ക്ലാസും അതിന്റെ പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നു.

2. നിങ്ങളുടെ കോഡ് പ്രവർത്തിപ്പിക്കുക, അങ്ങനെ അത് ഒരു ഗ്നപ്ലോട്ട് കൺട്രോൾ ഫയൽ സൃഷ്ടിക്കുന്നു.

3. gnuplot നിയന്ത്രണ ഫയലിന്റെ പേര് ഉപയോഗിച്ച് gnuplot-ലേക്ക് വിളിക്കുക.

4. നിങ്ങളുടെ പ്രിയപ്പെട്ട ഗ്രാഫിക്സ് വ്യൂവറിൽ നിർമ്മിച്ച ഗ്രാഫിക്സ് ഫയൽ കാണുക.

ഘട്ടം 1-നെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് ചുവടെ ചർച്ച ചെയ്തിരിക്കുന്ന ഉദാഹരണ പ്ലോട്ടുകളിൽ നിന്നുള്ള കോഡ് കാണുക.

An ഉദാഹരണം പ്രോഗ്രാം ആ ഉപയോഗങ്ങൾ The ഗ്നുപ്ലോട്ട് ക്ലാസ്
ഉപയോഗിക്കുന്ന ഒരു ഉദാഹരണ പ്രോഗ്രാം ns-3ന്റെ Gnuplot ക്ലാസ് ഇവിടെ കാണാം:

src/stats/examples/gnuplot-example.cc

ഈ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന്, ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ ./വാഫ് ഷെൽ
$ cd ബിൽഡ്/ഡീബഗ്/src/stats/ഉദാഹരണങ്ങൾ
$ ./gnuplot-example

ഇത് ഉദാഹരണം ഉള്ള ഡയറക്‌ടറിയിൽ ഇനിപ്പറയുന്ന ഗ്നപ്‌ലോട്ട് കൺട്രോൾ ഫയലുകൾ ഹാജരാക്കണം
സ്ഥിതി ചെയ്യുന്നത്:

പ്ലോട്ട്-2d.plt
plot-2d-with-error-bars.plt
പ്ലോട്ട്-3d.plt

ഈ gnuplot നിയന്ത്രണ ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന്, ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ gnuplot പ്ലോട്ട്-2d.plt
$ gnuplot plot-2d-with-error-bars.plt
$ gnuplot പ്ലോട്ട്-3d.plt

ഉദാഹരണം ഉള്ള ഡയറക്ടറിയിൽ ഇത് ഇനിപ്പറയുന്ന ഗ്രാഫിക്സ് ഫയലുകൾ നിർമ്മിക്കണം
സ്ഥിതി ചെയ്യുന്നത്:

പ്ലോട്ട്-2d.png
plot-2d-with-error-bars.png
പ്ലോട്ട്-3d.png

നിങ്ങളുടെ പ്രിയപ്പെട്ട ഗ്രാഫിക്സ് വ്യൂവറിൽ നിങ്ങൾക്ക് ഈ ഗ്രാഫിക്സ് ഫയലുകൾ കാണാൻ കഴിയും. നിങ്ങൾക്ക് ജിമ്പ് ഉണ്ടെങ്കിൽ
നിങ്ങളുടെ മെഷീനിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്, ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും:

$ gimp പ്ലോട്ട്-2d.png
$ gimp plot-2d-with-error-bars.png
$ gimp പ്ലോട്ട്-3d.png

An ഉദാഹരണം 2-ഡൈമൻഷണൽ തന്ത്രം
ഇനിപ്പറയുന്ന 2-ഡൈമൻഷണൽ പ്ലോട്ട്
[ചിത്രം]

gnuplot-example.cc-ൽ നിന്നുള്ള ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്:

നെയിംസ്‌പെയ്‌സ് std ഉപയോഗിക്കുന്നു;

string fileNameWithNoExtension = "പ്ലോട്ട്-2d";
string graphicsFileName = fileNameWithNoExtension + ".png";
സ്ട്രിംഗ് plotFileName = fileNameWithNoExtension + ".plt";
string plotTitle = "2-D Plot";
string dataTitle = "2-D ഡാറ്റ";

// പ്ലോട്ട് ഉടനടി മാറ്റി അതിന്റെ ശീർഷകം സജ്ജമാക്കുക.
ഗ്നുപ്ലോട്ട് പ്ലോട്ട് (ഗ്രാഫിക്സ് ഫയൽ നെയിം);
plot.SetTitle (പ്ലോട്ട്ടൈറ്റിൽ);

// ഗ്രാഫിക്സ് ഫയൽ നിർമ്മിക്കുക, അത് പ്ലോട്ട് ഫയൽ സൃഷ്ടിക്കുമ്പോൾ അത് സൃഷ്ടിക്കും
// എന്നത് ഗ്നുപ്ലോട്ടിനൊപ്പം ഉപയോഗിക്കുന്നു, ഒരു PNG ഫയൽ ആകുക.
plot.SetTerminal ("png");

// ഓരോ അക്ഷത്തിനും ലേബലുകൾ സജ്ജമാക്കുക.
plot.SetLegend ("X മൂല്യങ്ങൾ", "Y മൂല്യങ്ങൾ");

// x അക്ഷത്തിനുള്ള ശ്രേണി സജ്ജമാക്കുക.
plot.AppendExtra ("സെറ്റ് xrange [-6:+6]");

// ഡാറ്റാസെറ്റ് ഉടനടി സ്ഥാപിക്കുക, അതിന്റെ ശീർഷകം സജ്ജമാക്കുക, പോയിന്റുകൾ ആക്കുക
// ബന്ധിപ്പിക്കുന്ന ലൈനുകൾക്കൊപ്പം പ്ലോട്ട് ചെയ്തിരിക്കുന്നു.
Gnuplot2dDataset ഡാറ്റാസെറ്റ്;
dataset.SetTitle (dataTitle);
dataset.SetStyle (Gnuplot2dDataset::LINES_POINTS);

ഇരട്ട x;
ഇരട്ട y;

// 2-D ഡാറ്റാസെറ്റ് സൃഷ്‌ടിക്കുക.
ഇതിനായി (x = -5.0; x <= +5.0; x += 1.0)
{
// 2-D കർവ് കണക്കാക്കുക
//
// 2
// y = x.
//
y = x * x;

// ഈ പോയിന്റ് ചേർക്കുക.
ഡാറ്റാസെറ്റ്.ചേർക്കുക (x, y);
}

// പ്ലോട്ടിലേക്ക് ഡാറ്റാസെറ്റ് ചേർക്കുക.
plot.AddDataset (ഡാറ്റസെറ്റ്);

// പ്ലോട്ട് ഫയൽ തുറക്കുക.
ഓഫ്സ്ട്രീം പ്ലോട്ട്ഫയൽ (plotFileName.c_str());

// പ്ലോട്ട് ഫയൽ എഴുതുക.
plot.GenerateOutput (പ്ലോട്ട്ഫയൽ);

// പ്ലോട്ട് ഫയൽ അടയ്ക്കുക.
plotFile.close ();

An ഉദാഹരണം 2-ഡൈമൻഷണൽ തന്ത്രം കൂടെ പിശക് ബാറുകൾ
x, y ദിശകളിൽ പിശക് ബാറുകളുള്ള ഇനിപ്പറയുന്ന 2-ഡൈമൻഷണൽ പ്ലോട്ട്
[ചിത്രം]

gnuplot-example.cc-ൽ നിന്നുള്ള ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്:

നെയിംസ്‌പെയ്‌സ് std ഉപയോഗിക്കുന്നു;

string fileNameWithNoExtension = "plot-2d-with-error-bars";
string graphicsFileName = fileNameWithNoExtension + ".png";
സ്ട്രിംഗ് plotFileName = fileNameWithNoExtension + ".plt";
string plotTitle = "2-D Plot with Error Bars";
string dataTitle = "പിശക് ബാറുകളുള്ള 2-D ഡാറ്റ";

// പ്ലോട്ട് ഉടനടി മാറ്റി അതിന്റെ ശീർഷകം സജ്ജമാക്കുക.
ഗ്നുപ്ലോട്ട് പ്ലോട്ട് (ഗ്രാഫിക്സ് ഫയൽ നെയിം);
plot.SetTitle (പ്ലോട്ട്ടൈറ്റിൽ);

// ഗ്രാഫിക്സ് ഫയൽ നിർമ്മിക്കുക, അത് പ്ലോട്ട് ഫയൽ സൃഷ്ടിക്കുമ്പോൾ അത് സൃഷ്ടിക്കും
// എന്നത് ഗ്നുപ്ലോട്ടിനൊപ്പം ഉപയോഗിക്കുന്നു, ഒരു PNG ഫയൽ ആകുക.
plot.SetTerminal ("png");

// ഓരോ അക്ഷത്തിനും ലേബലുകൾ സജ്ജമാക്കുക.
plot.SetLegend ("X മൂല്യങ്ങൾ", "Y മൂല്യങ്ങൾ");

// x അക്ഷത്തിനുള്ള ശ്രേണി സജ്ജമാക്കുക.
plot.AppendExtra ("സെറ്റ് xrange [-6:+6]");

// ഡാറ്റാസെറ്റ് ഉടനടി സ്ഥാപിക്കുക, അതിന്റെ ശീർഷകം സജ്ജമാക്കുക, പോയിന്റുകൾ ആക്കുക
// ബന്ധിപ്പിക്കുന്ന ലൈനുകളില്ലാതെ പ്ലോട്ട് ചെയ്‌തിരിക്കുന്നു.
Gnuplot2dDataset ഡാറ്റാസെറ്റ്;
dataset.SetTitle (dataTitle);
dataset.SetStyle (Gnuplot2dDataset::POINTS);

// ഡാറ്റാസെറ്റിന് x, y ദിശകളിൽ പിശക് ബാറുകൾ ഉള്ളതാക്കുക.
dataset.SetErrorBars (Gnuplot2dDataset::XY);

ഇരട്ട x;
ഇരട്ട xErrorDelta;
ഇരട്ട y;
ഇരട്ട yErrorDelta;

// 2-D ഡാറ്റാസെറ്റ് സൃഷ്‌ടിക്കുക.
ഇതിനായി (x = -5.0; x <= +5.0; x += 1.0)
{
// 2-D കർവ് കണക്കാക്കുക
//
// 2
// y = x.
//
y = x * x;

// x ദിശയിലുള്ള അനിശ്ചിതത്വം സ്ഥിരമാക്കി മാറ്റുക
// y ദിശയിലെ അനിശ്ചിതത്വം സ്ഥിരമായ ഒരു ഭാഗമാണ്
// y യുടെ മൂല്യം.
xErrorDelta = 0.25;
yErrorDelta = 0.1 * y;

// x, y എന്നിവയിലെ അനിശ്ചിതത്വങ്ങൾക്കൊപ്പം ഈ പോയിന്റ് ചേർക്കുക
// സംവിധാനം.
dataset.Add (x, y, xErrorDelta, yErrorDelta);
}

// പ്ലോട്ടിലേക്ക് ഡാറ്റാസെറ്റ് ചേർക്കുക.
plot.AddDataset (ഡാറ്റസെറ്റ്);

// പ്ലോട്ട് ഫയൽ തുറക്കുക.
ഓഫ്സ്ട്രീം പ്ലോട്ട്ഫയൽ (plotFileName.c_str());

// പ്ലോട്ട് ഫയൽ എഴുതുക.
plot.GenerateOutput (പ്ലോട്ട്ഫയൽ);

// പ്ലോട്ട് ഫയൽ അടയ്ക്കുക.
plotFile.close ();

An ഉദാഹരണം 3-ഡൈമൻഷണൽ തന്ത്രം
ഇനിപ്പറയുന്ന 3-ഡൈമൻഷണൽ പ്ലോട്ട്
[ചിത്രം]

gnuplot-example.cc-ൽ നിന്നുള്ള ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്:

നെയിംസ്‌പെയ്‌സ് std ഉപയോഗിക്കുന്നു;

string fileNameWithNoExtension = "പ്ലോട്ട്-3d";
string graphicsFileName = fileNameWithNoExtension + ".png";
സ്ട്രിംഗ് plotFileName = fileNameWithNoExtension + ".plt";
string plotTitle = "3-D Plot";
string dataTitle = "3-D ഡാറ്റ";

// പ്ലോട്ട് ഉടനടി മാറ്റി അതിന്റെ ശീർഷകം സജ്ജമാക്കുക.
ഗ്നുപ്ലോട്ട് പ്ലോട്ട് (ഗ്രാഫിക്സ് ഫയൽ നെയിം);
plot.SetTitle (പ്ലോട്ട്ടൈറ്റിൽ);

// ഗ്രാഫിക്സ് ഫയൽ നിർമ്മിക്കുക, അത് പ്ലോട്ട് ഫയൽ സൃഷ്ടിക്കുമ്പോൾ അത് സൃഷ്ടിക്കും
// എന്നത് ഗ്നുപ്ലോട്ടിനൊപ്പം ഉപയോഗിക്കുന്നു, ഒരു PNG ഫയൽ ആകുക.
plot.SetTerminal ("png");

// പ്ലോട്ട് x അക്ഷത്തിന് ചുറ്റും 30 ഡിഗ്രി തിരിക്കുക, തുടർന്ന് തിരിക്കുക
// പുതിയ z അക്ഷത്തിന് ചുറ്റും 120 ഡിഗ്രി പ്ലോട്ട് ചെയ്യുക.
plot.AppendExtra ("സെറ്റ് വ്യൂ 30, 120, 1.0, 1.0");

// z-അക്ഷത്തിനുള്ള പൂജ്യം x-അക്ഷത്തിലും y-ആക്സിസ് തലത്തിലും ആക്കുക.
plot.AppendExtra ("സെറ്റ് ticslevel 0");

// ഓരോ അക്ഷത്തിനും ലേബലുകൾ സജ്ജമാക്കുക.
plot.AppendExtra ("xlabel 'X മൂല്യങ്ങൾ' സജ്ജമാക്കുക");
plot.AppendExtra ("ylabel 'Y മൂല്യങ്ങൾ' സജ്ജമാക്കുക");
plot.AppendExtra ("zlabel 'Z മൂല്യങ്ങൾ' സജ്ജമാക്കുക");

// x, y അക്ഷങ്ങൾക്കുള്ള ശ്രേണികൾ സജ്ജമാക്കുക.
plot.AppendExtra ("സെറ്റ് xrange [-5:+5]");
plot.AppendExtra ("സെറ്റ് yrange [-5:+5]");

// ഡാറ്റാസെറ്റ് ഉടനടി സ്ഥാപിക്കുക, അതിന്റെ ശീർഷകം സജ്ജമാക്കുക, പോയിന്റുകൾ ആക്കുക
// വരികൾ വഴി ബന്ധിപ്പിച്ചിരിക്കുന്നു.
Gnuplot3dDataset ഡാറ്റാസെറ്റ്;
dataset.SetTitle (dataTitle);
dataset.SetStyle ("വരികൾക്കൊപ്പം");

ഇരട്ട x;
ഇരട്ട y;
ഇരട്ട z;

// 3-D ഡാറ്റാസെറ്റ് സൃഷ്‌ടിക്കുക.
ഇതിനായി (x = -5.0; x <= +5.0; x += 1.0)
{
വേണ്ടി (y = -5.0; y <= +5.0; y += 1.0)
{
// 3-D ഉപരിതലം കണക്കാക്കുക
//
// 2 2
// z = x * y .
//
z = x * x * y * y;

// ഈ പോയിന്റ് ചേർക്കുക.
ഡാറ്റാസെറ്റ്.ചേർക്കുക (x, y, z);
}

// ഓരോ x മൂല്യത്തിന്റെയും ഡാറ്റയുടെ അവസാനം ബ്ലാങ്ക് ലൈൻ ആവശ്യമാണ്
3-D ഉപരിതല ഗ്രിഡ് പ്രവർത്തിക്കാനുള്ള പോയിന്റുകൾ.
dataset.AddEmptyLine ();
}

// പ്ലോട്ടിലേക്ക് ഡാറ്റാസെറ്റ് ചേർക്കുക.
plot.AddDataset (ഡാറ്റസെറ്റ്);

// പ്ലോട്ട് ഫയൽ തുറക്കുക.
ഓഫ്സ്ട്രീം പ്ലോട്ട്ഫയൽ (plotFileName.c_str());

// പ്ലോട്ട് ഫയൽ എഴുതുക.
plot.GenerateOutput (പ്ലോട്ട്ഫയൽ);

// പ്ലോട്ട് ഫയൽ അടയ്ക്കുക.
plotFile.close ();

ഉപയോഗിക്കുന്നു പൈത്തൺ ലേക്ക് പ്രവർത്തിപ്പിക്കുക ns-3
പൈത്തൺ ബൈൻഡിംഗുകൾ C++ കോഡ് അനുവദിക്കുന്നു ns-3 പൈത്തണിൽ നിന്ന് വിളിക്കണം.

പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ഈ അധ്യായം കാണിച്ചുതരുന്നു ns-3 ഒപ്പം അത്
ഒരു C++ നായി പൈത്തൺ ബൈൻഡിംഗുകൾ സൃഷ്ടിക്കുന്ന പ്രക്രിയ ns-3 ഘടകം.

അവതാരിക
പൈത്തൺ ബൈൻഡിംഗുകളുടെ ലക്ഷ്യം ns-3 രണ്ട് മടങ്ങ് ആകുന്നു:

1. പൈത്തണിൽ സമ്പൂർണ്ണ സിമുലേഷൻ സ്ക്രിപ്റ്റുകൾ എഴുതാൻ പ്രോഗ്രാമറെ അനുവദിക്കുക (-
http://www.python.org);

2. പുതിയ മോഡലുകൾ പ്രോട്ടോടൈപ്പ് ചെയ്യുക (ഉദാ. റൂട്ടിംഗ് പ്രോട്ടോക്കോളുകൾ).

തൽക്കാലം, ബൈൻഡിംഗുകളുടെ പ്രാഥമിക ശ്രദ്ധ ആദ്യ ലക്ഷ്യമാണ്, എന്നാൽ രണ്ടാമത്തേത്
ലക്ഷ്യവും ഒടുവിൽ പിന്തുണയ്ക്കപ്പെടും. പൈത്തൺ ബൈൻഡിംഗുകൾ ns-3 വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്നു
PyBindGen എന്ന പുതിയ ഉപകരണം ഉപയോഗിക്കുന്നു (http://code.google.com/p/pybindgen).

An ഉദാഹരണം പൈത്തൺ സ്ക്രിപ്റ്റ് ആ റൺസ് ns-3
പൈത്തണിൽ എഴുതിയതും പ്രവർത്തിക്കുന്നതുമായ ചില ഉദാഹരണ കോഡ് ഇതാ ns-3, എഴുതിയിരിക്കുന്നത്
C++ ൽ. ഈ പൈത്തൺ ഉദാഹരണം ഇതിൽ കാണാം ഉദാഹരണങ്ങൾ/tutorial/first.py:

ns.applications ഇറക്കുമതി ചെയ്യുക
ഇറക്കുമതി ns.core
ഇറക്കുമതി ns.internet
ns.network ഇറക്കുമതി ചെയ്യുക
ഇറക്കുമതി ns.point_to_point

ns.core.LogComponentEnable("UdpEchoClientApplication", ns.core.LOG_LEVEL_INFO)
ns.core.LogComponentEnable("UdpEchoServerApplication", ns.core.LOG_LEVEL_INFO)

നോഡുകൾ = ns.network.NodeContainer()
നോഡുകൾ.സൃഷ്ടിക്കുക(2)

pointToPoint = ns.point_to_point.PointToPointHelper()
pointToPoint.SetDeviceAttribute("DataRate", ns.core.StringValue("5Mbps"))
pointToPoint.SetChannelAttribute("Delay", ns.core.StringValue("2ms"))

ഉപകരണങ്ങൾ = pointToPoint.Install(nodes)

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

വിലാസം = ns.internet.Ipv4AddressHelper()
വിലാസം.SetBase(ns.network.Ipv4Address("10.1.1.0"), ns.network.Ipv4Mask("255.255.255.0"))

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

echoServer = ns.applications.UdpEchoServerHelper(9)

serverApps = echoServer.Install(നോഡുകൾ.നേടുക(1))
serverApps.Start(ns.core.Seconds(1.0))
serverApps.Stop(ns.core.Seconds(10.0))

echoClient = ns.applications.UdpEchoClientHelper(ഇന്റർഫേസുകൾ.GetAddress(1), 9)
echoClient.SetAttribute("MaxPackets", ns.core.UintegerValue(1))
echoClient.SetAttribute("ഇന്റർവെൽ", ns.core.TimeValue(ns.core.Seconds (1.0)))
echoClient.SetAttribute("PacketSize", ns.core.UintegerValue(1024))

clientApps = echoClient.Install(നോഡുകൾ.നേടുക(0))
clientApps.Start(ns.core.Seconds(2.0))
clientApps.Stop(ns.core.Seconds(10.0))

ns.core.Simulator.Run()
ns.core.Simulator.Destroy()

പ്രവർത്തിക്കുന്ന പൈത്തൺ സ്ക്രിപ്റ്റുകൾ
ns3 കണ്ടെത്തുന്നതിന് പൈത്തൺ പാത സ്വയമേവ അപ്ഡേറ്റ് ചെയ്യുന്ന ചില ഓപ്ഷനുകൾ waf-ൽ അടങ്ങിയിരിക്കുന്നു
മൊഡ്യൂൾ. ഉദാഹരണ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന്, ഇത് പരിപാലിക്കാൻ വാഫ് ഉപയോഗിക്കുന്നതിന് രണ്ട് വഴികളുണ്ട്. ഒന്ന്
ഒരു വാഫ് ഷെൽ പ്രവർത്തിപ്പിക്കുക എന്നതാണ്; ഉദാ:

$ ./waf --shell
$ പൈത്തൺ ഉദാഹരണങ്ങൾ/wireless/mixed-wireless.py

മറ്റൊന്ന് waf-ലേക്ക് --pyrun ഓപ്ഷൻ ഉപയോഗിക്കുക എന്നതാണ്:

$ ./waf --pyrun ഉദാഹരണങ്ങൾ/wireless/mixed-wireless.py

സി ഡീബഗ്ഗറിന് കീഴിൽ ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ:

$ ./waf --shell
$ gdb --args പൈത്തൺ ഉദാഹരണങ്ങൾ/wireless/mixed-wireless.py

വിളിക്കുന്ന നിങ്ങളുടെ സ്വന്തം പൈത്തൺ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ ns-3 അതിന് ഈ പാതയുണ്ട്,
/path/to/your/example/my-script.py, ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ ./waf --shell
$ python /path/to/your/example/my-script.py

ഷാവേസ്
പൈത്തൺ ബൈൻഡിംഗുകൾ ns-3 ഒരു ജോലി പുരോഗമിക്കുകയാണ്, ചില പരിമിതികൾ അറിയപ്പെടുന്നു
ഡെവലപ്പർമാർ. ഈ പരിമിതികളിൽ ചിലത് (എല്ലാം അല്ല) ഇവിടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു.

അപൂർണ്ണം കവറേജ്
ഒന്നാമതായി, API-യുടെ 100% പൈത്തണിൽ പിന്തുണയ്‌ക്കുന്നില്ല എന്നത് ഓർമ്മിക്കുക. ചില
കാരണങ്ങൾ ഇവയാണ്:

1. ചില API-കളിൽ പോയിന്ററുകൾ ഉൾപ്പെടുന്നു, അവയ്ക്ക് ഏത് തരത്തിലുള്ള മെമ്മറിയെക്കുറിച്ചുള്ള അറിവ് ആവശ്യമാണ്
സെമാന്റിക്സ് കടന്നുപോകുന്നു (ആരുടെ ഉടമസ്ഥതയിലുള്ള മെമ്മറി). അത്തരം അറിവ് പ്രവർത്തനത്തിന്റെ ഭാഗമല്ല
ഒപ്പുകൾ, ഒന്നുകിൽ ഡോക്യുമെന്റ് ചെയ്തതോ ചിലപ്പോൾ രേഖപ്പെടുത്താത്തതോ ആണ്. വ്യാഖ്യാനങ്ങളാണ്
ആ പ്രവർത്തനങ്ങൾ ബന്ധിപ്പിക്കുന്നതിന് ആവശ്യമാണ്;

2. ചിലപ്പോൾ അസാധാരണമായ ഒരു അടിസ്ഥാന ഡാറ്റാ തരം അല്ലെങ്കിൽ C++ നിർമ്മാണം ഉപയോഗിക്കുന്നു, അത് ഇതുവരെ ഉപയോഗിച്ചിട്ടില്ല
PyBindGen പിന്തുണയ്ക്കുന്നു;

3. GCC-XML ടെംപ്ലേറ്റ് അധിഷ്‌ഠിത ക്ലാസുകൾ തൽക്ഷണം ചെയ്യാത്ത പക്ഷം റിപ്പോർട്ട് ചെയ്യുന്നില്ല.

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

പരിവർത്തന നിർമ്മാതാക്കൾ
പരിവർത്തന നിർമ്മാതാക്കൾ PyBindGen ഇതുവരെ പൂർണ്ണമായി പിന്തുണച്ചിട്ടില്ല, അവ എല്ലായ്പ്പോഴും പ്രവർത്തിക്കുന്നു
ഒരു API പൈത്തണിലേക്ക് വിവർത്തനം ചെയ്യുമ്പോൾ വ്യക്തമായ കൺസ്ട്രക്‌ടറുകൾ. ഉദാഹരണത്തിന്, C++ ൽ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയും
ഈ:

Ipv4AddressHelper ipAddrs;
ipAddrs.SetBase ("192.168.0.0", "255.255.255.0");
ipAddrs.Assign (backboneDevices);

പൈത്തണിൽ, തൽക്കാലം നിങ്ങൾ ചെയ്യേണ്ടത്:

ipAddrs = ns3.Ipv4AddressHelper()
ipAddrs.SetBase(ns3.Ipv4Address("192.168.0.0"), ns3.Ipv4Mask("255.255.255.0"))
ipAddrs.Assign(നട്ടെല്ലുള്ള ഉപകരണങ്ങൾ)

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

NUM_NODES_SIDE_DEFAULT = 3

cmd = ns3.CommandLine()

cmd.NumNodesSide = ഒന്നുമില്ല
cmd.AddValue("NumNodesSide", "ഗ്രിഡ് സൈഡ് നോഡുകളുടെ എണ്ണം (മൊത്തം നോഡുകളുടെ എണ്ണം ഈ സംഖ്യ സ്‌ക്വയർ ആയിരിക്കും)")

cmd.Parse(argv)

[...]

cmd.NumNodesSide ഒന്നുമല്ലെങ്കിൽ:
num_nodes_side = NUM_NODES_SIDE_DEFAULT
വേറെ:
num_nodes_side = int(cmd.NumNodesSide)

പിന്തുടരുന്നു
കോൾബാക്ക് അധിഷ്‌ഠിത ട്രെയ്‌സിംഗ് പുതിയതായി പൈത്തണിന് ഇതുവരെ ശരിയായി പിന്തുണയ്‌ക്കുന്നില്ല ns-3 API ആവശ്യമാണ്
ഇത് പിന്തുണയ്ക്കുന്നതിന് നൽകണം.

സാധാരണ API വഴി Pcap ഫയൽ റൈറ്റിംഗ് പിന്തുണയ്ക്കുന്നു.

Ascii ട്രെയ്‌സിംഗ് മുതൽ പിന്തുണയ്‌ക്കുന്നു ns-3.4 പൈത്തണിലേക്ക് വിവർത്തനം ചെയ്ത സാധാരണ C++ API വഴി.
എന്നിരുന്നാലും, ascii ട്രെയ്‌സിങ്ങിന് ആസ്കിയിലേക്ക് കടന്നുപോകാൻ ഒരു ഓസ്‌ട്രീം ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കേണ്ടതുണ്ട്
ട്രെയ്സിംഗ് രീതികൾ. പൈത്തണിൽ, C++ std::ofstream അനുവദിക്കുന്നതിനായി ചുരുങ്ങിയത് പൊതിഞ്ഞിരിക്കുന്നു
ഈ. ഉദാഹരണത്തിന്:

ascii = ns3.ofstream("wifi-ap.tr") # ഫയൽ സൃഷ്‌ടിക്കുക
ns3.YansWifiPhyHelper.AsciiAll(ascii)
ns3.സിമുലേറ്റർ.റൺ()
ns3.Simulator.Destroy()
ascii.close() # ഫയൽ അടയ്ക്കുക

ഒരു മുന്നറിയിപ്പ് ഉണ്ട്: ഫയൽ ഒബ്ജക്റ്റ് മാലിന്യം ശേഖരിക്കാൻ അനുവദിക്കരുത് ns-3
ഇപ്പോഴും അത് ഉപയോഗിക്കുന്നു. അതായത് മുകളിലുള്ള 'ascii' വേരിയബിൾ പോകാൻ അനുവദിക്കരുത് എന്നാണ്
പരിധിക്ക് പുറത്താണ് അല്ലെങ്കിൽ പ്രോഗ്രാം തകരാറിലാകും.

സിഗ്വിൻ പരിമിതി
പൈത്തൺ ബൈൻഡിംഗുകൾ സിഗ്വിനിൽ പ്രവർത്തിക്കില്ല. ഇത് ഒരു gccxml ബഗ് മൂലമാണ്.

സിഗ്വിനിനുള്ളിൽ നിന്ന് API നിർവചനങ്ങൾ വീണ്ടും സ്കാൻ ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് അതിൽ നിന്ന് രക്ഷപ്പെടാം
പരിസ്ഥിതി (./waf --പൈത്തൺ-സ്കാൻ). എന്നിരുന്നാലും ഏറ്റവും സാധ്യതയുള്ള പരിഹാരം ഒരുപക്ഷേ വേണ്ടിവരും
നമ്മൾ CygWin-ൽ പൈത്തൺ ബൈൻഡിംഗുകൾ പ്രവർത്തനരഹിതമാക്കുന്നു.

Windows-ലെ പൈത്തൺ ബൈൻഡിംഗിനെക്കുറിച്ച് നിങ്ങൾക്ക് ശരിക്കും താൽപ്പര്യമുണ്ടെങ്കിൽ, mingw, നേറ്റീവ് എന്നിവ ഉപയോഗിച്ച് നിർമ്മിക്കാൻ ശ്രമിക്കുക
പകരം പെരുമ്പാമ്പ്. അല്ലെങ്കിൽ, പൈത്തൺ ബൈൻഡിംഗുകൾ ഇല്ലാതെ നിർമ്മിക്കാൻ, പൈത്തൺ ബൈൻഡിംഗുകൾ പ്രവർത്തനരഹിതമാക്കുക
കോൺഫിഗറേഷൻ ഘട്ടം:

$ ./waf കോൺഫിഗർ ചെയ്യുക --disable-python

ജോലി കൂടെ പൈത്തൺ ബൈൻഡിംഗുകൾ
നിലവിൽ രണ്ട് തരത്തിലുള്ള പൈത്തൺ ബൈൻഡിംഗുകൾ ഉണ്ട് ns-3:

1. മോണോലിത്തിക്ക് ബൈൻഡിംഗുകളിൽ എല്ലാ മൊഡ്യൂളുകൾക്കുമുള്ള API നിർവചനങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അവയിൽ കണ്ടെത്താനാകും
ഒരൊറ്റ ഡയറക്ടറി, ബൈൻഡിംഗ്സ്/പൈത്തൺ.

2. മോഡുലാർ ബൈൻഡിംഗുകളിൽ ഒരൊറ്റ മൊഡ്യൂളിനായി API നിർവചനങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അവ ഓരോന്നിലും കണ്ടെത്താനാകും
മൊഡ്യൂളിന്റെ ബൈൻഡിംഗുകൾ ഡയറക്ടറി.

പൈത്തൺ ബൈൻഡിംഗുകൾ വർക്ക്ഫ്ലോ
പൈത്തൺ ബൈൻഡിംഗുകൾ കൈകാര്യം ചെയ്യുന്ന പ്രക്രിയ ഇനിപ്പറയുന്നതാണ്:

1. ആനുകാലികമായി ഒരു ഡവലപ്പർ GCC-XML ഉപയോഗിക്കുന്നു (http://www.gccxml.org) അടിസ്ഥാനമാക്കിയുള്ള API സ്കാനിംഗ്
സ്‌ക്രിപ്റ്റ്, സ്‌കാൻ ചെയ്‌ത API നിർവചനം ഇങ്ങനെ സംരക്ഷിക്കുന്നു ബൈൻഡിംഗുകൾ/പൈത്തൺ/ns3_module_*.py ഫയലുകൾ
അല്ലെങ്കിൽ ഓരോ മൊഡ്യൂളുകളിലും പൈത്തൺ ഫയലുകളായി' ബൈൻഡിംഗുകൾ ഡയറക്ടറി. ഈ ഫയലുകൾ താഴെ സൂക്ഷിച്ചിരിക്കുന്നു
പ്രധാനത്തിൽ പതിപ്പ് നിയന്ത്രണം ns-3 സംഭരണിയാണ്;

2. മറ്റ് ഡെവലപ്പർമാർ റിപ്പോസിറ്ററി ക്ലോൺ ചെയ്യുകയും ഇതിനകം സ്കാൻ ചെയ്ത API നിർവചനങ്ങൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നു;

3. കോൺഫിഗർ ചെയ്യുമ്പോൾ ns-3, ഇതിനകം ഇല്ലെങ്കിൽ pybindgen സ്വയമേവ ഡൗൺലോഡ് ചെയ്യപ്പെടും
ഇൻസ്റ്റാൾ ചെയ്തു. റിലീസ് ചെയ്തു ns-3 ടാർബോളുകൾ pybindgen ന്റെ ഒരു പകർപ്പ് അയയ്ക്കും.

പൈത്തൺ ബൈൻഡിംഗുകൾ കംപൈൽ ചെയ്യുന്നതിൽ എന്തെങ്കിലും തെറ്റ് സംഭവിക്കുകയും നിങ്ങൾ അവ അവഗണിക്കുകയും ചെയ്യുകയാണെങ്കിൽ
കൂടാതെ C++ ഉപയോഗിച്ച് മുന്നോട്ട് പോകുക, നിങ്ങൾക്ക് ഇതുപയോഗിച്ച് പൈത്തൺ പ്രവർത്തനരഹിതമാക്കാം:

$ ./waf --disable-python

നിർദ്ദേശങ്ങൾ വേണ്ടി കൈകാര്യം പുതിയ ഫയലുകൾ or മാറി API- കൾ
അതിനാൽ നിങ്ങൾ നിലവിലുള്ളത് മാറ്റുകയാണ് ns-3 API-കളും പൈത്തൺ ബൈൻഡിംഗുകളും ഇനി കംപൈൽ ചെയ്യുന്നില്ലേ? ചെയ്യുക
നിരാശപ്പെടരുത്, മാറ്റങ്ങൾ പ്രതിഫലിപ്പിക്കുന്ന പുതിയ ബൈൻഡിംഗുകൾ സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് ബൈൻഡിംഗുകൾ പുനഃസ്ഥാപിക്കാം
ലേക്ക് ns-3 API.

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

മോണോലിത്തിക്ക് പൈത്തൺ ബൈൻഡിംഗുകൾ
സ്കാൻ ചെയ്യുന്നു The മോണോലിത്തിക്ക് പൈത്തൺ ബൈൻഡിംഗുകൾ
മോണോലിത്തിക്ക് പൈത്തൺ ബൈൻഡിംഗുകൾ സ്കാൻ ചെയ്യുന്നതിന് ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ ./waf --പൈത്തൺ-സ്കാൻ

സംഘടന of The മോണോലിത്തിക്ക് പൈത്തൺ ബൈൻഡിംഗുകൾ
മോണോലിത്തിക്ക് പൈത്തൺ API നിർവചനങ്ങൾ ഇനിപ്പറയുന്ന രീതിയിൽ ക്രമീകരിച്ചിരിക്കുന്നു. ഓരോന്നിനും ns-3 മൊഡ്യൂൾ
, ഫയല് ബൈൻഡിംഗുകൾ/പൈത്തൺ/ns3_module_ .py അതിന്റെ API വിവരിക്കുന്നു. അവയിൽ ഓരോന്നും
ഫയലുകൾക്ക് 3 ടോപ്ലെവൽ ഫംഗ്ഷനുകൾ ഉണ്ട്:

1. മാഷ് രജിസ്റ്റർ_തരം(മൊഡ്യൂൾ)(): ഈ ഫംഗ്‌ഷൻ പുതിയ തരങ്ങൾ രജിസ്റ്റർ ചെയ്യുന്നത് ശ്രദ്ധിക്കുന്നു (ഉദാ
C++ ക്ലാസുകൾ, enums) താ മൊഡ്യൂളിൽ നിർവചിച്ചിരിക്കുന്നത്;

2. മാഷ് രജിസ്റ്റർ_രീതികൾ(മൊഡ്യൂൾ)(): ഈ ഫംഗ്ഷൻ ഓരോ ക്ലാസിനും വിളിക്കുന്നു , മറ്റൊന്ന്
ഫംഗ്‌ഷൻ രജിസ്റ്റർ_മെഥോഡ്‌സ്_എൻഎസ്3 (മൊഡ്യൂൾ). ഈ പിന്നീടുള്ള ഫംഗ്‌ഷനുകൾ രീതി ചേർക്കുന്നു
ഓരോ ക്ലാസിനുമുള്ള നിർവചനങ്ങൾ;

3. മാഷ് രജിസ്റ്റർ_പ്രവർത്തനങ്ങൾ(മൊഡ്യൂൾ)(): ഈ ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുന്നു ns-3 ഉൾപ്പെടുന്ന പ്രവർത്തനങ്ങൾ
ആ മൊഡ്യൂൾ.

മൊഡ്യുളർ പൈത്തൺ ബൈൻഡിംഗുകൾ
പൊതു അവലോകനം
ns 3.11 മുതൽ, പഴയ മോണോലിത്തിക്ക് സമാന്തരമായി മോഡുലാർ ബൈൻഡിംഗുകൾ ചേർക്കുന്നു.
ബന്ധനങ്ങൾ.

പുതിയ പൈത്തൺ ബൈൻഡിംഗുകൾ പഴയതിന് 'ns3' എന്നതിനുപകരം ഒരു 'ns' നെയിംസ്പേസിലേക്ക് ജനറേറ്റുചെയ്യുന്നു.
ബന്ധനങ്ങൾ. ഉദാഹരണം:

ns.network ഇറക്കുമതി നോഡിൽ നിന്ന്
n1 = നോഡ്()

മോഡുലാർ പൈത്തൺ ബൈൻഡിംഗുകൾക്കൊപ്പം:

1. ഓരോന്നിനും ഒരു പ്രത്യേക പൈത്തൺ എക്സ്റ്റൻഷൻ മൊഡ്യൂൾ ഉണ്ട് ns-3 മൊഡ്യൂൾ;

2. എപിഐ നിർവചനങ്ങൾ (അപിഡെഫുകൾ) സ്കാൻ ചെയ്യുന്നത് ഓരോ എൻഎസ് മൊഡ്യൂൾ അടിസ്ഥാനത്തിലാണ്;

3. ഓരോ മൊഡ്യൂളിന്റെയും apidefs ഫയലുകൾ മൊഡ്യൂളിന്റെ ഒരു 'ബൈൻഡിംഗ്സ്' ഉപഡയറക്‌ടറിയിൽ സംഭരിച്ചിരിക്കുന്നു.
ഡയറക്ടറി;

സ്കാൻ ചെയ്യുന്നു The മൊഡ്യുളർ പൈത്തൺ ബൈൻഡിംഗുകൾ
കോർ മൊഡ്യൂളിനായി മോഡുലാർ പൈത്തൺ ബൈൻഡിംഗുകൾ സ്കാൻ ചെയ്യുന്നതിന്, ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ ./waf --apiscan=core

എല്ലാ മൊഡ്യൂളുകൾക്കുമായി മോഡുലാർ പൈത്തൺ ബൈൻഡിംഗുകൾ സ്കാൻ ചെയ്യുന്നതിന്, ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ ./waf --apiscan=എല്ലാം

ഉണ്ടാക്കുന്നു a പുതിയ മൊഡ്യൂൾ
നിങ്ങൾ ഒരു പുതിയ മൊഡ്യൂൾ ചേർക്കുകയാണെങ്കിൽ, പൈത്തൺ ബൈൻഡിംഗുകൾ കംപൈൽ ചെയ്യുന്നത് തുടരും, പക്ഷേ അങ്ങനെ ചെയ്യില്ല
പുതിയ മൊഡ്യൂൾ മൂടുക.

ഒരു പുതിയ മൊഡ്യൂൾ കവർ ചെയ്യുന്നതിന്, നിങ്ങൾ ഒരു സൃഷ്ടിക്കേണ്ടതുണ്ട് ബൈൻഡിംഗുകൾ/പൈത്തൺ/ns3_module_ .py ഫയൽ,
മുമ്പത്തെ വിഭാഗങ്ങളിൽ വിവരിച്ചതിന് സമാനമായി, അത് വേരിയബിളിൽ രജിസ്റ്റർ ചെയ്യുക
LOCAL_MODULES() in ബൈൻഡിംഗുകൾ/പൈത്തൺ/ns3modulegen.py

ചേർക്കുന്നു മൊഡ്യുളർ ബൈൻഡിംഗുകൾ ലേക്ക് A നിലവിലുള്ള മൊഡ്യൂൾ
നിലവിലുള്ളതിലേക്ക് മോഡുലാർ ബൈൻഡിംഗുകൾക്കുള്ള പിന്തുണ ചേർക്കുന്നതിന് ns-3 മൊഡ്യൂൾ, ഇനിപ്പറയുന്നവ ചേർക്കുക
അതിന്റെ wscript ബിൽഡ്() ഫംഗ്‌ഷനിലേക്കുള്ള ലൈൻ:

bld.ns3_python_bindings()

സംഘടന of The മൊഡ്യുളർ പൈത്തൺ ബൈൻഡിംഗുകൾ
ദി src/ / ബന്ധനങ്ങൾ ഡയറക്ടറിയിൽ ഇനിപ്പറയുന്ന ഫയലുകൾ അടങ്ങിയിരിക്കാം, അവയിൽ ചിലത്
ഓപ്ഷണൽ:

· callbacks_list.py: ഇതൊരു സ്കാൻ ചെയ്ത ഫയലാണ്, തൊടരുത്. യുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു
കോൾബാക്ക്<...> ടെംപ്ലേറ്റ് സംഭവങ്ങൾ സ്കാൻ ചെയ്ത തലക്കെട്ടുകളിൽ കണ്ടെത്തി;

· modulegen__gcc_LP64.py: ഇതൊരു സ്കാൻ ചെയ്ത ഫയലാണ്, തൊടരുത്. സ്കാൻ ചെയ്ത API നിർവചനങ്ങൾ
GCC, LP64 ആർക്കിടെക്ചറിനായി (64-ബിറ്റ്)

· modulegen__gcc_ILP32.py: ഇതൊരു സ്കാൻ ചെയ്ത ഫയലാണ്, തൊടരുത്. സ്കാൻ ചെയ്ത API നിർവചനങ്ങൾ
GCC, ILP32 ആർക്കിടെക്ചറിനായി (32-ബിറ്റ്)

· modulegen_customizations.py: ഇഷ്‌ടാനുസൃതമാക്കുന്നതിന് നിങ്ങൾക്ക് ഈ ഫയൽ ഓപ്‌ഷണലായി ചേർക്കാവുന്നതാണ്
pybindgen കോഡ് ജനറേഷൻ

· സ്കാൻ-ഹെഡർ.എച്ച്: ഏത് തലക്കെട്ട് ഫയൽ സ്കാൻ ചെയ്യണമെന്ന് ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങൾക്ക് ഈ ഫയൽ ഓപ്ഷണലായി ചേർക്കാവുന്നതാണ്
മൊഡ്യൂളിനായി. അടിസ്ഥാനപരമായി ഈ ഫയൽ ns3/ ന് പകരം സ്കാൻ ചെയ്തിരിക്കുന്നു -module.h.
സാധാരണഗതിയിൽ, ആദ്യ പ്രസ്താവന #include "ns3/ -module.h", കൂടാതെ മറ്റു ചിലത്
ടെംപ്ലേറ്റ് ഇൻസ്റ്റിറ്റേഷനുകൾ നിർബന്ധമാക്കാനുള്ള സ്റ്റഫ്;

· module_helpers.cc: പൈത്തണിലേക്ക് ലിങ്ക് ചെയ്യുന്നതിനായി ഇതുപോലുള്ള അധിക ഫയലുകൾ നിങ്ങൾക്ക് ചേർക്കാവുന്നതാണ്
എക്സ്റ്റൻഷൻ മൊഡ്യൂൾ, പക്ഷേ അവ wscript-ൽ രജിസ്റ്റർ ചെയ്യണം. നോക്കൂ
src/core/wscript എങ്ങനെ ചെയ്യണം എന്നതിന്റെ ഒരു ഉദാഹരണം;

· .py: ഈ ഫയൽ നിലവിലുണ്ടെങ്കിൽ, അത് ns3-നുള്ള "ഫ്രണ്ടെൻഡ്" പൈത്തൺ മൊഡ്യൂളായി മാറുന്നു.
മൊഡ്യൂൾ, ഒപ്പം എക്സ്റ്റൻഷൻ മൊഡ്യൂൾ (.so ഫയൽ) _ ആയി മാറുന്നു .അതിനാൽ പകരം .അങ്ങനെ.
ദി .py ഫയൽ മൊഡ്യൂളിൽ നിന്ന് എല്ലാ ചിഹ്നങ്ങളും ഇറക്കുമതി ചെയ്യണം _ (ഇത് കൂടുതൽ
തോന്നുന്നതിലും ബുദ്ധിമുട്ടാണ്, ഉദാഹരണത്തിനായി src/core/bindings/core.py കാണുക), തുടർന്ന് ചേർക്കാം
ചില അധിക പ്യുവർ-പൈത്തൺ നിർവചനങ്ങൾ.

കൂടുതൽ വിവരം വേണ്ടി ഡെവലപ്പർമാർ
നിങ്ങൾ ഒരു ഡെവലപ്പർ ആണെങ്കിൽ, കൂടുതൽ വിവരങ്ങൾ ആവശ്യമുണ്ടെങ്കിൽ ns-3ന്റെ പൈത്തൺ ബൈൻഡിംഗുകൾ, ദയവായി കാണുക
പൈത്തൺ ബൈൻഡിംഗുകൾ വിക്കി പേജ്.

ടെസ്റ്റുകൾ
പൊതു അവലോകനം
ഈ ഡോക്യുമെന്റിന്റെ പരിശോധനയും സാധൂകരണവും സംബന്ധിച്ചുള്ളതാണ് ns-3 സോഫ്റ്റ്വെയർ.

ഈ പ്രമാണം നൽകുന്നു

· ടെർമിനോളജി, സോഫ്റ്റ്‌വെയർ ടെസ്റ്റിംഗ് എന്നിവയെ കുറിച്ചുള്ള പശ്ചാത്തലം (അധ്യായം 2);

· ns-3 ടെസ്റ്റിംഗ് ചട്ടക്കൂടിന്റെ ഒരു വിവരണം (അധ്യായം 3);

മോഡൽ ഡെവലപ്പർമാർക്കോ പുതിയ മോഡൽ സംഭാവകർക്കോ എങ്ങനെ ടെസ്റ്റുകൾ എഴുതാം എന്നതിനുള്ള ഒരു ഗൈഡ് (അധ്യായം
4);

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

പശ്ചാത്തലം
ഈ അധ്യായം കഴിയുക be ഒഴിവാക്കി by വായനക്കാർ പരിചിതമായ കൂടെ The അടിസ്ഥാനകാര്യങ്ങൾ of സോഫ്റ്റ്വെയർ പരിശോധന.

വൈകല്യങ്ങളില്ലാത്ത സോഫ്‌റ്റ്‌വെയർ എഴുതുന്നത് ബുദ്ധിമുട്ടുള്ള ഒരു നിർദ്ദേശമാണ്. എന്നതിന് പല മാനങ്ങളുണ്ട്
പ്രശ്‌നം കൂടാതെ വ്യത്യസ്ത പദങ്ങൾ കൊണ്ട് എന്താണ് അർത്ഥമാക്കുന്നത് എന്നതിനെക്കുറിച്ച് വളരെയധികം ആശയക്കുഴപ്പമുണ്ട്
വ്യത്യസ്ത സന്ദർഭങ്ങൾ. അവലോകനം ചെയ്യാൻ കുറച്ച് സമയം ചെലവഴിക്കുന്നത് മൂല്യവത്താണെന്ന് ഞങ്ങൾ കണ്ടെത്തി
വിഷയവും ചില നിബന്ധനകളും നിർവചിക്കുന്നു.

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

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

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

ദി ns-3 പ്രോജക്റ്റ് ഈ പ്രക്രിയകളിലൊന്നിന് വേണ്ടി വാദിക്കുന്ന ബിസിനസ്സിലല്ല, പക്ഷേ
പ്രോജക്റ്റിന് മൊത്തത്തിൽ ടെസ്റ്റ് പ്രക്രിയയെ അറിയിക്കാൻ സഹായിക്കുന്ന ആവശ്യകതകളുണ്ട്.

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

ശരിയാണ്
ഒരു സോഫ്‌റ്റ്‌വെയർ പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കുക എന്നതാണ് ടെസ്റ്റിംഗിന്റെ പ്രധാന ലക്ഷ്യം
''ശരിയായി.'' വേണ്ടി ns-3 ഇതിനർത്ഥം നമ്മൾ എന്തെങ്കിലും അനുകരിക്കുകയാണെങ്കിൽ, സിമുലേഷൻ ചെയ്യണം എന്നാണ്
ഒരു നിശ്ചിത കൃത്യതയിലേക്ക് ചില ഭൗതിക അസ്തിത്വത്തെയോ പ്രക്രിയയെയോ വിശ്വസ്തതയോടെ പ്രതിനിധീകരിക്കുന്നു
കൃത്യത.

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

മൂല്യനിർണ്ണയം ഒപ്പം പരിശോധന
ഒരു കമ്പ്യൂട്ടർ മോഡൽ എന്തിന്റെയെങ്കിലും ഗണിതശാസ്ത്രപരമായ അല്ലെങ്കിൽ ലോജിക്കൽ പ്രാതിനിധ്യമാണ്. ഇതിന് കഴിയും
ഒരു വാഹനം, ആനയെ പ്രതിനിധീകരിക്കുന്നു (കാണുക ദാവീദ് ഹരേലിന്റെ സംവാദം കുറിച്ച് മോഡലിംഗ് an ആന at
SIMUTools 2009, അല്ലെങ്കിൽ ഒരു നെറ്റ്‌വർക്കിംഗ് കാർഡ്. മോഡലുകൾക്ക് ആഗോളം പോലുള്ള പ്രക്രിയകളെ പ്രതിനിധീകരിക്കാനും കഴിയും
ചൂടാക്കൽ, ഫ്രീവേ ട്രാഫിക് ഫ്ലോ അല്ലെങ്കിൽ ഒരു നെറ്റ്‌വർക്കിംഗ് പ്രോട്ടോക്കോളിന്റെ ഒരു സ്പെസിഫിക്കേഷൻ. മോഡലുകൾ ആകാം
ഒരു ലോജിക്കൽ പ്രോസസ് സ്പെസിഫിക്കേഷന്റെ പൂർണ്ണമായും വിശ്വസ്തമായ പ്രതിനിധാനങ്ങൾ, പക്ഷേ അവ
ഒരു ഭൗതിക വസ്തുവിനെയോ പ്രക്രിയയെയോ പൂർണ്ണമായി അനുകരിക്കാൻ കഴിയില്ല. മിക്ക കേസുകളിലും, എ
കംപ്യൂട്ടേഷണലായി സിമുലേഷൻ നടത്തുന്നതിന് മോഡലിന് നിരവധി ലളിതവൽക്കരണങ്ങൾ വരുത്തിയിട്ടുണ്ട്
വലിച്ചെടുക്കാവുന്ന.

ഓരോ മോഡലിനും എ ലക്ഷ്യം സിസ്റ്റം അത് അനുകരിക്കാൻ ശ്രമിക്കുകയാണെന്ന്. ആദ്യപടി
ഒരു സിമുലേഷൻ മോഡൽ സൃഷ്ടിക്കുന്നത് ഈ ടാർഗെറ്റ് സിസ്റ്റവും വിശദാംശങ്ങളുടെ നിലവാരവും തിരിച്ചറിയുന്നതിനാണ്
സിമുലേഷൻ പുനർനിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്ന കൃത്യത. ഒരു ലോജിക്കൽ പ്രക്രിയയുടെ കാര്യത്തിൽ,
ടാർഗെറ്റ് സിസ്റ്റം "ആർഎഫ്‌സി 793 നിർവ്വചിച്ചിരിക്കുന്ന ടിസിപി" ആയി തിരിച്ചറിയാം. ഈ സാഹചര്യത്തിൽ, ഇത്
RFC പൂർണ്ണമായും വിശ്വസ്തമായും പുനർനിർമ്മിക്കുന്ന ഒരു മോഡൽ സൃഷ്ടിക്കുന്നത് ഒരുപക്ഷേ അഭികാമ്യമായിരിക്കും
793. ഒരു ശാരീരിക പ്രക്രിയയുടെ കാര്യത്തിൽ ഇത് സാധ്യമല്ല. എങ്കിൽ, ഉദാഹരണത്തിന്, നിങ്ങൾ
ഒരു വയർലെസ് നെറ്റ്‌വർക്കിംഗ് കാർഡ് അനുകരിക്കാൻ ആഗ്രഹിക്കുന്നു, നിങ്ങൾക്ക് ആവശ്യമുണ്ടെന്ന് നിങ്ങൾക്ക് നിർണ്ണയിക്കാവുന്നതാണ്, ''ഒരു
802.11 സ്പെസിഫിക്കേഷന്റെ കൃത്യമായ MAC-ലെവൽ നിർവ്വഹണവും [...] അത്ര മന്ദഗതിയിലല്ല
802.11a സ്പെസിഫിക്കേഷന്റെ PHY-ലെവൽ മോഡൽ.''

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

ഈ അമൂർത്ത മാതൃക പിന്നീട് ഒരു ആയി വികസിപ്പിച്ചെടുക്കുന്നു ns-3 അമൂർത്തമായത് നടപ്പിലാക്കുന്ന മാതൃക
ഒരു കമ്പ്യൂട്ടർ പ്രോഗ്രാമായി മോഡൽ. ഇതിനോട് യോജിക്കുന്ന തരത്തിൽ നടപ്പിലാക്കൽ പ്രക്രിയ
അമൂർത്ത മാതൃക എന്ന് വിളിക്കുന്നു മാതൃക പരിശോധന സാഹിത്യത്തിൽ.

ഇതുവരെയുള്ള പ്രക്രിയ ഓപ്പൺ ലൂപ്പാണ്. നൽകിയിരിക്കുന്ന ns-3 എന്ന് തീരുമാനിക്കുക എന്നതാണ് അവശേഷിക്കുന്നത്
മോഡലിന് ചില യാഥാർത്ഥ്യങ്ങളുമായി ബന്ധമുണ്ട് -- ഒരു മോഡൽ അതിന്റെ കൃത്യമായ പ്രതിനിധാനമാണ്
ഒരു യഥാർത്ഥ സിസ്റ്റം, ഒരു ലോജിക്കൽ പ്രോസസ് അല്ലെങ്കിൽ ഒരു ഫിസിക്കൽ എന്റിറ്റി.

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

ദി ns-3 ടെസ്റ്റിംഗ് എൻവയോൺമെന്റ് മോഡൽ മൂല്യനിർണ്ണയത്തിനും രണ്ടും അനുവദിക്കുന്നതിനുള്ള ടൂളുകൾ നൽകുന്നു
പരിശോധന, മൂല്യനിർണ്ണയ ഫലങ്ങളുടെ പ്രസിദ്ധീകരണം പ്രോത്സാഹിപ്പിക്കുന്നു.

ദൃഢത
സമ്മർദങ്ങളെയോ പരിതസ്ഥിതിയിലെ മാറ്റങ്ങളെയോ നേരിടാനുള്ള കഴിവാണ് കരുത്ത്,
ഇൻപുട്ടുകൾ അല്ലെങ്കിൽ കണക്കുകൂട്ടലുകൾ മുതലായവ. ഒരു സിസ്റ്റമോ രൂപകല്പനയോ അത്തരം കാര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ കഴിയുമെങ്കിൽ അത് ''ശക്തമാണ്''
പ്രവർത്തനക്ഷമതയുടെ കുറഞ്ഞ നഷ്ടത്തോടെ മാറ്റങ്ങൾ.

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

ഉൽപ്പാദിപ്പിക്കുന്നതിലൂടെ ശേഷിയുടെ അടുത്തോ അതിനപ്പുറമോ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെയും സിസ്റ്റത്തെ സമ്മർദ്ദത്തിലാക്കാം
അല്ലെങ്കിൽ വിവിധ തരത്തിലുള്ള വിഭവങ്ങളുടെ ക്ഷീണം അനുകരിക്കുന്നു. ഈ തരം പരിശോധനയെ വിളിക്കുന്നു
''സ്ട്രെസ് ടെസ്റ്റിംഗ്.''

സിസ്റ്റവും അതിന്റെ ഘടകങ്ങളും പ്രകടമാക്കുന്ന ''ക്ലീൻ ടെസ്റ്റുകൾ'' എന്ന് വിളിക്കപ്പെടുന്നവയ്ക്ക് വിധേയമായേക്കാം
ഒരു പോസിറ്റീവ് ഫലം -- അതായത്, സിസ്റ്റം ഒരു വലിയ പ്രതികരണമായി ശരിയായി പ്രവർത്തിക്കുന്നു
പ്രതീക്ഷിക്കുന്ന കോൺഫിഗറേഷനുകളുടെ വ്യത്യാസം.

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

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

ദി ns-3 ടെസ്റ്റിംഗ് എൻവയോൺമെന്റ് ടെസ്റ്റ് സജ്ജീകരിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനും അനുവദിക്കുന്ന ടൂളുകൾ നൽകുന്നു
ഒന്നിലധികം സിസ്റ്റങ്ങളിൽ (ബിൽഡ്‌ബോട്ട്) പരിതഃസ്ഥിതികൾ ശുദ്ധീകരിക്കാൻ പ്രോത്സാഹിപ്പിക്കുന്നതിന് ക്ലാസുകൾ നൽകുന്നു
പ്രതീക്ഷിക്കുന്ന ''പ്രയോഗക്ഷമതാ ഡൊമെയ്‌നിലൂടെ'' സിസ്റ്റത്തിന്റെ പ്രവർത്തനം പരിശോധിക്കുന്നതിനുള്ള പരിശോധനകൾ
ഒപ്പം ''കൃത്യതയുടെ പരിധി''.

പ്രകടനം
ശരി, ''പെർഫോമന്റ്'' ഒരു യഥാർത്ഥ ഇംഗ്ലീഷ് പദമല്ല. എന്നിരുന്നാലും, ഇത് വളരെ സംക്ഷിപ്തമായ ഒരു നിയോലോജിസമാണ്
നമുക്ക് എന്താണ് വേണ്ടതെന്ന് വിവരിക്കാൻ ഇത് പലപ്പോഴും ഉപയോഗിക്കുന്നു ns-3 ആകാൻ: ശക്തവും വേഗതയേറിയതും
ജോലി ചെയ്തുതീർക്കുക.

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

ൽ ns-3 ടെസ്റ്റ് ചട്ടക്കൂട്, വിവിധ തരത്തിലുള്ള ടെസ്റ്റുകൾ ടൈമിംഗ് ചെയ്യുന്നതിനുള്ള പിന്തുണ ഞങ്ങൾ നൽകുന്നു.

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

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

A പ്രാദേശിക റിഗ്രഷൻ ഒരു മാറ്റം മാറിയ ഘടകത്തെ നേരിട്ട് ബാധിക്കുന്ന ഒന്നാണ്. വേണ്ടി
ഉദാഹരണത്തിന്, ഒരു ഘടകഭാഗം അലോക്കേറ്റ് ചെയ്യാനും സൌജന്യ മെമ്മറി നൽകാനും പരിഷ്കരിച്ചിട്ടുണ്ടെങ്കിലും പഴയ പോയിന്ററുകൾ ആണെങ്കിൽ
ഉപയോഗിച്ചു, ഘടകം തന്നെ പരാജയപ്പെടുന്നു.

A വിദൂര റിഗ്രഷൻ ഒരു ഘടകത്തിലേക്കുള്ള മാറ്റം പ്രവർത്തനത്തെ തകർക്കുന്ന ഒന്നാണ്
മറ്റൊരു ഘടകം. ഇത് സൂചിപ്പിക്കുന്നതും എന്നാൽ തിരിച്ചറിയപ്പെടാത്തതുമായ ഒരു ലംഘനത്തെ പ്രതിഫലിപ്പിക്കുന്നു
ഘടകങ്ങൾ തമ്മിലുള്ള കരാർ.

An അനാവരണം റിഗ്രഷൻ മുമ്പ് നിലവിലുള്ള ഒരു ബഗ് ഉള്ള ഒരു സാഹചര്യം സൃഷ്ടിക്കുന്ന ഒന്നാണ്
യാതൊരു സ്വാധീനവുമില്ലാത്തത് സിസ്റ്റത്തിൽ പെട്ടെന്ന് വെളിപ്പെടുന്നു. ഇത് വ്യായാമം പോലെ ലളിതമായിരിക്കാം
ആദ്യമായി ഒരു കോഡ് പാത.

A പ്രകടനം റിഗ്രഷൻ സിസ്റ്റത്തിന്റെ പ്രകടന ആവശ്യകതകൾക്ക് കാരണമാകുന്ന ഒന്നാണ്
ലംഘിക്കപ്പെടും. ഉദാഹരണത്തിന്, ആവർത്തിച്ചേക്കാവുന്ന താഴ്ന്ന നിലയിലുള്ള ഫംഗ്ഷനിൽ ചില ജോലികൾ ചെയ്യുന്നത്
വലിയ സംഖ്യകൾ ചില വീക്ഷണകോണുകളിൽ നിന്ന് പെട്ടെന്ന് സിസ്റ്റം ഉപയോഗശൂന്യമാക്കിയേക്കാം.

ദി ns-3 പരിശോധനാ ചട്ടക്കൂട് സാധൂകരിക്കുന്നതിന് ഉപയോഗിക്കുന്ന പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഉപകരണങ്ങൾ നൽകുന്നു
സാധ്യമായ റിഗ്രെഷനുകൾ പെട്ടെന്ന് തിരിച്ചറിയാൻ സഹായിക്കുന്നതിന് രാത്രികാല ടെസ്റ്റ് സ്യൂട്ടുകളിൽ കോഡ് പരിശോധിച്ചുറപ്പിക്കുക.

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

ബിൽഡ്ബോട്ടുകൾ
ns-3 ടെസ്റ്റിംഗിന്റെ ഏറ്റവും ഉയർന്ന തലത്തിൽ ബിൽഡ്ബോട്ടുകളാണ് (ബിൽഡ് റോബോട്ടുകൾ). നിങ്ങളാണെങ്കിൽ
ഈ സിസ്റ്റം നോക്കുക പരിചിതമല്ല http://djmitche.github.com/buildbot/docs/0.7.11/.
ഇത് അനുവദിക്കുന്ന ഒരു ഓപ്പൺ സോഴ്സ് ഓട്ടോമേറ്റഡ് സിസ്റ്റമാണ് ns-3 പുനർനിർമിക്കുകയും ഓരോന്നും പരീക്ഷിക്കുകയും വേണം
സമയം എന്തെങ്കിലും മാറിയിരിക്കുന്നു. ഞങ്ങൾ നിരവധി വ്യത്യസ്ത സിസ്റ്റങ്ങളിൽ ബിൽഡ്ബോട്ടുകൾ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ
അത് ഉറപ്പാക്കാൻ കഴിയും ns-3 പിന്തുണയ്ക്കുന്ന എല്ലാ സിസ്റ്റങ്ങളിലും ശരിയായി നിർമ്മിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു.

ഉപയോക്താക്കൾ (ഡെവലപ്പർമാരും) സാധാരണയായി ബിൽഡ്ബോട്ട് സിസ്റ്റവുമായി സംവദിക്കില്ല
പരിശോധനാ ഫലങ്ങളെക്കുറിച്ചുള്ള അതിന്റെ സന്ദേശങ്ങൾ വായിക്കുക. ഒന്നിൽ ഒരു പരാജയം കണ്ടെത്തിയാൽ
ഓട്ടോമേറ്റഡ് ബിൽഡ്, ടെസ്റ്റ് ജോലികൾ, ബിൽഡ്ബോട്ട് ഒരു ഇമെയിൽ അയയ്ക്കും ns-ഡെവലപ്പർമാർ
അയക്കേണ്ട പട്ടിക. ഈ ഇമെയിൽ ഇതുപോലെ കാണപ്പെടും

ഇമെയിലിൽ കാണിച്ചിരിക്കുന്ന മുഴുവൻ വിശദാംശങ്ങളും URL-ൽ കീവേഡ് തിരയാൻ കഴിയും പരാജയപ്പെട്ടു ഒപ്പം
തിരഞ്ഞെടുക്കുക stdio പരാജയത്തിന്റെ കാരണം കാണുന്നതിന് അനുബന്ധ ഘട്ടത്തിനായുള്ള ലിങ്ക്.

പിശകുകളൊന്നും ഇല്ലെങ്കിൽ ബിൽഡ്ബോട്ട് അതിന്റെ ജോലി നിശബ്ദമായി ചെയ്യും, കൂടാതെ സിസ്റ്റം കടന്നുപോകും
എല്ലാം ശരിയാണെന്ന് സ്ഥിരീകരിക്കാൻ എല്ലാ ദിവസവും സൈക്കിളുകൾ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും ചെയ്യുക.

Test.py
ബിൽഡ്ബോട്ടുകൾ ഒരു പൈത്തൺ പ്രോഗ്രാം ഉപയോഗിക്കുന്നു, test.py, അത് എല്ലാം പ്രവർത്തിപ്പിക്കുന്നതിന് ഉത്തരവാദിയാണ്
പരിശോധനകൾ നടത്തുകയും തത്ഫലമായുണ്ടാകുന്ന റിപ്പോർട്ടുകൾ മനുഷ്യർക്ക് വായിക്കാൻ കഴിയുന്ന രൂപത്തിലേക്ക് ശേഖരിക്കുകയും ചെയ്യുന്നു. ഈ പരിപാടി
ഉപയോക്താക്കൾക്കും ഡെവലപ്പർമാർക്കും ഉപയോഗിക്കാനും ലഭ്യമാണ്.

test.py ടെസ്റ്റുകളുടെ എണ്ണവും തരവും വ്യക്തമാക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്നതിൽ വളരെ അയവുള്ളതാണ്
ഓടുക; കൂടാതെ ഉൽപ്പാദിപ്പിക്കുന്നതിനുള്ള അളവും തരവും.

ഓടുന്നതിന് മുമ്പ് test.py, ns3 ന്റെ ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും ചെയ്തുകൊണ്ടാണ് നിർമ്മിച്ചതെന്ന് ഉറപ്പാക്കുക
ഇനിപ്പറയുന്നവ

$ ./waf കോൺഫിഗർ --enable-examples --enable-tests
$ ./waf

സ്ഥിരസ്ഥിതിയായി, test.py ലഭ്യമായ എല്ലാ ടെസ്റ്റുകളും റൺ ചെയ്യുകയും സ്റ്റാറ്റസ് വളരെ സംക്ഷിപ്തമായി റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യും
രൂപം. കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു

$ ./test.py

പലതിലും കലാശിക്കും പാസ്സ്, പരാജയം, തകര്ച്ച or SKIP ഇനിപ്പറയുന്ന തരത്തിലുള്ള സൂചനകൾ
പ്രവർത്തിപ്പിച്ച ടെസ്റ്റും അതിന്റെ പ്രദർശന നാമവും.

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.939സെ)
പരാജയം: TestSuite ns3-wifi-propagation-loss-models
പാസ്സ്: TestSuite ഒബ്ജക്റ്റ്-നെയിം-സർവീസ്
പാസ്: TestSuite pcap-file-object
പാസ്: TestSuite ns3-tcp-cwnd
...
പാസ്: TestSuite ns3-tcp-ഇന്ററോപ്പറബിളിറ്റി
പാസ്സ്: ഉദാഹരണം csma-ബ്രോഡ്കാസ്റ്റ്
PASS: ഉദാഹരണം csma-multicast

തങ്ങളുടേതാണോ എന്ന് നിർണ്ണയിക്കാൻ താൽപ്പര്യമുള്ള ഉപയോക്താക്കൾക്ക് ഈ മോഡ് ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്
വിതരണം ശരിയായി പ്രവർത്തിക്കുന്നു, എന്ന് നിർണ്ണയിക്കാൻ താൽപ്പര്യമുള്ള ഡെവലപ്പർമാർ
അവർ വരുത്തിയ മാറ്റങ്ങൾ ഏതെങ്കിലും തിരിച്ചടിക്ക് കാരണമായി.

പെരുമാറ്റം നിയന്ത്രിക്കാൻ നിരവധി ഓപ്ഷനുകൾ ലഭ്യമാണ് test.py. നിങ്ങൾ ഓടുകയാണെങ്കിൽ
test.py --സഹായിക്കൂ ഇതുപോലുള്ള ഒരു കമാൻഡ് സംഗ്രഹം നിങ്ങൾ കാണും:

ഉപയോഗം: test.py [ഓപ്ഷനുകൾ]

ഓപ്ഷനുകൾ:
-h, --സഹായം ഈ സഹായ സന്ദേശം കാണിച്ച് പുറത്തുകടക്കുക
-ബി ബിൽഡ്പാത്ത്, --ബിൽഡ്പാത്ത്=ബിൽഡ്പാത്ത്
ns-3 നിർമ്മിച്ച പാത വ്യക്തമാക്കുക (ഡിഫോൾട്ടായി
നിലവിലെ വേരിയന്റിനായുള്ള ഡയറക്ടറി നിർമ്മിക്കുക)
-c KIND, --constrain=KIND
ടെസ്റ്റ്-റണ്ണറെ ഒരുതരം ടെസ്റ്റ് വഴി നിയന്ത്രിക്കുക
-ഇ ഉദാഹരണം, --ഉദാഹരണം=ഉദാഹരണം
പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരൊറ്റ ഉദാഹരണം വ്യക്തമാക്കുക (ആപേക്ഷിക പാതയില്ല
ആവശ്യമുണ്ട്)
-g, --grind valgrind ഉപയോഗിച്ച് ടെസ്റ്റ് സ്യൂട്ടുകളും ഉദാഹരണങ്ങളും പ്രവർത്തിപ്പിക്കുക
-k, --kinds ലഭ്യമായ ടെസ്റ്റുകളുടെ തരങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു
-l, --list അറിയപ്പെടുന്ന ടെസ്റ്റുകളുടെ ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക
-m, --ടെസ്റ്റ് സ്യൂട്ടുകളിൽ നിന്നും ടെസ്റ്റിൽ നിന്നും ഒന്നിലധികം പരാജയങ്ങൾ റിപ്പോർട്ട് ചെയ്യുക
കേസുകൾ
-n, --nowaf ടെസ്റ്റിംഗ് ആരംഭിക്കുന്നതിന് മുമ്പ് waf പ്രവർത്തിപ്പിക്കരുത്
-p PYEXAMPLE, --pyexample=PYEXAMPLE
പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരൊറ്റ പൈത്തൺ ഉദാഹരണം വ്യക്തമാക്കുക (ബന്ധുവിനൊപ്പം
പാത)
-r, --retain എല്ലാ താൽക്കാലിക ഫയലുകളും നിലനിർത്തുന്നു (സാധാരണയായി ഇവയാണ്
ഇല്ലാതാക്കി)
-s TEST-SUITE, --suite=TEST-SUITE
പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരൊറ്റ ടെസ്റ്റ് സ്യൂട്ട് വ്യക്തമാക്കുക
-t TEXT-FILE, --text=TEXT-FILE
വിശദമായ പരിശോധനാ ഫലങ്ങൾ TEXT-FILE.txt-ലേക്ക് എഴുതുക
-v, --വെർബോസ് പ്രിന്റ് പുരോഗതിയും വിവര സന്ദേശങ്ങളും
-w HTML-FILE, --web=HTML-FILE, --html=HTML-FILE
HTML-FILE.html-ലേക്ക് വിശദമായ പരിശോധനാ ഫലങ്ങൾ എഴുതുക
-x XML-FILE, --xml=XML-FILE
വിശദമായ പരിശോധനാ ഫലങ്ങൾ XML-FILE.xml-ലേക്ക് എഴുതുക

ഒരാൾക്ക് ഒരു ഓപ്ഷണൽ ഔട്ട്പുട്ട് ശൈലി വ്യക്തമാക്കുകയാണെങ്കിൽ, അതിന്റെ വിശദമായ വിവരണങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയും
ടെസ്റ്റുകളും സ്റ്റാറ്റസും. ലഭ്യമായ ശൈലികൾ ടെക്സ്റ്റ് ഒപ്പം എച്ച്ടിഎംഎൽ. ബിൽഡ്ബോട്ടുകൾ HTML തിരഞ്ഞെടുക്കും
ഉപയോഗിച്ച് രാത്രികാല ബിൽഡുകൾക്കായി HTML ടെസ്റ്റ് റിപ്പോർട്ടുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഓപ്ഷൻ

$ ./test.py --html=nightly.html

ഈ സാഹചര്യത്തിൽ, ''nightly.html'' എന്ന പേരിലുള്ള ഒരു HTML ഫയൽ മനോഹരമായ ഒരു സംഗ്രഹത്തോടെ സൃഷ്ടിക്കപ്പെടും
നടത്തിയ പരിശോധനയുടെ. താൽപ്പര്യമുള്ള ഉപയോക്താക്കൾക്ക് ഒരു ''മനുഷ്യ വായനായോഗ്യമായ'' ഫോർമാറ്റ് ലഭ്യമാണ്
വിശദാംശങ്ങൾ.

$ ./test.py --text=results.txt

മുകളിലുള്ള ഉദാഹരണത്തിൽ, ടെസ്റ്റ് സ്യൂട്ട് പരിശോധിക്കുന്നു ns-3 വയർലെസ് ഉപകരണ പ്രചരണ നഷ്ടം
മോഡലുകൾ പരാജയപ്പെട്ടു. സ്ഥിരസ്ഥിതിയായി കൂടുതൽ വിവരങ്ങളൊന്നും നൽകിയിട്ടില്ല.

പരാജയം കൂടുതൽ പര്യവേക്ഷണം ചെയ്യാൻ, test.py ഒരൊറ്റ ടെസ്റ്റ് സ്യൂട്ട് വ്യക്തമാക്കാൻ അനുവദിക്കുന്നു.
കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു

$ ./test.py --suite=ns3-wifi-propagation-loss-models

അല്ലെങ്കിൽ തത്തുല്യമായി

$ ./test.py -s ns3-wifi-propagation-loss-models

ആ ഒരൊറ്റ ടെസ്റ്റ് സ്യൂട്ട് പ്രവർത്തിപ്പിക്കുന്നതിൽ ഫലം.

പരാജയം: TestSuite ns3-wifi-propagation-loss-models

പരാജയത്തെക്കുറിച്ചുള്ള വിശദമായ വിവരങ്ങൾ കണ്ടെത്താൻ, ഏത് തരത്തിലുള്ള ഔട്ട്പുട്ട് വ്യക്തമാക്കണം
ആഗ്രഹിച്ചു. ഉദാഹരണത്തിന്, മിക്ക ആളുകൾക്കും ഒരു ടെക്സ്റ്റ് ഫയലിൽ താൽപ്പര്യമുണ്ടാകാം:

$ ./test.py --suite=ns3-wifi-propagation-loss-models --text=results.txt

എന്നതിലേക്ക് എഴുതിയ ടെസ്റ്റ് സ്റ്റാറ്റസ് ഉപയോഗിച്ച് ആ ഒരൊറ്റ ടെസ്റ്റ് സ്യൂട്ട് പ്രവർത്തിപ്പിക്കുന്നതിന് ഇത് കാരണമാകും
ഫയൽ ''results.txt''.

ആ ഫയലിൽ ഇനിപ്പറയുന്നതിന് സമാനമായ എന്തെങ്കിലും നിങ്ങൾ കണ്ടെത്തണം

പരാജയം: ടെസ്റ്റ് സ്യൂട്ട് ''ns3-wifi-propagation-loss-models'' (യഥാർത്ഥ 0.02 ഉപയോക്താവ് 0.01 സിസ്റ്റം 0.00)
പാസ്: ടെസ്റ്റ് കേസ് "ചെക്ക് ... ഫ്രിസ് ... മോഡൽ ..." (യഥാർത്ഥ 0.01 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00)
പരാജയം: ടെസ്റ്റ് കേസ് "ചെക്ക്... ലോഗ് ഡിസ്റ്റൻസ്... മോഡൽ" (യഥാർത്ഥ 0.01 ഉപയോക്താവ് 0.01 സിസ്റ്റം 0.00)
വിശദാംശങ്ങൾ:
സന്ദേശം: അപ്രതീക്ഷിതമായ SNR മൂല്യം ലഭിച്ചു
വ്യവസ്ഥ: [യഥാർത്ഥത്തിൽ പരാജയപ്പെട്ടതിന്റെ നീണ്ട വിവരണം]
യഥാർത്ഥം: 176.395
പരിധി: 176.407 +- 0.0005
ഫയൽ: ../src/test/ns3wifi/propagation-loss-models-test-suite.cc
വരി: 360

ടെസ്റ്റ് സ്യൂട്ട് രണ്ട് ടെസ്റ്റ് കേസുകൾ ഉൾക്കൊള്ളുന്നതാണെന്ന് ശ്രദ്ധിക്കുക. ആദ്യ ടെസ്റ്റ് കേസ് പരിശോധിച്ചു
ഫ്രിസ് പ്രചരണ നഷ്ട മാതൃകയും കടന്നുപോയി. രണ്ടാമത്തെ ടെസ്റ്റ് കേസ് ലോഗ് പരിശോധിക്കുന്നതിൽ പരാജയപ്പെട്ടു
വിദൂര പ്രചരണ മാതൃക. ഈ സാഹചര്യത്തിൽ, 176.395 ന്റെ ഒരു SNR കണ്ടെത്തി, കൂടാതെ പരിശോധന
മൂന്ന് ദശാംശ സ്ഥാനങ്ങളിൽ നിന്ന് ശരിയായ 176.407 മൂല്യം പ്രതീക്ഷിക്കുന്നു. നടപ്പിലാക്കിയ ഫയൽ
പരാജയപ്പെട്ട പരിശോധനയും പരാജയത്തിന് കാരണമായ കോഡിന്റെ വരിയും പട്ടികപ്പെടുത്തിയിട്ടുണ്ട്.

നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് ഇത് ഉപയോഗിച്ച് ഒരു HTML ഫയൽ എളുപ്പത്തിൽ എഴുതാമായിരുന്നു --html ഓപ്ഷൻ
മുകളിൽ വിവരിച്ചതുപോലെ.

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

$ ./test.py --constrain=unit

അതുപോലെ, ഇനിപ്പറയുന്ന കമാൻഡ് സ്മോക്ക് ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മാത്രമേ കാരണമാകൂ:

$ ./test.py --constrain=unit

നിയമപരമായ നിയന്ത്രണങ്ങളുടെ ഒരു ദ്രുത ലിസ്റ്റ് കാണുന്നതിന്, അവ ലിസ്റ്റുചെയ്യാൻ നിങ്ങൾക്ക് ആവശ്യപ്പെടാം.
താഴെ പറയുന്ന കമാൻഡ്

$ ./test.py --തരം

ഇനിപ്പറയുന്ന പട്ടിക പ്രദർശിപ്പിക്കുന്നതിന് കാരണമാകും:

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.939സെ) വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
bvt: ബിൽഡ് വെരിഫിക്കേഷൻ ടെസ്റ്റുകൾ (ബിൽഡ് വിജയകരമായി പൂർത്തീകരിച്ചോ എന്നറിയാൻ)
കോർ: എല്ലാ TestSuite അടിസ്ഥാനമാക്കിയുള്ള ടെസ്റ്റുകളും പ്രവർത്തിപ്പിക്കുക (ഉദാഹരണങ്ങൾ ഒഴിവാക്കുക)
ഉദാഹരണം: ഉദാഹരണങ്ങൾ (ഉദാഹരണ പ്രോഗ്രാമുകൾ വിജയകരമായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് കാണാൻ)
പ്രകടനം: പ്രകടന പരിശോധനകൾ (സിസ്റ്റം പ്രതീക്ഷിച്ചത്ര വേഗതയേറിയതാണോയെന്ന് പരിശോധിക്കുക)
സിസ്റ്റം: സിസ്റ്റം ടെസ്റ്റുകൾ (മൊഡ്യൂളുകളുടെ സംയോജനം പരിശോധിക്കാൻ മൊഡ്യൂളുകൾ വ്യാപിക്കുന്നു)
യൂണിറ്റ്: യൂണിറ്റ് ടെസ്റ്റുകൾ (അടിസ്ഥാന പ്രവർത്തനക്ഷമത പരിശോധിക്കുന്നതിനുള്ള മൊഡ്യൂളുകൾക്കുള്ളിൽ)

ഇത്തരത്തിലുള്ള ഏതെങ്കിലും പരിശോധനകൾ ഒരു നിയന്ത്രണമായി നൽകാവുന്നതാണ് --നിയന്ത്രണം ഓപ്ഷൻ.

ലഭ്യമായ എല്ലാ ടെസ്റ്റ് സ്യൂട്ടുകളുടെയും ഒരു ദ്രുത ലിസ്റ്റ് കാണുന്നതിന്, നിങ്ങൾക്ക് അവ ആവശ്യപ്പെടാം
പട്ടികപ്പെടുത്തിയിരിക്കുന്നു. താഴെ പറയുന്ന കമാൻഡ്,

$ ./test.py --list

ഇതുപോലുള്ള ടെസ്റ്റ് സ്യൂട്ടിന്റെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കും

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.939സെ)
ഹിസ്റ്റോഗ്രാം
ns3-വൈഫൈ-ഇടപെടൽ
ns3-tcp-cwnd
ns3-tcp-ഇന്ററോപ്പറബിളിറ്റി
സാമ്പിൾ
ഉപകരണങ്ങൾ-മെഷ്-ജ്വാല
ഉപകരണങ്ങൾ-mesh-dot11s
ഉപകരണങ്ങൾ-മെഷ്
...
വസ്തു-നാമം-സേവനം
തിരിച്ചു വിളിക്കുക
ഗുണവിശേഷങ്ങൾ
config
ആഗോള മൂല്യം
കമാൻഡ്-ലൈൻ
അടിസ്ഥാന-റാൻഡം-നമ്പർ
വസ്തു

ഈ ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന ഏതെങ്കിലും സ്യൂട്ടുകൾ ഉപയോഗിച്ച് സ്വയം പ്രവർത്തിപ്പിക്കുന്നതിന് തിരഞ്ഞെടുക്കാവുന്നതാണ് --സ്യൂട്ട് എന്ന ഓപ്ഷൻ
മുകളിൽ കാണിച്ചിരിക്കുന്നു.

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

$ ./test.py --example=udp-echo

ആ ഒരൊറ്റ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകുന്നു.

പാസ്: ഉദാഹരണ ഉദാഹരണങ്ങൾ/udp/udp-echo

ഉപയോഗിച്ച് ns-3 നിർമ്മിച്ച ഡയറക്ടറി നിങ്ങൾക്ക് വ്യക്തമാക്കാം --ബിൽഡ്പാത്ത് എന്ന ഓപ്ഷൻ
പിന്തുടരുന്നു.

$ ./test.py --buildpath=/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build/debug --example=wifi-simple-adhoc

ഒരു പൈത്തൺ ഉദാഹരണ പ്രോഗ്രാം ഉപയോഗിച്ച് ഒരാൾക്ക് പ്രവർത്തിപ്പിക്കാൻ കഴിയും --ഉദാഹരണം ഓപ്ഷൻ. എന്നത് ശ്രദ്ധിക്കുക
ഉദാഹരണത്തിനുള്ള ആപേക്ഷിക പാത ഉൾപ്പെടുത്തണം, പൈത്തൺ ഉദാഹരണങ്ങൾക്ക് അവ ആവശ്യമാണ്
വിപുലീകരണങ്ങൾ. പ്രവേശിക്കുന്നു

$ ./test.py --pyexample=examples/tutorial/first.py

ആ ഒരൊറ്റ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകുന്നു.

പാസ്: ഉദാഹരണ ഉദാഹരണങ്ങൾ/ ട്യൂട്ടോറിയൽ/first.py

പൈത്തൺ ഉദാഹരണങ്ങൾ നിർമ്മിച്ചിട്ടില്ലാത്തതിനാൽ, ns-3 ഉള്ള ഡയറക്ടറി നിങ്ങൾ വ്യക്തമാക്കേണ്ടതില്ല
അവരെ പ്രവർത്തിപ്പിക്കുന്നതിനായി നിർമ്മിച്ചതാണ്.

സാധാരണയായി ഉദാഹരണ പ്രോഗ്രാമുകൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അവ വലിയ അളവിലുള്ള ട്രേസ് ഫയൽ ഡാറ്റ എഴുതുന്നു.
ഇത് സാധാരണയായി വിതരണത്തിന്റെ അടിസ്ഥാന ഡയറക്‌ടറിയിൽ സൂക്ഷിക്കുന്നു (ഉദാ.
/home/user/ns-3-dev). എപ്പോൾ test.py ഒരു ഉദാഹരണം പ്രവർത്തിക്കുന്നു, ഇത് ശരിക്കും അശ്രദ്ധമാണ്
ട്രേസ് ഫയലുകൾക്കൊപ്പം. ഉദാഹരണം നിർമ്മിക്കാനും പ്രവർത്തിപ്പിക്കാനും കഴിയുമോ എന്ന് നിർണ്ണയിക്കാൻ അത് ആഗ്രഹിക്കുന്നു
തെറ്റ് കൂടാതെ. ഇത് സ്ഥിതി ചെയ്യുന്നതിനാൽ, ട്രേസ് ഫയലുകൾ എയിൽ എഴുതിയിരിക്കുന്നു
/tmp/അൺചെക്ക്ഡ്-ട്രേസ് ഡയറക്ടറി. മുകളിലുള്ള ഉദാഹരണം നിങ്ങൾ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് കണ്ടെത്താനാകും
ബന്ധപ്പെട്ട udp-echo.tr ഒപ്പം udp-echo-n-1.pcap അവിടെ ഫയലുകൾ.

ലഭ്യമായ ഉദാഹരണങ്ങളുടെ പട്ടിക "ഉദാഹരണങ്ങൾ" എന്ന ഡയറക്ടറിയിലെ ഉള്ളടക്കം നിർവചിച്ചിരിക്കുന്നു
വിതരണം. ഉപയോഗിച്ച് നിർവ്വഹണത്തിനായി നിങ്ങൾ ഒരു ഉദാഹരണം തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ --ഉദാഹരണം ഓപ്ഷൻ,
test.py ഉദാഹരണം കോൺഫിഗർ ചെയ്‌തിട്ടുണ്ടോ ഇല്ലയോ എന്ന് തീരുമാനിക്കാൻ ഒരു ശ്രമവും നടത്തില്ല
അത് പ്രവർത്തിപ്പിക്കാനും ശ്രമത്തിന്റെ ഫലം റിപ്പോർട്ടുചെയ്യാനും ശ്രമിക്കും.

എപ്പോൾ test.py റൺ ചെയ്യുന്നു, സ്ഥിരസ്ഥിതിയായി, സിസ്റ്റം പൂർണ്ണമായി എന്ന് ഇത് ആദ്യം ഉറപ്പാക്കും
പണിതത്. തിരഞ്ഞെടുക്കുന്നതിലൂടെ ഇത് പരാജയപ്പെടുത്താം --നൗഫ് ഓപ്ഷൻ.

$ ./test.py --list --nowaf

ഇനിപ്പറയുന്നതിന് സമാനമായി നിലവിൽ നിർമ്മിച്ച ടെസ്റ്റ് സ്യൂട്ടുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കും:

ns3-വൈഫൈ-പ്രചരണം-നഷ്ട-മോഡലുകൾ
ns3-tcp-cwnd
ns3-tcp-ഇന്ററോപ്പറബിളിറ്റി
pcap-file-object
വസ്തു-നാമം-സേവനം
ക്രമരഹിത-സംഖ്യ-ജനറേറ്ററുകൾ

യുടെ അഭാവം ശ്രദ്ധിക്കുക വഫ് സന്ദേശങ്ങൾ നിർമ്മിക്കുക.

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

$ ./test.py --ഗ്രൈൻഡ്

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

$ ./test.py --retain

ഒടുവിൽ test.py ഒരു നൽകുന്നു --വാക്കുകൾ വലിയ അളവിലുള്ള വിവരങ്ങൾ പ്രിന്റ് ചെയ്യുന്ന ഓപ്ഷൻ
അതിന്റെ പുരോഗതിയെക്കുറിച്ച്. ഇല്ലെങ്കിൽ ഇത് വളരെ ഉപയോഗപ്രദമാകുമെന്ന് പ്രതീക്ഷിക്കുന്നില്ല
ഒരു തെറ്റ്. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്കും സ്റ്റാൻഡേർഡ് പിശകിലേക്കും പ്രവേശനം ലഭിക്കും
ടെസ്റ്റ് സ്യൂട്ടുകളും ഉദാഹരണങ്ങളും പ്രവർത്തിപ്പിച്ച് റിപ്പോർട്ട് ചെയ്തു. ഇനിപ്പറയുന്ന രീതിയിൽ വെർബോസ് തിരഞ്ഞെടുക്കുക:

$ ./test.py --verbose

ഈ ഓപ്ഷനുകളെല്ലാം മിശ്രണം ചെയ്യാനും പൊരുത്തപ്പെടുത്താനും കഴിയും. ഉദാഹരണത്തിന്, എല്ലാ ns-3 കോറും പ്രവർത്തിപ്പിക്കാൻ
വാൽഗ്രിൻഡിന് കീഴിലുള്ള ടെസ്റ്റ് സ്യൂട്ടുകൾ, വെർബോസ് മോഡിൽ, ഒരു HTML ഔട്ട്‌പുട്ട് ഫയൽ സൃഷ്ടിക്കുമ്പോൾ, ഒന്ന്
ചെയ്യും:

$ ./test.py --verbose --grind --constrain=core --html=results.html

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

· ബിൽഡ് വെരിഫിക്കേഷൻ ടെസ്റ്റുകൾ

· യൂണിറ്റ് ടെസ്റ്റുകൾ

· സിസ്റ്റം ടെസ്റ്റുകൾ

· ഉദാഹരണങ്ങൾ

· പ്രകടന പരിശോധനകൾ

ബിൽഡ് വെരിഫിക്കേഷൻ ടെസ്റ്റുകൾ
വിതരണത്തോടൊപ്പം നിർമ്മിച്ചതും ഉപയോഗിക്കുന്നതുമായ താരതമ്യേന ലളിതമായ ടെസ്റ്റുകളാണ് ഇവ
ബിൽഡ് ഏറെക്കുറെ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ. ഞങ്ങളുടെ നിലവിലെ യൂണിറ്റ് ടെസ്റ്റുകൾ ഇവിടെയുണ്ട്
അവർ പരിശോധിക്കുന്ന കോഡിന്റെ ഉറവിട ഫയലുകൾ ns-3 മൊഡ്യൂളുകളിൽ നിർമ്മിച്ചിരിക്കുന്നു; അങ്ങനെ യോജിക്കുന്നു
BVT-കളുടെ വിവരണം. ns-3 കോഡിൽ നിർമ്മിച്ച അതേ സോഴ്സ് കോഡിലാണ് BVT-കൾ ജീവിക്കുന്നത്.
ഞങ്ങളുടെ നിലവിലെ ടെസ്റ്റുകൾ ഇത്തരത്തിലുള്ള പരിശോധനയുടെ ഉദാഹരണങ്ങളാണ്.

ഘടകം ടെസ്റ്റുകൾ
യൂണിറ്റ് ടെസ്റ്റുകൾ കൂടുതൽ ഉൾപ്പെട്ടിരിക്കുന്ന ടെസ്റ്റുകളാണ്, അത് ഒരു കോഡ് ഉണ്ടെന്ന് ഉറപ്പാക്കാൻ വിശദമായി പോകുന്നു
ഐസൊലേഷനിൽ പരസ്യം ചെയ്തതുപോലെ പ്രവർത്തിക്കുന്നു. അത്തരമൊരു പരിശോധനയ്ക്ക് യഥാർത്ഥത്തിൽ ഒരു കാരണവുമില്ല
ഒരു ns-3 മൊഡ്യൂളിൽ നിർമ്മിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, യൂണിറ്റ് ഒബ്ജക്റ്റിനായി പരിശോധിക്കുന്നുവെന്ന് ഇത് മാറുന്നു
നെയിം സർവീസ് ഒബ്ജക്റ്റ് നെയിം സർവീസ് കോഡിന്റെ അതേ വലുപ്പമാണ്. യൂണിറ്റ് ടെസ്റ്റുകൾ
ns-3 കോഡിൽ നിർമ്മിച്ചിട്ടില്ലാത്ത ഒരു ബിറ്റ് പ്രവർത്തനക്ഷമത പരിശോധിക്കുന്ന ടെസ്റ്റുകളാണ്,
എന്നാൽ അത് പരിശോധിക്കുന്ന കോഡിന്റെ അതേ ഡയറക്ടറിയിൽ ജീവിക്കുക. ഈ പരിശോധനകൾ സാധ്യമാണ്
ഒരു മൊഡ്യൂളിൽ ഒന്നിലധികം നടപ്പാക്കൽ ഫയലുകളുടെ സംയോജനവും പരിശോധിക്കുക. ഫയല്
src/core/test/names-test-suite.cc ഇത്തരത്തിലുള്ള പരിശോധനയുടെ ഒരു ഉദാഹരണമാണ്. ഫയല്
അറിയപ്പെടുന്ന ഒരു നല്ല pcap ഉപയോഗിക്കുന്ന മറ്റൊരു ഉദാഹരണമാണ് src/network/test/pcap-file-test-suite.cc
ഒരു ടെസ്റ്റ് വെക്റ്റർ ഫയലായി ഫയൽ. ഈ ഫയൽ പ്രാദേശികമായി src/network ഡയറക്ടറിയിൽ സംഭരിച്ചിരിക്കുന്നു.

സിസ്റ്റം ടെസ്റ്റുകൾ
സിസ്റ്റത്തിൽ ഒന്നിലധികം മൊഡ്യൂളുകൾ ഉൾപ്പെടുന്നവയാണ് സിസ്റ്റം ടെസ്റ്റുകൾ. ഞങ്ങൾക്ക് ധാരാളം ഉണ്ട്
ഞങ്ങളുടെ നിലവിലെ റിഗ്രഷൻ ചട്ടക്കൂടിൽ ഇത്തരത്തിലുള്ള പരിശോധന പ്രവർത്തിക്കുന്നു, പക്ഷേ അവ സാധാരണമാണ്
ഓവർലോഡ് ചെയ്ത ഉദാഹരണങ്ങൾ. ഡയറക്‌ടറിയിൽ ഇത്തരത്തിലുള്ള പരിശോധനയ്‌ക്കായി ഞങ്ങൾ ഒരു പുതിയ സ്ഥലം നൽകുന്നു
എസ്ആർസി/ടെസ്റ്റ്. src/test/ns3tcp/ns3-interop-test-suite.cc ഫയൽ ഇത്തരത്തിലുള്ള ഒരു ഉദാഹരണമാണ്
പരീക്ഷയുടെ. ns-3 TCP നടപ്പിലാക്കൽ പരിശോധിക്കാൻ ഇത് NSC TCP ഉപയോഗിക്കുന്നു. പലപ്പോഴും പരീക്ഷയുണ്ടാകും
ഇത്തരത്തിലുള്ള പരിശോധനയ്ക്ക് ആവശ്യമായ വെക്‌ടറുകൾ, അവ ഡയറക്‌ടറിയിൽ സൂക്ഷിക്കുന്നു
പരീക്ഷണ ജീവിതങ്ങൾ. ഉദാഹരണത്തിന്, ns3tcp-interop-response-vectors.pcap ഒരു അടങ്ങുന്ന ഒരു ഫയലാണ്.
പരീക്ഷണത്തിൻ കീഴിലുള്ള ns-3 TCP യുടെ പ്രതീക്ഷിക്കുന്ന പ്രതികരണങ്ങളായി ഉപയോഗിക്കുന്ന TCP തലക്കെട്ടുകളുടെ എണ്ണം
എൻഎസ്‌സി ടിസിപി സൃഷ്ടിച്ച ഒരു ഉത്തേജനത്തിലേക്ക്, അത് ''അറിയപ്പെടുന്ന നല്ല'' നടപ്പാക്കലായി ഉപയോഗിക്കുന്നു.

ഉദാഹരണങ്ങൾ
അവ നിർമ്മിച്ചിട്ടുണ്ടെന്നും പ്രവർത്തിക്കുമെന്നും ഉറപ്പാക്കാൻ ഉദാഹരണങ്ങൾ ചട്ടക്കൂട് ഉപയോഗിച്ച് പരിശോധിക്കുന്നു. ഒന്നുമില്ല
പരിശോധിച്ചു, നിലവിൽ pcap ഫയലുകൾ എഴുതപ്പെട്ടിരിക്കുന്നു / tmp തള്ളിക്കളയണം. എങ്കിൽ
ഉദാഹരണങ്ങൾ പ്രവർത്തിക്കുന്നു (ക്രാഷ് ചെയ്യരുത്) അവർ ഈ പുക പരിശോധനയിൽ വിജയിക്കുന്നു.

പ്രകടനം ടെസ്റ്റുകൾ
സിസ്റ്റത്തിന്റെ ഒരു പ്രത്യേക ഭാഗം വ്യായാമം ചെയ്യുകയും നിർണ്ണയിക്കുകയും ചെയ്യുന്നവയാണ് പെർഫോമൻസ് ടെസ്റ്റുകൾ
പരിശോധനകൾ ന്യായമായ സമയത്തിനുള്ളിൽ പൂർത്തീകരിച്ചിട്ടുണ്ടെങ്കിൽ.

പ്രവർത്തിക്കുന്ന ടെസ്റ്റുകൾ
ടെസ്റ്റുകൾ സാധാരണയായി ഉയർന്ന നില ഉപയോഗിച്ചാണ് നടത്തുന്നത് test.py പ്രോഗ്രാം. യുടെ ഒരു ലിസ്റ്റ് ലഭിക്കാൻ
ലഭ്യമായ കമാൻഡ്-ലൈൻ ഓപ്ഷനുകൾ, പ്രവർത്തിപ്പിക്കുക test.py --സഹായിക്കൂ

ടെസ്റ്റ് പ്രോഗ്രാം test.py രണ്ട് ടെസ്റ്റുകളും ചേർത്തിട്ടുള്ള ഉദാഹരണങ്ങളും പ്രവർത്തിപ്പിക്കും
പരിശോധിക്കാനുള്ള പട്ടിക. ടെസ്റ്റുകളും ഉദാഹരണങ്ങളും തമ്മിലുള്ള വ്യത്യാസം ഇനിപ്പറയുന്നതാണ്. ടെസ്റ്റുകൾ
നിർദ്ദിഷ്ട സിമുലേഷൻ ഔട്ട്‌പുട്ട് അല്ലെങ്കിൽ ഇവന്റുകൾ പ്രതീക്ഷിക്കുന്ന സ്വഭാവവുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് സാധാരണയായി പരിശോധിക്കുക.
വിപരീതമായി, ഉദാഹരണങ്ങളുടെ ഔട്ട്പുട്ട് പരിശോധിക്കില്ല, കൂടാതെ ടെസ്റ്റ് പ്രോഗ്രാം കേവലം പരിശോധിക്കുന്നു
ഉദാഹരണ പ്രോഗ്രാമിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസ് പിശകില്ലാതെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ.

ചുരുക്കത്തിൽ, എല്ലാ ടെസ്റ്റുകളും പ്രവർത്തിപ്പിക്കുന്നതിന്, ആദ്യം കോൺഫിഗറേഷൻ ഘട്ടത്തിൽ ടെസ്റ്റുകൾ കോൺഫിഗർ ചെയ്യണം, കൂടാതെ
കൂടാതെ (ഓപ്ഷണലായി) ഉദാഹരണങ്ങൾ പരിശോധിക്കണമെങ്കിൽ:

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

തുടർന്ന്, ns-3 നിർമ്മിക്കുക, അത് നിർമ്മിച്ച ശേഷം, പ്രവർത്തിപ്പിക്കുക test.py. test.py -h ഒരു നമ്പർ കാണിക്കും
test.py-യുടെ സ്വഭാവം പരിഷ്‌ക്കരിക്കുന്ന കോൺഫിഗറേഷൻ ഓപ്ഷനുകളുടെ.

പരിപാടി test.py C++ ടെസ്റ്റുകൾക്കും ഉദാഹരണങ്ങൾക്കുമായി, ഒരു താഴ്ന്ന-നില C++ പ്രോഗ്രാം വിളിക്കുന്നു
ടെസ്റ്റ് റണ്ണർ യഥാർത്ഥത്തിൽ പരിശോധനകൾ നടത്താൻ. താഴെ ചർച്ച ചെയ്തതുപോലെ, ഇത് ടെസ്റ്റ് റണ്ണർ ഒരു പക്ഷേ
പരിശോധനകൾ ഡീബഗ് ചെയ്യുന്നതിനുള്ള സഹായകരമായ മാർഗം.

ഡീബഗ്ഗിംഗ് ടെസ്റ്റുകൾ
ടെസ്റ്റ് പ്രോഗ്രാമുകളുടെ ഡീബഗ്ഗിംഗ് ലോ-ലെവൽ ടെസ്റ്റ്-റണ്ണർ പ്രവർത്തിപ്പിക്കുന്നതാണ് നല്ലത്
പ്രോഗ്രാം. പൊതു പൈത്തൺ കോഡിൽ നിന്നുള്ള പാലമാണ് ടെസ്റ്റ് റണ്ണർ ns-3 കോഡ്. അത്
C++ ൽ എഴുതിയത് കൂടാതെ ഓട്ടോമാറ്റിക് ടെസ്റ്റ് കണ്ടെത്തൽ പ്രക്രിയ ഉപയോഗിക്കുന്നു ns-3 കണ്ടെത്താനുള്ള കോഡ് കൂടാതെ
വിവിധ ടെസ്റ്റുകൾ എല്ലാം നടപ്പിലാക്കാൻ അനുവദിക്കുക.

അതിനുള്ള പ്രധാന കാരണം test.py ഡീബഗ്ഗിംഗിന് അനുയോജ്യമല്ല, അത് അനുവദനീയമല്ല
ഉപയോഗിച്ച് ലോഗിംഗ് ഓണാക്കണം NS_LOG test.py പ്രവർത്തിക്കുമ്പോൾ പരിസ്ഥിതി വേരിയബിൾ. ഈ
ടെസ്റ്റ് റണ്ണർ എക്സിക്യൂട്ടബിളിന് പരിമിതി ബാധകമല്ല. അതിനാൽ, നിങ്ങൾക്ക് ലോഗിംഗ് കാണണമെങ്കിൽ
നിങ്ങളുടെ ടെസ്റ്റുകളിൽ നിന്നുള്ള ഔട്ട്പുട്ട്, നിങ്ങൾ നേരിട്ട് ടെസ്റ്റ്-റണ്ണർ ഉപയോഗിച്ച് അവ പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്.

ടെസ്റ്റ്-റണ്ണർ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനായി, മറ്റേതൊരു ns-3 എക്സിക്യൂട്ടബിൾ പോലെ നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിക്കുന്നു -- ഉപയോഗിച്ച്
വാഫ്. ലഭ്യമായ ഓപ്ഷനുകളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കാൻ, നിങ്ങൾക്ക് ടൈപ്പ് ചെയ്യാം:

$ ./waf --റൺ "ടെസ്റ്റ്-റണ്ണർ --സഹായം"

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

വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/craigdo/repos/ns-3-allinone-test/ns-3-dev/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.353സെ)
--assert: ഒരു പിശക് കണ്ടെത്തിയാൽ, സെഗ്‌ഫോൾട്ടിനോട് (അസേർട്ട് പോലെ) ടെസ്റ്റുകളോട് പറയുക
--basedir=dir: അടിസ്ഥാന ഡയറക്ടറി (എസ്ആർസി എവിടെ കണ്ടെത്താം) ''dir'' ആയി സജ്ജമാക്കുക
--tempdir=dir: താൽക്കാലിക ഡയറക്ടറി (ഡാറ്റ ഫയലുകൾ എവിടെ കണ്ടെത്താം) ''dir'' ആയി സജ്ജമാക്കുക
--constrain=ടെസ്റ്റ്-ടൈപ്പ്: ''ടെസ്റ്റ്-ടൈപ്പ്'' എന്ന തരത്തിലുള്ള ടെസ്റ്റ് സ്യൂട്ടുകൾക്കുള്ള പരിശോധനകൾ നിയന്ത്രിക്കുക
--സഹായം: ഈ സന്ദേശം അച്ചടിക്കുക
--തരം: ലഭ്യമായ എല്ലാ തരത്തിലുള്ള ടെസ്റ്റുകളും ലിസ്റ്റ് ചെയ്യുക
--ലിസ്റ്റ്: എല്ലാ ടെസ്റ്റ് സ്യൂട്ടുകളും ലിസ്റ്റുചെയ്യുക (ടെസ്റ്റ്-ടൈപ്പ് ഉപയോഗിച്ച് ഓപ്ഷണലായി പരിമിതപ്പെടുത്തിയിരിക്കുന്നു)
--out=file-name: ടെസ്റ്റ് സ്റ്റാറ്റസ് ഔട്ട്പുട്ട് ഫയൽ ''file-name'' ആയി സജ്ജമാക്കുക
--suite=suite-name: ''suite-name'' എന്ന പേരിൽ ടെസ്റ്റ് സ്യൂട്ട് പ്രവർത്തിപ്പിക്കുക
--verbose: റൺ ടെസ്റ്റ് സ്യൂട്ടുകളിൽ സന്ദേശങ്ങൾ ഓണാക്കുക

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

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

$ ./വാഫ് ഷെൽ
$ cd ബിൽഡ്/ഡീബഗ്/utils
$ gdb ടെസ്റ്റ് റണ്ണർ
$ run --suite=global-value --assert

ഗ്ലോബൽ-വാല്യൂ ടെസ്റ്റ് സ്യൂട്ടിൽ ഒരു പിശക് കണ്ടെത്തിയാൽ, ഒരു സെഗ്ഫോൾട്ട് സൃഷ്ടിക്കപ്പെടും
കൂടാതെ (ഉറവിട നില) ഡീബഗ്ഗർ ഇവിടെ നിർത്തും NS_TEST_ASSERT_MSG അത് കണ്ടെത്തി
പിശക്.

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

നിങ്ങൾ test.py-ൽ നിന്ന് ഒരു ടെസ്റ്റ് നടത്തുകയാണെങ്കിൽ, പൈത്തൺ പ്രോഗ്രാം അടിസ്ഥാനപരമായ ഓപ്ഷൻ നൽകും
നിങ്ങൾ. ടെസ്റ്റ് റണ്ണറിൽ നിന്ന് നേരിട്ട് ടെസ്റ്റുകളിലൊന്ന് പ്രവർത്തിപ്പിക്കുന്നതിന് വാഫ്, നിങ്ങൾ ചെയ്യേണ്ടതുണ്ട്
അടിസ്ഥാന ഡയറക്‌ടറിക്കൊപ്പം പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ടെസ്റ്റ് സ്യൂട്ട് വ്യക്തമാക്കുക. അതിനാൽ നിങ്ങൾക്ക് ഷെൽ ഉപയോഗിക്കാം
കൂടാതെ ചെയ്യുക:

$ ./waf --run "test-runner --basedir=`pwd` --suite=pcap-file-object"

എന്നതിലെ ''പിന്നോക്ക'' ഉദ്ധരണി അടയാളങ്ങൾ ശ്രദ്ധിക്കുക പിഡബ്ല്യുഡി കമാൻഡ്.

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

പരിശോധന ഔട്ട്പുട്ട്
പല ടെസ്റ്റ് സ്യൂട്ടുകളും ഈ പ്രക്രിയയിൽ താൽക്കാലിക ഫയലുകൾ (pcap ഫയലുകൾ പോലുള്ളവ) എഴുതേണ്ടതുണ്ട്
ടെസ്റ്റുകൾ നടത്തുന്നു. ടെസ്റ്റുകൾക്ക് എഴുതാൻ ഒരു താൽക്കാലിക ഡയറക്ടറി ആവശ്യമാണ്. പൈത്തൺ
ടെസ്റ്റ് യൂട്ടിലിറ്റി (test.py) ഒരു താൽക്കാലിക ഫയൽ സ്വയമേവ നൽകും, എന്നാൽ ഒറ്റയ്ക്ക് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ
ഈ താൽക്കാലിക ഡയറക്ടറി നൽകണം. അടിസ്ഥാനപരമായ കാര്യത്തിലെന്നപോലെ, അത് ആകാം
തുടർച്ചയായി നൽകേണ്ടി വരുന്നത് അരോചകമാണ് --tempdir, അതിനാൽ ടെസ്റ്റ് റണ്ണർ ഒന്ന് കണ്ടെത്തും
നിങ്ങൾ ഒരെണ്ണം നൽകിയില്ലെങ്കിൽ നിങ്ങൾക്കായി. ഇത് ആദ്യം പേരുള്ള പരിസ്ഥിതി വേരിയബിളുകൾക്കായി തിരയുന്നു ടിഎംപി
ഒപ്പം TEMP അവ ഉപയോഗിക്കുകയും ചെയ്യുന്നു. ഇല്ലെങ്കിൽ ടിഎംപി വേണ്ടാ TEMP അത് തിരഞ്ഞെടുക്കുന്നു എന്ന് നിർവചിച്ചിരിക്കുന്നു / tmp. കോഡ്
തുടർന്ന് ഡയറക്‌ടറി (ns-3) സൃഷ്‌ടിച്ചത് എന്താണെന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഐഡന്റിഫയറിൽ ടാക്ക് ചെയ്യുന്നു, തുടർന്ന് സമയം
(hh.mm.ss) തുടർന്ന് ഒരു വലിയ ക്രമരഹിത സംഖ്യ. ടെസ്റ്റ് റണ്ണർ അതിന്റെ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്നു
താൽക്കാലിക ഡയറക്ടറിയായി ഉപയോഗിക്കേണ്ട പേര്. താൽക്കാലിക ഫയലുകൾ പിന്നീട് ഒരു ഡയറക്ടറിയിലേക്ക് പോകുന്നു
പോലെ എന്തെങ്കിലും പേരിടും

/tmp/ns-3.10.25.37.61537845

സമയം ഒരു സൂചനയായി നൽകിയിരിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് താരതമ്യേന എളുപ്പത്തിൽ പുനർനിർമ്മിക്കാൻ കഴിയും
നിങ്ങൾക്ക് തിരികെ പോയി അതിൽ സ്ഥാപിച്ചിരിക്കുന്ന ഫയലുകൾ നോക്കണമെങ്കിൽ ഡയറക്ടറി ഉപയോഗിച്ചു
ഡയറക്ടറി.

താരതമ്യം ചെയ്യാൻ ജനറേറ്റ് ചെയ്യുന്ന pcap ട്രെയ്‌സുകൾ പോലെയുള്ള ടെസ്റ്റ് ഔട്ട്‌പുട്ടാണ് ഔട്ട്‌പുട്ടിന്റെ മറ്റൊരു ക്ലാസ്
റഫറൻസ് ഔട്ട്പുട്ട്. ടെസ്റ്റ് സ്യൂട്ടുകൾ എല്ലാം കഴിഞ്ഞ് ടെസ്റ്റ് പ്രോഗ്രാം സാധാരണയായി ഇവ ഇല്ലാതാക്കും
ഓടുക. ടെസ്റ്റ് ഔട്ട്പുട്ട് ഇല്ലാതാക്കുന്നത് പ്രവർത്തനരഹിതമാക്കാൻ, റൺ ചെയ്യുക test.py "നിലനിർത്തുക" ഓപ്ഷൻ ഉപയോഗിച്ച്:

$ ./test.py -r

കൂടാതെ ടെസ്റ്റ് ഔട്ട്പുട്ട് കണ്ടെത്താനാകും testpy-output/ ഡയറക്ടറി.

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

$ ./waf --run "test-runner --basedir=`pwd` --suite=pcap-file-object --out=myfile.xml"

ഫയൽ നോക്കിയാൽ myfile.xml നിങ്ങൾ ഇതുപോലെ ഒന്ന് കാണണം,


pcap-file-object

PcapFile :: മോഡ് ഉപയോഗിച്ച് തുറക്കുക ''w'' പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക
പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00


PcapFile :: മോഡ് ഉപയോഗിച്ച് തുറക്കുക ''r'' പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക
പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00


PcapFile :: മോഡ് ഉപയോഗിച്ച് തുറക്കുക ''a'' പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക
പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00


PcapFileHeader ശരിയായി കൈകാര്യം ചെയ്യുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക
പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00


PcapRecordHeader ശരിയായി കൈകാര്യം ചെയ്യുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക
പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00


PcapFile-ന് അറിയപ്പെടുന്ന ഒരു നല്ല pcap ഫയൽ വായിക്കാൻ കഴിയുമോ എന്ന് പരിശോധിക്കുക
പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00

പാസ്സ്
യഥാർത്ഥ 0.00 ഉപയോക്താവ് 0.00 സിസ്റ്റം 0.00


നിങ്ങൾക്ക് XML പരിചിതമാണെങ്കിൽ, ഇത് സ്വയം വിശദീകരിക്കേണ്ടതാണ്. അതും എ
ടെസ്റ്റ് സ്യൂട്ടുകൾ അവയുടെ ഔട്ട്പുട്ട് ഒരു മാസ്റ്ററിലേക്ക് കൂട്ടിച്ചേർക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതിനാൽ XML ഫയൽ പൂർത്തിയാക്കുക
വിവരിച്ചിരിക്കുന്നതുപോലെ XML സ്റ്റാറ്റസ് ഫയൽ test.py വിഭാഗം.

ഡീബഗ്ഗിംഗ് പരിശോധന സ്യൂട്ട് പരാജയങ്ങൾ
പോലുള്ള ടെസ്റ്റ് ക്രാഷുകൾ ഡീബഗ് ചെയ്യാൻ

ക്രാഷ്: TestSuite ns3-wifi-interference

താഴെ പറയുന്ന രീതിയിൽ gdb വഴി നിങ്ങൾക്ക് അന്തർലീനമായ ടെസ്റ്റ്-റണ്ണർ പ്രോഗ്രാം ആക്സസ് ചെയ്യാൻ കഴിയും, തുടർന്ന് പാസ്സാക്കുക
പ്രവർത്തിപ്പിക്കാനുള്ള "--basedir=`pwd`" ആർഗ്യുമെന്റ് (ആവശ്യമനുസരിച്ച് നിങ്ങൾക്ക് മറ്റ് ആർഗ്യുമെന്റുകളും നൽകാം, പക്ഷേ
baseir ആണ് ഏറ്റവും കുറഞ്ഞ ആവശ്യം):

$ ./waf --command-template="gdb %s" --run "test-runner"
വാഫ്: ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു `/home/tomh/hg/sep09/ns-3-allinone/ns-3-dev-678/build'
വാഫ്: ഡയറക്ടറി വിടുന്നു `/home/tomh/hg/sep09/ns-3-allinone/ns-3-dev-678/build'
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയായി (0.380സെ)
GNU gdb 6.8-debian
പകർപ്പവകാശം (C) 2008 സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ, Inc.
L cense GPLv3+: GNU GPL പതിപ്പ് 3 അല്ലെങ്കിൽ അതിനുശേഷമുള്ളത്http://gnu.org/licenses/gpl.html>
ഇതൊരു സ്വതന്ത്ര സോഫ്‌റ്റ്‌വെയർ ആണ്: നിങ്ങൾക്ക് ഇത് മാറ്റാനും പുനർവിതരണം ചെയ്യാനും സ്വാതന്ത്ര്യമുണ്ട്.
നിയമം അനുവദിക്കുന്ന പരിധി വരെ വാറന്റി ഇല്ല. "പകർപ്പ് കാണിക്കുക" എന്ന് ടൈപ്പ് ചെയ്യുക
കൂടാതെ വിശദാംശങ്ങൾക്ക് "വാറന്റി കാണിക്കുക".
ഈ GDB "x86_64-linux-gnu" ആയി ക്രമീകരിച്ചിരിക്കുന്നു...
(gdb) r --basedir=`pwd`
പ്രോഗ്രാം ആരംഭിക്കുന്നു: <..>/build/debug/utils/test-runner --basedir=`pwd`
[libthread_db ഉപയോഗിച്ച് ത്രെഡ് ഡീബഗ്ഗിംഗ് പ്രവർത്തനക്ഷമമാക്കി]
അവകാശവാദം പരാജയപ്പെട്ടു. ഫയൽ=../src/core/model/type-id.cc, line=138, cond="uid <= m_information.size () && uid != 0"
...

ഒരു മെമ്മറി പ്രശ്നം ഡീബഗ് ചെയ്യുന്നതിന് valgrind എങ്ങനെ ഉപയോഗിക്കാമെന്നതിന്റെ മറ്റൊരു ഉദാഹരണം ഇതാ:

VALGR: TestSuite devices-mesh-dot11s-regression

$ ./waf --command-template="valgrind %s --basedir=`pwd` --suite=devices-mesh-dot11s-regression" --run test-runner

ക്ലാസ് ടെസ്റ്റ് റണ്ണർ
സമർപ്പിത ടെസ്റ്റ് പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്ന എക്സിക്യൂട്ടബിളുകൾ ഒരു TestRunner ക്ലാസ് ഉപയോഗിക്കുന്നു. ഈ ക്ലാസ്
ഓട്ടോമാറ്റിക് ടെസ്റ്റ് രജിസ്ട്രേഷനും ലിസ്റ്റിംഗും, അതുപോലെ തന്നെ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള ഒരു മാർഗവും നൽകുന്നു
വ്യക്തിഗത പരിശോധനകൾ. വ്യക്തിഗത ടെസ്റ്റ് സ്യൂട്ടുകൾ സ്വയം ചേർക്കാൻ C++ ഗ്ലോബൽ കൺസ്ട്രക്‌ടറുകൾ ഉപയോഗിക്കുന്നു
ടെസ്റ്റ് റണ്ണർ നിയന്ത്രിക്കുന്ന ടെസ്റ്റ് സ്യൂട്ടുകളുടെ ഒരു ശേഖരം. ലിസ്റ്റുചെയ്യാൻ ടെസ്റ്റ് റണ്ണർ ഉപയോഗിക്കുന്നു
ലഭ്യമായ എല്ലാ ടെസ്റ്റുകളും റൺ ചെയ്യേണ്ട ഒരു ടെസ്റ്റ് തിരഞ്ഞെടുക്കാൻ. ഇത് വളരെ ലളിതമായ ക്ലാസാണ്
ടെസ്റ്റ് സ്യൂട്ടുകൾ നൽകുന്നതിനും കൂട്ടിച്ചേർക്കുന്നതിനും നേടുന്നതിനും മൂന്ന് സ്റ്റാറ്റിക് രീതികൾ നൽകുന്നു
ടെസ്റ്റുകളുടെ ശേഖരം. ക്ലാസിനുള്ള ഡോക്‌സിജൻ കാണുക ns3::ടെസ്റ്റ് റണ്ണർ വിവരങ്ങൾക്ക്.

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

· ബിൽഡ് വെരിഫിക്കേഷൻ ടെസ്റ്റുകൾ

· യൂണിറ്റ് ടെസ്റ്റുകൾ

· സിസ്റ്റം ടെസ്റ്റുകൾ

· ഉദാഹരണങ്ങൾ

· പ്രകടന പരിശോധനകൾ

ഈ വർഗ്ഗീകരണം TestSuite ക്ലാസിൽ നിന്ന് എക്‌സ്‌പോർട്ട് ചെയ്‌തതാണ്. ഈ ക്ലാസ് വളരെ ലളിതമാണ്,
ഈ തരം കയറ്റുമതി ചെയ്യുന്നതിനും ടെസ്റ്റ് കേസുകൾ ശേഖരിക്കുന്നതിനുമുള്ള ഒരു സ്ഥലമായി മാത്രം നിലവിലുണ്ട്. ഒരു ഉപയോക്താവിൽ നിന്ന്
വീക്ഷണം, സിസ്റ്റത്തിൽ ഒരു പുതിയ TestSuite സൃഷ്‌ടിക്കുന്നതിന് ഒരാൾക്ക് പുതിയത് നിർവചിക്കേണ്ടതുണ്ട്
ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ക്ലാസ് ടെസ്റ്റ് സ്യൂട്ട് ഈ രണ്ട് ചുമതലകളും നിർവഹിക്കുക.

ഇനിപ്പറയുന്ന കോഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു പുതിയ ക്ലാസ്സിനെ നിർവചിക്കും test.py ഒരു ''യൂണിറ്റ്'' ടെസ്റ്റ് ആയി
ഡിസ്പ്ലേ പേരിനൊപ്പം, my-test-suite-name.

ക്ലാസ് മൈ സ്യൂട്ട്: പൊതു ടെസ്റ്റ് സ്യൂട്ട്
{
പൊതുവായത്:
MyTestSuite ();
};

MyTestSuite::MyTestSuite ()
: TestSuite ("my-test-suite-name", UNIT)
{
AddTestCase (പുതിയ MyTestCase);
}

MyTestSuite myTestSuite;

മികച്ചതായിരിക്കാൻ ആവശ്യമായ എല്ലാ രജിസ്ട്രേഷനും റിപ്പോർട്ടിംഗും അടിസ്ഥാന ക്ലാസ് ശ്രദ്ധിക്കുന്നു
ടെസ്റ്റ് ചട്ടക്കൂടിലെ പൗരൻ.

പരിശോധന കേസ്
ടെസ്റ്റ്കേസ് ക്ലാസ് ഉപയോഗിച്ചാണ് വ്യക്തിഗത ടെസ്റ്റുകൾ സൃഷ്ടിക്കുന്നത്. ഒരു ടെസ്റ്റ് ഉപയോഗിക്കുന്നതിനുള്ള സാധാരണ മോഡലുകൾ
കേസിൽ "ഒരു ഫീച്ചറിന് ഒരു ടെസ്റ്റ് കേസ്", "ഓരോ രീതിയിലും ഒരു ടെസ്റ്റ് കേസ്" എന്നിവ ഉൾപ്പെടുന്നു. മിശ്രിതങ്ങൾ
ഈ മോഡലുകൾ ഉപയോഗിക്കാം.

സിസ്റ്റത്തിൽ ഒരു പുതിയ ടെസ്റ്റ് കെയ്‌സ് സൃഷ്‌ടിക്കുന്നതിന്, ഒരാൾ ചെയ്യേണ്ടത് ഇതിൽ നിന്ന് അനന്തരാവകാശം നേടുക എന്നതാണ്
ടെസ്റ്റ്കേസ് അടിസ്ഥാന ക്ലാസ്, ടെസ്റ്റ് കേസിന് ഒരു പേര് നൽകാനും അസാധുവാക്കാനും കൺസ്ട്രക്റ്ററെ അസാധുവാക്കുക
The ഡോറൺ ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള രീതി.

ക്ലാസ് MyTestCase : പൊതു ടെസ്റ്റ്കേസ്
{
MyTestCase ();
വെർച്വൽ ശൂന്യമായ DoRun (ശൂന്യം);
};

MyTestCase::MyTestCase ()
: TestCase ("കുറച്ച് പ്രവർത്തനക്ഷമത പരിശോധിക്കുക")
{
}

ശൂന്യം
MyTestCase::DoRun (അസാധു)
{
NS_TEST_ASSERT_MSG_EQ (ശരി, ശരി, "ചില പരാജയ സന്ദേശം");
}

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

ഈ യൂട്ടിലിറ്റികൾ ഇവിടെ രേഖപ്പെടുത്തിയിട്ടില്ല, എന്നാൽ ഉദാഹരണത്തിന്, TCP ടെസ്റ്റുകൾ എങ്ങനെയെന്ന് കാണുക
ൽ കണ്ടെത്തി src/test/ns3tcp/ pcap ഫയലുകളും റഫറൻസ് ഔട്ട്പുട്ടും ഉപയോഗിക്കുക.

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

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

മാതൃക ടെസ്റ്റ് സ്യൂട്ട് അസ്ഥികൂടം
ആദ്യം മുതൽ ആരംഭിക്കുമ്പോൾ (അതായത്, നിലവിലുള്ള ടെസ്റ്റ്‌സ്യൂട്ടിലേക്ക് ടെസ്റ്റ്കേസ് ചേർക്കുന്നില്ല), ഇവ
കാര്യങ്ങൾ മുൻകൂട്ടി തീരുമാനിക്കേണ്ടതുണ്ട്:

· ടെസ്റ്റ് സ്യൂട്ടിനെ എന്ത് വിളിക്കും

· അത് ഏത് തരത്തിലുള്ള ടെസ്റ്റായിരിക്കും (ബിൽഡ് വെരിഫിക്കേഷൻ ടെസ്റ്റ്, യൂണിറ്റ് ടെസ്റ്റ്, സിസ്റ്റം ടെസ്റ്റ്, അല്ലെങ്കിൽ
പ്രകടന പരിശോധന)

ടെസ്റ്റ് കോഡ് എവിടെയാണ് നിലനിൽക്കുന്നത് (നിലവിലുള്ള ns-3 മൊഡ്യൂളിൽ അല്ലെങ്കിൽ പ്രത്യേകമായി
src/test/ ഡയറക്ടറി). ആ ഡയറക്‌ടറിയിലെ wscript ഫയൽ നിങ്ങൾ എഡിറ്റ് ചെയ്യേണ്ടി വരും
നിങ്ങളുടെ പുതിയ കോഡ് കംപൈൽ ചെയ്യുക, അതൊരു പുതിയ ഫയലാണെങ്കിൽ.

എന്നൊരു പരിപാടി src/create-module.py ഒരു നല്ല തുടക്കമാണ്. ഈ പ്രോഗ്രാം ആകാം
തുടങ്ങിയ അഭ്യർത്ഥിച്ചു create-module.py റൂട്ടർ എന്ന ഒരു സാങ്കൽപ്പിക പുതിയ മൊഡ്യൂളിനായി റൂട്ടർ. ഒരിക്കല്
നിങ്ങൾ ഇത് ചെയ്യുക, നിങ്ങൾ ഒരു കാണും റൂട്ടർ ഡയറക്ടറി, കൂടാതെ എ test/router-test-suite.cc ടെസ്റ്റ് സ്യൂട്ട്.
ഈ ഫയൽ നിങ്ങളുടെ പ്രാരംഭ പരിശോധനയ്ക്ക് ഒരു ആരംഭ പോയിന്റായിരിക്കാം. ഇതൊരു പ്രവർത്തിക്കുന്ന ടെസ്റ്റ് സ്യൂട്ടാണ്,
നടത്തിയ യഥാർത്ഥ പരിശോധനകൾ നിസ്സാരമാണെങ്കിലും. ഇത് നിങ്ങളുടെ മൊഡ്യൂളിന്റെ ടെസ്റ്റിലേക്ക് പകർത്തുക
ഡയറക്‌ടറി, കൂടാതെ ആ ഫയലിലെ "റൗട്ടർ" എന്നതിന് ഒരു ആഗോള പകരം വയ്ക്കൽ നടത്തുക
നിങ്ങൾ പരീക്ഷിക്കാൻ ആഗ്രഹിക്കുന്ന മോഡലിലേക്ക്. നിങ്ങൾക്ക് കൂടുതൽ വിവരണാത്മകമായ കാര്യങ്ങൾ എഡിറ്റ് ചെയ്യാനും കഴിയും
ടെസ്റ്റ് കേസ് പേര്.

ഈ ടെസ്റ്റ് കംപൈൽ ചെയ്യുന്നതിന് നിങ്ങളുടെ wscript-ലേക്ക് ഒരു ബ്ലോക്ക് ചേർക്കേണ്ടതുണ്ട്:

module_test.source = [
'test/router-test-suite.cc',
]

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

RouterTestSuite::RouterTestSuite ()
: TestSuite ("റൂട്ടർ", UNIT)

ഈ കമാൻഡ് പരീക്ഷിക്കുക:

$ ./test.py -s റൂട്ടർ

താഴെപ്പറയുന്ന തരത്തിലുള്ള ഔട്ട്പുട്ട് നിർമ്മിക്കണം:

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

പ്രവർത്തിച്ച ഉദാഹരണത്തിനായി src/lte/test/test-lte-antenna.cc കാണുക.

പരിശോധന മാക്രോകൾ
ടെസ്‌റ്റ് പ്രോഗ്രാം ഔട്ട്‌പുട്ട് പ്രതീക്ഷിക്കുന്ന രീതിയിൽ പരിശോധിക്കാൻ നിരവധി മാക്രോകൾ ലഭ്യമാണ്
ഔട്ട്പുട്ട്. ഈ മാക്രോകൾ നിർവചിച്ചിരിക്കുന്നത് src/core/model/test.h.

ഉപയോഗിക്കുന്ന മാക്രോകളുടെ പ്രധാന സെറ്റിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:

NS_TEST_ASSERT_MSG_EQ(യഥാർത്ഥം, പരിധി, സന്ദേശം)
NS_TEST_ASSERT_MSG_NE(യഥാർത്ഥം, പരിധി, സന്ദേശം)
NS_TEST_ASSERT_MSG_LT(യഥാർത്ഥം, പരിധി, സന്ദേശം)
NS_TEST_ASSERT_MSG_GT(യഥാർത്ഥം, പരിധി, സന്ദേശം)
NS_TEST_ASSERT_MSG_EQ_TOL(യഥാർത്ഥ, പരിധി, ടോൾ, സന്ദേശം)

ആദ്യത്തെ വാദം യഥാർത്ഥ പരീക്ഷണത്തിന് കീഴിലുള്ള മൂല്യമാണ്, രണ്ടാമത്തെ മൂല്യം പരിധി പ്രതീക്ഷിച്ചതാണ്
മൂല്യം (അല്ലെങ്കിൽ പരീക്ഷിക്കേണ്ട മൂല്യം), അവസാന ആർഗ്യുമെന്റ് msg എന്നതിലേക്കുള്ള പിശക് സന്ദേശം
പരീക്ഷ പരാജയപ്പെട്ടാൽ പ്രിന്റ് ഔട്ട് ചെയ്യുക.

മുകളിലുള്ള ആദ്യത്തെ നാല് മാക്രോകൾ തുല്യത, അസമത്വം, അതിലും കുറവോ വലുതോ പരിശോധിക്കുന്നു
യഥാക്രമം. മുകളിലുള്ള അഞ്ചാമത്തെ മാക്രോ സമത്വത്തിനായി പരിശോധിക്കുന്നു, പക്ഷേ ഒരു നിശ്ചിത സഹിഷ്ണുതയ്ക്കുള്ളിൽ.
ഒരു പരിധിക്കെതിരെ തുല്യതയ്ക്കായി ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ പരിശോധിക്കുമ്പോൾ ഈ വേരിയന്റ് ഉപയോഗപ്രദമാണ്,
റൗണ്ടിംഗ് പിശകുകൾ കാരണം ഒരു ടെസ്റ്റ് പരാജയം ഒഴിവാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നിടത്ത്.

അവസാനമായി, കീവേഡ് മുകളിൽ പറഞ്ഞവയുടെ വകഭേദങ്ങളുണ്ട് ASSERT ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു പ്രതീക്ഷിക്കുക.
ഈ വേരിയന്റുകൾ പ്രത്യേകം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് രീതികളിൽ (പ്രത്യേകിച്ച് കോൾബാക്കുകൾ) റിട്ടേണിംഗ് ഉപയോഗിക്കുന്നതിന് വേണ്ടിയാണ്
ശൂന്യം. നിങ്ങളുടെ ടെസ്റ്റ് പ്രോഗ്രാമുകളിൽ ഉപയോഗിക്കുന്ന കോൾബാക്കുകൾക്കായി അവരുടെ ഉപയോഗം റിസർവ് ചെയ്യുക; അല്ലെങ്കിൽ, ഉപയോഗിക്കുക
The ASSERT വേരിയന്റുകൾ.

എങ്ങനെ ലേക്ക് ചേർക്കുക an ഉദാഹരണം പ്രോഗ്രാം ലേക്ക് The പരിശോധന സ്യൂട്ട്
ഉദാഹരണങ്ങൾ കംപൈൽ ചെയ്ത് വിജയകരമായി പൂർത്തിയാക്കുന്ന "സ്മോക്ക് ടെസ്റ്റ്" (ഇല്ലാതെ
മെമ്മറി ലീക്കുകൾ) ഉപയോഗിച്ച് ഉദാഹരണങ്ങൾ-to-run.py നിങ്ങളുടെ മൊഡ്യൂളിന്റെ ടെസ്റ്റ് ഡയറക്ടറിയിൽ സ്ക്രിപ്റ്റ് സ്ഥിതിചെയ്യുന്നു.
ചുരുക്കത്തിൽ, നിങ്ങളുടെ ടെസ്റ്റ് ഡയറക്‌ടറിയിൽ ഈ ഫയലിന്റെ ഒരു ഉദാഹരണം ഉൾപ്പെടുത്തുന്നതിലൂടെ, നിങ്ങൾക്ക് ഇത് സംഭവിക്കാം
ലിസ്റ്റുചെയ്ത ഉദാഹരണങ്ങൾ നടപ്പിലാക്കാൻ ടെസ്റ്റ് റണ്ണർ. നിങ്ങൾ എന്ന് ഉറപ്പുവരുത്തുന്നതാണ് സാധാരണയായി നല്ലത്
ടെസ്റ്റുകളിൽ തെറ്റുപറ്റാതിരിക്കാൻ, കുറഞ്ഞ സമയമുള്ള ഉദാഹരണങ്ങൾ തിരഞ്ഞെടുക്കുക. കാണുക
ഉദാഹരണം src/lte/test/ ഡയറക്ടറി.

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

ശ്രദ്ധിക്കുക:
വിവരണക്കുറിപ്പു്

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

ഡിസൈൻ സമീപനം
ഇത് എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് പരിഗണിക്കുക; അത് എന്ത് ചെയ്യണം. ഈ കാര്യങ്ങളെക്കുറിച്ച് ചിന്തിക്കുക:

· പ്രവർത്തനം: അതിന് എന്ത് പ്രവർത്തനക്ഷമത ഉണ്ടായിരിക്കണം? എന്താണ് ആട്രിബ്യൂട്ടുകൾ അല്ലെങ്കിൽ കോൺഫിഗറേഷൻ
ഉപയോക്താവിന് വെളിപ്പെട്ടോ?

· പുനരുപയോഗം: എന്റെ ഡിസൈൻ എത്രത്തോളം മറ്റുള്ളവർക്ക് വീണ്ടും ഉപയോഗിക്കാനാകും? എന്നതിൽ നിന്നുള്ള കോഡ് എനിക്ക് വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുമോ?
ns-2 ആരംഭിക്കാൻ? ഒരു ഉപയോക്താവ് എങ്ങനെ മോഡലിനെ ബാക്കിയുള്ളവയുമായി സമന്വയിപ്പിക്കും
അനുകരണം?

· ആശ്രിതത്വങ്ങൾ: എന്റെ പുതിയ കോഡിന് പുറത്തുള്ള ഡിപൻഡൻസികളുടെ ആമുഖം എനിക്ക് എങ്ങനെ കുറയ്ക്കാനാകും
കഴിയുന്നത്ര (ഇത് കൂടുതൽ മോഡുലാർ ആക്കാൻ)? ഉദാഹരണത്തിന്, ഞാൻ എന്തെങ്കിലും ഒഴിവാക്കണം
IPv4-ലും ഉപയോഗിക്കണമെങ്കിൽ IPv6-നെ ആശ്രയിക്കണോ? ഞാൻ ഏതെങ്കിലും ആശ്രിതത്വം ഒഴിവാക്കണം
IP-യിലാണോ?

യുമായി ബന്ധപ്പെടാൻ മടിക്കേണ്ട ns-3-ഉപയോക്താക്കൾ or ns-ഡെവലപ്പർമാർ നിങ്ങൾക്ക് ചോദ്യങ്ങളുണ്ടെങ്കിൽ ലിസ്റ്റ് ചെയ്യുക.
പ്രത്യേകിച്ചും, നിങ്ങളുടെ പുതിയ മോഡലിന്റെ പൊതു API-യെക്കുറിച്ച് ചിന്തിക്കുകയും ആവശ്യപ്പെടുകയും ചെയ്യേണ്ടത് പ്രധാനമാണ്
പ്രതികരണം. നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ നിങ്ങളുടെ ജോലിയെക്കുറിച്ച് മറ്റുള്ളവരെ അറിയിക്കാനും ഇത് സഹായിക്കുന്നു
സഹകാരികൾ.

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

പിശക് മോഡലിന്റെ പ്രധാന API എന്നത് ഒരു പാക്കറ്റിലേക്ക് കൈമാറുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷനും അതിന്റെ റിട്ടേൺ മൂല്യവുമാണ്
എന്തെങ്കിലും അഴിമതി നടന്നിട്ടുണ്ടോ എന്ന് വിളിക്കുന്നയാളോട് പറയുന്ന ഒരു ബൂളിയൻ ആണ് ഈ ഫംഗ്ഷൻ. കുറിപ്പ്
പിശക് മോഡലിനെ ആശ്രയിച്ച്, പാക്കറ്റ് ഡാറ്റ ബഫർ കേടായേക്കാം അല്ലെങ്കിൽ കേടാകാതിരിക്കാം.
നമുക്ക് ഈ ഫംഗ്‌ഷൻ "IsCorrupt()" എന്ന് വിളിക്കാം.

ഇതുവരെ, ഞങ്ങളുടെ രൂപകൽപ്പനയിൽ, ഞങ്ങൾക്കുണ്ട്:

ക്ലാസ് പിശക് മോഡൽ
{
പൊതുവായത്:
/ **
പാക്കറ്റ് തെറ്റായി/കേടായതായി കണക്കാക്കണമെങ്കിൽ * \\ ശരിയാണെന്ന് നൽകുന്നു
പിശക് മോഡൽ പ്രയോഗിക്കുന്നതിനുള്ള * \param pkt പാക്കറ്റ്
*/
bool IsCorrupt (Ptr pkt);
};

ഞങ്ങൾ ഒരു കോൺസ്റ്റ് പോയിന്റർ പാസാക്കുന്നില്ലെന്ന കാര്യം ശ്രദ്ധിക്കുക, അതുവഴി ഫംഗ്‌ഷനെ പരിഷ്‌ക്കരിക്കാൻ അനുവദിക്കുന്നു
IsCorrupt() true എന്ന് നൽകുകയാണെങ്കിൽ പാക്കറ്റ്. എല്ലാ പിശക് മോഡലുകളും യഥാർത്ഥത്തിൽ പാക്കറ്റിനെ പരിഷ്കരിക്കില്ല;
പാക്കറ്റ് ഡാറ്റ ബഫർ കേടായിട്ടുണ്ടോ ഇല്ലയോ എന്നത് രേഖപ്പെടുത്തണം.

ഇൻ പോലെയുള്ള ഇതിന്റെ പ്രത്യേക പതിപ്പുകളും ഞങ്ങൾ ആഗ്രഹിച്ചേക്കാം ns-2, അങ്ങനെയല്ലെങ്കിലും
പോളിമോർഫിസത്തിനായുള്ള ഡിസൈൻ ചോയ്സ് മാത്രം, ഞങ്ങൾ ഒരു അടിസ്ഥാന ക്ലാസ് സബ്ക്ലാസ് ചെയ്യുമെന്ന് ഞങ്ങൾ അനുമാനിക്കുന്നു
RateErrorModel, ListErrorModel മുതലായവ പോലുള്ള പ്രത്യേക ക്ലാസുകൾക്കുള്ള ErrorModel
ൽ ചെയ്തു ns-2.

ഈ സമയത്ത് നിങ്ങൾ ചിന്തിക്കുന്നുണ്ടാകാം, "എന്തുകൊണ്ട് IsCorrupt() ഒരു വെർച്വൽ രീതി ആക്കിക്കൂടാ?". അതാണ്
ഒരു സമീപനം; മറ്റൊന്ന് a മുഖേന പബ്ലിക് നോൺ വെർച്വൽ ഫംഗ്‌ഷൻ പരോക്ഷമാക്കുക എന്നതാണ്
പ്രൈവറ്റ് വെർച്വൽ ഫംഗ്‌ഷൻ (സി++-ൽ ഇത് നോൺ വെർച്വൽ ഇന്റർഫേസ് ഐഡിയം എന്നാണ് അറിയപ്പെടുന്നത്.
ൽ സ്വീകരിച്ചു ns-3 പിശക് മോഡൽ ക്ലാസ്).

അടുത്തതായി, ഈ ഉപകരണത്തിന് IP അല്ലെങ്കിൽ മറ്റ് പ്രോട്ടോക്കോളുകളിൽ എന്തെങ്കിലും ആശ്രിതത്വം വേണോ? ഞങ്ങൾക്ക് വേണ്ട
ഇന്റർനെറ്റ് പ്രോട്ടോക്കോളുകളിൽ ഡിപൻഡൻസികൾ സൃഷ്ടിക്കുന്നതിന് (പിശക് മോഡൽ ബാധകമായിരിക്കണം
നോൺ-ഇന്റർനെറ്റ് പ്രോട്ടോക്കോളുകളും), അതിനാൽ ഞങ്ങൾ അത് പിന്നീട് മനസ്സിൽ സൂക്ഷിക്കും.

ഈ പിശക് മോഡൽ ഒബ്‌ജക്‌റ്റുകൾ എങ്ങനെ ഉൾപ്പെടുത്തും എന്നതാണ് മറ്റൊരു പരിഗണന. ഇടുന്നത് ഞങ്ങൾ വിഭാവനം ചെയ്യുന്നു
ചില NetDevice നടപ്പിലാക്കലുകളിൽ ഒരു വ്യക്തമായ സെറ്റർ, ഉദാഹരണത്തിന്.:

/ **
* PointToPointNetDevice-ലേക്ക് സ്വീകരിക്കുന്ന പിശക് മോഡൽ അറ്റാച്ചുചെയ്യുക.
*
* PointToPointNetDevice ഓപ്ഷണലായി ഒരു ErrorModel ഉൾപ്പെടുത്തിയേക്കാം
* പാക്കറ്റ് സ്വീകരിക്കുന്ന ചെയിൻ.
*
* @ErrorModel കാണുക
* @param em Ptr പിശക് മോഡലിലേക്ക്.
*/
അസാധുവായ PointToPointNetDevice::SetReceiveErrorModel(Ptr em);

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

കുറച്ച് ആലോചിച്ച ശേഷം നിലവിലുള്ളത് നോക്കി ns-2 കോഡ്, ഒരു ബേസിന്റെ സാമ്പിൾ API ഇതാ
പ്രാരംഭ അവലോകനത്തിനായി പോസ്റ്റ് ചെയ്യാവുന്ന ക്ലാസും ആദ്യ ഉപവിഭാഗവും:

ക്ലാസ് പിശക് മോഡൽ
{
പൊതുവായത്:
പിശക് മോഡൽ ();
വെർച്വൽ ~ErrorModel ();
bool IsCorrupt (Ptr pkt);
ശൂന്യമായ റീസെറ്റ് (അസാധു);
ശൂന്യം പ്രാപ്തമാക്കുക (അസാധു);
ശൂന്യം പ്രവർത്തനരഹിതമാക്കുക (അസാധു);
bool IsEnabled (അസാധു) const;
സ്വകാര്യം:
വെർച്വൽ ബൂൾ DoCorrupt (Ptr pkt) = 0;
വെർച്വൽ ശൂന്യത DoReset (അസാധു) = 0;
};

enum ErrorUnit
{
EU_BIT,
EU_BYTE,
EU_PKT
};

// ഒരു അണ്ടർലയിങ്ങുമായി ബന്ധപ്പെട്ട് ഏതൊക്കെ പാക്കറ്റുകളാണ് പിഴച്ചതെന്ന് നിർണ്ണയിക്കുക
// റാൻഡം വേരിയബിൾ ഡിസ്ട്രിബ്യൂഷൻ, ഒരു പിശക് നിരക്ക്, നിരക്കിന്റെ യൂണിറ്റ്.
class RateErrorModel : public ErrorModel
{
പൊതുവായത്:
RateErrorModel ();
വെർച്വൽ ~RateErrorModel ();
enum ErrorUnit GetUnit (അസാധു) const;
അസാധുവായ SetUnit (enum ErrorUnit error_unit);
ഇരട്ട GetRate (അസാധു) കോൺസ്റ്റ്;
അസാധുവായ സെറ്റ് റേറ്റ് (ഇരട്ട നിരക്ക്);
അസാധുവായ SetRandomVariable (const RandomVariable &ranvar);
സ്വകാര്യം:
വെർച്വൽ ബൂൾ DoCorrupt (Ptr pkt);
വെർച്വൽ ശൂന്യമായ DoReset (അസാധു);
};

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

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

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

അവലോകനം The ns-3 കോഡിംഗ് ശൈലി പ്രമാണം
ഈ സമയത്ത്, നിങ്ങൾ താൽക്കാലികമായി നിർത്തി വായിക്കാൻ ആഗ്രഹിച്ചേക്കാം ns-3 കോഡിംഗ് ശൈലി പ്രമാണം, പ്രത്യേകിച്ച്
പ്രോജക്റ്റിലേക്ക് നിങ്ങളുടെ കോഡ് തിരികെ നൽകാൻ നിങ്ങൾ പരിഗണിക്കുകയാണെങ്കിൽ. കോഡിംഗ് ശൈലി
പ്രധാന പ്രോജക്റ്റ് പേജിൽ നിന്ന് പ്രമാണം ലിങ്ക് ചെയ്തിരിക്കുന്നു: ns-3 കോഡിംഗ് ശൈലി.

തീരുമാനിക്കുക എവിടെ in The ഉറവിടം വൃക്ഷം The മാതൃക വേണം താമസിക്കുക
അതിലെല്ലാം ns-3 മോഡൽ സോഴ്സ് കോഡ് ഡയറക്ടറിയിലാണ് src /. ഏതാണ് നിങ്ങൾ തിരഞ്ഞെടുക്കേണ്ടത്
ഉപഡയറക്‌ടറി അത് വസിക്കുന്നു. ഇത് ഏതെങ്കിലും തരത്തിലുള്ള പുതിയ മോഡൽ കോഡാണെങ്കിൽ, അത് ഇടുന്നതിൽ അർത്ഥമുണ്ട്
കടന്നു src / എവിടെയോ ഡയറക്ടറി, പ്രത്യേകിച്ച് ബിൽഡുമായി സംയോജിപ്പിക്കുന്നതിനുള്ള എളുപ്പത്തിനായി
സിസ്റ്റം.

പിശക് മോഡലിന്റെ കാര്യത്തിൽ, ഇത് പാക്കറ്റ് ക്ലാസുമായി വളരെ ബന്ധപ്പെട്ടിരിക്കുന്നു, അതിനാൽ ഇത് അർത്ഥമാക്കുന്നു
ൽ ഇത് നടപ്പിലാക്കാൻ src/network/ മൊഡ്യൂൾ എവിടെ ns-3 പാക്കറ്റുകൾ നടപ്പിലാക്കുന്നു.

വാഫ് ഒപ്പം wscript
ns-3 ഉപയോഗിക്കുന്നത് വഫ് ബിൽഡ് സിസ്റ്റം. നിങ്ങളുടെ പുതിയത് സംയോജിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കും ns-3 വാഫ് ഉപയോഗിക്കുന്നു
ബിൽഡ് സിസ്റ്റം. ഈ സിസ്റ്റത്തിലേക്ക് നിങ്ങളുടെ പുതിയ ഉറവിട ഫയലുകൾ സംയോജിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കും. ഈ
എന്നതിലേക്ക് നിങ്ങളുടെ ഫയലുകൾ ചേർക്കാൻ ആവശ്യപ്പെടുന്നു wscript ഓരോ ഡയറക്ടറിയിലും ഫയൽ കണ്ടെത്തി.

നമുക്ക് ശൂന്യമായ ഫയലുകളിൽ ആരംഭിക്കാം error-model.h, error-model.cc എന്നിവയിൽ ഇത് ചേർക്കുക
src/network/wscript. ഇത് ശരിക്കും .cc ഫയൽ ബാക്കിയുള്ളവയിലേക്ക് ചേർക്കുന്നത് മാത്രമാണ്
ഉറവിട ഫയലുകൾ, കൂടാതെ .h ഫയൽ ഹെഡർ ഫയലുകളുടെ ലിസ്റ്റിലേക്ക്.

ഇപ്പോൾ, ടോപ്പ് ലെവൽ ഡയറക്ടറിയിലേക്ക് പോപ്പ് അപ്പ് ചെയ്ത് "./test.py" എന്ന് ടൈപ്പ് ചെയ്യുക. നിങ്ങൾ തകർക്കാൻ പാടില്ലായിരുന്നു
ഈ പ്രവർത്തനത്തിലൂടെ എന്തും.

ഉൾപ്പെടുന്നു കാവൽക്കാർ
അടുത്തതായി, നമുക്ക് കുറച്ച് ചേർക്കാം ഉൾപ്പെടുന്നു കാവൽക്കാർ ഞങ്ങളുടെ തലക്കെട്ട് ഫയലിൽ.:

#ifndef ERROR_MODEL_H
#ERROR_MODEL_H നിർവ്വചിക്കുക
...
#അവസാനം

നെയിംസ്പേസ് ns3
ns-3 ഉപയോഗിക്കുന്നത് ns-3 നെയിംസ്പേസ് മറ്റ് നെയിംസ്പേസുകളിൽ നിന്ന് അതിന്റെ ചിഹ്നങ്ങളെ വേർതിരിച്ചെടുക്കാൻ. സാധാരണഗതിയിൽ, എ
ഉപയോക്താവ് അടുത്തതായി ഒരു ഇടും ns-3 cc, h ഫയലുകളിൽ നെയിംസ്പേസ് ബ്ലോക്ക്.:

നെയിംസ്പേസ് ns3 {
...
}

ഈ സമയത്ത്, ഞങ്ങളുടെ പുതിയ ക്ലാസുകൾ നിർവചിക്കാൻ തുടങ്ങാൻ കഴിയുന്ന ചില അസ്ഥികൂട ഫയലുകൾ ഉണ്ട്.
തലക്കെട്ട് ഫയൽ ഇതുപോലെ കാണപ്പെടുന്നു:

#ifndef ERROR_MODEL_H
#ERROR_MODEL_H നിർവ്വചിക്കുക

നെയിംസ്പേസ് ns3 {

} // നെയിംസ്പേസ് ns3
#അവസാനം

അതേസമയം error-model.cc ഫയൽ ഇതുപോലെ കാണപ്പെടുന്നു:

#"error-model.h" ഉൾപ്പെടുത്തുക

നെയിംസ്പേസ് ns3 {

} // നെയിംസ്പേസ് ns3

ഈ ഫയലുകൾ കംപൈൽ ചെയ്യണം, കാരണം അവയ്ക്ക് ഉള്ളടക്കങ്ങളൊന്നുമില്ല. ഞങ്ങൾ ഇപ്പോൾ തയ്യാറാണ്
ക്ലാസുകൾ ചേർക്കാൻ ആരംഭിക്കുക.

പ്രാരംഭ നടപ്പിലാക്കൽ
ഈ ഘട്ടത്തിൽ, ഞങ്ങൾ ഇപ്പോഴും ചില സ്കാർഫോൾഡിംഗിൽ പ്രവർത്തിക്കുകയാണ്, എന്നാൽ നമുക്ക് ഞങ്ങളുടെ നിർവചിക്കാൻ തുടങ്ങാം
ക്ലാസുകൾ, പിന്നീട് ചേർക്കേണ്ട പ്രവർത്തനക്ഷമത.

ഇൻഹെറിറ്റ് നിന്ന് The വസ്തു ക്ലാസ്?
ഇത് ഒരു പ്രധാന ഡിസൈൻ ഘട്ടമാണ്; ക്ലാസ് ഉപയോഗിക്കണോ എന്ന് വസ്തു നിങ്ങളുടെ പുതിയവയുടെ അടിസ്ഥാന ക്ലാസായി
ക്ലാസുകൾ.

എന്ന അധ്യായത്തിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ ns-3 ഒബ്ജക്റ്റ് മോഡൽ, ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ക്ലാസുകൾ
വസ്തു പ്രത്യേക ഗുണങ്ങൾ നേടുക:

· ദി ns-3 ടൈപ്പും ആട്രിബ്യൂട്ടും സിസ്റ്റം (ആട്രിബ്യൂട്ടുകൾ കാണുക)

· ഒരു ഒബ്ജക്റ്റ് അഗ്രഗേഷൻ സിസ്റ്റം

ഒരു സ്മാർട്ട് പോയിന്റർ റഫറൻസ് കൗണ്ടിംഗ് സിസ്റ്റം (ക്ലാസ് പിടിആർ)

ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ക്ലാസുകൾ ഒബ്ജക്റ്റ്ബേസ്} മുകളിലുള്ള ആദ്യത്തെ രണ്ട് പ്രോപ്പർട്ടികൾ നേടുക, പക്ഷേ ചെയ്യരുത്
സ്മാർട്ട് പോയിന്ററുകൾ നേടുക. ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ക്ലാസുകൾ RefCountBase സ്മാർട്ട് പോയിന്റർ മാത്രം നേടുക
റഫറൻസ് കൗണ്ടിംഗ് സിസ്റ്റം.

പ്രായോഗികമായി, ക്ലാസ് വസ്തു അതിനു മുകളിലുള്ള മൂന്നിന്റെ വകഭേദമാണ് ns-3 ഡെവലപ്പർ ചെയ്യും
ഏറ്റവും സാധാരണയായി കണ്ടുമുട്ടുന്നത്.

ഞങ്ങളുടെ കാര്യത്തിൽ, ആട്രിബ്യൂട്ട് സിസ്റ്റം ഉപയോഗിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, ഞങ്ങൾ സംഭവങ്ങൾ കടന്നുപോകും
ഉടനീളം ഈ വസ്തുവിന്റെ ns-3 പൊതു API, അങ്ങനെ ക്ലാസ് വസ്തു നമുക്ക് അനുയോജ്യമാണ്.

പ്രാരംഭ ക്ലാസുകൾ
തുടരാനുള്ള ഒരു മാർഗ്ഗം, ഏറ്റവും കുറഞ്ഞ ഫംഗ്‌ഷനുകൾ നിർവചിച്ചുകൊണ്ട് ആരംഭിക്കുകയും അവ വേണോ എന്ന് നോക്കുകയും ചെയ്യുക എന്നതാണ്
സമാഹരിക്കുക. ക്ലാസ് ഒബ്‌ജക്‌റ്റിൽ നിന്ന് ഉരുത്തിരിഞ്ഞു വരുമ്പോൾ എല്ലാം നടപ്പിലാക്കാൻ എന്താണ് വേണ്ടതെന്ന് നമുക്ക് അവലോകനം ചെയ്യാം.:

#ifndef ERROR_MODEL_H
#ERROR_MODEL_H നിർവ്വചിക്കുക

#ഉൾപ്പെടുത്തുക "ns3/object.h"

നെയിംസ്പേസ് ns3 {

ക്ലാസ് പിശക് മോഡൽ: പൊതു വസ്തു
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);

പിശക് മോഡൽ ();
വെർച്വൽ ~ErrorModel ();
};

class RateErrorModel : public ErrorModel
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);

RateErrorModel ();
വെർച്വൽ ~RateErrorModel ();
};
#അവസാനം

ഇവിടെ ശ്രദ്ധിക്കേണ്ട ചില കാര്യങ്ങൾ. നാം ഉൾപ്പെടുത്തേണ്ടതുണ്ട് object.h. ഇൻ കൺവെൻഷൻ ns-3 അങ്ങനെയാണെങ്കിൽ
തലക്കെട്ട് ഫയൽ ഒരേ ഡയറക്‌ടറിയിൽ ലൊക്കേഷൻ ചെയ്‌തിരിക്കുന്നു, അത് ഒരു പാതയും കൂടാതെ ഉൾപ്പെടുത്തിയേക്കാം
ഉപസർഗ്ഗം. അതിനാൽ, ഞങ്ങൾ ErrorModel നടപ്പിലാക്കുകയാണെങ്കിൽ src/core/model ഡയറക്ടറി, ഞങ്ങൾ
വെറുതെ പറയാമായിരുന്നു"# ഉൾപ്പെടുത്തുക "object.h""എന്നാൽ ഞങ്ങൾ അകത്തുണ്ട് src/network/model, അതിനാൽ നമ്മൾ ചെയ്യണം
അത് ഉൾപ്പെടുത്തുക "# ഉൾപ്പെടുത്തുക "ns3/object.h"". ഇത് നെയിംസ്‌പെയ്‌സിന് പുറത്ത് പോകുന്നുവെന്നതും ശ്രദ്ധിക്കുക
പ്രഖ്യാപനം.

രണ്ടാമതായി, ഓരോ ക്ലാസും ഒരു സ്റ്റാറ്റിക് പബ്ലിക് മെമ്പർ ഫംഗ്‌ഷൻ നടപ്പിലാക്കണം GetTypeId (അസാധു).

മൂന്നാമതായി, കൺസ്ട്രക്‌റ്ററുകളും ഡിസ്ട്രക്‌റ്ററുകളും അനുവദിക്കുന്നതിനുപകരം നടപ്പിലാക്കുന്നത് നല്ലതാണ്
കംപൈലർ അവ സൃഷ്ടിക്കുകയും ഡിസ്ട്രക്റ്റർ വെർച്വൽ ആക്കുകയും ചെയ്യുന്നു. C++ ൽ, ആ പകർപ്പും ശ്രദ്ധിക്കുക
അസൈൻമെന്റ് ഓപ്പറേറ്ററും കോപ്പി കൺസ്ട്രക്‌റ്ററുകളും നിർവചിച്ചിട്ടില്ലെങ്കിൽ അവ സ്വയമേവ സൃഷ്‌ടിക്കപ്പെടും, അതിനാൽ
നിങ്ങൾക്ക് അവ ആവശ്യമില്ലെങ്കിൽ, നിങ്ങൾ അവ സ്വകാര്യ അംഗങ്ങളായി നടപ്പിലാക്കണം. ഈ വശം
സ്കോട്ട് മെയേഴ്സിന്റെ എഫക്റ്റീവ് C++ പുസ്തകത്തിൽ C++ ചർച്ച ചെയ്തിട്ടുണ്ട്. ഇനം 45.

ഇപ്പോൾ .cc ഫയലിലെ ചില അനുബന്ധ സ്കെലിറ്റൽ ഇംപ്ലിമെന്റേഷൻ കോഡ് നോക്കാം.:

#"error-model.h" ഉൾപ്പെടുത്തുക

നെയിംസ്പേസ് ns3 {

NS_OBJECT_ENSURE_REGISTERED (പിശക് മോഡൽ);

TypeId ErrorModel ::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3::ErrorModel")
.SetParent ()
;
റിട്ടേൺ ടിഡ്;
}

ErrorModel::ErrorModel ()
{
}

ErrorModel::~ErrorModel ()
{
}

NS_OBJECT_ENSURE_REGISTERED (RateErrorModel);

TypeId RateErrorModel ::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3:: RateErrorModel")
.SetParent ()
.AddConstructor ()
;
റിട്ടേൺ ടിഡ്;
}

RateErrorModel::RateErrorModel ()
{
}

RateErrorModel::~RateErrorModel ()
{
}

എന്താണ് GetTypeId (അസാധു) പ്രവർത്തനം? ഈ പ്രവർത്തനം ചില കാര്യങ്ങൾ ചെയ്യുന്നു. ഇത് എ രജിസ്റ്റർ ചെയ്യുന്നു
TypeId സിസ്റ്റത്തിലേക്കുള്ള അദ്വിതീയ സ്ട്രിംഗ്. ഇത് വസ്തുക്കളുടെ ശ്രേണി സ്ഥാപിക്കുന്നു
ആട്രിബ്യൂട്ട് സിസ്റ്റം (വഴി സെറ്റ്പാരന്റ്). ചില വസ്തുക്കൾ വഴി സൃഷ്ടിക്കാൻ കഴിയുമെന്നും ഇത് പ്രഖ്യാപിക്കുന്നു
ഒബ്ജക്റ്റ് സൃഷ്ടിക്കൽ ചട്ടക്കൂട് (ആഡ് കൺസ്ട്രക്റ്റർ).

മാക്രോ NS_OBJECT_ENSURE_REGISTERED (ക്ലാസ് നാമം) ഓരോ ക്ലാസ്സിനും ഒരിക്കൽ കൂടി ആവശ്യമാണ്
ഒരു പുതിയ GetTypeId രീതി നിർവചിക്കുന്നു, ഇത് ക്ലാസിന്റെ യഥാർത്ഥ രജിസ്ട്രേഷൻ ചെയ്യുന്നു
സിസ്റ്റം. ഒബ്ജക്റ്റ് മോഡൽ അധ്യായത്തിൽ ഇത് കൂടുതൽ വിശദമായി ചർച്ചചെയ്യുന്നു.

ഉൾപ്പെടെ ബാഹ്യ ഫയലുകൾ
ലോഗ് ചെയ്യുന്നു പിന്തുണ
ഇവിടെ, എഴുതുക a ബിറ്റ് കുറിച്ച് ചേർക്കുന്നു |ns3| ലോഗിംഗ് മാക്രോകൾ. കുറിപ്പ് ആ LOG_COMPONENT_DEFINE is
ചെയ്തു പുറത്ത് The നെയിംസ്പേസ് ns3

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

ചേർക്കുക അടിസ്ഥാനപരമായ പിന്തുണ in The ക്ലാസ്
/* point-to-point-net-device.h */
ക്ലാസ് ErrorModel;

/ **
* പാക്കറ്റ് ഇവന്റുകൾ സ്വീകരിക്കുന്നതിനുള്ള പിശക് മോഡൽ
*/
Ptr m_receiveErrorModel;

ചേർക്കുക ആക്സസ്സർ
ശൂന്യം
PointToPointNetDevice::SetReceiveErrorModel (Ptr) em)
{
NS_LOG_FUNCTION (ഇത് << em);
m_receiveErrorModel = em;
}

.AddAtribute ("ReceiveErrorModel",
"പാക്കറ്റ് നഷ്ടം അനുകരിക്കാൻ ഉപയോഗിക്കുന്ന റിസീവർ പിശക് മോഡൽ",
പോയിന്റർ മൂല്യം (),
MakePointerAccessor (&PointToPointNetDevice::m_receiveErrorModel),
MakePointerChecker ())

പ്ലംബ് ഇങ്ങോട്ട് The സിസ്റ്റം
അസാധുവായ PointToPointNetDevice:: സ്വീകരിക്കുക (Ptr പാക്കറ്റ്)
{
NS_LOG_FUNCTION (ഈ << പാക്കറ്റ്);
uint16_t പ്രോട്ടോക്കോൾ = 0;

എങ്കിൽ (m_receiveErrorModel && m_receiveErrorModel->ഇസ് കറപ്റ്റ് (പാക്കറ്റ്) )
{
//
// ഞങ്ങൾക്ക് ഒരു പിശക് മോഡൽ ഉണ്ടെങ്കിൽ, അത് നഷ്ടപ്പെടാനുള്ള സമയമാണെന്ന് സൂചിപ്പിക്കുന്നു
// കേടായ പാക്കറ്റ്, ഈ പാക്കറ്റ് അപ്പ് ഫോർവേഡ് ചെയ്യരുത്, അത് പോകട്ടെ.
//
m_dropTrace (പാക്കറ്റ്);
}
മറ്റാരെങ്കിലും
{
//
// റിസീവ് ട്രെയ്സ് ഹുക്ക് അമർത്തുക, പോയിന്റ്-ടു-പോയിന്റ് പ്രോട്ടോക്കോൾ ഹെഡർ നീക്കം ചെയ്യുക
// കൂടാതെ ഈ പാക്കറ്റ് പ്രോട്ടോക്കോൾ സ്റ്റാക്കിലേക്ക് കൈമാറുക.
//
m_rxTrace (പാക്കറ്റ്);
ProcessHeader(പാക്കറ്റ്, പ്രോട്ടോക്കോൾ);
m_rxCallback (ഇത്, പാക്കറ്റ്, പ്രോട്ടോക്കോൾ, GetRemote ());
എങ്കിൽ (!m_promiscCallback.IsNull ())
{ m_promiscCallback (ഇത്, പാക്കറ്റ്, പ്രോട്ടോക്കോൾ, GetRemote (),
GetAddress (), NetDevice ::PACKET_HOST);
}
}
}

സൃഷ്ടിക്കാൻ ശൂന്യം പ്രവർത്തനയോഗ്യമായ സ്ക്രിപ്റ്റ്
/* simple-error-model.cc */

// പിശക് മോഡൽ
// നോഡ് 3-ന്റെ NetDevice-ൽ ഒരു പിശക് മോഡൽ ചേർക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
//ചാനലും നോഡും വഴി നമുക്ക് NetDevice-ലേക്ക് ഒരു ഹാൻഡിൽ ലഭിക്കും
// പോയിന്ററുകൾ
Ptr nd3 = PointToPointTopology::GetNetDevice
(n3, channel2);
Ptr em = സൃഷ്ടിക്കുക ();
nd3->SetReceiveErrorModel (em);

bool
ErrorModel::DoCorrupt (പാക്കറ്റ്&p)
{
NS_LOG_FUNCTION;
NS_LOG_UNCOND("അഴിമതി!");
തെറ്റായ
}

ഈ ഘട്ടത്തിൽ, നമ്മുടെ നിസ്സാരമായ ErrorModel ഉപയോഗിച്ച് നമുക്ക് പ്രോഗ്രാം റൺ ചെയ്യാൻ കഴിയും
PointToPointNetDevice-ന്റെ പാത. ഇത് "അഴിമതി" എന്ന സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യുന്നു. ഓരോ പാക്കറ്റിനും
നോഡ് n3-ൽ ലഭിച്ചു. അടുത്തതായി, പ്രവർത്തിക്കുന്ന ഒരു ഉപവിഭാഗത്തിൽ ചേർക്കുന്നതിന് ഞങ്ങൾ പിശക് മോഡലിലേക്ക് മടങ്ങുന്നു
കൂടുതൽ രസകരമായ പിശക് മോഡലിംഗ്.

ചേർക്കുക a ഉപവിഭാഗം
നിസ്സാരമായ അടിസ്ഥാന ക്ലാസ് ErrorModel രസകരമായ ഒന്നും ചെയ്യുന്നില്ല, എന്നാൽ ഇത് ഒരു നൽകുന്നു
ഉപയോഗപ്രദമായ ബേസ് ക്ലാസ് ഇന്റർഫേസ് (കറപ്റ്റ് () കൂടാതെ റീസെറ്റ് ()), വെർച്വൽ ഫംഗ്‌ഷനുകളിലേക്ക് ഫോർവേഡ് ചെയ്‌തു
ഉപവിഭാഗമാക്കാം. അടിസ്ഥാന പിശക് മോഡൽ എന്ന് വിളിക്കുന്നതിനെ അടുത്തതായി പരിഗണിക്കാം
The ns-2 പിശക് മോഡൽ ക്ലാസ് (ഇൻ ns-2/ക്യൂ/എർമോഡൽ.{cc,h}).

ഒരു ഉപയോക്തൃ ഇന്റർഫേസ് വീക്ഷണകോണിൽ നിന്ന് ഇതിന് എന്ത് പ്രോപ്പർട്ടികൾ ഉണ്ടായിരിക്കണം? ഞങ്ങൾ ഇത് ചെയ്യാൻ ആഗ്രഹിക്കുന്നു
എന്നതിൽ ഉപയോഗിച്ചിരിക്കുന്ന ErrorModel തരം നിസ്സാരമായി മാറ്റാൻ ഉപയോക്താവിന് കഴിയും
നെറ്റ് ഡിവൈസ്. കോൺഫിഗർ ചെയ്യാവുന്ന പാരാമീറ്ററുകൾ സജ്ജീകരിക്കാനുള്ള കഴിവും ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.

ഞങ്ങൾ പരിഗണിക്കുന്ന ചില ലളിതമായ ആവശ്യകതകൾ ഇതാ:

· നഷ്ടം നിയന്ത്രിക്കുന്ന റാൻഡം വേരിയബിൾ സജ്ജമാക്കാനുള്ള കഴിവ് (സ്ഥിരസ്ഥിതി യൂണിഫോം വേരിയബിൾ ആണ്)

· ഗ്രാനുലാരിറ്റിയുടെ യൂണിറ്റ് (ബിറ്റ്, ബൈറ്റ്, പാക്കറ്റ്, സമയം) സജ്ജീകരിക്കാനുള്ള കഴിവ്
പ്രയോഗിച്ചു.

മുകളിലെ യൂണിറ്റിന് അനുയോജ്യമായ പിശകുകളുടെ നിരക്ക് (ഉദാ: 10^-3) സജ്ജമാക്കാനുള്ള കഴിവ്
ഗ്രാനുലാരിറ്റി.

· പ്രവർത്തനക്ഷമമാക്കാനുള്ള/അപ്രാപ്തമാക്കാനുള്ള കഴിവ് (സ്ഥിരസ്ഥിതി പ്രാപ്തമാക്കിയിരിക്കുന്നു)

എങ്ങനെ ലേക്ക് ഉപവിഭാഗം
ഞങ്ങൾ BasicErrorModel-നെ ErrorModel-ന്റെ ഒരു ഉപവിഭാഗമായി ഇനിപ്പറയുന്ന രീതിയിൽ പ്രഖ്യാപിക്കുന്നു:

class BasicErrorModel : public ErrorModel
{
പൊതുവായത്:
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);
...
സ്വകാര്യം:
// അടിസ്ഥാന ക്ലാസ് പ്യുവർ വെർച്വൽ ഫംഗ്‌ഷനുകൾ നടപ്പിലാക്കുക
വെർച്വൽ ബൂൾ DoCorrupt (Ptr പി);
വെർച്വൽ ബൂൾ DoReset (അസാധു);
...
}

കൂടാതെ ഒരു അദ്വിതീയ TypeId സ്ട്രിംഗ് സജ്ജീകരിച്ച് സബ്ക്ലാസ് GetTypeId ഫംഗ്ഷൻ കോൺഫിഗർ ചെയ്യുക.
രക്ഷിതാവിനെ പിശക് മോഡലിലേക്ക് സജ്ജമാക്കുക:

TypeId RateErrorModel ::GetTypeId (അസാധു)
{
സ്റ്റാറ്റിക് TypeId tid = TypeId ("ns3:: RateErrorModel")
.SetParent ()
.AddConstructor ()
...

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

ഒരു പുതിയ മൊഡ്യൂൾ ചേർക്കുന്നതിന് ആവശ്യമായ ഘട്ടങ്ങളിലൂടെ ഈ അധ്യായം നിങ്ങളെ നയിക്കുന്നു ns-3.

ഘട്ടം 0 - മൊഡ്യൂൾ ലേഔട്ട്
എല്ലാ മൊഡ്യൂളുകളും ഇതിൽ കാണാം ഉറവിട ഡയറക്ടറി. ഓരോ മൊഡ്യൂളും ഒരു ഡയറക്ടറിയിൽ കാണാം
അതിന് മൊഡ്യൂളിന്റെ അതേ പേരുണ്ട്. ഉദാഹരണത്തിന്, ദി സ്പെക്ട്രം മൊഡ്യൂൾ ഇവിടെ കാണാം:
എസ്ആർസി/സ്പെക്ട്രം. എന്നതിൽ നിന്ന് ഞങ്ങൾ ഉദ്ധരിക്കും സ്പെക്ട്രം ചിത്രീകരണത്തിനുള്ള മൊഡ്യൂൾ.

ഒരു പ്രോട്ടോടൈപ്പിക്കൽ മൊഡ്യൂളിന് ഇനിപ്പറയുന്ന ഡയറക്‌ടറി ഘടനയും ആവശ്യമായ ഫയലുകളും ഉണ്ട്:

src /
മൊഡ്യൂൾ-നാമം/
ബന്ധനങ്ങൾ/
ഡോക്/
ഉദാഹരണങ്ങൾ/
wscript
സഹായി/
മോഡൽ/
പരിശോധന /
ഉദാഹരണങ്ങൾ-to-run.py
wscript

ഓരോ മൊഡ്യൂളിലും എല്ലാ ഡയറക്ടറികളും ഉണ്ടായിരിക്കില്ല.

ഘട്ടം 1 - സൃഷ്ടിക്കാൻ a മൊഡ്യൂൾ അസ്ഥികൂടം
ഉറവിട ഡയറക്ടറിയിൽ ഒരു പൈത്തൺ പ്രോഗ്രാം നൽകിയിട്ടുണ്ട്, അത് പുതിയതിന് ഒരു അസ്ഥികൂടം സൃഷ്ടിക്കും
മൊഡ്യൂൾ. ഈ ചർച്ചയുടെ ഉദ്ദേശ്യങ്ങൾക്കായി നിങ്ങളുടെ പുതിയ മൊഡ്യൂൾ വിളിക്കപ്പെട്ടതായി ഞങ്ങൾ അനുമാനിക്കും
പുതിയ മൊഡ്യൂൾ. എസ് ഉറവിട ഡയറക്ടറി, പുതിയ മൊഡ്യൂൾ സൃഷ്ടിക്കാൻ ഇനിപ്പറയുന്നവ ചെയ്യുക:

$ ./create-module.py new-module

അടുത്തത്, cd കടന്നു പുതിയ മൊഡ്യൂൾ; നിങ്ങൾ ഈ ഡയറക്ടറി ലേഔട്ട് കണ്ടെത്തും:

$ cd പുതിയ മൊഡ്യൂൾ
s ls
ഡോക് ഉദാഹരണങ്ങൾ സഹായ മോഡൽ ടെസ്റ്റ് wscript

കൂടുതൽ വിശദമായി, ദി create-module.py സ്ക്രിപ്റ്റ് ഡയറക്‌ടറികളും ഇനീഷ്യലും സൃഷ്‌ടിക്കും
അസ്ഥികൂടം wscript, .h, .cc ഒപ്പം .rst ഫയലുകൾ. അസ്ഥികൂട ഫയലുകളുള്ള പൂർണ്ണമായ മൊഡ്യൂൾ കാണപ്പെടുന്നു
ഇതുപോലെ:

src /
പുതിയ മൊഡ്യൂൾ/
ഡോക്/
new-module.rst
ഉദാഹരണങ്ങൾ/
new-module-example.cc
wscript
സഹായി/
new-module-helper.cc
new-module-helper.h
മോഡൽ/
new-module.cc
new-module.h
പരിശോധന /
new-module-test-suite.cc
wscript

(ആവശ്യമെങ്കിൽ ബന്ധനങ്ങൾ/ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ഡയറക്ടറി ഘട്ടം -29 സമയത്ത് യാന്ത്രികമായി സൃഷ്ടിക്കപ്പെടും
നിർമ്മാണം.)

ഈ മൊഡ്യൂൾ എങ്ങനെ ഇഷ്‌ടാനുസൃതമാക്കാം എന്നതിലൂടെ ഞങ്ങൾ അടുത്തതായി നടക്കുന്നു. അറിയിക്കുന്നു വാഫ് ഫയലുകളെക്കുറിച്ച്
രണ്ടും എഡിറ്റ് ചെയ്തുകൊണ്ടാണ് നിങ്ങളുടെ മൊഡ്യൂൾ നിർമ്മിക്കുന്നത് wscript ഫയലുകൾ. ഞങ്ങൾ അതിലൂടെ നടക്കും
ഈ അധ്യായത്തിലെ പ്രധാന ഘട്ടങ്ങൾ.

എല്ലാം ns-3 മൊഡ്യൂളുകൾ ആശ്രയിച്ചിരിക്കുന്നു കോർ മൊഡ്യൂളിലും സാധാരണയായി മറ്റ് മൊഡ്യൂളുകളിലും. ഈ ആശ്രിതത്വം
എന്നതിൽ വ്യക്തമാക്കിയിട്ടുണ്ട് wscript ഫയൽ (മൊഡ്യൂളിന്റെ മുകളിലെ തലത്തിൽ, പ്രത്യേകമല്ല wscript
ഫയലിൽ ഫയൽ ചെയ്യുക ഉദാഹരണങ്ങൾ ഡയറക്ടറി!). അസ്ഥികൂടത്തിൽ wscript നിങ്ങളുടേത് പ്രഖ്യാപിക്കുന്ന കോൾ
പുതിയ മൊഡ്യൂൾ വാഫ് ഇതുപോലെ കാണപ്പെടും (എഡിറ്റുചെയ്യുന്നതിന് മുമ്പ്):

ഡെഫ് ബിൽഡ് (bld):
മൊഡ്യൂൾ = bld.create_ns3_module('new-module', ['core'])

എന്ന് നമുക്ക് ഊഹിക്കാം പുതിയ മൊഡ്യൂൾ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു ഇന്റർനെറ്റ്, ചലനാത്മകം, ഒപ്പം aodv മൊഡ്യൂളുകൾ. ശേഷം
അത് എഡിറ്റ് ചെയ്യുന്നു wscript ഫയൽ ഇതുപോലെ ആയിരിക്കണം:

ഡെഫ് ബിൽഡ് (bld):
മൊഡ്യൂൾ = bld.create_ns3_module('പുതിയ-മൊഡ്യൂൾ', ['ഇന്റർനെറ്റ്', 'മൊബിലിറ്റി', 'aodv'])

ഫസ്റ്റ് ലെവൽ മൊഡ്യൂൾ ഡിപൻഡൻസികൾ മാത്രമേ ലിസ്റ്റ് ചെയ്യാവൂ എന്ന കാര്യം ശ്രദ്ധിക്കുക, അതിനാലാണ് ഞങ്ങൾ നീക്കം ചെയ്തത്
കോർ; The ഇന്റർനെറ്റ് മൊഡ്യൂൾ അതിനെ ആശ്രയിച്ചിരിക്കുന്നു കോർ.

നിങ്ങളുടെ മൊഡ്യൂളിന് മിക്കവാറും മോഡൽ സോഴ്സ് ഫയലുകൾ ഉണ്ടായിരിക്കും. പ്രാരംഭ അസ്ഥികൂടങ്ങൾ (അത് ചെയ്യും
കംപൈൽ വിജയകരമായി) സൃഷ്ടിക്കപ്പെടുന്നു model/new-module.cc ഒപ്പം മോഡൽ/new-module.h.

നിങ്ങളുടെ മൊഡ്യൂളിന് സഹായ ഉറവിട ഫയലുകൾ ഉണ്ടെങ്കിൽ, അവ ഇതിലേക്ക് പോകും സഹായി/
ഡയറക്ടറി; വീണ്ടും, പ്രാരംഭ അസ്ഥികൂടങ്ങൾ ആ ഡയറക്ടറിയിൽ സൃഷ്ടിക്കപ്പെടുന്നു.

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

NewModuleTestSuite::NewModuleTestSuite ()
: TestSuite ("പുതിയ-മൊഡ്യൂൾ", UNIT)
{
AddTestCase (പുതിയ NewModuleTestCase1);
}

ഘട്ടം 3 - പ്രഖ്യാപിക്കുക ഉറവിടം ഫയലുകൾ
നിങ്ങളുടെ പുതിയ മൊഡ്യൂളിനുള്ള പൊതു തലക്കെട്ടും സോഴ്സ് കോഡ് ഫയലുകളും ഇതിൽ വ്യക്തമാക്കിയിരിക്കണം
wscript നിങ്ങളുടെ ടെക്സ്റ്റ് എഡിറ്റർ ഉപയോഗിച്ച് അത് പരിഷ്കരിച്ചുകൊണ്ട് ഫയൽ.

ഒരു ഉദാഹരണമായി, പ്രഖ്യാപിച്ചതിന് ശേഷം സ്പെക്ട്രം മൊഡ്യൂൾ, ദി src/സ്പെക്ട്രം/wscript വ്യക്തമാക്കുന്നു
ഇനിപ്പറയുന്ന ലിസ്റ്റ് ഉള്ള സോഴ്സ് കോഡ് ഫയലുകൾ:

ഡെഫ് ബിൽഡ് (bld):

മൊഡ്യൂൾ = bld.create_ns3_module('സ്പെക്ട്രം', ['ഇന്റർനെറ്റ്', 'പ്രചാരണം', 'ആന്റിന', 'ആപ്ലിക്കേഷനുകൾ'])

module.source = [
'model/spectrum-model.cc',
'model/spectrum-value.cc',
.
.
.
'model/microwave-oven-spectrum-value-helper.cc',
'helper/spectrum-helper.cc',
'helper/adhoc-aloha-noack-ideal-phy-helper.cc',
'helper/waveform-generator-helper.cc',
'helper/spectrum-analyzer-helper.cc',
]

ഈ സ്രോതസ്സുകൾ കംപൈൽ ചെയ്യുന്നതിലൂടെ ഉണ്ടാകുന്ന ഒബ്ജക്റ്റുകൾ ഒരു ലിങ്ക് ലൈബ്രറിയിലേക്ക് കൂട്ടിച്ചേർക്കപ്പെടും,
ഈ മൊഡ്യൂളിനെ ആശ്രയിക്കുന്ന ഏത് പ്രോഗ്രാമുകളിലേക്കും ലിങ്ക് ചെയ്യപ്പെടും.

എന്നാൽ അത്തരം പ്രോഗ്രാമുകൾ എങ്ങനെയാണ് ഞങ്ങളുടെ പുതിയ മൊഡ്യൂളിന്റെ പൊതു API പഠിക്കുന്നത്? വായിക്കൂ!

ഘട്ടം 4 - പ്രഖ്യാപിക്കുക പൊതു ഹെഡ്ഡർ ഫയലുകൾ
നിങ്ങളുടെ മോഡലിന്റെയും സഹായികളുടെയും പൊതു API നിർവചിക്കുന്ന ഹെഡർ ഫയലുകളും ആയിരിക്കണം
ൽ വ്യക്തമാക്കിയിട്ടുണ്ട് wscript ഫയൽ.

തുടരുന്നു സ്പെക്ട്രം മോഡൽ ചിത്രീകരണം, പൊതു തലക്കെട്ട് ഫയലുകൾ വ്യക്തമാക്കിയിരിക്കുന്നു
താഴെ പറയുന്ന ചരണത്തോടെ. (അതിനുള്ള വാദം ശ്രദ്ധിക്കുക ബ്ലഡ് ഫംഗ്ഷൻ പറയുന്നു വാഫ് ലേക്ക്
ഈ മൊഡ്യൂളിന്റെ തലക്കെട്ടുകൾ മറ്റൊന്നിനൊപ്പം ഇൻസ്റ്റാൾ ചെയ്യുക ns-3 തലക്കെട്ടുകൾ):

തലക്കെട്ടുകൾ = bld(സവിശേഷതകൾ='ns3header')

headers.module = 'സ്പെക്ട്രം'

headers.source = [
'model/spectrum-model.h',
'model/spectrum-value.h',
.
.
.
'model/microwave-oven-spectrum-value-helper.h',
'helper/spectrum-helper.h',
'helper/adhoc-aloha-noack-ideal-phy-helper.h',
'helper/waveform-generator-helper.h',
'helper/spectrum-analyzer-helper.h',
]

ഈ രീതിയിൽ പബ്ലിക് ആക്കിയ തലക്കെട്ടുകൾ ഉൾപ്പെടുത്തി നിങ്ങളുടെ മോഡലിന്റെ ഉപയോക്താക്കൾക്ക് ആക്‌സസ് ചെയ്യാൻ കഴിയും
തുടങ്ങിയ പ്രസ്താവനകൾ

#ഉൾപ്പെടുത്തുക "ns3/spectrum-model.h"

നിങ്ങളുടെ നടപ്പാക്കലിൽ കർശനമായി ആന്തരികമായി ഉപയോഗിച്ച തലക്കെട്ടുകൾ ഇവിടെ ഉൾപ്പെടുത്താൻ പാടില്ല. അവർ
പോലുള്ള പ്രസ്‌താവനകൾ ഉൾപ്പെടുത്തി നിങ്ങളുടെ നടപ്പാക്കലിലേക്ക് ഇപ്പോഴും ആക്‌സസ് ചെയ്യാൻ കഴിയും

#ഉൾപ്പെടുത്തുക "my-module-implementation.h"

ഘട്ടം 5 - പ്രഖ്യാപിക്കുക ടെസ്റ്റുകൾ
നിങ്ങളുടെ പുതിയ മൊഡ്യൂളിന് ടെസ്റ്റുകളുണ്ടെങ്കിൽ, അവ നിങ്ങളുടേതിൽ വ്യക്തമാക്കിയിരിക്കണം wscript ഫയൽ ചെയ്തത്
നിങ്ങളുടെ ടെക്സ്റ്റ് എഡിറ്റർ ഉപയോഗിച്ച് ഇത് പരിഷ്കരിക്കുന്നു.

ദി സ്പെക്ട്രം മോഡൽ ടെസ്റ്റുകൾ ഇനിപ്പറയുന്ന ഖണ്ഡികയിൽ വ്യക്തമാക്കിയിരിക്കുന്നു:

module_test = bld.create_ns3_module_test_library('സ്പെക്ട്രം')

module_test.source = [
'test/spectrum-interference-test.cc',
'test/spectrum-value-test.cc',
]

കാണുക ടെസ്റ്റുകൾ ടെസ്റ്റ് കേസുകൾ എങ്ങനെ എഴുതാം എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്.

ഘട്ടം 6 - പ്രഖ്യാപിക്കുക ഉദാഹരണങ്ങൾ
നിങ്ങളുടെ പുതിയ മൊഡ്യൂളിന് ഉദാഹരണങ്ങളുണ്ടെങ്കിൽ, അവ നിങ്ങളുടേതിൽ വ്യക്തമാക്കിയിരിക്കണം ഉദാഹരണങ്ങൾ/wscript
ഫയൽ. (അസ്ഥികൂടം മുകളിലെ നില wscript ആവർത്തിച്ച് ഉൾപ്പെടുത്തും ഉദാഹരണങ്ങൾ/wscript എങ്കിൽ മാത്രം
കോൺഫിഗർ ചെയ്യുന്ന സമയത്ത് ഉദാഹരണങ്ങൾ പ്രവർത്തനക്ഷമമാക്കി.)

ദി സ്പെക്ട്രം മോഡൽ അതിന്റെ ആദ്യ ഉദാഹരണം നിർവചിക്കുന്നു src/സ്പെക്ട്രം/ഉദാഹരണങ്ങൾ/wscript കൂടെ

ഡെഫ് ബിൽഡ് (bld):
obj = bld.create_ns3_program('adhoc-aloha-ideal-phy',
['സ്പെക്ട്രം', 'മൊബിലിറ്റി'])
obj.source = 'adhoc-aloha-ideal-phy.cc'

ഫംഗ്‌ഷനിലേക്കുള്ള രണ്ടാമത്തെ ആർഗ്യുമെന്റ് എന്നത് ശ്രദ്ധിക്കുക create_ns3_program() മൊഡ്യൂളുകളുടെ പട്ടികയാണ്
സൃഷ്ടിക്കുന്ന പ്രോഗ്രാം ആശ്രയിച്ചിരിക്കുന്നു; വീണ്ടും, ഉൾപ്പെടുത്താൻ മറക്കരുത് പുതിയ മൊഡ്യൂൾ in
പട്ടിക. നേരിട്ടുള്ള മൊഡ്യൂൾ ഡിപൻഡൻസികൾ മാത്രം ലിസ്റ്റ് ചെയ്യുന്നതാണ് നല്ലത് വാഫ്
പൂർണ്ണ ആശ്രിത വൃക്ഷം ഊഹിക്കുക.

ഇടയ്ക്കിടെ, വ്യക്തതയ്ക്കായി, നിങ്ങളുടെ ഉദാഹരണത്തിനായി നടപ്പിലാക്കൽ വിഭജിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
നിരവധി ഉറവിട ഫയലുകൾ. ഈ സാഹചര്യത്തിൽ, ആ ഫയലുകൾ കൂടുതൽ സ്പഷ്ടമായി ഉൾപ്പെടുത്തുക
ഉദാഹരണത്തിന്റെ ഉറവിടങ്ങൾ:

obj = bld.create_ns3_program('new-module-example', [new-module])
obj.source = ['new-module-example.cc', 'new-module-example-part.cc']

ഇനിപ്പറയുന്ന ഫംഗ്‌ഷൻ കോൾ ഉപയോഗിച്ചാണ് പൈത്തൺ ഉദാഹരണങ്ങൾ വ്യക്തമാക്കുന്നത്. രണ്ടാമത്തേത് ശ്രദ്ധിക്കുക
ഫംഗ്ഷനുള്ള വാദം register_ns3_script() പൈത്തൺ മൊഡ്യൂളുകളുടെ പട്ടികയാണ്
ഉദാഹരണം ആശ്രയിച്ചിരിക്കുന്നു:

bld.register_ns3_script('new-module-example.py', ['new-module'])

ഘട്ടം 7 - ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കുക as ടെസ്റ്റുകൾ
വ്യക്തമായ ടെസ്റ്റ് കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് പുറമേ, ടെസ്റ്റ് ചട്ടക്കൂട് ഉപകരണമാക്കാനും കഴിയും
ഉദാഹരണങ്ങളിലെ റിഗ്രഷനുകൾ കണ്ടെത്താൻ ശ്രമിക്കുന്നതിന് പൂർണ്ണ ഉദാഹരണ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുക. എന്നിരുന്നാലും, എല്ലാം അല്ല
ഉദാഹരണങ്ങൾ റിഗ്രഷൻ ടെസ്റ്റുകൾക്ക് അനുയോജ്യമാണ്. ഫയല് test/examples-to-run.py നിയന്ത്രിക്കുന്നു
പരീക്ഷണ ചട്ടക്കൂട് പ്രവർത്തിക്കുമ്പോൾ ഉദാഹരണങ്ങളുടെ അഭ്യർത്ഥന.

ദി സ്പെക്ട്രം പ്രവർത്തിപ്പിക്കുന്ന മാതൃകാ ഉദാഹരണങ്ങൾ test.py എന്നിവയിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്
src/spectrum/test/examples-to-run.py C++, Python എന്നിവയുടെ ഇനിപ്പറയുന്ന രണ്ട് ലിസ്റ്റുകൾ ഉപയോഗിക്കുന്നു
ഉദാഹരണങ്ങൾ:

# C++ ഉദാഹരണങ്ങളുടെ ഒരു ലിസ്റ്റ്, അവ നിലനിൽക്കുന്നു എന്ന് ഉറപ്പാക്കാൻ റൺ ചെയ്യണം
# നിർമ്മിക്കാവുന്നതും കാലക്രമേണ പ്രവർത്തിപ്പിക്കാവുന്നതുമാണ്. പട്ടികയിലെ ഓരോ ട്യൂപ്പിളിലും അടങ്ങിയിരിക്കുന്നു
#
# (ഉദാഹരണം_പേര്, ഡൂ_റൺ, ഡൂ_വൽഗ്രൈൻഡ്_റൺ).
#
# കൂടുതൽ വിവരങ്ങൾക്ക് test.py കാണുക.
cpp_examples = [
("adhoc-aloha-ideal-phy", "True", "True"),
("adhoc-aloha-Ideal-phy-with-microwave-Oven", "True", "True"),
("adhoc-aloha-Ideal-phy-matrix-propagation-loss-model", "True", "True"),
]

# പൈത്തൺ ഉദാഹരണങ്ങളുടെ ഒരു ലിസ്റ്റ്, അവ നിലനിൽക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ
# കാലക്രമേണ പ്രവർത്തിപ്പിക്കാം. പട്ടികയിലെ ഓരോ ട്യൂപ്പിളിലും അടങ്ങിയിരിക്കുന്നു
#
# (ഉദാഹരണത്തിന്റെ_പേര്, പ്രവർത്തിക്കുക).
#
# കൂടുതൽ വിവരങ്ങൾക്ക് test.py കാണുക.
പൈത്തൺ_ഉദാഹരണങ്ങൾ = [
("sample-simulator.py", "True"),
]

കമന്റിൽ സൂചിപ്പിച്ചിരിക്കുന്നതുപോലെ, പ്രവർത്തിപ്പിക്കാനുള്ള ഉദാഹരണങ്ങളുടെ C++ ലിസ്റ്റിലെ ഓരോ എൻട്രിയിലും അടങ്ങിയിരിക്കുന്നു
ടുപ്പിൾ (ഉദാഹരണം_പേര്, പ്രവർത്തിപ്പിക്കുക, do_valgrind_run)എവിടെ

· ഉദാഹരണം_പേര് പ്രവർത്തിപ്പിക്കാനുള്ള എക്സിക്യൂട്ടബിൾ ആണ്,

· പ്രവർത്തിപ്പിക്കുക ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു വ്യവസ്ഥയാണ്, കൂടാതെ

· do_valgrind_run valgrind-ന് കീഴിൽ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു വ്യവസ്ഥയാണ്. (ഈ
ചില പരിശോധനകൾ നടക്കുമ്പോൾ NSC നിയമവിരുദ്ധ നിർദ്ദേശ ക്രാഷുകൾക്ക് കാരണമാകുന്നതിനാൽ ഇത് ആവശ്യമാണ്
valgrind ന് കീഴിൽ പ്രവർത്തിക്കുന്നു.)

രണ്ട് വ്യവസ്ഥകളും ആശ്രയിക്കാവുന്ന പൈത്തൺ പ്രസ്താവനകളാണെന്ന കാര്യം ശ്രദ്ധിക്കുക വാഫ് കോൺഫിഗറേഷൻ
വേരിയബിളുകൾ. ഉദാഹരണത്തിന്,

("tcp-nsc-lfn", "NSC_ENABLED == True", "NSC_ENABLED == False"),

പ്രവർത്തിപ്പിക്കാനുള്ള ഉദാഹരണങ്ങളുടെ പൈത്തൺ ലിസ്റ്റിലെ ഓരോ എൻട്രിയിലും ട്യൂപ്പിൾ അടങ്ങിയിരിക്കുന്നു (ഉദാഹരണം_പേര്,
do_run), എവിടെ, C++ ഉദാഹരണങ്ങൾക്കായി,

· ഉദാഹരണം_പേര് പ്രവർത്തിപ്പിക്കാനുള്ള പൈത്തൺ സ്ക്രിപ്റ്റ് ആണ്, കൂടാതെ

· പ്രവർത്തിപ്പിക്കുക ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു വ്യവസ്ഥയാണ്.

വീണ്ടും, വ്യവസ്ഥയെ ആശ്രയിക്കാവുന്ന ഒരു പൈത്തൺ പ്രസ്താവനയാണ് വാഫ് കോൺഫിഗറേഷൻ വേരിയബിളുകൾ.
ഉദാഹരണത്തിന്,

("realtime-udp-echo.py", "ENABLE_REAL_TIME == തെറ്റ്"),

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

$ ./waf കോൺഫിഗർ --enable-examples --enable-tests
$ ./waf ബിൽഡ്
$ ./test.py

നിങ്ങളുടെ പുതിയ മൊഡ്യൂളിന്റെ ടെസ്റ്റ് സ്യൂട്ടിനായി തിരയുക (ഉദാഹരണ പ്രോഗ്രാമുകൾ, നിങ്ങളുടെ മൊഡ്യൂളിൽ എന്തെങ്കിലും ഉണ്ടെങ്കിൽ
പ്രവർത്തനക്ഷമമാക്കി) ടെസ്റ്റ് ഔട്ട്പുട്ടിൽ.

ഘട്ടം 9 - പൈത്തൺ ബൈൻഡിംഗുകൾ
നിങ്ങളുടെ മൊഡ്യൂളിലേക്ക് പൈത്തൺ ബൈൻഡിംഗുകൾ ചേർക്കുന്നത് ഓപ്ഷണൽ ആണ്, കൂടാതെ ഘട്ടം കമന്റ് ചെയ്തതാണ്
സ്ഥിരസ്ഥിതി create-module.py സ്ക്രിപ്റ്റ്.

# bld.ns3_python_bindings()

നിങ്ങൾക്ക് പൈത്തൺ ബൈൻഡിംഗുകൾ ഉൾപ്പെടുത്തണമെങ്കിൽ (പൈത്തൺ ns-3 എഴുതണമെങ്കിൽ മാത്രം മതി
C++ ns-3 പ്രോഗ്രാമുകൾക്ക് പകരം പ്രോഗ്രാമുകൾ), മുകളിൽ പറഞ്ഞവ അൺകമന്റ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യണം
പൈത്തൺ API സ്കാനിംഗ് സിസ്റ്റം (ഈ മാനുവലിൽ മറ്റെവിടെയെങ്കിലും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്) കൂടാതെ നിങ്ങളുടെ മൊഡ്യൂൾ സ്കാൻ ചെയ്യുക
പുതിയ ബന്ധനങ്ങൾ സൃഷ്ടിക്കുക.

ഉണ്ടാക്കുന്നു വിവരണക്കുറിപ്പു്
ns-3 രണ്ട് തരത്തിലുള്ള ഡോക്യുമെന്റേഷൻ നൽകുന്നു: എക്സ്പോസിറ്ററി "ഉപയോക്തൃ-ഗൈഡ്"-സ്റ്റൈൽ ചാപ്റ്ററുകൾ, കൂടാതെ
സോഴ്സ് കോഡ് API ഡോക്യുമെന്റേഷൻ.

"ഉപയോക്തൃ-ഗൈഡ്" അധ്യായങ്ങൾ കൈകൊണ്ട് എഴുതിയതാണ് പുനഃസംഘടിപ്പിച്ച ടെക്സ്റ്റ് ഫോർമാറ്റ്.rst), അതായത്
പൈത്തൺ ഡോക്യുമെന്റേഷൻ സിസ്റ്റം പ്രോസസ്സ് ചെയ്തത് സ്ഫിംക്സ് വെബ് പേജുകളും പിഡിഎഫ് ഫയലുകളും സൃഷ്ടിക്കാൻ.
API ഡോക്യുമെന്റേഷൻ സോഴ്‌സ് കോഡിൽ നിന്ന് തന്നെ സൃഷ്ടിച്ചതാണ്, ഉപയോഗിച്ച് ഡോക്സിജൻ, സൃഷ്ടിക്കാൻ
ക്രോസ്-ലിങ്ക് ചെയ്ത വെബ് പേജുകൾ. ഇവ രണ്ടും പ്രധാനമാണ്: സ്ഫിങ്ക്സ് അധ്യായങ്ങൾ വിശദീകരിക്കുന്നു എന്തുകൊണ്ട്
ഒരു മോഡൽ ഉപയോഗിക്കുന്നതിന്റെ അവലോകനവും; API ഡോക്യുമെന്റേഷൻ വിശദീകരിക്കുന്നു എങ്ങനെ വിശദാംശങ്ങൾ.

ഈ അധ്യായം ഈ ടൂളുകളുടെ ഒരു ദ്രുത അവലോകനം നൽകുന്നു, ഇഷ്ടപ്പെട്ട ഉപയോഗത്തെ ഊന്നിപ്പറയുന്നു
ഇഷ്‌ടാനുസൃതമാക്കലുകൾ ns-3.

എല്ലാ സ്റ്റാൻഡേർഡ് ഡോക്യുമെന്റേഷനുകളും നിർമ്മിക്കുന്നതിന്:

$ ./waf ഡോക്‌സ്

കൂടുതൽ പ്രത്യേക ഓപ്ഷനുകൾക്കായി, വായിക്കുക.

ഡോക്യുമെന്റിംഗ് കൂടെ സ്ഫിംക്സ്
ഞങ്ങൾ ഉപയോഗിക്കുന്നു സ്ഫിംക്സ് ഓരോന്നിന്റെയും രൂപകൽപ്പനയും ഉപയോഗവും വിവരിക്കുന്ന എക്സ്പോസിറ്ററി അധ്യായങ്ങൾ സൃഷ്ടിക്കാൻ
മൊഡ്യൂൾ. ഇപ്പോൾ നിങ്ങൾ വായിക്കുന്നത് വിവരണക്കുറിപ്പു് അധ്യായം. ദി കാണിക്കുക ഉറവിടം ലെ ലിങ്ക്
സൈഡ്ബാർ ഈ അധ്യായത്തിനായുള്ള റീസ്ട്രക്ചർഡ് ടെക്സ്റ്റ് ഉറവിടം കാണിക്കും.

ചേർക്കുന്നു പുതിയ അദ്ധ്യായങ്ങൾ
ഒരു പുതിയ അധ്യായം ചേർക്കുന്നത് മൂന്ന് ഘട്ടങ്ങളെടുക്കും (കൂടുതൽ വിശദമായി താഴെ വിവരിച്ചിരിക്കുന്നു):

1. തിരഞ്ഞെടുക്കുക എവിടെ? ഡോക്യുമെന്റേഷൻ ഫയൽ(കൾ) സജീവമാകും.

2. ബന്ധം നിലവിലുള്ള ഒരു പേജിൽ നിന്ന് പുതിയ ഡോക്യുമെന്റേഷനിലേക്ക്.

3. പുതിയ ഫയൽ ചേർക്കുക Makefile.

എവിടെ?
ഒരു നിർദ്ദിഷ്ട മൊഡ്യൂളിനുള്ള ഡോക്യുമെന്റേഷൻ, ഫൂ, സാധാരണയായി അകത്ത് പോകണം src/foo/doc/. ഉദാഹരണത്തിന്
src/foo/doc/foo.rst മൊഡ്യൂളിനുള്ള ഉയർന്ന തലത്തിലുള്ള പ്രമാണമായിരിക്കും. ദി
src/create-module.py സ്ക്രിപ്റ്റ് നിങ്ങൾക്കായി ഈ ഫയൽ സൃഷ്ടിക്കും.

ചില മോഡലുകൾക്ക് നിരവധി ആവശ്യമുണ്ട് .rst ഫയലുകൾ, കണക്കുകൾ; ഇവയെല്ലാം അകത്തേക്ക് പോകണം
src/foo/doc/ ഡയറക്ടറി. ഡോക്‌സ് യഥാർത്ഥത്തിൽ നിർമ്മിച്ചിരിക്കുന്നത് ഒരു സ്ഫിംഗ്‌സ് മേക്ക്‌ഫൈലാണ്. പ്രത്യേകിച്ച് വേണ്ടി
ഉൾപ്പെട്ട ഡോക്യുമെന്റേഷൻ, ഒരു ലോക്കൽ ഉണ്ടായിരിക്കുന്നത് സഹായകമായേക്കാം Makefile ലെ src/foo/doc/
ഈ മൊഡ്യൂളിനായി ഡോക്യുമെന്റേഷൻ നിർമ്മിക്കുന്നത് ലളിതമാക്കുന്നതിനുള്ള ഡയറക്ടറി (ഏരിയെല് ഒരു ഉദാഹരണമാണ്).
ഇത് സജ്ജീകരിക്കുന്നത് പ്രത്യേകിച്ച് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, എന്നാൽ ഈ അധ്യായത്തിന്റെ പരിധിക്കപ്പുറമാണ്.

ചില സന്ദർഭങ്ങളിൽ, ഡോക്യുമെന്റേഷൻ ഒന്നിലധികം മോഡലുകളിൽ വ്യാപിക്കുന്നു; ദി നെറ്റ്വർക്ക് അധ്യായം ഒരു ഉദാഹരണമാണ്. ഇൻ
ഈ കേസുകൾ കൂട്ടിച്ചേർക്കുന്നു .rst ഫയലുകൾ നേരിട്ട് ഡോക്/മോഡലുകൾ/ഉറവിടം/ ഉചിതമായിരിക്കാം.

ബന്ധം
സ്ഫിങ്ക്സ് അറിയണം എവിടെ നിങ്ങളുടെ പുതിയ അധ്യായം ദൃശ്യമാകും. മിക്ക കേസുകളിലും, ഒരു പുതിയ മോഡൽ
എന്ന അധ്യായത്തിൽ പ്രത്യക്ഷപ്പെടണം മോഡലുകൾ പുസ്തകം. നിങ്ങളുടെ അധ്യായം അവിടെ ചേർക്കാൻ, എഡിറ്റ് ചെയ്യുക
doc/models/source/index.rst

.. ടോക്ട്രീ::
:maxdepth: 1

സംഘടന
ജീവസഞ്ചാരണം
ആന്റിന
aodv
പ്രയോഗങ്ങൾ
...

നിങ്ങളുടെ പ്രമാണത്തിന്റെ പേര് ചേർക്കുക (ഇല്ലാതെ .rst വിപുലീകരണം) ഈ ലിസ്റ്റിലേക്ക്. ദയവായി സൂക്ഷിക്കുക
നിർദ്ദിഷ്‌ട അധ്യായങ്ങൾക്കായുള്ള വിഷ്വൽ സ്കാനിംഗ് സുഗമമാക്കുന്നതിന്, അക്ഷരമാലാ ക്രമത്തിലുള്ള മോഡൽ ചാപ്റ്ററുകൾ.

Makefile
ഉചിതമായതിലേക്ക് നിങ്ങളുടെ പ്രമാണവും ചേർക്കേണ്ടതുണ്ട് Makefile, അങ്ങനെ ഉണ്ടാക്കുക അത് പരിശോധിക്കാൻ അറിയാം
അപ്ഡേറ്റുകൾക്കായി. മോഡലുകളുടെ പുസ്തകം Makefile ആണ് doc/models/Makefile, മാനുവൽ പുസ്തകം Makefile ആണ്
doc/manual/Makefile.

# $SOURCETEMP-ലേക്ക് പകർത്തേണ്ട എല്ലാ മോഡൽ ലൈബ്രറി .rst ഫയലുകളും ലിസ്റ്റ് ചെയ്യുക
ഉറവിടങ്ങൾ = \
source/conf.py \
ഉറവിടം/_സ്റ്റാറ്റിക് \
source/index.rst \
ഉറവിടം/replace.txt \
source/organization.rst \
...
$(SRC)/antenna/doc/source/antenna.rst \
...

നിങ്ങൾ നിങ്ങളുടെ ചേർക്കുക .rst എന്നതിലേക്കുള്ള ഫയലുകൾ SOURCES വേരിയബിൾ. കണക്കുകൾ ചേർക്കാൻ, ലെ അഭിപ്രായങ്ങൾ വായിക്കുക
Makefile ഏത് വേരിയബിളിൽ നിങ്ങളുടെ ഇമേജ് ഫയലുകൾ അടങ്ങിയിരിക്കണമെന്ന് കാണാൻ. വീണ്ടും, ദയവായി ഇവ സൂക്ഷിക്കുക
അക്ഷരമാലാക്രമത്തിൽ.

കെട്ടിടം സ്ഫിംക്സ് ഡോക്സ്
സ്ഫിങ്ക്സ് ഡോക്യുമെന്റേഷൻ നിർമ്മിക്കുന്നത് വളരെ ലളിതമാണ്. എല്ലാ സ്ഫിങ്ക്സും നിർമ്മിക്കാൻ
പ്രമാണീകരണം:

$ ./വാഫ് സ്ഫിൻക്സ്

മോഡലുകളുടെ ഡോക്യുമെന്റേഷൻ നിർമ്മിക്കുന്നതിന്:

$ ഉണ്ടാക്കുക -C ഡോക്/മോഡലുകൾ

സൃഷ്ടിച്ച ഡോക്യുമെന്റേഷൻ പോയിന്റ് കാണാൻ നിങ്ങളുടെ ബ്രൗസർ doc/models/build/html.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, പ്രക്രിയയെ നയിക്കാൻ സ്ഫിങ്ക്സ് മേക്ക് ഉപയോഗിക്കുന്നു. ഡിഫോൾട്ട് ടാർഗെറ്റ് എല്ലാം നിർമ്മിക്കുന്നു
പ്രവർത്തനക്ഷമമാക്കിയ ഔട്ട്പുട്ട് ഫോമുകൾ, ഇതിൽ ns-3 ഒന്നിലധികം പേജുകളാണ് HTML, ഒറ്റ പേജ് singlehtml, ഒപ്പം
pdf (ലാറ്റക്സ്). മൾട്ടി-പേജ് html നിർമ്മിക്കാൻ, നിങ്ങൾ ചേർക്കുക HTML ലക്ഷ്യം:

$ make -C doc/models html

നിങ്ങളെപ്പോലെ ബിൽഡ് സമയം (ബിൽഡ് ചാറ്ററിന്റെ വലുപ്പം) കുറയ്ക്കാൻ ഇത് സഹായകമാകും
നിങ്ങളുടെ അധ്യായം എഴുതുന്നു.

നിങ്ങളുടെ ഡോക്യുമെന്റേഷൻ റിപ്പോയിൽ സമർപ്പിക്കുന്നതിന് മുമ്പ്, അത് ഇല്ലാതെ നിർമ്മിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക
പിശകുകൾ അല്ലെങ്കിൽ മുന്നറിയിപ്പുകൾ. ബിൽഡ് പ്രോസസ് ധാരാളം ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നു (മിക്കവാറും സാധാരണ സംഭാഷണങ്ങൾ
LaTeX-ൽ നിന്ന്), ഏതെങ്കിലും സ്ഫിൻക്സ് മുന്നറിയിപ്പുകൾ ഉണ്ടോ എന്ന് നോക്കുന്നത് ബുദ്ധിമുട്ടാക്കും
പിശകുകൾ. പ്രധാനപ്പെട്ട മുന്നറിയിപ്പുകളും പിശകുകളും കണ്ടെത്തുന്നതിന് ഇത് നിർമ്മിക്കുക HTML പതിപ്പ്, തുടർന്ന് തിരയുക
ബിൽഡ് ലോഗ് മുന്നറിയിപ്പ് or പിശക്.

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

ഈ രണ്ട് വരികൾ ഉപയോഗിച്ച് പ്രമാണങ്ങൾ ആരംഭിക്കുക:

.. ഉൾപ്പെടുന്നു:: replace.txt
.. ഹൈലൈറ്റ്:: cpp

ആദ്യ വരി ചില ലളിതമായ മാറ്റിസ്ഥാപിക്കൽ പ്രാപ്തമാക്കുന്നു. ഉദാഹരണത്തിന്, ടൈപ്പിംഗ് |ns3| ആയി റെൻഡർ ചെയ്യുന്നു
ns-3. രണ്ടാമത്തേത് ഭാഷയെ വ്യക്തമായി ഹൈലൈറ്റ് ചെയ്യുന്ന ഡിഫോൾട്ട് സോഴ്സ് കോഡ് സജ്ജമാക്കുന്നു
ഫയൽ, കാരണം പാർസർ ഊഹം എപ്പോഴും കൃത്യമല്ല. (ഇത് സജ്ജമാക്കാനും സാധ്യമാണ്
ഒരൊറ്റ കോഡ് ബ്ലോക്കിനുള്ള ഭാഷ വ്യക്തമായി, താഴെ കാണുക.)

· വിഭാഗങ്ങൾ:

വിഭാഗം തലക്കെട്ടുകൾ അടയാളപ്പെടുത്തുന്നതിൽ സ്ഫിങ്ക്സ് വളരെ ഉദാരമനസ്കനാണ്. കൺവെൻഷൻ പ്രകാരം, ഞങ്ങൾ ഇത് തിരഞ്ഞെടുക്കുന്നു
അധികാരശ്രേണി:

.. തലക്കെട്ട് ശ്രേണി:
------------- അധ്യായം
************* വിഭാഗം (#.#)
============ ഉപവിഭാഗം (#.#.#)
############## ഉപവിഭാഗം

· വാക്യഘടന ഹൈലൈറ്റിംഗ്:

ഡിഫോൾട്ട് സിന്റാക്സ് ഹൈലൈറ്റർ ഉപയോഗിക്കുന്നതിന്, ഒരു സോഴ്സ്കോഡ് ബ്ലോക്ക് ആരംഭിക്കുക:

പതനം ─────────────────────────────
│Sphinx ഉറവിടം │ റെൻഡർ ചെയ്ത ഔട്ട്പുട്ട് │
പതനം ─────────────────────────────
│ │ ദി ഫ്രോബ്നിറ്റ്സ് ആക്സസ് ചെയ്യുന്നത്: │
│ ``Frobnitz`` ആക്സസ് ചെയ്തത്:: │ │
│ │ Foo::Frobnitz frob; │
│ ഫൂ::ഫ്രോബ്നിറ്റ്സ് ഫ്രോബ്; │ frob.Set (...); │
│ frob.Set (...); │ │
പതനം ────────────────────────────┘

ഒരു നിർദ്ദിഷ്ട വാക്യഘടന ഹൈലൈറ്റർ ഉപയോഗിക്കുന്നതിന്, ഉദാഹരണത്തിന്, ബാഷ് ഷെൽ കമാൻഡുകൾ:

പതനം ───┐
│Sphinx ഉറവിടം │ റെൻഡർ ചെയ്ത ഔട്ട്പുട്ട് │
പതനം ───┤
│ │ │
│ .. സോഴ്സ് കോഡ്:: ബാഷ് │ $ ls │
│ │ │
│ $ ls │ │
പതനം ───┘

· ചുരുക്കെഴുത്തുകൾ:

ഈ ചുരുക്കെഴുത്തുകൾ നിർവചിച്ചിരിക്കുന്നു:

┌──────────────────────┬─────
│Sphinx ഉറവിടം │ റെൻഡർ ചെയ്ത ഔട്ട്പുട്ട് │
───────────────────────.
│ │ ns-3 │
│ |ns3| │ │
───────────────────────.
│ │ ns-2 │
│ |ns2| │ │
───────────────────────.
│ │ │
│ |ചെക്ക്| │ │
───────────────────────.
│ │ ആർഎഫ്സി 6282 │
│ :rfc:`6282` │ │
└──────────────────────┴

ഡോക്യുമെന്റിംഗ് കൂടെ ഡോക്സിജൻ
ഞങ്ങൾ ഉപയോഗിക്കുന്നു ഡോക്സിജൻ സൃഷ്ടിക്കാൻ ബ്രൗസ് ചെയ്യാവുന്ന API ഡോക്യുമെന്റേഷൻ. ഡോക്സിജൻ പലതും നൽകുന്നു
ഉപയോഗപ്രദമായ സവിശേഷതകൾ:

· എല്ലാ ക്ലാസ് അംഗങ്ങളുടെയും സംഗ്രഹ പട്ടിക.

എല്ലാ ക്ലാസുകൾക്കുമുള്ള അനന്തരാവകാശത്തിന്റെയും സഹകരണത്തിന്റെയും ഗ്രാഫുകൾ.

· ഓരോ ഫംഗ്ഷനും നടപ്പിലാക്കുന്ന സോഴ്സ് കോഡിലേക്കുള്ള ലിങ്കുകൾ.

· ഒരു അംഗം ഉപയോഗിക്കുന്ന എല്ലാ സ്ഥലങ്ങളിലേക്കുമുള്ള ലിങ്കുകൾ.

ഒരു ഫംഗ്‌ഷൻ നടപ്പിലാക്കാൻ ഉപയോഗിക്കുന്ന എല്ലാ ഒബ്‌ജക്‌റ്റുകളിലേക്കുമുള്ള ലിങ്കുകൾ.

ഒരു നിർദ്ദിഷ്ട പ്രോട്ടോക്കോളുമായി ബന്ധപ്പെട്ട എല്ലാ ക്ലാസുകളും പോലുള്ള അനുബന്ധ ക്ലാസുകളുടെ ഗ്രൂപ്പിംഗ്.

കൂടാതെ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു ടൈപ്പ് ഐഡി ഓരോ ക്ലാസിനുമുള്ള ഡോക്യുമെന്റേഷനിൽ ചേർക്കുന്നതിനുള്ള സംവിധാനം

· ദി കോൺഫിഗറേഷൻ അത്തരം വസ്തുക്കളിൽ എത്തിച്ചേരാൻ കഴിയുന്ന പാതകൾ.

· ഏതെങ്കിലും ഒരു ഡോക്യുമെന്റേഷൻ ഗുണവിശേഷങ്ങൾഉൾപ്പെടെ ഗുണവിശേഷങ്ങൾ രക്ഷാകർതൃ ക്ലാസുകളിൽ നിർവചിച്ചിരിക്കുന്നത്.

· ഏതെങ്കിലും ഒരു ഡോക്യുമെന്റേഷൻ ട്രെയ്സ് ക്ലാസ് നിർവചിച്ച ഉറവിടങ്ങൾ.

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

തിരഞ്ഞെടുത്ത ശൈലി
JavaDoc ശൈലിയാണ് ഡോക്‌സിജൻ കമന്റുകൾക്കായി തിരഞ്ഞെടുത്ത ശൈലി:

/ **
* ഈ ക്ലാസിന്റെ അല്ലെങ്കിൽ രീതിയുടെ ഹ്രസ്വ വിവരണം.
* തൊട്ടടുത്തുള്ള വരികൾ ഒരൊറ്റ ഖണ്ഡികയായി മാറുന്നു.
*
* ദൈർഘ്യമേറിയ വിവരണം, ധാരാളം വിശദാംശങ്ങൾ.
*
* ശൂന്യമായ വരികൾ പ്രത്യേക ഖണ്ഡികകൾ.
*
* ക്ലാസ് അല്ലെങ്കിൽ രീതി എന്താണ് ചെയ്യുന്നതെന്ന്, ഏത് അൽഗോരിതം ഉപയോഗിച്ച് വിശദീകരിക്കുക.
* ആർഗ്യുമെന്റുകളുടെയും റിട്ടേൺ മൂല്യങ്ങളുടെയും യൂണിറ്റുകൾ വിശദീകരിക്കുക.
*
* \ശ്രദ്ധിക്കുക.
*
* (ആർഗ്യുമെന്റുകളുള്ള ഫംഗ്‌ഷനുകൾക്ക് അല്ലെങ്കിൽ മൂല്യമുള്ള റിട്ടേൺ :)
* \param foo ഈ വാദത്തെ വിവരിക്കുന്ന സംക്ഷിപ്ത നാമപദം.
* \param bar കുറിപ്പ് വാചക കേസും അവസാനിപ്പിക്കുന്ന കാലയളവും.
മൂല്യം വിവരിക്കുന്ന സംക്ഷിപ്ത നാമ വാക്യം * \തിരുത്തുക.
*
* \ആന്തരികം
*
* നിങ്ങൾക്ക് ആന്തരിക നടപ്പാക്കൽ വിശദാംശങ്ങളും ചർച്ച ചെയ്യാം.
* ഈ മെറ്റീരിയൽ മനസ്സിലാക്കുന്നത് ഉപയോഗിക്കേണ്ട ആവശ്യമില്ല
* ക്ലാസ് അല്ലെങ്കിൽ രീതി.
*/
ക്ലാസ് ഉദാഹരണം

ഈ ശൈലിയിൽ ഡോക്‌സിജൻ കമന്റ് ബ്ലോക്ക് രണ്ട് `*' പ്രതീകങ്ങളിൽ ആരംഭിക്കുന്നു: / **, കൂടാതെ മുമ്പും
ഇനം രേഖപ്പെടുത്തുന്നു.

ഒരു ഹ്രസ്വ വിവരണം ആവശ്യമുള്ള ഇനങ്ങൾക്ക്, ഈ ഹ്രസ്വ ഫോമുകളിലേതെങ്കിലും അനുയോജ്യമാണ്:

/** ഡിസ്ട്രക്റ്റർ നടപ്പിലാക്കൽ. */
DoDispose ();

int m_count; //!< എണ്ണം ...

വരിയുടെ അവസാനത്തെ കമന്റിന്റെ പ്രത്യേക രൂപം ശ്രദ്ധിക്കുക, //!, ഇത് സൂചിപ്പിക്കുന്നത്
മുൻപും ഇനം.

ശ്രദ്ധിക്കേണ്ട ചില ഇനങ്ങൾ:

· പ്രാരംഭ മൂലധനം ഉൾപ്പെടെയുള്ള വാക്യ കേസ് ഉപയോഗിക്കുക.

· വിരാമചിഹ്നങ്ങൾ ഉപയോഗിക്കുക, പ്രത്യേകിച്ച് വാക്യങ്ങളുടെയോ ശൈലികളുടെയോ അവസാനം `.

· ദി \ചുരുക്കത്തിലുള്ള ടാഗ് ആവശ്യമില്ല; ആദ്യ വാചകം ചുരുക്കമായി ഉപയോഗിക്കും
വിവരണം.

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

ഉപയോഗപ്രദം സവിശേഷതകൾ
· പാരമ്പര്യ അംഗങ്ങൾക്ക് രക്ഷിതാവിൽ നിന്ന് ഡോക്‌സ് സ്വയമേവ അവകാശമായി ലഭിക്കും, (എന്നാൽ മാറ്റിസ്ഥാപിക്കാം
പ്രാദേശിക ഡോക്യുമെന്റേഷൻ വഴി).

1. അടിസ്ഥാന ക്ലാസ് രേഖപ്പെടുത്തുക.

2. സബ് ക്ലാസ്സിൽ, ഒരു സാധാരണ കമന്റിനൊപ്പം പാരമ്പര്യമായി ലഭിച്ച ഫംഗ്ഷനുകൾ:

// പാരമ്പര്യ രീതികൾ
വെർച്വൽ ശൂന്യത FooBar (ശൂന്യം);
വെർച്വൽ ഇൻറ്റ് ബാർഫൂ (ഡബിൾ ബാസ്);

ഒപ്പുകൾ കൃത്യമായി പൊരുത്തപ്പെടണം, അതിനാൽ ഔപചാരിക വാദം ഉൾപ്പെടുത്തുക (അസാധു)

സ്റ്റാറ്റിക് ഫംഗ്‌ഷനുകൾക്ക് ഇത് പ്രവർത്തിക്കില്ല; കാണുക GetTypeId, താഴെ, ഒരു ഉദാഹരണം.

കെട്ടിടം ഡോക്സിജൻ ഡോക്സ്
ഡോക്‌സിജൻ ഡോക്യുമെന്റേഷൻ നിർമ്മിക്കുന്നത് വളരെ ലളിതമാണ്:

$ ./വാഫ് ഡോക്സിജൻ

ഡിഫോൾട്ട് കോൺഫിഗറേഷൻ ഉപയോഗിച്ച് ഇത് നിർമ്മിക്കുന്നു, ഇത് ഡോക്യുമെന്റേഷൻ വിഭാഗങ്ങൾ സൃഷ്ടിക്കുന്നു
എല്ലാം ഇനങ്ങൾ, അവയ്ക്ക് വ്യക്തമായ അഭിപ്രായ ഡോക്യുമെന്റേഷൻ ബ്ലോക്കുകൾ ഇല്ലെങ്കിലും. ഇതിന് ഉണ്ട്
രേഖപ്പെടുത്താത്ത ഇനങ്ങൾക്കുള്ള മുന്നറിയിപ്പുകൾ അടിച്ചമർത്തുന്നതിന്റെ ഫലം, എന്നാൽ എല്ലാം ദൃശ്യമാണെന്ന് ഉറപ്പാക്കുന്നു
ജനറേറ്റഡ് ഔട്ട്പുട്ടിൽ.

ഡോക്യുമെന്റേഷൻ എഴുതുമ്പോൾ, ഏത് ഇനങ്ങളാണ് സൃഷ്ടിക്കുന്നതെന്ന് കാണുന്നത് കൂടുതൽ ഉപയോഗപ്രദമാണ്
മുന്നറിയിപ്പുകൾ, സാധാരണയായി നഷ്‌ടമായ ഡോക്യുമെന്റേഷനെക്കുറിച്ചുള്ള. മുഴുവൻ മുന്നറിയിപ്പുകളുടെ പട്ടിക കാണുന്നതിന്, ഉപയോഗിക്കുക
doc/doxygen.warnings.report.sh സ്ക്രിപ്റ്റ്:

$ doc/doxygen.warnings.report.sh
വാഫ്: 'ബിൽഡ്' എന്ന ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു
...
വാഫ്: 'ബിൽഡ്' എന്ന ഡയറക്ടറി വിടുന്നു
'ബിൽഡ്' വിജയകരമായി പൂർത്തിയാക്കി (3മി.24.094സെ)

പൂർണ്ണ പിശകുകളോടെ ഡോക്‌സിജൻ ഡോക്‌സ് പുനർനിർമ്മിക്കുന്നു...പൂർത്തിയായി.

ഡോക്‌സിജൻ മുന്നറിയിപ്പുകളുടെ റിപ്പോർട്ട്
----------------------------------------

(എല്ലാ എണ്ണങ്ങളും താഴ്ന്ന പരിധികളാണ്.)

മൊഡ്യൂൾ/ഡയറക്‌ടറി പ്രകാരം മുന്നറിയിപ്പുകൾ:

കൗണ്ട് ഡയറക്ടറി
----------------------------------------
3844 src/lte/model
1718 src/wimax/മോഡൽ
1423 എസ്ആർസി/കോർ/മോഡൽ
....
138 അധിക രേഖകളില്ലാത്ത പാരാമീറ്ററുകൾ.
----------------------------------------
ആകെ 15765 മുന്നറിയിപ്പുകൾ
മുന്നറിയിപ്പുകളുള്ള 126 ഡയറക്ടറികൾ

ഫയൽ പ്രകാരമുള്ള മുന്നറിയിപ്പുകൾ (അക്ഷരമാലാക്രമത്തിൽ)

ഫയൽ എണ്ണുക
----------------------------------------
17 doc/introspected-doxygen.h
15 ഉദാഹരണങ്ങൾ/routing/manet-routing-compare.cc
26 ഉദാഹരണങ്ങൾ/സ്ഥിതിവിവരക്കണക്കുകൾ/wifi-example-apps.h
....
----------------------------------------
മുന്നറിയിപ്പുകളുള്ള 967 ഫയലുകൾ

ഫയൽ പ്രകാരമുള്ള മുന്നറിയിപ്പുകൾ (സംഖ്യകൾ)

ഫയൽ എണ്ണുക
----------------------------------------
374 src/lte/model/lte-asn1-header.h
280 src/lte/model/lte-rrc-sap.h
262 src/lte/model/lte-rrc-header.h
....
----------------------------------------
മുന്നറിയിപ്പുകളുള്ള 967 ഫയലുകൾ

ഡോക്‌സിജൻ മുന്നറിയിപ്പുകളുടെ സംഗ്രഹം
----------------------------------------
126 ഡയറക്ടറികൾ
967 ഫയലുകൾ
15765 മുന്നറിയിപ്പുകൾ

എല്ലാ മുന്നറിയിപ്പുകളും കാണിക്കുന്നതിനും റൺ സമയം കുറയ്ക്കുന്നതിനും സ്ക്രിപ്റ്റ് കോൺഫിഗറേഷൻ പരിഷ്കരിക്കുന്നു.
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ എഴുത്തിൽ ഞങ്ങൾക്ക് ഉണ്ട് a ഭൂരിഭാഗം രേഖകളില്ലാത്ത വസ്തുക്കളുടെ. റിപ്പോര്ട്ട്
മൊഡ്യൂൾ പ്രകാരം മുന്നറിയിപ്പുകൾ സംഗ്രഹിക്കുന്നു src/*/*, കൂടാതെ ഫയൽ വഴി, അക്ഷരമാലാക്രമത്തിലും സംഖ്യാ ക്രമത്തിലും.

സ്‌ക്രിപ്റ്റിന് കാര്യങ്ങൾ കുറയ്ക്കാനും ഇത് കൂടുതൽ കൈകാര്യം ചെയ്യാനുമുള്ള കുറച്ച് ഓപ്ഷനുകൾ ഉണ്ട്. സഹായത്തിനായി,
ഉപയോഗിക്കുക -h ഓപ്ഷൻ. ഡോക്‌സിജൻ ബിൽഡ് ചെയ്യാനും ഫുൾ ജനറേറ്റ് ചെയ്യാനും ഒരു തവണ പ്രവർത്തിപ്പിച്ച ശേഷം
മുന്നറിയിപ്പ് ലോഗ്, നിങ്ങൾക്ക് ലോഗ് ഫയൽ വിവിധ "ഫിൽട്ടറുകൾ" ഉപയോഗിച്ച് വീണ്ടും പ്രോസസ്സ് ചെയ്യാൻ കഴിയും
പൂർണ്ണ ഡോക്സിജൻ നിർമ്മിക്കുന്നത്, വീണ്ടും ഉപയോഗിച്ച് -s ഓപ്ഷൻ. ഇതിൽ നിന്നുള്ള മുന്നറിയിപ്പുകൾ നിങ്ങൾക്ക് ഒഴിവാക്കാം
*/ഉദാഹരണങ്ങൾ/* ഫയലുകൾ (-e ഓപ്ഷൻ), കൂടാതെ/അല്ലെങ്കിൽ */ടെസ്റ്റ്/* ഫയലുകൾ (-t).

ഡോക്യുമെന്റേഷൻ അഭിപ്രായങ്ങൾ എഴുതുമ്പോൾ ഒരുപക്ഷേ ഏറ്റവും ഉപയോഗപ്രദമായ ഓപ്ഷൻ -m ഏത്
റിപ്പോർട്ടിനെ ഫയലുകൾ പൊരുത്തപ്പെടുത്തുന്നതിന് മാത്രമായി പരിമിതപ്പെടുത്തും src/ /*, ഒപ്പം റിപ്പോർട്ട് പിന്തുടരുക
യഥാർത്ഥ മുന്നറിയിപ്പ് ലൈനുകൾ. കൂടെ സംയോജിപ്പിക്കുക ഇവിടെ, നിങ്ങൾക്ക് മുന്നറിയിപ്പുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം
ഒരൊറ്റ മൊഡ്യൂളിൽ ഏറ്റവും അടിയന്തിരം:

$ doc/doxygen.warnings.report.sh -m mesh/helper
...
ഡോക്‌സിജൻ മുന്നറിയിപ്പുകളുടെ സംഗ്രഹം
----------------------------------------
1 ഡയറക്ടറികൾ
3 ഫയലുകൾ
149 മുന്നറിയിപ്പുകൾ

ഫിൽട്ടർ ചെയ്ത മുന്നറിയിപ്പുകൾ
========================================
src/mesh/helper/dot11s/dot11s-installer.h:72: മുന്നറിയിപ്പ്: ns3 ക്ലാസ്സിലെ m_root (വേരിയബിൾ) അംഗം::Dot11sStack രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.
src/mesh/helper/dot11s/dot11s-installer.h:35: മുന്നറിയിപ്പ്: അംഗത്തിന്റെ മടക്ക തരം ns3::Dot11sStack::GetTypeId രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല
src/mesh/helper/dot11s/dot11s-installer.h:56: മുന്നറിയിപ്പ്: അംഗത്തിന്റെ മടക്ക തരം ns3::Dot11sStack::InstallStack രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല
src/mesh/helper/flame/lfame-installer.h:40: മുന്നറിയിപ്പ്: ns3 ക്ലാസിന്റെ അംഗം GetTypeId() (ഫംഗ്ഷൻ) ::FlameStack രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.
src/mesh/helper/flame/flame-installer.h:60: മുന്നറിയിപ്പ്: അംഗത്തിന്റെ മടക്ക തരം ns3::FlameStack::InstallStack രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല
src/mesh/helper/mesh-helper.h:213: മുന്നറിയിപ്പ്: അംഗം m_nInterfaces (variable) of class ns3::MeshHelper രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.
src/mesh/helper/mesh-helper.h:214: മുന്നറിയിപ്പ്: അംഗം m_spreadChannelPolicy (variable) of class ns3::MeshHelper രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.
src/mesh/helper/mesh-helper.h:215: മുന്നറിയിപ്പ്: ns3 ക്ലാസിലെ m_stack (വേരിയബിൾ) അംഗം::MeshHelper രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.
src/mesh/helper/mesh-helper.h:216: മുന്നറിയിപ്പ്: ns3 ക്ലാസിലെ m_stackFactory (വേരിയബിൾ) അംഗം::MeshHelper രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല.
src/mesh/helper/mesh-helper.h:209: മുന്നറിയിപ്പ്: അംഗത്തിന്റെ പാരാമീറ്ററുകൾ ns3::MeshHelper::CreateInterface (എല്ലാം) രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല
src/mesh/helper/mesh-helper.h:119: മുന്നറിയിപ്പ്: അംഗത്തിന്റെ പാരാമീറ്ററുകൾ ns3::MeshHelper::SetStandard (എല്ലാം) രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല

ഇപ്പോൾ കോഡ് മനസ്സിലാക്കുകയും കുറച്ച് ഡോക്‌സ് എഴുതുകയും ചെയ്യുക എന്നതാണ് കാര്യം!

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

· ഡോക്സിജൻ ഉപയോഗിക്കുക മൊഡ്യൂളുകൾ ഗ്രൂപ്പുമായി ബന്ധപ്പെട്ട ഇനങ്ങൾക്ക്.

ഒരു മൊഡ്യൂളിനുള്ള പ്രധാന തലക്കെട്ടിൽ, ഒരു Doxgyen ഗ്രൂപ്പ് സൃഷ്ടിക്കുക:

/ **
* \defgroup foo Foo പ്രോട്ടോക്കോൾ.
*/

ബന്ധപ്പെട്ട ഓരോ ക്ലാസും ഗ്രൂപ്പിൽ ഉൾപ്പെട്ടതായി അടയാളപ്പെടുത്തുക:

/ **
* \inggroup foo
*
* ഫൂ പാക്കറ്റ് തരം.
*/
ക്ലാസ് ഫൂ

· നിനക്കറിയാമോ ടൈപ്പ്ഡെഫുകൾ ഔപചാരിക വാദങ്ങൾ ഉണ്ടാകുമോ? ഇത് പ്രവർത്തനത്തിന്റെ ഡോക്യുമെന്റേഷൻ പ്രാപ്തമാക്കുന്നു
സൂചിക ഒപ്പുകൾ:

/ **
* ബാർ കോൾബാക്ക് ഫംഗ്‌ഷൻ സിഗ്നേച്ചർ.
*
* \param ale ഇംപീരിയൽ ഔൺസിൽ ഒരു പൈന്റ് ഏലിന്റെ വലിപ്പം.
*/
ടൈപ്പ്ഡെഫ് അസാധുവാണ് (* ബാർകോൾബാക്ക്)(കോൺസ്റ്റ് ഇൻറ്റ് എലെ);

· പകർത്തുക ഗുണങ്ങളെ ൽ നിന്നുള്ള സഹായ സ്ട്രിംഗുകൾ GetTypeId സംക്ഷിപ്തമായി ഉപയോഗിക്കുന്നതിനുള്ള രീതി
ബന്ധപ്പെട്ട അംഗങ്ങളുടെ വിവരണങ്ങൾ.

· \bugid{298} ഞങ്ങളുടെ ബഗ്‌സില്ലയിൽ ബഗ് 298-ലേക്ക് ഒരു ലിങ്ക് സൃഷ്ടിക്കും.

· \pname{foo} ഒരു വിവരണത്തിൽ ഫോർമാറ്റ് ചെയ്യും ഫൂ പോലെ \പരം ഫൂ പരാമീറ്റർ, അത് വ്യക്തമാക്കുന്നു
നിങ്ങൾ ഒരു യഥാർത്ഥ വാദത്തെയാണ് പരാമർശിക്കുന്നത്.

· \RFC{301} RFC 301-ലേക്ക് ഒരു ലിങ്ക് സൃഷ്ടിക്കും.

· \ആന്തരികം നടപ്പാക്കൽ വിശദാംശങ്ങളുടെ ഒരു ചർച്ച ആരംഭിക്കാൻ മാത്രമേ ഉപയോഗിക്കാവൂ, അല്ല
അടയാളം സ്വകാര്യ ഫംഗ്‌ഷനുകൾ (അവ ഇതിനകം അടയാളപ്പെടുത്തിയിരിക്കുന്നു സ്വകാര്യ!)

· തുച്ഛമായ പേരുകൾ ഉപയോഗിച്ച് ക്ലാസുകൾ സൃഷ്ടിക്കരുത്, ഉദാഹരണത്തിന് ക്ലാസ് A, ടെസ്റ്റ് സ്യൂട്ടുകളിൽ പോലും. ഇവ
ക്ലാസ് നാമത്തിന്റെ അക്ഷരാർത്ഥമായ `A' യുടെ എല്ലാ ഉദാഹരണങ്ങളും ലിങ്കുകളായി റെൻഡർ ചെയ്യാൻ കാരണമാകുന്നു.

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

· ഡിഫോൾട്ട് കൺസ്ട്രക്റ്റർ/ഡിസ്ട്രക്റ്റർ:

MyClass (); //!< ഡിഫോൾട്ട് കൺസ്ട്രക്റ്റർ
~MyClass (); //!< വിനാശകാരി

· ഡമ്മി ഡിസ്ട്രക്റ്ററും ഡോഡിസ്പോസും:

/** ഡമ്മി ഡിസ്ട്രക്റ്റർ, DoDispose കാണുക. */
~MyClass ();

/** ഡിസ്ട്രക്റ്റർ നടപ്പിലാക്കൽ */
വെർച്വൽ ശൂന്യമായ DoDispose ();

· GetTypeId:

/ **
* ഈ തരം രജിസ്റ്റർ ചെയ്യുക.
* ഒബ്ജക്റ്റ് TypeId തിരികെ നൽകുക.
*/
സ്റ്റാറ്റിക് ടൈപ്പ് ഐഡ് GetTypeId (അസാധു);

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

എങ്ങനെ മാത്രം പ്രവർത്തനക്ഷമമാക്കാം എന്ന് ഈ അധ്യായം ചർച്ച ചെയ്യുന്നു ns-3 നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള മൊഡ്യൂളുകൾ
ഉപയോഗിച്ച്.

എങ്ങനെ ലേക്ക് പ്രവർത്തനക്ഷമമാക്കുക a ഉപഗണം of ns-3's മൊഡ്യൂളുകൾ
പങ്കിട്ട ലൈബ്രറികൾ നിർമ്മിക്കുകയാണെങ്കിൽ, ഒരു മൊഡ്യൂൾ പ്രവർത്തനക്ഷമമാക്കുന്നത് കുറഞ്ഞത് ഒന്നിന് കാരണമാകും
നിർമ്മിക്കുന്ന ലൈബ്രറി:

libns3-modulename.so

മൊഡ്യൂളിന് ഒരു ടെസ്റ്റ് ലൈബ്രറി ഉണ്ടെങ്കിൽ, ടെസ്റ്റ് ലൈബ്രറികൾ നിർമ്മിക്കുന്നു

libns3-modulename-test.so

എന്നിവയും നിർമ്മിക്കപ്പെടും. മൊഡ്യൂൾ ആശ്രയിക്കുന്ന മറ്റ് മൊഡ്യൂളുകളും അവയുടെ ടെസ്റ്റ് ലൈബ്രറികളും
എന്നിവയും നിർമിക്കും.

സ്ഥിരസ്ഥിതിയായി, എല്ലാ മൊഡ്യൂളുകളും അന്തർനിർമ്മിതമാണ് ns-3. ഇവയുടെ ഒരു ഉപവിഭാഗം പ്രവർത്തനക്ഷമമാക്കാൻ രണ്ട് വഴികളുണ്ട്
മൊഡ്യൂളുകൾ:

1. waf's --enable-modules ഓപ്ഷൻ ഉപയോഗിക്കുന്നു

2. ഉപയോഗിക്കുന്നു ns-3 കോൺഫിഗറേഷൻ ഫയൽ

പ്രവർത്തനക്ഷമമാക്കുക മൊഡ്യൂളുകൾ ഉപയോഗിച്ച് വാഫിന്റെ --പ്രവർത്തനക്ഷമമാക്കുക-മൊഡ്യൂളുകൾ ഓപ്ഷൻ
ഉദാഹരണവും ടെസ്റ്റുകളും ഉള്ള കോർ മൊഡ്യൂൾ മാത്രം പ്രവർത്തനക്ഷമമാക്കാൻ, ഉദാഹരണത്തിന്, ഈ കമാൻഡുകൾ പരീക്ഷിക്കുക:

$ ./വാഫ് ക്ലീൻ
$ ./waf കോൺഫിഗർ ചെയ്യുക --enable-examples --enable-tests --enable-modules=core
$ ./waf ബിൽഡ്
$ cd ബിൽഡ്/ഡീബഗ്/
s ls

കൂടാതെ ഇനിപ്പറയുന്ന ലൈബ്രറികൾ ഉണ്ടായിരിക്കണം:

ബൈൻഡിംഗ്സ് libns3-core.so ns3 സ്ക്രാച്ച് യൂട്ടിലുകൾ
ഉദാഹരണങ്ങൾ libns3-core-test.so സാമ്പിളുകൾ src

ശ്രദ്ധിക്കുക ./വാഫ് വെടിപ്പുള്ള ഏത് മൊഡ്യൂൾ ലൈബ്രറികൾ എന്ന് കൂടുതൽ വ്യക്തമാക്കാൻ മാത്രമാണ് ഇവിടെ ഘട്ടം ചെയ്യുന്നത്
നിർമ്മിക്കപ്പെട്ടു. നിങ്ങൾ ചെയ്യേണ്ടതില്ല ./വാഫ് വെടിപ്പുള്ള മൊഡ്യൂളുകളുടെ ഉപസെറ്റുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിന്.

test.py പ്രവർത്തിപ്പിക്കുന്നത് മൊഡ്യൂൾ കോറിനെ ആശ്രയിക്കുന്ന ടെസ്റ്റുകൾ മാത്രം പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകും:

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

"കോർ" മൊഡ്യൂളിന് പകരം "നെറ്റ്‌വർക്ക്" മൊഡ്യൂളിനായി മുകളിലുള്ള ഘട്ടങ്ങൾ ആവർത്തിക്കുക, കൂടാതെ
നെറ്റ്‌വർക്ക് കോറിനെ ആശ്രയിച്ചിരിക്കുന്നതിനാൽ ഇനിപ്പറയുന്നവ നിർമ്മിക്കപ്പെടും:

ബൈൻഡിംഗ്സ് libns3-core.so libns3-network.so ns3 സ്ക്രാച്ച് യൂട്ടിലുകൾ
ഉദാഹരണങ്ങൾ libns3-core-test.so libns3-network-test.so സാമ്പിളുകൾ src

test.py പ്രവർത്തിപ്പിക്കുന്നത് കോർ, നെറ്റ്‌വർക്ക് മൊഡ്യൂളുകളെ മാത്രം ആശ്രയിക്കുന്ന ടെസ്റ്റുകൾക്ക് കാരണമാകും
പ്രവർത്തിപ്പിക്കുക:

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

പ്രവർത്തനക്ഷമമാക്കുക മൊഡ്യൂളുകൾ ഉപയോഗിച്ച് The ns-3 കോൺഫിഗറേഷൻ ഫയല്
ഒരു കോൺഫിഗറേഷൻ ഫയൽ, .ns3rc, ചേർത്തു ns-3 അത് ഏത് എന്ന് വ്യക്തമാക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്നു
മൊഡ്യൂളുകൾ ബിൽഡിൽ ഉൾപ്പെടുത്തണം.

ഒരു ഉപവിഭാഗം പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ ns-3 മൊഡ്യൂളുകൾ, മുൻഗണനാ നിയമങ്ങൾ ഇപ്രകാരമാണ്:

1. --enable-modules കോൺഫിഗർ ചെയ്യുന്ന സ്ട്രിംഗ് ഏതെങ്കിലും .ns3rc ഫയലിനെ മറികടക്കുന്നു

2. മുകളിലെ തലത്തിലുള്ള .ns3rc ഫയൽ ns-3 ഡയറക്‌ടറി ഉണ്ടെങ്കിൽ അടുത്തതായി പരിശോധിക്കും

3. സിസ്റ്റം തിരയുന്നു ~/.ns3rc മുകളിൽ പറഞ്ഞ രണ്ടും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ

മുകളിൽ പറഞ്ഞതൊന്നും നിർമ്മിക്കേണ്ട മൊഡ്യൂളുകളെ പരിമിതപ്പെടുത്തുന്നില്ലെങ്കിൽ, waf അറിയുന്ന എല്ലാ മൊഡ്യൂളുകളും ഇഷ്ടം പോലെയാണ്
നിർമ്മിക്കപ്പെടും.

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

നിങ്ങൾ ഉയർന്ന തലത്തിലാണെന്ന് കരുതുക ns-3 ഡയറക്ടറി, നിങ്ങൾക്ക് .ns3rc യുടെ ഒരു പകർപ്പ് ലഭിക്കും
എന്ന ഫയൽ ഉപയോഗങ്ങൾ ഇനിപ്പറയുന്ന ഡയറക്‌ടറി:

$ cp utils/.ns3rc .

.ns3rc ഫയൽ ഇപ്പോൾ നിങ്ങളുടെ ഉയർന്ന തലത്തിലായിരിക്കണം ns-3 ഡയറക്ടറി, അതിൽ അടങ്ങിയിരിക്കുന്നു
താഴെ:

#! /usr/bin/env പൈത്തൺ

# ns-3 പ്രവർത്തിപ്പിക്കുമ്പോൾ പ്രവർത്തനക്ഷമമാക്കുന്ന മൊഡ്യൂളുകളുടെ ഒരു ലിസ്റ്റ്.
# ലിസ്റ്റുചെയ്ത മൊഡ്യൂളുകളെ ആശ്രയിക്കുന്ന മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കും.
#
# 'എല്ലാ_മൊഡ്യൂളുകളും' തിരഞ്ഞെടുത്ത് എല്ലാ മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കാം.
modules_enabled = ['all_modules']

# ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമാക്കുക.
example_enabled = തെറ്റ്

# ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമായി സജ്ജമാക്കുക.
tests_enabled = തെറ്റ്

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

#! /usr/bin/env പൈത്തൺ

# ns-3 പ്രവർത്തിപ്പിക്കുമ്പോൾ പ്രവർത്തനക്ഷമമാക്കുന്ന മൊഡ്യൂളുകളുടെ ഒരു ലിസ്റ്റ്.
# ലിസ്റ്റുചെയ്ത മൊഡ്യൂളുകളെ ആശ്രയിക്കുന്ന മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കും.
#
# 'എല്ലാ_മൊഡ്യൂളുകളും' തിരഞ്ഞെടുത്ത് എല്ലാ മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കാം.
modules_enabled = ['core']

# ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമാക്കുക.
example_enabled = ശരി

# ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമായി സജ്ജമാക്കുക.
tests_enabled = ശരി

നിങ്ങൾ ഈ കമാൻഡുകൾ പരീക്ഷിച്ചാൽ ഇപ്പോൾ കോർ മൊഡ്യൂൾ മാത്രമേ പ്രവർത്തനക്ഷമമാകൂ:

$ ./വാഫ് ക്ലീൻ
$ ./waf കോൺഫിഗർ ചെയ്യുക
$ ./waf ബിൽഡ്
$ cd ബിൽഡ്/ഡീബഗ്/
s ls

കൂടാതെ ഇനിപ്പറയുന്ന ലൈബ്രറികൾ ഉണ്ടായിരിക്കണം:

ബൈൻഡിംഗ്സ് libns3-core.so ns3 സ്ക്രാച്ച് യൂട്ടിലുകൾ
ഉദാഹരണങ്ങൾ libns3-core-test.so സാമ്പിളുകൾ src

ശ്രദ്ധിക്കുക ./വാഫ് വെടിപ്പുള്ള ഏത് മൊഡ്യൂൾ ലൈബ്രറികൾ എന്ന് കൂടുതൽ വ്യക്തമാക്കാൻ മാത്രമാണ് ഇവിടെ ഘട്ടം ചെയ്യുന്നത്
നിർമ്മിക്കപ്പെട്ടു. നിങ്ങൾ ചെയ്യേണ്ടതില്ല ./വാഫ് വെടിപ്പുള്ള മൊഡ്യൂളുകളുടെ ഉപസെറ്റുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിന്.

test.py പ്രവർത്തിപ്പിക്കുന്നത് മൊഡ്യൂൾ കോറിനെ ആശ്രയിക്കുന്ന ടെസ്റ്റുകൾ മാത്രം പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകും:

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

"കോർ" മൊഡ്യൂളിന് പകരം "നെറ്റ്‌വർക്ക്" മൊഡ്യൂളിനായി മുകളിലുള്ള ഘട്ടങ്ങൾ ആവർത്തിക്കുക, കൂടാതെ
നെറ്റ്‌വർക്ക് കോറിനെ ആശ്രയിച്ചിരിക്കുന്നതിനാൽ ഇനിപ്പറയുന്നവ നിർമ്മിക്കപ്പെടും:

ബൈൻഡിംഗ്സ് libns3-core.so libns3-network.so ns3 സ്ക്രാച്ച് യൂട്ടിലുകൾ
ഉദാഹരണങ്ങൾ libns3-core-test.so libns3-network-test.so സാമ്പിളുകൾ src

test.py പ്രവർത്തിപ്പിക്കുന്നത് കോർ, നെറ്റ്‌വർക്ക് മൊഡ്യൂളുകളെ മാത്രം ആശ്രയിക്കുന്ന ടെസ്റ്റുകൾക്ക് കാരണമാകും
പ്രവർത്തിപ്പിക്കുക:

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

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

ഈ അധ്യായം എങ്ങനെ നിർമ്മിക്കാമെന്ന് ചർച്ച ചെയ്യുന്നു ns-3 അതിന്റെ ഉദാഹരണങ്ങളും പരിശോധനകളും ഉള്ളതോ അല്ലാതെയോ.

എങ്ങനെ ലേക്ക് പ്രവർത്തനക്ഷമമാക്കുക/പ്രവർത്തനരഹിതമാക്കുക ഉദാഹരണങ്ങൾ ഒപ്പം ടെസ്റ്റുകൾ in ns-3
ഉദാഹരണങ്ങളും പരിശോധനകളും പ്രവർത്തനക്ഷമമാക്കാനോ പ്രവർത്തനരഹിതമാക്കാനോ 3 വഴികളുണ്ട് ns-3:

1. build.py എപ്പോൾ ഉപയോഗിക്കുന്നു ns-3 ആദ്യമായി നിർമ്മിച്ചതാണ്

2. ഒരിക്കൽ വഫ് ഉപയോഗിക്കുന്നത് ns-3 നിർമ്മിച്ചു

3. ഉപയോഗിക്കുന്നു ns-3 കോൺഫിഗറേഷൻ ഫയൽ ഒരിക്കൽ ns-3 നിർമ്മിച്ചു

പ്രവർത്തനക്ഷമമാക്കുക / അപ്രാപ്‌തമാക്കുക ഉദാഹരണങ്ങൾ ഒപ്പം ടെസ്റ്റുകൾ ഉപയോഗിച്ച് build.py
എപ്പോൾ ഉദാഹരണങ്ങളും പരിശോധനകളും പ്രവർത്തനക്ഷമമാക്കാനും/അപ്രാപ്‌തമാക്കാനും നിങ്ങൾക്ക് build.py ഉപയോഗിക്കാം ns-3 ആദ്യത്തേതിന് വേണ്ടി നിർമ്മിച്ചതാണ്
സമയം.

സ്ഥിരസ്ഥിതിയായി, ഉദാഹരണങ്ങളും പരിശോധനകളും അന്തർനിർമ്മിതമല്ല ns-3.

ns-3-allinone ഡയറക്‌ടറിയിൽ നിന്ന്, നിങ്ങൾക്ക് നിർമ്മിക്കാൻ കഴിയും ns-3 ഉദാഹരണങ്ങളോ പരിശോധനകളോ ഇല്ലാതെ
ചെയ്യുന്നതിലൂടെ:

$ ./build.py

ഉയർന്ന തലത്തിൽ test.py പ്രവർത്തിക്കുന്നു ns-3 ഡയറക്ടറി ഇപ്പോൾ ഉദാഹരണങ്ങളോ പരിശോധനകളോ ഉണ്ടാകില്ല
പ്രവർത്തിപ്പിക്കുക:

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

നിങ്ങൾ നിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ns-3 ഉദാഹരണങ്ങളും പരിശോധനകളും ഉപയോഗിച്ച്, ഇനിപ്പറയുന്നതിൽ നിന്ന് ഇനിപ്പറയുന്നവ ചെയ്യുക
ns-3-അലിനോൺ ഡയറക്ടറി:

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

ഉയർന്ന തലത്തിൽ test.py പ്രവർത്തിക്കുന്നു ns-3 ഡയറക്ടറി എല്ലാ ഉദാഹരണങ്ങൾക്കും ടെസ്റ്റുകൾക്കും കാരണമാകും
പ്രവർത്തിപ്പിക്കാൻ:

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

പ്രവർത്തനക്ഷമമാക്കുക / അപ്രാപ്‌തമാക്കുക ഉദാഹരണങ്ങൾ ഒപ്പം ടെസ്റ്റുകൾ ഉപയോഗിച്ച് വാഫ്
ഉദാഹരണങ്ങളും പരിശോധനകളും ഒരിക്കൽ പ്രവർത്തനക്ഷമമാക്കാനും/അപ്രാപ്‌തമാക്കാനും നിങ്ങൾക്ക് waf ഉപയോഗിക്കാം ns-3 പണിതിട്ടുണ്ട്.

സ്ഥിരസ്ഥിതിയായി, ഉദാഹരണങ്ങളും പരിശോധനകളും അന്തർനിർമ്മിതമല്ല ns-3.

ഉയർന്ന തലത്തിൽ നിന്ന് ns-3 ഡയറക്ടറി, നിങ്ങൾക്ക് നിർമ്മിക്കാൻ കഴിയും ns-3 ഉദാഹരണങ്ങളോ പരിശോധനകളോ ഇല്ലാതെ
ചെയ്യുന്നതിലൂടെ:

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

test.py ഇപ്പോൾ പ്രവർത്തിപ്പിക്കുന്നത് ഉദാഹരണങ്ങളോ ടെസ്റ്റുകളോ പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകില്ല:

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

നിങ്ങൾ നിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ns-3 ഉദാഹരണങ്ങളും പരിശോധനകളും ഉപയോഗിച്ച്, മുകളിൽ നിന്ന് ഇനിപ്പറയുന്നവ ചെയ്യുക
ലെവൽ ns-3 ഡയറക്ടറി:

$ ./waf കോൺഫിഗർ --enable-examples --enable-tests
$ ./waf ബിൽഡ്

test.py പ്രവർത്തിപ്പിക്കുന്നത് എല്ലാ ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകും:

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

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

ഉദാഹരണങ്ങളും പരിശോധനകളും പ്രവർത്തനരഹിതമാക്കുമ്പോൾ, മുൻഗണനാ നിയമങ്ങൾ ഇപ്രകാരമാണ്:

1. --enable-examples/--disable-examples കോൺഫിഗർ സ്ട്രിംഗുകൾ ഏതെങ്കിലും .ns3rc ഫയലിനെ മറികടക്കുന്നു

2. --enable-tests/--disable-tests കോൺഫിഗർ ചെയ്യുന്ന സ്ട്രിംഗുകൾ ഏതെങ്കിലും .ns3rc ഫയലിനെ അസാധുവാക്കുന്നു

3. മുകളിലെ തലത്തിലുള്ള .ns3rc ഫയൽ ns-3 ഡയറക്‌ടറി ഉണ്ടെങ്കിൽ അടുത്തതായി പരിശോധിക്കും

4. സിസ്റ്റം തിരയുന്നു ~/.ns3rc മുമ്പത്തെ ഘട്ടത്തിൽ .ns3rc ഫയൽ കണ്ടെത്തിയില്ലെങ്കിൽ

മുകളിൽ പറഞ്ഞവയൊന്നും നിലവിലില്ലെങ്കിൽ, ഉദാഹരണങ്ങളും പരിശോധനകളും നിർമ്മിക്കപ്പെടില്ല.

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

നിങ്ങൾ ഉയർന്ന തലത്തിലാണെന്ന് കരുതുക ns-3 ഡയറക്ടറി, നിങ്ങൾക്ക് .ns3rc യുടെ ഒരു പകർപ്പ് ലഭിക്കും
എന്ന ഫയൽ ഉപയോഗങ്ങൾ ഇനിപ്പറയുന്ന ഡയറക്‌ടറി:

$ cp utils/.ns3rc .

.ns3rc ഫയൽ ഇപ്പോൾ നിങ്ങളുടെ ഉയർന്ന തലത്തിലായിരിക്കണം ns-3 ഡയറക്ടറി, അതിൽ അടങ്ങിയിരിക്കുന്നു
താഴെ:

#! /usr/bin/env പൈത്തൺ

# ns-3 പ്രവർത്തിപ്പിക്കുമ്പോൾ പ്രവർത്തനക്ഷമമാക്കുന്ന മൊഡ്യൂളുകളുടെ ഒരു ലിസ്റ്റ്.
# ലിസ്റ്റുചെയ്ത മൊഡ്യൂളുകളെ ആശ്രയിക്കുന്ന മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കും.
#
# 'എല്ലാ_മൊഡ്യൂളുകളും' തിരഞ്ഞെടുത്ത് എല്ലാ മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കാം.
modules_enabled = ['all_modules']

# ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമാക്കുക.
example_enabled = തെറ്റ്

# ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമായി സജ്ജമാക്കുക.
tests_enabled = തെറ്റ്

ഉയർന്ന തലത്തിൽ നിന്ന് ns-3 ഡയറക്ടറി, നിങ്ങൾക്ക് നിർമ്മിക്കാൻ കഴിയും ns-3 ഉദാഹരണങ്ങളോ പരിശോധനകളോ ഇല്ലാതെ
ചെയ്യുന്നതിലൂടെ:

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

test.py ഇപ്പോൾ പ്രവർത്തിപ്പിക്കുന്നത് ഉദാഹരണങ്ങളോ ടെസ്റ്റുകളോ പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകില്ല:

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

നിങ്ങൾ നിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ns-3 ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും ഉപയോഗിച്ച്, മാറ്റാൻ നിങ്ങളുടെ പ്രിയപ്പെട്ട എഡിറ്റർ ഉപയോഗിക്കുക
example_enabled, tests_enabled എന്നീ ഫയലുകൾക്കായുള്ള .ns3rc ഫയലിലെ മൂല്യങ്ങൾ ശരിയാണ്:

#! /usr/bin/env പൈത്തൺ

# ns-3 പ്രവർത്തിപ്പിക്കുമ്പോൾ പ്രവർത്തനക്ഷമമാക്കുന്ന മൊഡ്യൂളുകളുടെ ഒരു ലിസ്റ്റ്.
# ലിസ്റ്റുചെയ്ത മൊഡ്യൂളുകളെ ആശ്രയിക്കുന്ന മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കും.
#
# 'എല്ലാ_മൊഡ്യൂളുകളും' തിരഞ്ഞെടുത്ത് എല്ലാ മൊഡ്യൂളുകളും പ്രവർത്തനക്ഷമമാക്കാം.
modules_enabled = ['all_modules']

# ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമാക്കുക.
example_enabled = ശരി

# ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഇത് ശരി എന്നതിന് തുല്യമായി സജ്ജമാക്കുക.
tests_enabled = ശരി

ഉയർന്ന തലത്തിൽ നിന്ന് ns-3 ഡയറക്ടറി, നിങ്ങൾക്ക് നിർമ്മിക്കാൻ കഴിയും ns-3 ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും ഉപയോഗിച്ച് ലളിതമായി
ചെയ്യുന്നത്:

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

test.py പ്രവർത്തിപ്പിക്കുന്നത് എല്ലാ ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകും:

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

ട്രബിൾഷൂട്ടിംഗ്
നിർമ്മാണത്തിലോ പ്രവർത്തിപ്പിക്കുമ്പോഴോ സംഭവിക്കാവുന്ന സാധാരണ പിശകുകളെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ ഈ അധ്യായത്തിൽ പോസ്റ്റ് ചെയ്യുന്നു
ns-3 പ്രോഗ്രാമുകൾ.

ദയവായി ശ്രദ്ധിക്കുക വിക്കി (http://www.nsnam.org/wiki/Troubleshooting) സംഭാവന ചെയ്തിരിക്കാം
ഇനങ്ങൾ.

പണിയുക പിശകുകൾ
പ്രവർത്തന സമയം പിശകുകൾ
ചിലപ്പോൾ, ഒരു വിജയകരമായ ബിൽഡിന് ശേഷം ഒരു പ്രോഗ്രാമിൽ പിശകുകൾ സംഭവിക്കാം. ഇവ പ്രവർത്തന സമയമാണ്
പിശകുകൾ, കൂടാതെ മെമ്മറി കേടാകുമ്പോഴോ പോയിന്റർ മൂല്യങ്ങൾ അപ്രതീക്ഷിതമായിരിക്കുമ്പോഴോ സാധാരണയായി സംഭവിക്കാം
ശൂന്യം.

എന്ത് സംഭവിക്കാം എന്നതിന്റെ ഒരു ഉദാഹരണം ഇതാ:

$ ./waf --റൺ tcp-point-to-point
'/home/tomh/ns-3-nsc/build' എന്ന ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു
സമാഹാരം വിജയകരമായി പൂർത്തിയായി
കമാൻഡ് ['/home/tomh/ns-3-nsc/build/debug/examples/tcp-point-to-point'] കോഡ് -11 ഉപയോഗിച്ച് പുറത്തുകടന്നു

പ്രോഗ്രാം പരാജയപ്പെട്ടുവെന്ന് പിശക് സന്ദേശം പറയുന്നു, പക്ഷേ അത് വ്യക്തമല്ല
ഈ വിവരങ്ങളിൽ നിന്ന് എന്ത് തെറ്റായിരിക്കാം. കൂടുതൽ സൂക്ഷ്മമായി പരിശോധിക്കാൻ, അത് താഴെ പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കുക
The ജിഡിബി ഡീബഗ്ഗർ:

$ ./waf --run tcp-point-to-point --command-template="gdb %s"
'/home/tomh/ns-3-nsc/build' എന്ന ഡയറക്ടറിയിൽ പ്രവേശിക്കുന്നു
സമാഹാരം വിജയകരമായി പൂർത്തിയായി
GNU gdb Red Hat Linux (6.3.0.0-1.134.fc5rh)
പകർപ്പവകാശം 2004 സ്വതന്ത്ര സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷൻ, Inc.
GDB ഒരു സ്വതന്ത്ര സോഫ്‌റ്റ്‌വെയറാണ്, GNU ജനറൽ പബ്ലിക് ലൈസൻസിന് കീഴിൽ, നിങ്ങൾ
ചില വ്യവസ്ഥകൾക്ക് വിധേയമായി അത് മാറ്റുന്നതിനും/അല്ലെങ്കിൽ അതിന്റെ പകർപ്പുകൾ വിതരണം ചെയ്യുന്നതിനും സ്വാഗതം.
വ്യവസ്ഥകൾ കാണുന്നതിന് "പകർപ്പ് കാണിക്കുക" എന്ന് ടൈപ്പ് ചെയ്യുക.
GDB-യ്ക്ക് തികച്ചും വാറന്റി ഇല്ല. വിശദാംശങ്ങൾക്ക് "വാറന്റി കാണിക്കുക" എന്ന് ടൈപ്പ് ചെയ്യുക.
ഈ GDB "i386-redhat-linux-gnu" ആയി ക്രമീകരിച്ചിരിക്കുന്നു... ഹോസ്റ്റ് libthread_db ഉപയോഗിക്കുന്നു
ലൈബ്രറി "/lib/libthread_db.so.1".

(gdb) പ്രവർത്തിപ്പിക്കുക
പ്രോഗ്രാം ആരംഭിക്കുന്നു: /home/tomh/ns-3-nsc/build/debug/examples/tcp-point-to-point
ടാർഗെറ്റ് മെമ്മറിയിൽ നിന്ന് വായിക്കുന്ന പങ്കിട്ട ഒബ്‌ജക്‌റ്റിൽ നിന്നുള്ള ചിഹ്നങ്ങൾ വായിക്കുന്നത്...പൂർത്തിയായി.
ലോഡ് ചെയ്ത സിസ്റ്റം 0xf5c000-ൽ DSO വിതരണം ചെയ്തു

പ്രോഗ്രാമിന് സിഗ്നൽ SIGSEGV ലഭിച്ചു, സെഗ്മെന്റേഷൻ തകരാർ.
പ്രധാനത്തിൽ 0x0804aa12 (argc=1, argv=0xbfdfefa4)
at ../examples/tcp-point-to-point.cc:136
136 Ptr ലോക്കൽ സോക്കറ്റ് = സോക്കറ്റ് ഫാക്ടറി->ക്രിയേറ്റ് സോക്കറ്റ് ();
(gdb) p ലോക്കൽ സോക്കറ്റ്
$1 = {m_ptr = 0x3c5d65}
(gdb) p socketFactory
$2 = {m_ptr = 0x0}
(gdb) ഉപേക്ഷിക്കുക
പ്രോഗ്രാം പ്രവർത്തിക്കുന്നു. എന്തായാലും പുറത്തുകടക്കണോ? (y അല്ലെങ്കിൽ n) വൈ

പ്രോഗ്രാം അഭ്യർത്ഥിച്ച രീതി ആദ്യം ശ്രദ്ധിക്കുക-- ഒരു ആർഗ്യുമെന്റായി പ്രവർത്തിപ്പിക്കാനുള്ള കമാൻഡ് നൽകുക
കമാൻഡ് ടെംപ്ലേറ്റ് "gdb %s".

ഒരു null pointer socketFactory ഒഴിവാക്കാനുള്ള ശ്രമം നടന്നതായി ഇത് നമ്മോട് പറയുന്നു.

gdb സൂചിപ്പിക്കുന്നത് പോലെ നമുക്ക് tcp-point-to-point-ന്റെ 136 വരി നോക്കാം:

Ptr socketFactory = n2->GetObject (Tcp::iid);
Ptr ലോക്കൽ സോക്കറ്റ് = സോക്കറ്റ് ഫാക്ടറി->ക്രിയേറ്റ് സോക്കറ്റ് ();
ലോക്കൽ സോക്കറ്റ്->ബൈൻഡ് ();

GetObject-ന്റെ റിട്ടേൺ മൂല്യം പരിശോധിക്കപ്പെടുന്നില്ല എന്നതാണ് ഇവിടെയുള്ള കുറ്റവാളി
ശൂന്യം.

ചിലപ്പോൾ നിങ്ങൾ ഉപയോഗിക്കേണ്ടി വന്നേക്കാം വാൽഗ്രിൻഡ് മെമ്മറി പരിശോധന കൂടുതൽ സൂക്ഷ്മമായ പിശകുകൾക്ക്. വീണ്ടും,
നിങ്ങൾ സമാനമായി valgrind ന്റെ ഉപയോഗം അഭ്യർത്ഥിക്കുന്നു:

$ ./waf --run tcp-point-to-point --command-template="valgrind %s"

SOURCE

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

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ns-3-മാനുവൽ ഓൺലൈനായി ഉപയോഗിക്കുക