ns-3 നെറ്റ്‌വർക്ക് സിമുലേറ്റർ ട്യൂട്ടോറിയൽ. അധ്യായം 4

അധ്യായം 1,2
അധ്യായം 3

4 ആശയ അവലോകനം
4.1 പ്രധാന സംഗ്രഹങ്ങൾ
4.1.1 നോഡ്
4.1.2 അപേക്ഷ
4.1.3 ചാനൽ
4.1.4 നെറ്റ് ഉപകരണം
4.1.5 ടോപ്പോളജിക്കൽ അസിസ്റ്റൻ്റുകൾ
4.2 ആദ്യ ns-3 സ്ക്രിപ്റ്റ്
4.2.1 ബോയിലർ പ്ലേറ്റ് കോഡ്
4.2.2 പ്ലഗ്-ഇന്നുകൾ
4.2.3 ns3 നെയിംസ്പേസ്
4.2.4 ലോഗിംഗ്
4.2.5 പ്രധാന പ്രവർത്തനം
4.2.6 ടോപ്പോളജി സഹായികൾ ഉപയോഗിക്കുന്നു
4.2.7 ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച്
4.2.8 സിമുലേറ്റർ
4.2.9 നിങ്ങളുടെ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു
4.3 ns-3 ഉറവിട കോഡ്

ചാപ്റ്റർ 4

ആശയ അവലോകനം

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

4.1 പ്രധാന സംഗ്രഹങ്ങൾ

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

4.1.1 നോഡ്

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

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

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

4.1.2 അപേക്ഷ

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

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

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

4.1.3 ചാനൽ

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

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

ഈ ട്യൂട്ടോറിയലിൽ ഞങ്ങൾ ചാനലിൻ്റെ പ്രത്യേക പതിപ്പുകൾ ഉപയോഗിക്കും CsmaChannelCsmaChannel, PointToPointChannelPointToPointChannel и WifiChannelWifiChannel. CsmaChannel, ഉദാഹരണത്തിന്, ഒരു കാരിയർ-സെൻസ് മൾട്ടിപ്പിൾ ആക്സസ് കമ്മ്യൂണിക്കേഷൻസ് എൻവയോൺമെൻ്റ് നടപ്പിലാക്കുന്ന ഒരു കമ്മ്യൂണിക്കേഷൻസ് സബ്നെറ്റിൻ്റെ ഒരു പതിപ്പ് മാതൃകയാക്കുന്നു. ഇത് ഞങ്ങൾക്ക് ഇഥർനെറ്റ് പോലെയുള്ള പ്രവർത്തനക്ഷമത നൽകുന്നു.

4.1.4 നെറ്റ് ഉപകരണം

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

Сетевая карта не будет работать без программного драйвера, управляющего её оборудованием. В Unix (или Linux), часть периферийного оборудования классифицируется как device. Устройства управляются с помощью драйверов устройств (device drivers), а сетевые устройства (NIC) управляются с использованием драйверов сетевых устройств (നെറ്റ്വർക്ക് ഡിവൈസ് ഡ്രൈവറുകൾ) എന്നിവയെ മൊത്തത്തിൽ നെറ്റ്‌വർക്ക് ഉപകരണങ്ങൾ എന്ന് വിളിക്കുന്നു (നെറ്റ് ഉപകരണങ്ങൾ). В Unix и Linux вы обращаетесь к сетевым устройствам по таким именам, как например eth0.

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

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

4.1.5 ടോപ്പോളജിക്കൽ അസിസ്റ്റൻ്റുകൾ

ഒരു യഥാർത്ഥ നെറ്റ്‌വർക്കിൽ, നെറ്റ്‌വർക്ക് കാർഡുകൾ ചേർത്ത (അല്ലെങ്കിൽ അന്തർനിർമ്മിത) ഹോസ്റ്റ് കമ്പ്യൂട്ടറുകൾ നിങ്ങൾ കണ്ടെത്തും. ns-3-ൽ, NetDevices ഘടിപ്പിച്ചിട്ടുള്ള നോഡുകൾ നിങ്ങൾ കാണുമെന്ന് ഞങ്ങൾ പറയും. ഒരു വലിയ സിമുലേറ്റഡ് നെറ്റ്‌വർക്കിൽ, നിങ്ങൾ നിരവധി വസ്തുക്കൾക്കിടയിൽ കണക്ഷനുകൾ സംഘടിപ്പിക്കേണ്ടതുണ്ട് നോഡ്, നെറ്റ് ഡിവൈസ് и ചാനൽ.

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

4.2 ആദ്യ ns-3 സ്ക്രിപ്റ്റ്

മുകളിൽ നിർദ്ദേശിച്ച പ്രകാരം നിങ്ങൾ സിസ്റ്റം ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, നിങ്ങളുടെ ഹോം ഡയറക്‌ടറിയിലെ repos എന്ന ഡയറക്‌ടറിയിൽ ns-3 റിലീസ് ഉണ്ടായിരിക്കും. ഡയറക്ടറിയിലേക്ക് പോകുക റിലീസ്

നിങ്ങൾക്ക് അത്തരമൊരു ഡയറക്‌ടറി ഇല്ലെങ്കിൽ, ns-3 ൻ്റെ റിലീസ് പതിപ്പ് നിർമ്മിക്കുമ്പോൾ നിങ്ങൾ ഔട്ട്‌പുട്ട് ഡയറക്‌ടറി വ്യക്തമാക്കിയിട്ടില്ല എന്നാണ് ഇതിനർത്ഥം, ഇതുപോലെ നിർമ്മിക്കുക:
$ ./waf കോൺഫിഗർ —ബിൽഡ്-പ്രൊഫൈൽ=റിലീസ് —ഔട്ട്=ബിൽഡ്/റിലീസ്,
$ ./waf ബിൽഡ്

ഇനിപ്പറയുന്നതിന് സമാനമായ ഒരു ഡയറക്ടറി ഘടന നിങ്ങൾ അവിടെ കാണും:

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

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

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

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

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

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

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

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

4.2.2 പ്ലഗ്-ഇന്നുകൾ

ഉൾപ്പെടുത്തൽ പ്രസ്താവനകളുടെ ഒരു ശ്രേണിയിൽ നിന്നാണ് കോഡ് ആരംഭിക്കുന്നത് (ഉൾപ്പെടുന്നു).

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

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

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

നിങ്ങൾക്ക് അത്തരമൊരു ഡയറക്‌ടറി ഇല്ലെങ്കിൽ, ns-3 ൻ്റെ റിലീസ് പതിപ്പ് നിർമ്മിക്കുമ്പോൾ നിങ്ങൾ ഔട്ട്‌പുട്ട് ഡയറക്‌ടറി വ്യക്തമാക്കിയിട്ടില്ല എന്നാണ് ഇതിനർത്ഥം, ഇതുപോലെ നിർമ്മിക്കുക:
$ ./waf കോൺഫിഗർ ചെയ്യുക --build-profile=debug --out=build/debug
$ ./waf ബിൽഡ്
അഥവാ
$ ./waf കോൺഫിഗർ ചെയ്യുക --build-profile=optimized --out=build/optimized
$ ./waf ബിൽഡ്

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

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

ഉദാഹരണങ്ങളും ടെസ്റ്റുകളും ഉൾപ്പെടുന്ന ഡീബഗ് ബിൽഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് പ്രോജക്റ്റ് ക്രമീകരിക്കുന്നതിന്. നിങ്ങളും ചെയ്തു

$ ./waf

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

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

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

using namespace ns3;

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

4.2.4 ലോഗിംഗ്

തിരക്കഥയുടെ അടുത്ത വരി,

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

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

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

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

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

4.2.5 പ്രധാന പ്രവർത്തനം

സ്ക്രിപ്റ്റിൻ്റെ ഇനിപ്പറയുന്ന വരികളിൽ നിങ്ങൾ കാണും,

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

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

Time::SetResolution (Time::NS);

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

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

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

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

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

4.2.6 ടോപ്പോളജി സഹായികൾ ഉപയോഗിക്കുന്നു

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

NodeContainer nodes;
nodes.Create (2);

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

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

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

PointToPointHelper

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

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

ആദ്യ വരി,

PointToPointHelper pointToPoint;

സ്റ്റാക്കിൽ ഒരു വസ്തുവിൻ്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കുന്നു PointToPointHelper. ഒരു ഉയർന്ന തലത്തിൽ നിന്ന് ഇനിപ്പറയുന്ന വരി,

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

വസ്തുവിനോട് പറയുന്നു PointToPointHelper "5 Mbit/s" (സെക്കൻഡിൽ അഞ്ച് മെഗാബിറ്റ്) മൂല്യം ഉപയോഗിക്കുക "വിവര നിരക്ക്".

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

സമാനമായത് "വിവര നിരക്ക്PointToPointNetDevice-ൽ, PointToPointChannel-മായി ബന്ധപ്പെട്ട "Delay" ആട്രിബ്യൂട്ട് നിങ്ങൾ കണ്ടെത്തും. അവസാന വരി

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

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

NetDeviceContainer

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

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

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

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

InternetStackHelper

ഞങ്ങൾക്ക് ഇപ്പോൾ നോഡുകളും ഉപകരണങ്ങളും ക്രമീകരിച്ചിട്ടുണ്ട്, എന്നാൽ ഞങ്ങളുടെ നോഡുകളിൽ പ്രോട്ടോക്കോൾ സ്റ്റാക്കുകൾ ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല. കോഡിൻ്റെ അടുത്ത രണ്ട് വരികൾ ഇത് ശ്രദ്ധിക്കും.

InternetStackHelper stack;
stack.Install (nodes);

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

Ipv4 വിലാസം സഹായി

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

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

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

കോഡിൻ്റെ ഇനിപ്പറയുന്ന വരി,

Ipv4InterfaceContainer interfaces = address.Assign (devices);

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

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

4.2.7 ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച്

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

UdpEchoServerHelper

ഞങ്ങൾ നേരത്തെ സൃഷ്‌ടിച്ച നോഡുകളിലൊന്നിൽ യുഡിപി എക്കോ സെർവർ ആപ്ലിക്കേഷൻ കോൺഫിഗർ ചെയ്യാൻ ഞങ്ങളുടെ first.cc ഉദാഹരണ സ്‌ക്രിപ്റ്റിലെ ഇനിപ്പറയുന്ന കോഡ് ലൈനുകൾ ഉപയോഗിക്കുന്നു.

UdpEchoServerHelper echoServer (9);

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

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

മറ്റ് പല സഹായ വസ്തുക്കളെയും പോലെ, വസ്തു UdpEchoServerHelper ഒരു രീതി ഉണ്ട് ഇൻസ്റ്റോൾ. ഈ രീതി ഫലപ്രദമായി നടപ്പിലാക്കുന്നത് ഒരു അടിസ്ഥാന എക്കോ സെർവർ ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുകയും അത് ഹോസ്റ്റുമായി ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു. രസകരമെന്നു പറയട്ടെ, രീതി ഇൻസ്റ്റോൾ സ്വീകരിക്കുന്നു നോഡ് കണ്ടെയ്‌നർ മറ്റുള്ളവരെ പോലെ ഒരു പരാമീറ്ററായി ഇൻസ്റ്റോൾ നമ്മൾ കണ്ട രീതികൾ.

ഇവിടെ പ്രവർത്തിക്കുന്ന C++ ഇംപ്ലിസിറ്റ് കൺവേർഷൻ രീതിയുടെ ഫലം എടുക്കുന്നു node.Get(1) (നോഡ് ഒബ്‌ജക്‌റ്റിലേക്ക് ഒരു സ്മാർട്ട് പോയിൻ്റർ തിരികെ നൽകുന്നു - Ptr ) കൂടാതെ അജ്ഞാത ഒബ്‌ജക്‌റ്റിനായി കൺസ്‌ട്രക്‌ടറിൽ ഇത് ഉപയോഗിക്കുന്നു നോഡ് കണ്ടെയ്നർഅത് പിന്നീട് രീതിയിലേക്ക് കൈമാറുന്നു ഇൻസ്റ്റോൾ. ഏത് രീതിയിലാണ് ഒപ്പ് കംപൈൽ ചെയ്‌ത് എക്‌സിക്യൂട്ട് ചെയ്‌തതെന്ന് നിങ്ങൾക്ക് C++ കോഡിൽ നിർണ്ണയിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, പരോക്ഷമായ പരിവർത്തനങ്ങൾ നോക്കുക.

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

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

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

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

UdpEchoClientHelper

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

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

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

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

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

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

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

4.2.8 സിമുലേറ്റർ

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

Simulator::Run ();

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

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

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

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

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

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

Simulator::Destroy ();
return 0;
}

സിമുലേറ്റർ എപ്പോൾ നിർത്തും?

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

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

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

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

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

• തുടങ്ങിയവ.

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

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

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

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

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

4.2.9 നിങ്ങളുടെ സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നു

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

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

ഇപ്പോൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ആദ്യ മാതൃക സ്ക്രിപ്റ്റ് നിർമ്മിക്കുക വാഫ്:

$ ./waf

നിങ്ങളുടെ ആദ്യ ഉദാഹരണം വിജയകരമായി സൃഷ്ടിച്ചുവെന്ന് സൂചിപ്പിക്കുന്ന സന്ദേശങ്ങൾ നിങ്ങൾ കാണും.

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

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

$ ./waf --run scratch/myfirst

നിങ്ങൾ സമാനമായ ഔട്ട്പുട്ട് കാണും:

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

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

4.3 ns-3 ഉറവിട കോഡ്

ഇപ്പോൾ നിങ്ങൾ ചില ns-3 സഹായികൾ ഉപയോഗിച്ചുകഴിഞ്ഞു, ഈ പ്രവർത്തനം നടപ്പിലാക്കുന്ന ചില സോഴ്സ് കോഡ് നിങ്ങൾക്ക് പരിശോധിക്കാം. ഏറ്റവും പുതിയ കോഡ് ഇനിപ്പറയുന്ന ലിങ്കിൽ ഞങ്ങളുടെ വെബ് സെർവറിൽ കാണാൻ കഴിയും: https://gitlab.com/nsnam/ns-3-dev.git. അവിടെ നിങ്ങൾ ഞങ്ങളുടെ ns-3 ഡെവലപ്‌മെൻ്റ് ട്രീയുടെ മെർക്കുറിയൽ സംഗ്രഹ പേജ് കാണും. പേജിൻ്റെ മുകളിൽ നിങ്ങൾ നിരവധി ലിങ്കുകൾ കാണും,

summary | shortlog | changelog | graph | tags | files

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

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

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

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

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