ការបង្រៀនក្លែងធ្វើបណ្តាញ ns-3 ។ ជំពូកទី 5

ជំពូក 1,2
ជំពូក 3
ជំពូក 4

5 ការកំណត់
5.1 ការប្រើប្រាស់ម៉ូឌុលកត់ត្រា
5.1.1 ទិដ្ឋភាពទូទៅនៃការកត់ត្រា
5.1.2 បើកដំណើរការកំណត់ហេតុ
5.1.3 ការបន្ថែមការកត់ត្រាទៅក្នុងលេខកូដរបស់អ្នក។
5.2 ការប្រើអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា
5.2.1 បដិសេធតម្លៃគុណលក្ខណៈលំនាំដើម
5.2.2 ការចាប់យកពាក្យបញ្ជាផ្ទាល់ខ្លួនរបស់អ្នក។
5.3 ការប្រើប្រាស់ប្រព័ន្ធតាមដាន
5.3.1 ការតាមដាន ASCII
ការញែកដាន ASCII
5.3.2 PCAP ដាន

ជំពូកទី 5

ការលៃតម្រូវ

5.1 ការប្រើប្រាស់ម៉ូឌុលកត់ត្រា

យើង​បាន​មើល​យ៉ាង​ខ្លី​រួចហើយ​នៅ​ម៉ូឌុល​កត់ត្រា ns-3 ដោយ​មើល​លើ​ស្គ្រីប first.cc. នៅក្នុងជំពូកនេះ យើងនឹងពិនិត្យមើលឱ្យកាន់តែដិតដល់នូវការប្រើប្រាស់ដែលអាចធ្វើទៅបានសម្រាប់ប្រព័ន្ធរងនៃការកាប់ឈើ។

5.1.1 ទិដ្ឋភាពទូទៅនៃការកត់ត្រា

ប្រព័ន្ធធំ ៗ ជាច្រើនគាំទ្រប្រភេទនៃការកត់ត្រាសារមួយចំនួន ហើយ ns-3 មិនមានករណីលើកលែងនោះទេ។ ក្នុងករណីខ្លះមានតែសារកំហុសប៉ុណ្ណោះដែលត្រូវបានសរសេរទៅ "កុងសូលប្រតិបត្តិករ" (ដែលជាធម្មតា stderr នៅលើប្រព័ន្ធដែលមានមូលដ្ឋានលើ Unix) ។ នៅលើប្រព័ន្ធផ្សេងទៀត សារព្រមានអាចត្រូវបានបង្ហាញ ក៏ដូចជាព័ត៌មានលម្អិតបន្ថែម។ ក្នុង​ករណី​ខ្លះ ឧបករណ៍​កត់ត្រា​ត្រូវ​បាន​ប្រើ​ដើម្បី​បញ្ចេញ​សារ​បំបាត់​កំហុស​ដែល​អាច​ធ្វើឱ្យ​លទ្ធផល​ព្រាល​បាន​លឿន។

subHRD ដែលប្រើក្នុង ns-3 សន្មត់ថាគ្រប់កម្រិតនៃមាតិកាព័ត៌មានទាំងនេះមានប្រយោជន៍ ហើយយើងផ្តល់នូវវិធីសាស្រ្តជ្រើសរើសជាស្រទាប់សម្រាប់ការកត់ត្រាសារ។ ការកត់ត្រាអាចត្រូវបានបិទទាំងស្រុង បើកដំណើរការដោយផ្អែកលើសមាសធាតុនីមួយៗ ឬជាសកល។ ចំពោះគោលបំណងនេះ កម្រិតមាតិកាព័ត៌មានដែលអាចលៃតម្រូវបានត្រូវបានប្រើប្រាស់។ ម៉ូឌុលកត់ត្រា ns-3 ផ្តល់នូវវិធីសាមញ្ញមួយដើម្បីទទួលបានព័ត៌មានមានប្រយោជន៍ពីការក្លែងធ្វើរបស់អ្នក។

អ្នកគួរតែយល់ថាយើងផ្តល់យន្តការគោលបំណងទូទៅមួយ - តាមដាន - សម្រាប់ការទាញយកទិន្នន័យពីម៉ូដែលរបស់អ្នក ដែលគួរតែជាលទ្ធផលដែលពេញចិត្តសម្រាប់ការក្លែងធ្វើ (សម្រាប់ព័ត៌មានបន្ថែមអំពីប្រព័ន្ធតាមដានរបស់យើង សូមមើលវគ្គបង្រៀន 5.3)។ ការកត់ត្រាគួរតែជាវិធីសាស្ត្រដែលពេញចិត្តសម្រាប់ការទទួលបានព័ត៌មានបំបាត់កំហុស ការព្រមាន សារកំហុស ឬសម្រាប់ការចេញសារយ៉ាងឆាប់រហ័សពីស្គ្រីប ឬគំរូរបស់អ្នកគ្រប់ពេល។

បច្ចុប្បន្ន ប្រព័ន្ធកំណត់កម្រិតប្រាំពីរ (ប្រភេទ) នៃសារកំណត់ហេតុក្នុងការបង្កើនលំដាប់នៃមាតិកាព័ត៌មាន។

• LOG_ERROR - សារកំហុសក្នុងការកត់ត្រា (ម៉ាក្រូដែលពាក់ព័ន្ធ៖ NS_LOG_ERROR);
• LOG_WARN - សារព្រមានកំណត់ហេតុ (ម៉ាក្រូដែលពាក់ព័ន្ធ៖ NS_LOG_WARN);
• LOG_DEBUG - កត់ត្រាសារបំបាត់កំហុសពិសេសកម្រ (ម៉ាក្រូដែលពាក់ព័ន្ធ៖ NS_LOG_DEBUG);
• LOG_INFO - ការចុះឈ្មោះសារព័ត៌មានអំពីដំណើរការនៃកម្មវិធី (ម៉ាក្រូដែលពាក់ព័ន្ធ៖ NS_LOG_INFO);
• LOG_FUNCTION - កំណត់ហេតុសារដែលពិពណ៌នាអំពីមុខងារនីមួយៗដែលហៅថា (ម៉ាក្រូដែលទាក់ទងពីរ៖ NS_LOG_FUNCTION ប្រើសម្រាប់មុខងារសមាជិក និង NS_LOG_FUNCTION_NOARGS ប្រើសម្រាប់មុខងារឋិតិវន្ត);
• LOG_LOGIC - សារកត់ត្រាដែលពិពណ៌នាអំពីលំហូរឡូជីខលនៅក្នុងមុខងារមួយ (ម៉ាក្រូដែលទាក់ទង៖ NS_LOG_LOGIC);
• LOG_ALL - កត់ត្រាអ្វីគ្រប់យ៉ាងដែលបានរៀបរាប់ខាងលើ (មិនមានម៉ាក្រូដែលពាក់ព័ន្ធ)។
  សម្រាប់ប្រភេទនីមួយៗ (LOG_TYPE) ក៏មាន LOG_LEVEL_TYPE ផងដែរ ដែលប្រសិនបើប្រើ អនុញ្ញាតឱ្យចូលគ្រប់កម្រិតខាងលើវា បន្ថែមពីលើកម្រិតរបស់វា។ (ជាលទ្ធផល LOG_ERROR និង LOG_LEVEL_ERROR និង LOG_ALL និង LOG_LEVEL_ALL គឺសមមូលមុខងារ។) ឧទាហរណ៍ ការបើក LOG_INFO នឹងអនុញ្ញាតតែសារដែលផ្តល់ដោយម៉ាក្រូ NS_LOG_INFO ខណៈពេលដែលការបើក LOG_LOG_LEVEL_INFO ដោយសារ WARN_DE នឹងរួមបញ្ចូលផងដែរ NS_LOG_ERROR

យើងក៏ផ្តល់ម៉ាក្រូកត់ត្រាដោយគ្មានលក្ខខណ្ឌដែលតែងតែបង្ហាញ ដោយមិនគិតពីកម្រិតនៃការកត់ត្រា ឬសមាសធាតុជ្រើសរើស។

• NS_LOG_UNCOND - ការកត់ត្រាដោយគ្មានលក្ខខណ្ឌនៃសារដែលពាក់ព័ន្ធ (គ្មានកម្រិតនៃការកត់ត្រាដែលពាក់ព័ន្ធ)។

កម្រិតនីមួយៗអាចត្រូវបានសួរជាលក្ខណៈបុគ្គល ឬជាបណ្តុំ។ ការកត់ត្រាអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយប្រើអថេរបរិស្ថាន sh NS_LOG ឬដោយការកត់ត្រាការហៅមុខងារប្រព័ន្ធ។ ដូចដែលបានបង្ហាញពីមុន ប្រព័ន្ធកត់ត្រាមានឯកសារ Doxygen ហើយឥឡូវនេះគឺជាពេលវេលាដ៏ល្អដើម្បីពិនិត្យមើលវាប្រសិនបើអ្នកមិនទាន់មាន។

ឥឡូវ​នេះ​អ្នក​បាន​អាន​ឯកសារ​យ៉ាង​លម្អិត​ហើយ សូម​ប្រើ​ចំណេះដឹង​នោះ​ដើម្បី​ទទួល​បាន​ព័ត៌មាន​គួរ​ឱ្យ​ចាប់​អារម្មណ៍​មួយ​ចំនួន​ពី​ស្គ្រីប​ឧទាហរណ៍ scratch/myfirst.ccដែលអ្នកបានចងក្រងរួចហើយ។

5.1.2 បើកដំណើរការកំណត់ហេតុ

ចូរយើងប្រើអថេរបរិស្ថាន NS_LOG ដើម្បីដំណើរការកំណត់ហេតុមួយចំនួនទៀត ប៉ុន្តែជាដំបូង ដើម្បីទទួលបាន bearings របស់អ្នក ដំណើរការស្គ្រីបចុងក្រោយដូចដែលអ្នកបានធ្វើពីមុនមក។

$ ./waf --run scratch/myfirst

អ្នកគួរតែឃើញលទ្ធផលដែលធ្លាប់ស្គាល់ពីកម្មវិធីឧទាហរណ៍ ns-3 ដំបូង

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

វាប្រែថាសារ "ផ្ញើ" និង "ទទួល" ដែលអ្នកឃើញខាងលើគឺពិតជាសារដែលបានចូលពី កម្មវិធី UdpEchoClient и កម្មវិធី UdpEchoServer. ឧទាហរណ៍ យើងអាចស្នើសុំឱ្យកម្មវិធីអតិថិជនបោះពុម្ពព័ត៌មានបន្ថែមដោយកំណត់កម្រិតនៃការកត់ត្រារបស់វាតាមរយៈអថេរបរិស្ថាន NS_LOG។

ចាប់ពីពេលនេះតទៅ ខ្ញុំនឹងសន្មត់ថាអ្នកកំពុងប្រើសែលដូច sh ដែលប្រើវាក្យសម្ព័ន្ធ "VARIABLE=value" ។ ប្រសិនបើអ្នកកំពុងប្រើសែលដូច csh នោះអ្នកនឹងត្រូវបំប្លែងឧទាហរណ៍របស់ខ្ញុំទៅជាវាក្យសម្ព័ន្ធ "តម្លៃអថេរ setenv" ដែលទាមទារដោយសែលទាំងនោះ។

បច្ចុប្បន្ននេះ កម្មវិធីអតិថិជនអេកូ UDP ឆ្លើយតបទៅនឹងបន្ទាត់កូដខាងក្រោម scratch/myfirst.cc,

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);

វាបើកកម្រិតនៃការកត់ត្រា LOG_LEVEL_INFO ។ នៅពេលដែលយើងឆ្លងកាត់ទង់កម្រិតនៃការកត់ត្រា យើងពិតជាបើកកម្រិតនោះ និងកម្រិតទាបជាងទាំងអស់។ ក្នុងករណីនេះ យើងបានបើកដំណើរការ NS_LOG_INFO, NS_LOG_DEBUG, NS_LOG_WARN និង NS_LOG_ERROR។ យើងអាចបង្កើនកម្រិតនៃការកត់ត្រា និងទទួលបានព័ត៌មានបន្ថែម ដោយគ្មានការផ្លាស់ប្តូរស្គ្រីប និងការចងក្រងឡើងវិញ ដោយកំណត់អថេរបរិស្ថាន NS_LOG ដូចខាងក្រោម៖

$ export NS_LOG=UdpEchoClientApplication=level_all

ដូច្នេះយើងកំណត់អថេរ sh shell NS_LOG ទៅតម្លៃខាងក្រោម។

UdpEchoClientApplication=level_all

ផ្នែកខាងឆ្វេងនៃកិច្ចការគឺជាឈ្មោះនៃសមាសភាគដែលបានកត់ត្រាដែលយើងចង់កំណត់រចនាសម្ព័ន្ធ ហើយផ្នែកខាងស្តាំគឺជាទង់ដែលយើងចង់អនុវត្តសម្រាប់វា។ ក្នុងករណីនេះ យើងនឹងបើកដំណើរការបំបាត់កំហុសគ្រប់កម្រិតនៅក្នុងកម្មវិធី។ ប្រសិនបើអ្នកដំណើរការស្គ្រីបដោយប្រើ NS_LOG កំណត់តាមវិធីនេះ ប្រព័ន្ធកត់ត្រា ns-3 នឹងទទួលយកការផ្លាស់ប្តូរ ហើយអ្នកគួរតែឃើញលទ្ធផលដូចខាងក្រោម៖

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.404s)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
Received 1024 bytes from 10.1.1.2
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

ព័ត៌មានបំបាត់កំហុសបន្ថែមដែលផ្តល់ដោយកម្មវិធីឥឡូវនេះគឺនៅកម្រិត NS_LOG_FUNCTION ។ វាបង្ហាញរាល់ការហៅមុខងារកំឡុងពេលដំណើរការស្គ្រីប។ តាមក្បួនទូទៅ ក្នុងមុខងារវិធីសាស្រ្ត វាជាការប្រសើរក្នុងការប្រើ (យ៉ាងហោចណាស់)NS_LOG_FUNCTION (this)... ប្រើ NS_LOG_FUNCTION_NOARGS ()
មានតែនៅក្នុងមុខងារឋិតិវន្ត។ ទោះជាយ៉ាងណាក៏ដោយ ចំណាំថាប្រព័ន្ធ ns-3 មិនត្រូវបានទាមទារដើម្បីគាំទ្រមុខងារកត់ត្រាណាមួយឡើយ។ ការសម្រេចចិត្តអំពីចំនួនព័ត៌មានត្រូវបានកត់ត្រាទុកឱ្យអ្នកបង្កើតគំរូបុគ្គល។ ក្នុង​ករណី​នៃ​កម្មវិធី​អេកូ ចំនួន​ច្រើន​នៃ​លទ្ធផល​នៃ​ការ​កត់ត្រា​គឺ​អាច​ប្រើ​បាន​។

ឥឡូវនេះអ្នកអាចមើលកំណត់ហេតុនៃការហៅមុខងារដែលត្រូវបានធ្វើឡើងដោយកម្មវិធី។ ប្រសិនបើអ្នកក្រឡេកមើលឱ្យជិតអ្នកនឹងសម្គាល់ឃើញពោះវៀនធំនៅចន្លោះបន្ទាត់ កម្មវិធី UdpEchoClient និងឈ្មោះនៃវិធីសាស្ត្រ ដែលអ្នកអាចរំពឹងថានឹងឃើញ C++ scope operator (: :)។ នេះជាចេតនា។

នេះមិនមែនជាឈ្មោះនៃថ្នាក់នោះទេ ប៉ុន្តែជាឈ្មោះនៃសមាសភាគការកត់ត្រា។ នៅពេលដែលមានការផ្គូផ្គងរវាងឯកសារប្រភព និងថ្នាក់ ជាទូទៅវាជាឈ្មោះរបស់ថ្នាក់ ប៉ុន្តែអ្នកគួរតែដឹងថា តាមពិតវាមិនមែនជាឈ្មោះរបស់ថ្នាក់ទេ ហើយវាមានសញ្ញាតែមួយជំនួសឱ្យសញ្ញាពីរ។ នេះគឺជាវិធីមួយដើម្បីជួយអ្នកឱ្យបែងចែកឈ្មោះសណ្តែកកាប់ឈើចេញពីឈ្មោះថ្នាក់តាមវិធីដ៏ស្រទន់។

ទោះយ៉ាងណាក៏ដោយ ក្នុងករណីខ្លះ វាអាចពិបាកក្នុងការកំណត់ថាវិធីសាស្ត្រមួយណាដែលពិតជាបង្កើតសារកំណត់ហេតុ។ បើ​មើល​អត្ថបទ​ខាង​លើ​នេះ អ្នក​ប្រហែល​ជា​ឆ្ងល់​ថា​ត្រង់​ណា?Received 1024 bytes from 10.1.1.2" អ្នកអាចដោះស្រាយបញ្ហានេះដោយកំណត់កម្រិត បុព្វបទ_func ទៅអថេរបរិស្ថាន NS_LOG ។ សាកល្បងដូចខាងក្រោម៖

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func'

ចំណាំថាសញ្ញាសម្រង់គឺចាំបាច់ព្រោះរបារបញ្ឈរដែលយើងប្រើដើម្បីតំណាងឱ្យប្រតិបត្តិការ OR ក៏ជាឧបករណ៍ភ្ជាប់បំពង់ Unix ផងដែរ។ ឥឡូវនេះ ប្រសិនបើអ្នកដំណើរការស្គ្រីប អ្នកនឹងឃើញថាប្រព័ន្ធកត់ត្រាធានាថារាល់សារនៅក្នុងកំណត់ហេតុដែលបានផ្តល់ឱ្យត្រូវបានបុព្វបទដោយឈ្មោះសមាសភាគ។

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.417s)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

ឥឡូវនេះអ្នកអាចមើលឃើញថាសារទាំងអស់ដែលមកពីកម្មវិធីអតិថិជនអេកូ UDP ត្រូវបានកំណត់អត្តសញ្ញាណដូចនេះ។ សារ "Received 1024 bytes from 10.1.1.2"ឥឡូវនេះត្រូវបានកំណត់យ៉ាងច្បាស់ថាបានមកពីកម្មវិធីអតិថិជនអេកូ។ សារដែលនៅសល់ត្រូវតែមកពីកម្មវិធីម៉ាស៊ីនមេ UDP អេកូ។ យើងអាចបើកដំណើរការសមាសភាគនេះដោយបញ្ចូលបញ្ជីសមាសភាគដែលបំបែកដោយពោះវៀនធំនៅក្នុងអថេរបរិស្ថាន NS_LOG ។

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func:
               UdpEchoServerApplication=level_all|prefix_func'

ការព្រមាន៖ នៅក្នុងអត្ថបទឧទាហរណ៍ខាងលើ អ្នកនឹងត្រូវលុបតួអក្សរបន្ទាត់ថ្មីចេញ បន្ទាប់ពីសញ្ញា (:) វាត្រូវបានប្រើដើម្បីធ្វើទ្រង់ទ្រាយឯកសារ។ ឥឡូវនេះ ប្រសិនបើអ្នកដំណើរការស្គ្រីប អ្នកនឹងឃើញសារកំណត់ហេតុទាំងអស់ពីកម្មវិធីអេកូ និងម៉ាស៊ីនមេ។ អ្នក​អាច​មើល​ឃើញ​ថា​វា​អាច​មាន​ប្រយោជន៍​ខ្លាំង​ណាស់​ពេល​កែ​កំហុស។

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.406s)
UdpEchoServerApplication:UdpEchoServer()
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoServerApplication:StartApplication()
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
UdpEchoServerApplication:HandleRead(): Echoing packet
UdpEchoClientApplication:HandleRead(0x624920, 0x625160)
UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
UdpEchoServerApplication:StopApplication()
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

ពេលខ្លះវាមានប្រយោជន៍ផងដែរ ដើម្បីអាចមើលពេលវេលាក្លែងធ្វើ ដែលសារកំណត់ហេតុត្រូវបានបង្កើត។ អ្នកអាចធ្វើវាបានដោយបន្ថែម OR ប៊ីត បុព្វបទ_ម៉ោង:

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func|prefix_time: UdpEchoServerApplication=level_all|prefix_func|prefix_time'

ជាថ្មីម្តងទៀត អ្នកនឹងត្រូវលុបតួអក្សរបន្ទាត់ថ្មីខាងលើចេញ។ ប្រសិនបើអ្នកដំណើរការស្គ្រីបឥឡូវនេះ អ្នកគួរតែឃើញលទ្ធផលដូចខាងក្រោម៖

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.418s)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:SetDataSize(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
2.00369s UdpEchoServerApplication:HandleRead(): Echoing packet
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

សូមចំណាំថាអ្នកសាងសង់សម្រាប់ UdpEchoServer ត្រូវ​បាន​គេ​ហៅ​អំឡុង​ពេល​ក្លែង​ធ្វើ 0 វិនាទី។ នេះពិតជាកើតឡើងមុនពេលការក្លែងធ្វើចាប់ផ្តើម ប៉ុន្តែពេលវេលាត្រូវបានបង្ហាញជាសូន្យវិនាទី។ ដូចគ្នាដែរចំពោះសារអ្នកសាងសង់ UdpEchoClient.

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.418s)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:SetDataSize(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
2.00369s UdpEchoServerApplication:HandleRead(): Echoing packet
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

រំលឹកថា ស្គ្រីប scratch/first.cc ចាប់ផ្តើមកម្មវិធីម៉ាស៊ីនមេអេកូមួយវិនាទីមុនពេលចាប់ផ្តើមការក្លែងធ្វើ។ ឥឡូវនេះអ្នកអាចឃើញវិធីសាស្រ្តនេះ។ កម្មវិធីចាប់ផ្តើម ម៉ាស៊ីនមេត្រូវបានហៅយ៉ាងពិតប្រាកដក្នុងវិនាទីដំបូង។ អ្នកក៏អាចកត់សម្គាល់ផងដែរថាម៉ាស៊ីនភ្ញៀវអេកូចាប់ផ្តើមនៅក្នុងវិនាទីទីពីរនៃការក្លែងធ្វើ ដូចដែលយើងបានសួរនៅក្នុងស្គ្រីប។

ឥឡូវ​នេះ អ្នក​អាច​តាមដាន​ដំណើរ​ការ​ក្លែង​ធ្វើ​បាន​នៅ​ពេល​ហៅ​ទូរសព្ទ កាលវិភាគបញ្ជូន នៅក្នុងម៉ាស៊ីនភ្ញៀវដែលហៅ HandleRead callback Send នៅក្នុងកម្មវិធីម៉ាស៊ីនមេអេកូ។ ចំណាំថាពេលវេលាដែលបានកន្លងផុតទៅដើម្បីផ្ញើកញ្ចប់ព័ត៌មានតាមតំណពីចំណុចមួយទៅចំណុចគឺ 3,69 មិល្លីវិនាទី។ អ្នកអាចមើលឃើញថាម៉ាស៊ីនមេអេកូកត់ត្រាសារដែលវាបានឆ្លើយតបទៅនឹងកញ្ចប់ព័ត៌មាន ហើយបន្ទាប់មកបន្ទាប់ពីការពន្យាពេលឆានែល អ្នកឃើញថាម៉ាស៊ីនភ្ញៀវអេកូទទួលបានកញ្ចប់ព័ត៌មានអេកូនៅក្នុងវិធី HandleRead របស់វា។

នៅក្នុងការក្លែងធ្វើនេះ មានរឿងជាច្រើនកើតឡើងដោយអ្នកមិនបានចាប់អារម្មណ៍។ ប៉ុន្តែអ្នកអាចតាមដានដំណើរការទាំងមូលបានយ៉ាងងាយស្រួលដោយបើកដំណើរការសមាសធាតុកំណត់ហេតុទាំងអស់នៅក្នុងប្រព័ន្ធ។ សាកល្បងកំណត់អថេរ NS_LOG ទៅតម្លៃខាងក្រោម

$ export 'NS_LOG=*=level_all|prefix_func|prefix_time'

សញ្ញាផ្កាយខាងលើគឺជាតួអក្សរជំនួសសម្រាប់សមាសភាគការកត់ត្រា។ វានឹងរួមបញ្ចូលធាតុទាំងអស់នៅក្នុងសមាសធាតុទាំងអស់ដែលបានប្រើនៅក្នុងការក្លែងធ្វើ។ ខ្ញុំនឹងមិនផលិតឡើងវិញនូវលទ្ធផលនៅទីនេះទេ (នៅពេលសរសេរវាបង្កើត 1265 បន្ទាត់នៃទិន្នផលសម្រាប់កញ្ចប់អេកូតែមួយ) ប៉ុន្តែអ្នកអាចប្តូរទិសព័ត៌មាននេះទៅឯកសារមួយ ហើយមើលវានៅក្នុងកម្មវិធីនិពន្ធដែលអ្នកចូលចិត្ត។

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

ខ្ញុំផ្ទាល់ប្រើកំណែនៃការកត់ត្រាដែលប្រើពាក្យសំដីយ៉ាងខ្លាំងនេះ នៅពេលដែលខ្ញុំមានបញ្ហា ហើយមិនដឹងថាមានរឿងខុសកន្លែងណានោះទេ។ ខ្ញុំអាចធ្វើតាមការប្រតិបត្តិកូដបានយ៉ាងងាយស្រួលដោយមិនចាំបាច់កំណត់ចំណុចឈប់ និងជំហានតាមរយៈកូដនៅក្នុងកម្មវិធីបំបាត់កំហុស។ ខ្ញុំគ្រាន់តែអាចកែសម្រួលលទ្ធផលនៅក្នុងកម្មវិធីនិពន្ធដែលខ្ញុំចូលចិត្ត ហើយរកមើលអ្វីដែលខ្ញុំរំពឹងទុក ហើយឃើញអ្វីមួយដែលខ្ញុំនឹកស្មានមិនដល់។ នៅពេលដែលខ្ញុំមានគំនិតទូទៅអំពីអ្វីដែលនឹងខុស ខ្ញុំបានចូលទៅក្នុងកម្មវិធីបំបាត់កំហុស ដើម្បីស្វែងយល់ពីបញ្ហា។ ប្រភេទនៃលទ្ធផលនេះអាចមានប្រយោជន៍ជាពិសេសនៅពេលដែលស្គ្រីបរបស់អ្នកធ្វើអ្វីមួយដែលមិនបានរំពឹងទុកទាំងស្រុង។ ប្រសិនបើអ្នកប្រើតែកម្មវិធីបំបាត់កំហុស អ្នកអាចនឹងខកខានការកែប្រែទាំងស្រុង។ ការចុះឈ្មោះធ្វើឱ្យការផ្លាស់ប្តូរបែបនេះគួរឱ្យកត់សម្គាល់។

5.1.3 ការបន្ថែមការកត់ត្រាទៅក្នុងលេខកូដរបស់អ្នក។

អ្នកអាចបន្ថែមធាតុថ្មីទៅការក្លែងធ្វើរបស់អ្នកដោយធ្វើការហៅទៅកាន់សមាសធាតុកំណត់ហេតុពីម៉ាក្រូច្រើន។ តោះធ្វើវាក្នុងស្គ្រីប myfirst.ccដែលយើងមាននៅក្នុងថត "ស្អាត" ។ សូមចាំថាយើងបានកំណត់សមាសធាតុនៃការកត់ត្រានៅក្នុងសេណារីយ៉ូនេះ៖

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

អ្នកដឹងថាអ្នកអាចបើកការកត់ត្រាសារទាំងអស់ពីសមាសធាតុនេះដោយកំណត់អថេរបរិស្ថាន NS_LOG នៅកម្រិតផ្សេងៗគ្នា។ ចូរបន្តទៅមុខ ហើយបន្ថែមធាតុមួយចំនួនទៅស្គ្រីប។ ម៉ាក្រូដែលប្រើដើម្បីបន្ថែមសារកម្រិតព័ត៌មានទៅក្នុងកំណត់ហេតុគឺ NS_LOG_INFO។ តោះបន្ថែមសារមួយ (មុននឹងយើងចាប់ផ្តើមបង្កើត nodes) ដែលប្រាប់អ្នកថា script ស្ថិតនៅក្នុងដំណាក់កាល "Creating Topology"។ នេះត្រូវបានធ្វើនៅក្នុងអត្ថបទកូដខាងក្រោម,
បើកឡើង scratch/myfirst.cc នៅក្នុងកម្មវិធីនិពន្ធដែលអ្នកចូលចិត្ត ហើយបន្ថែមបន្ទាត់,
NS_LOG_INFO ("Creating Topology");
នៅចំពោះមុខបន្ទាត់,

NodeContainer nodes;
nodes.Create (2);

ឥឡូវនេះចងក្រងស្គ្រីបដោយប្រើ វ៉ាហ្វហើយសម្អាតអថេរ NS_LOG ដើម្បីបិទដំណើរការស្ទ្រីមកំណត់ហេតុដែលយើងបានបើកមុននេះ៖

$ ./waf
$ export NS_LOG=
Теперь, если вы запустите скрипт,
$ ./waf --run scratch/myfirst

អ្នក​នឹង​មិន​ឃើញ​សារ​ថ្មី​ទេ ព្រោះ​សមាសធាតុ​ចូល​ដែល​ពាក់ព័ន្ធ (FirstScriptExample) មិន​ត្រូវ​បាន​បើក។ ដើម្បី​មើល​សារ​របស់​អ្នក អ្នក​ត្រូវ​បើក​សមាសភាគ​កត់ត្រា FirstScript ឧទាហរណ៍ ជាមួយនឹងកម្រិតមិនទាបជាង NS_LOG_INFO ។ ប្រសិនបើអ្នកគ្រាន់តែចង់ឃើញកម្រិតនៃការកត់ត្រាជាក់លាក់នេះ អ្នកអាចបើកវាដូចនេះបាន។

$ export NS_LOG=FirstScriptExample=info

ប្រសិនបើអ្នកដំណើរការស្គ្រីបឥឡូវនេះ អ្នកនឹងឃើញសារថ្មី "Creating Topology"

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

5.2 ការប្រើអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា

5.2.1 បដិសេធតម្លៃគុណលក្ខណៈលំនាំដើម

វិធីមួយទៀតដើម្បីផ្លាស់ប្តូរឥរិយាបទនៃស្គ្រីប ns-3 ដោយមិនចាំបាច់កែសម្រួល ឬសាងសង់គឺត្រូវប្រើអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា។ យើងផ្តល់យន្តការមួយដើម្បីញែកអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា និងកំណត់អថេរមូលដ្ឋាន និងសកលដោយស្វ័យប្រវត្តិដោយផ្អែកលើលទ្ធផល។

ជំហានដំបូងក្នុងការប្រើប្រព័ន្ធអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជាគឺដើម្បីប្រកាសញែកបន្ទាត់ពាក្យបញ្ជា។ នេះពិតជាងាយស្រួលធ្វើ (នៅក្នុងកម្មវិធីចម្បងរបស់អ្នក) ដូចនៅក្នុងកូដខាងក្រោម។

int
main (int argc, char *argv[])
{
...
CommandLine cmd;
cmd.Parse (argc, argv);
...
}

អត្ថបទខ្លីពីរជួរដ៏សាមញ្ញនេះពិតជាមានប្រយោជន៍ខ្លាំងណាស់នៅក្នុងសិទ្ធិរបស់វា។ វាបើកទ្វារទៅកាន់ប្រព័ន្ធអថេរ និងគុណលក្ខណៈសកល ns-3 ។ ចូរបន្ថែមកូដពីរជួរទៅការចាប់ផ្តើមនៃមុខងារស្គ្រីបមេ scratch/myfirst.cc. បន្តទៅមុខ យើងចងក្រងស្គ្រីប ហើយដំណើរការវា នៅពេលដំណើរការ យើងស្នើសុំជំនួយដូចខាងក្រោម។

$ ./waf --run "scratch/myfirst --PrintHelp"

ពាក្យបញ្ជានេះនឹងសួរ វ៉ា ដំណើរការស្គ្រីប 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.413s)
TcpL4Protocol:TcpStateMachine()
CommandLine:HandleArgument(): Handle arg name=PrintHelp value=
--PrintHelp: Print this help message.
--PrintGroups: Print the list of groups.
--PrintTypeIds: Print all TypeIds.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintGlobals: Print the list of globals.

ឥឡូវនេះសូមក្រឡេកមើលជម្រើស - គុណលក្ខណៈបោះពុម្ព. យើងបាននិយាយរួចហើយអំពីប្រព័ន្ធគុណលក្ខណៈ ns-3 នៅពេលសិក្សាអក្សរទីមួយ.cc ។ យើងបានឃើញបន្ទាត់នៃកូដដូចខាងក្រោម,

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

ហើយពួកគេបាននិយាយថា អត្រា​ទិន្នន័យ តាមពិតគឺជាគុណលក្ខណៈ ឧបករណ៍ PointToPointNet. ចូរយើងប្រើពាក្យបញ្ជា argument parser ដើម្បីមើលគុណលក្ខណៈ ឧបករណ៍ PointToPointNet. បញ្ជីជំនួយនិយាយថាអ្វីដែលយើងត្រូវផ្តល់ ប្រភេទលេខសម្គាល់. នេះគឺជាឈ្មោះនៃថ្នាក់ដែលគុណលក្ខណៈនៃការចាប់អារម្មណ៍ជាកម្មសិទ្ធិ។ ក្នុងករណីរបស់យើងវានឹងមាន ns3::PointToPointNetDevice. តោះបន្តទៅមុខ ចូល

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

ប្រព័ន្ធនឹងបោះពុម្ពលក្ខណៈទាំងអស់នៃប្រភេទឧបករណ៍បណ្តាញនេះ។ អ្នកនឹងឃើញថាក្នុងចំណោមគុណលក្ខណៈនៅក្នុងបញ្ជីគឺ

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

នេះគឺជាតម្លៃលំនាំដើមដែលនឹងត្រូវបានប្រើដោយប្រព័ន្ធនៅពេលបង្កើតវត្ថុ ឧបករណ៍ PointToPointNet. យើងនឹងបដិសេធតម្លៃលំនាំដើមនេះដោយប្រើប៉ារ៉ាម៉ែត្រ គុណលក្ខណៈ в PointToPointHelper ខ្ពស់ជាង។ តោះប្រើតម្លៃលំនាំដើមសម្រាប់ឧបករណ៍ និងឆានែលពីចំណុចមួយទៅចំណុច។ ដើម្បីធ្វើដូចនេះយើងនឹងលុបការហៅចេញ SetDeviceAttribute и SetChannelAttribute ពី myfirst.ccដែលយើងមាននៅក្នុងថតស្អាត។

ស្គ្រីបរបស់អ្នកឥឡូវនេះគួរតែប្រកាសដោយសាមញ្ញ PointToPointHelper ហើយកុំធ្វើប្រតិបត្តិការដំឡើងណាមួយ ដូចបង្ហាញក្នុងឧទាហរណ៍ខាងក្រោម

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

ទៅមុខហើយបង្កើតស្គ្រីបថ្មីជាមួយ វ៉ា (./ វ៉ាហ្វ) ហើយតោះត្រឡប់ទៅវិញ ហើយរួមបញ្ចូលធាតុមួយចំនួនពីកម្មវិធីម៉ាស៊ីនមេ UDP អេកូ និងរួមបញ្ចូលបុព្វបទពេលវេលា។

$ export 'NS_LOG=UdpEchoServerApplication=level_all|prefix_time'

ប្រសិនបើអ្នកដំណើរការស្គ្រីប អ្នកគួរតែឃើញលទ្ធផលដូចខាងក្រោម៖

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.405s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.25732s Received 1024 bytes from 10.1.1.1
2.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

សូមចាំថាពេលចុងក្រោយដែលយើងមើលពេលវេលាក្លែងធ្វើ ពេលដែលកញ្ចប់ព័ត៌មានត្រូវបានទទួលដោយម៉ាស៊ីនមេអេកូ វាគឺ 2,00369 វិនាទី។

2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1

ឥឡូវនេះគាត់ទទួលបានកញ្ចប់ព័ត៌មានក្នុងរយៈពេល 2.25732 វិនាទី។ នេះគឺដោយសារតែយើងគ្រាន់តែកំណត់ឡើងវិញនូវអត្រាទិន្នន័យ PointToPointNetDevice ពីប្រាំ megabits ក្នុងមួយវិនាទីទៅតម្លៃលំនាំដើមគឺ 32768 bits ក្នុងមួយវិនាទី។ ប្រសិនបើយើងជំនួស DataRate ថ្មីដោយប្រើបន្ទាត់ពាក្យបញ្ជា យើងអាចបង្កើនល្បឿនការក្លែងធ្វើរបស់យើងម្តងទៀត។ យើងនឹងធ្វើដូចនេះតាមរូបមន្តដែលបង្កប់ដោយធាតុជំនួយ៖

$ ./waf --run "scratch/myfirst --ns3::PointToPointNetDevice::DataRate=5Mbps"

វានឹងត្រឡប់គុណលក្ខណៈ DataRate ទៅតម្លៃលំនាំដើមរបស់វាចំនួនប្រាំមេហ្គាប៊ីតក្នុងមួយវិនាទី។ តើអ្នកភ្ញាក់ផ្អើលនឹងលទ្ធផលទេ? វាប្រែថាដើម្បីត្រឡប់ឥរិយាបថដើមនៃស្គ្រីបយើងក៏ត្រូវកំណត់ការពន្យាពេលឆានែលដើម្បីផ្គូផ្គងល្បឿននៃពន្លឺ។ យើងអាចស្នើសុំឱ្យប្រព័ន្ធបន្ទាត់ពាក្យបញ្ជាដើម្បីបោះពុម្ពគុណលក្ខណៈឆានែលដូចដែលយើងបានធ្វើសម្រាប់ឧបករណ៍បណ្តាញ៖

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

យើង​នឹង​រក​ឃើញ​ថា​គុណលក្ខណៈ​ពន្យារ​ឆានែល​ត្រូវ​បាន​កំណត់​ដូច​ខាង​ក្រោម៖

--ns3::PointToPointChannel::Delay=[0ns]:
Transmission delay through the channel

បន្ទាប់មក យើងអាចកំណត់តម្លៃលំនាំដើមទាំងពីរនេះ តាមរយៈប្រព័ន្ធបន្ទាត់ពាក្យបញ្ជា។

$ ./waf --run "scratch/myfirst
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms"

ក្នុងករណីនេះ យើងស្ដារពេលវេលាដែលយើងមាន នៅពេលដែលយើងកំណត់ DataRate និង Delay យ៉ាងច្បាស់នៅក្នុងស្គ្រីប៖

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.417s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.00369s Received 1024 bytes from 10.1.1.1
2.00369s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

ចំណាំថាកញ្ចប់ព័ត៌មានត្រូវបានទទួលដោយម៉ាស៊ីនមេម្តងទៀតបន្ទាប់ពី 2,00369 វិនាទី។ យើងពិតជាអាចកំណត់គុណលក្ខណៈណាមួយដែលបានប្រើនៅក្នុងស្គ្រីបតាមវិធីនេះ។ ជាពិសេស យើងអាចកំណត់គុណលក្ខណៈ MaxPackets ទៅជាតម្លៃមិនមែនមួយ។ UdpEchoClient.

តើអ្នកនឹងប្រើវាដោយរបៀបណា? សាកល្បងប្រើ។ សូមចងចាំថាអ្នកត្រូវតែបញ្ចេញមតិអំពីកន្លែងដែលយើងបដិសេធតម្លៃគុណលក្ខណៈលំនាំដើម ហើយកំណត់យ៉ាងច្បាស់ កញ្ចប់អតិបរមា នៅក្នុងស្គ្រីប។ បន្ទាប់មកអ្នកត្រូវបង្កើតស្គ្រីបឡើងវិញ។ អ្នកក៏អាចប្រើបន្ទាត់ពាក្យបញ្ជាដើម្បីទទួលបានជំនួយវាក្យសម្ព័ន្ធសម្រាប់កំណត់តម្លៃគុណលក្ខណៈលំនាំដើមថ្មី។ នៅពេលដែលអ្នកយល់ពីរឿងនេះ អ្នកអាចគ្រប់គ្រងចំនួនកញ្ចប់ដែលបង្ហាញនៅលើបន្ទាត់ពាក្យបញ្ជា។ ដោយសារយើងជាមនុស្សស្មុគ្រស្មាញ បន្ទាត់ពាក្យបញ្ជារបស់យើងគួរតែមើលទៅដូចនេះ៖

$ ./waf --run "scratch/myfirst
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms
--ns3::UdpEchoClient::MaxPackets=2"

សំណួរ​ធម្មជាតិ​ដែល​កើត​ឡើង​ត្រង់​ចំណុច​នេះ​គឺ​ធ្វើ​ដូចម្តេច​ដើម្បី​ដឹង​អំពី​អត្ថិភាព​នៃ​លក្ខណៈ​ទាំង​អស់​នេះ។ ជាថ្មីម្តងទៀត ប្រព័ន្ធបន្ទាត់ពាក្យបញ្ជាមានមុខងារជំនួយសម្រាប់បញ្ហានេះ។ ប្រសិនបើយើងសុំជំនួយពីបន្ទាត់ពាក្យបញ្ជា យើងគួរតែឃើញ៖

$ ./waf --run "scratch/myfirst --PrintHelp"
myfirst [Program Arguments] [General Arguments]
General Arguments:
--PrintGlobals: Print the list of globals.
--PrintGroups: Print the list of groups.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintTypeIds: Print all TypeIds.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintHelp: Print this help message.

ប្រសិនបើអ្នកជ្រើសរើសអាគុយម៉ង់ "PrintGroups" អ្នកគួរតែឃើញបញ្ជីក្រុមដែលបានចុះឈ្មោះទាំងអស់។ ប្រភេទលេខសម្គាល់. ឈ្មោះក្រុមគឺស្របជាមួយនឹងឈ្មោះរបស់ម៉ូឌុលនៅក្នុងថតប្រភព (ទោះបីជាអក្សរធំក៏ដោយ) ។ ការបោះពុម្ពព័ត៌មានទាំងអស់ក្នុងពេលតែមួយនឹងមានពន្លឺខ្លាំងពេក ដូច្នេះមានតម្រងបន្ថែមសម្រាប់បោះពុម្ពព័ត៌មានតាមក្រុម។ ដូច្នេះម្តងទៀត ផ្តោតលើម៉ូឌុលចំណុចមួយទៅចំណុច៖

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

នៅទីនេះអ្នកអាចស្វែងរកឈ្មោះ TypeId ដែលមានសម្រាប់ការរកមើលគុណលក្ខណៈ ឧទាហរណ៍នៅក្នុង
--PrintAttributes = ns3 :: PointToPointChannelដូចដែលបានបង្ហាញខាងលើ។

វិធីមួយទៀតដើម្បីស្វែងយល់អំពីគុណលក្ខណៈគឺតាមរយៈ Doxygen ns‑3។ មានទំព័រមួយដែលរាយនាមគុណលក្ខណៈទាំងអស់ដែលបានចុះឈ្មោះនៅក្នុងម៉ាស៊ីនក្លែងធ្វើ។

5.2.2 ការចាប់យកពាក្យបញ្ជាផ្ទាល់ខ្លួនរបស់អ្នក។

អ្នកក៏អាចបន្ថែមទំពក់ផ្ទាល់ខ្លួនរបស់អ្នកតាមរយៈប្រព័ន្ធបន្ទាត់ពាក្យបញ្ជា។ នេះត្រូវបានធ្វើយ៉ាងសាមញ្ញដោយប្រើវិធីសាស្ត្រញែកបន្ទាត់ពាក្យបញ្ជា បន្ថែម​តម្លៃ.
ចូរយើងប្រើលក្ខណៈពិសេសនេះដើម្បីបញ្ជាក់ចំនួនកញ្ចប់ដែលត្រូវបង្ហាញតាមរបៀបខុសគ្នាទាំងស្រុង។ ចូរបន្ថែមអថេរមូលដ្ឋានដែលហៅថា nPackets ចូលទៅក្នុងមុខងារមួយ។ សំខាន់. យើង​នឹង​កំណត់​វា​ទៅ​មួយ​ដើម្បី​ផ្គូផ្គង​ឥរិយាបថ​លំនាំដើម​ពីមុន​របស់​យើង។ ដើម្បីអនុញ្ញាតឱ្យឧបករណ៍ញែកបន្ទាត់ពាក្យបញ្ជាផ្លាស់ប្តូរតម្លៃនេះ យើងត្រូវចាប់យកតម្លៃនេះនៅក្នុងឧបករណ៍ញែក។ យើងធ្វើដូចនេះដោយបន្ថែមការហៅទូរសព្ទ បន្ថែម​តម្លៃ. ទៅ​ហើយ​ប្តូរ​ស្គ្រីប scratch/myfirst.cc ដូច្នេះ ដើម្បីចាប់ផ្តើមជាមួយកូដខាងក្រោម

int
main (int argc, char *argv[])
{
uint32_t nPackets = 1;
CommandLine cmd;
cmd.AddValue("nPackets", "Number of packets to echo", nPackets);
cmd.Parse (argc, argv);
...

រមូរចុះក្រោមទៅចំណុចនៅក្នុងស្គ្រីបដែលយើងកំណត់គុណលក្ខណៈ MaxPackets ហើយប្តូរវា ដូច្នេះវាត្រូវបានកំណត់ទៅជាអថេរ nPackets ជំនួសឱ្យថេរ 1 ដូចដែលបានបង្ហាញខាងក្រោម។

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

ឥឡូវនេះ ប្រសិនបើអ្នកដំណើរការស្គ្រីប និងផ្គត់ផ្គង់អាគុយម៉ង់ -PrintHelp អ្នកគួរតែឃើញអាគុយម៉ង់អ្នកប្រើប្រាស់ថ្មី។ រាយនៅលើការបង្ហាញជំនួយ។ បញ្ចូល,

$ ./waf --run "scratch/myfirst --PrintHelp"
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.403s)
--PrintHelp: Print this help message.
--PrintGroups: Print the list of groups.
--PrintTypeIds: Print all TypeIds.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintGlobals: Print the list of globals.
User Arguments:
--nPackets: Number of packets to echo

ប្រសិនបើអ្នកចង់ផ្លាស់ប្តូរចំនួនកញ្ចប់ព័ត៌មានដែលបានបញ្ជូន អ្នកអាចធ្វើដូច្នេះបានដោយកំណត់អាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា - -nPackets ។

$ ./waf --run "scratch/myfirst --nPackets=2"

ឥឡូវនេះអ្នកគួរតែមើល

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.404s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.25732s Received 1024 bytes from 10.1.1.1
2.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
Sent 1024 bytes to 10.1.1.2
3.25732s Received 1024 bytes from 10.1.1.1
3.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

ឥឡូវនេះអ្នកបានផ្ញើកញ្ចប់ពីរ។ សាមញ្ញណាស់មែនទេ?
អ្នកអាចមើលឃើញថាក្នុងនាមជាអ្នកប្រើប្រាស់ ns-3 អ្នកអាចប្រើប្រព័ន្ធអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជាដើម្បីរៀបចំតម្លៃ និងគុណលក្ខណៈសកល។ ប្រសិនបើអ្នកជាអ្នកនិពន្ធគំរូ អ្នកអាចបន្ថែមគុណលក្ខណៈថ្មីទៅវត្ថុរបស់អ្នក ហើយពួកវានឹងអាចរកបានដោយស្វ័យប្រវត្តិសម្រាប់ការកំណត់រចនាសម្ព័ន្ធដោយអ្នកប្រើប្រាស់របស់អ្នកតាមរយៈប្រព័ន្ធបន្ទាត់ពាក្យបញ្ជា។ ប្រសិនបើអ្នកជាអ្នកនិពន្ធស្គ្រីប អ្នកអាចបន្ថែមអថេរថ្មីទៅក្នុងស្គ្រីបរបស់អ្នក ហើយដោតវាទៅក្នុងប្រព័ន្ធបន្ទាត់ពាក្យបញ្ជារបស់អ្នក។

5.3 ការប្រើប្រាស់ប្រព័ន្ធតាមដាន

ចំណុចទាំងមូលនៃគំរូគឺដើម្បីបង្កើតលទ្ធផលសម្រាប់ការសិក្សាបន្ថែម ហើយប្រព័ន្ធតាមដាន ns-3 គឺជាយន្តការចម្បងសម្រាប់រឿងនេះ។ ដោយសារ ns-3 គឺជាកម្មវិធី C++ មធ្យោបាយស្តង់ដារនៃការបង្កើតលទ្ធផលពីកម្មវិធី C++ អាចត្រូវបានប្រើ៖

#include <iostream>
...
int main ()
{
...
std::cout << "The value of x is " << x << std::endl;
...
}

អ្នកថែមទាំងអាចប្រើម៉ូឌុលកត់ត្រាដើម្បីបន្ថែមរចនាសម្ព័ន្ធតូចមួយទៅដំណោះស្រាយរបស់អ្នក។ មានបញ្ហាដែលគេស្គាល់ជាច្រើនដែលបណ្តាលមកពីវិធីសាស្រ្តនេះ ដូច្នេះហើយយើងបានផ្តល់ប្រព័ន្ធរងតាមដានព្រឹត្តិការណ៍ទូទៅដើម្បីដោះស្រាយបញ្ហាទាំងនេះ។

គោលដៅសំខាន់នៃប្រព័ន្ធតាមដាន ns-3 គឺ៖

• សម្រាប់កិច្ចការមូលដ្ឋាន ប្រព័ន្ធតាមដានគួរតែអនុញ្ញាតឱ្យអ្នកប្រើបង្កើតដានស្តង់ដារសម្រាប់ប្រភពពេញនិយម និងជ្រើសរើសវត្ថុដែលបង្កើតដាន។

• អ្នកប្រើប្រាស់កម្រិតមធ្យមគួរតែអាចពង្រីកប្រព័ន្ធតាមដាន ដើម្បីផ្លាស់ប្តូរទ្រង់ទ្រាយលទ្ធផលដែលបានបង្កើត ឬបញ្ចូលប្រភពដានថ្មី ដោយមិនចាំបាច់កែប្រែស្នូលម៉ាស៊ីនក្លែងធ្វើ។

• អ្នកប្រើប្រាស់កម្រិតខ្ពស់អាចកែប្រែស្នូលម៉ាស៊ីនក្លែងធ្វើ ដើម្បីបន្ថែមប្រភពដានថ្មី និងលិច។ ប្រព័ន្ធតាមដាន ns-3 ត្រូវបានបង្កើតឡើងនៅលើគោលការណ៍នៃប្រភពតាមដានឯករាជ្យ និងអ្នកទទួល ក៏ដូចជាយន្តការបង្រួបបង្រួមសម្រាប់ភ្ជាប់ប្រភពទៅកាន់អ្នកប្រើប្រាស់។

ប្រព័ន្ធតាមដាន ns-3 ត្រូវបានបង្កើតឡើងនៅលើគោលការណ៍នៃប្រភពតាមដានឯករាជ្យ និងអ្នកទទួល ក៏ដូចជាយន្តការបង្រួបបង្រួមសម្រាប់ភ្ជាប់ប្រភពទៅកាន់អ្នកទទួល។ ប្រភពដានគឺជាវត្ថុដែលអាចផ្តល់សញ្ញាអំពីព្រឹត្តិការណ៍ដែលកើតឡើងនៅក្នុងការក្លែងធ្វើ និងផ្តល់នូវការចូលទៅកាន់ទិន្នន័យមូលដ្ឋានដែលចាប់អារម្មណ៍។ ឧទាហរណ៍ ប្រភព​ដាន​អាច​បង្ហាញ​ពី​ពេល​ដែល​ឧបករណ៍​បណ្ដាញ​បាន​ទទួល​កញ្ចប់​ព័ត៌មាន ហើយ​ធ្វើ​ឱ្យ​មាតិកា​នៃ​កញ្ចប់​មាន​សម្រាប់​អ្នក​ទទួល​ដាន​ដែល​ចាប់​អារម្មណ៍។

ប្រភពដានដោយខ្លួនឯងគឺគ្មានប្រយោជន៍ទេ លុះត្រាតែពួកគេត្រូវបាន "ភ្ជាប់" ជាមួយផ្នែកផ្សេងទៀតនៃកូដដែលពិតជាធ្វើអ្វីមួយដែលមានប្រយោជន៍ជាមួយនឹងព័ត៌មានដែលផ្តល់ដោយលិច។ Tracers គឺជាអ្នកប្រើប្រាស់ព្រឹត្តិការណ៍ និងទិន្នន័យដែលផ្តល់ដោយប្រភពដាន។ ឧទាហរណ៍ អ្នកអាចបង្កើតដានដានដែលនឹង (នៅពេលភ្ជាប់ទៅប្រភពដាននៃឧទាហរណ៍មុន) បោះពុម្ពផ្នែកដែលចាប់អារម្មណ៍នៅក្នុងកញ្ចប់ព័ត៌មានដែលទទួលបាន។

ហេតុផលសម្រាប់ការបំបែកយ៉ាងច្បាស់លាស់នេះគឺដើម្បីអនុញ្ញាតឱ្យអ្នកប្រើប្រាស់ភ្ជាប់ប្រភេទលិចថ្មីទៅនឹងប្រភពដានដែលមានស្រាប់ដោយមិនចាំបាច់កែសម្រួល និងចងក្រងស្នូលម៉ាស៊ីនក្លែងធ្វើឡើងវិញ។ ដូច្នេះក្នុងឧទាហរណ៍ខាងលើ អ្នកប្រើប្រាស់អាចកំណត់ដានថ្មីនៅក្នុងស្គ្រីបរបស់ពួកគេ ហើយភ្ជាប់វាទៅប្រភពដានដែលមានស្រាប់ដែលបានកំណត់ក្នុងស្នូលក្លែងធ្វើដោយគ្រាន់តែកែសម្រួលស្គ្រីបអ្នកប្រើប្រាស់ប៉ុណ្ណោះ។

នៅក្នុងការបង្រៀននេះ យើងនឹងឆ្លងកាត់ប្រភពដែលបានកំណត់ជាមុន និងលិចមួយចំនួន ហើយបង្ហាញពីរបៀបដែលពួកវាអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយប្រើចំនួនតិចបំផុតនៃការខិតខំប្រឹងប្រែងលើផ្នែករបស់អ្នកប្រើ។ សូមមើលសៀវភៅណែនាំ ns-3 ឬផ្នែករបៀបសម្រាប់ព័ត៌មានអំពីការកំណត់រចនាសម្ព័ន្ធដានកម្រិតខ្ពស់ រួមទាំងការពង្រីកទំហំឈ្មោះដាន និងការបង្កើតប្រភពដានថ្មី។

5.3.1 ការតាមដាន ASCII

ns-3 ផ្តល់នូវមុខងារជំនួយដែលផ្តល់នូវប្រព័ន្ធតាមដានកម្រិតទាប ដើម្បីជួយអ្នកនូវព័ត៌មានលម្អិតនៅពេលរៀបចំការតាមដានកញ្ចប់ព័ត៌មានសាមញ្ញ។ ប្រសិនបើអ្នកបើកមុខងារនេះ អ្នកនឹងឃើញលទ្ធផលនៅក្នុងឯកសារ ASCII ។ សម្រាប់អ្នកដែលស្គាល់លទ្ធផល ns-2 ប្រភេទនៃដាននេះគឺស្រដៀងទៅនឹង out.trដែលត្រូវបានបង្កើតដោយស្គ្រីបជាច្រើន។

តោះចុះទៅអាជីវកម្ម ហើយបន្ថែមលទ្ធផលតាមដាន ASCII មួយចំនួនទៅស្គ្រីប scratch/myfirst.cc របស់យើង។ មុនពេលការហៅ Simulator :: Run ()បន្ថែមកូដខាងក្រោម៖
AsciiTraceHelper ascii;

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

ដូចសព្វវចនាធិប្បាយ ns-3 ផ្សេងទៀត កូដនេះប្រើវត្ថុជំនួយដើម្បីបង្កើតដាន ASCII ។ ជួរទីពីរមានការហៅតាមវិធីសាស្រ្ដពីរ។ វិធីសាស្រ្ត "ខាងក្នុង" បង្កើតFileStream() ប្រើសព្វវចនាធិប្បាយវត្ថុអនាមិកដើម្បីបង្កើតវត្ថុស្ទ្រីមឯកសារនៅលើជង់ (ដោយគ្មានឈ្មោះវត្ថុ) ហើយបញ្ជូនវាទៅវិធីសាស្ត្រដែលហៅថា។ យើង​នឹង​ចូល​ទៅ​ជ្រៅ​ទៅ​ក្នុង​រឿង​នេះ​នៅ​ពេល​អនាគត ប៉ុន្តែ​អ្វី​ដែល​អ្នក​ត្រូវ​ដឹង​នៅ​ត្រង់​ចំណុច​នេះ​គឺ​ថា​អ្នក​កំពុង​បង្កើត​វត្ថុ​ដែល​តំណាង​ឱ្យ​ឯកសារ​ដែល​គេ​ហៅ​ថា myfirst.tr ហើយផ្ទេរវាទៅ ns-3 ។ យើងប្រគល់ ns-3 ឱ្យថែទាំវត្ថុដែលបានបង្កើតពេញមួយជីវិតរបស់វា ក្នុងអំឡុងពេលដែលវាដោះស្រាយបញ្ហាដែលបង្កឡើងដោយដែនកំណត់ដែលគេស្គាល់តិចតួច (ដោយចេតនា) ដែលទាក់ទងនឹងអ្នកបង្កើតចម្លងវត្ថុស្ទ្រីម C ++ ។

ការហៅខាងក្រៅ បើកដំណើរការAsciiAll() ប្រាប់ជំនួយការថាអ្នកចង់បញ្ចូលការតាមដាន ASCII ក្នុងការក្លែងធ្វើរបស់អ្នកសម្រាប់ការភ្ជាប់ឧបករណ៍ពីចំណុចមួយទៅចំណុចទាំងអស់ ហើយអ្នកចង់ឱ្យអ្នកទទួលដាន (ជាក់លាក់) កត់ត្រាព័ត៌មានចលនាកញ្ចប់ព័ត៌មានក្នុងទម្រង់ ASCII ។

សម្រាប់អ្នកដែលស្គាល់ជាមួយ ns-2 ព្រឹត្តិការណ៍ដែលបានតាមដានគឺស្មើនឹងចំណុចដានដែលគេស្គាល់ដែលកត់ត្រាព្រឹត្តិការណ៍ "+", "-", "d" និង "r" ។
ឥឡូវអ្នកអាចបង្កើតស្គ្រីប ហើយដំណើរការវាពីបន្ទាត់ពាក្យបញ្ជា៖

$ ./waf --run scratch/myfirst

ដូចច្រើនដងពីមុនដែរ អ្នកនឹងឃើញសារជាច្រើនពី Waf ហើយបន្ទាប់មក "'build' បានបញ្ចប់ដោយជោគជ័យ" ជាមួយនឹងសារមួយចំនួនពីកម្មវិធីដែលកំពុងដំណើរការ។

នៅពេលដំណើរការកម្មវិធីនឹងបង្កើតឯកសារដែលមានឈ្មោះ myfirst.tr. ដោយសារតែធម្មជាតិនៃការងារ វ៉ាតាមលំនាំដើម ឯកសារត្រូវបានបង្កើតមិននៅក្នុងថតមូលដ្ឋាន ប៉ុន្តែនៅក្នុងថតកម្រិតកំពូលនៃឃ្លាំង។ ប្រសិនបើអ្នកចង់ផ្លាស់ប្តូរផ្លូវដែលដានត្រូវបានរក្សាទុក នោះអ្នកអាចប្រើប៉ារ៉ាម៉ែត្រ Waf ដើម្បីបញ្ជាក់វា --cwd. យើងមិនបានធ្វើវាទេ ដូច្នេះដើម្បីមើលឯកសារតាមដាន ASCII myfirst.tr នៅក្នុងកម្មវិធីនិពន្ធដែលអ្នកចូលចិត្ត យើងនឹងត្រូវការរុករកទៅថតកម្រិតកំពូលនៃឃ្លាំងរបស់យើង។

ការញែកដាន ASCII

មានព័ត៌មានជាច្រើននៅទីនោះក្នុងទម្រង់ក្រាស់ល្មម ប៉ុន្តែរឿងដំបូងដែលអ្នកត្រូវកត់សម្គាល់គឺថា ឯកសារមានបន្ទាត់នីមួយៗ។ វានឹងក្លាយជាអាចមើលឃើញយ៉ាងច្បាស់ប្រសិនបើអ្នកពង្រីកបង្អួចមើលឱ្យកាន់តែទូលំទូលាយ។

បន្ទាត់នីមួយៗនៅក្នុងឯកសារត្រូវគ្នាទៅនឹងព្រឹត្តិការណ៍តាមដាន។ ក្នុងករណីនេះ យើងតាមដានព្រឹត្តិការណ៍នៅក្នុងជួរបញ្ជូនដែលមានវត្តមាននៅក្នុងឧបករណ៍បណ្តាញពីចំណុចមួយទៅចំណុចនីមួយៗនៅក្នុងការក្លែងធ្វើ។ ជួរបញ្ជូនគឺជាជួរដែលកញ្ចប់ព័ត៌មាននីមួយៗត្រូវឆ្លងកាត់សម្រាប់តំណពីចំណុចមួយទៅចំណុចមួយ។ ចំណាំថាបន្ទាត់នីមួយៗនៅក្នុងឯកសារដានចាប់ផ្តើមដោយតួអក្សរតែមួយ (ហើយមានដកឃ្លាបន្ទាប់ពីវា)។ និមិត្តសញ្ញានេះនឹងមានអត្ថន័យដូចខាងក្រោមៈ

+: ប្រតិបត្តិការតម្រង់ជួរបានកើតឡើងនៅលើជួរឧបករណ៍។
-: ប្រតិបត្តិការទាញយកធាតុបានកើតឡើងនៅក្នុងជួរឧបករណ៍។
ឃ៖ កញ្ចប់ព័ត៌មានត្រូវបានទម្លាក់ ជាធម្មតាដោយសារតែជួរពេញ។
r៖ កញ្ចប់ព័ត៌មានត្រូវបានទទួលដោយឧបករណ៍បណ្តាញ។

ចូរយើងពិនិត្យមើលកាន់តែដិតដល់នូវបន្ទាត់ទីមួយនៅក្នុងឯកសារដាន។ ខ្ញុំ​នឹង​បំបែក​វា​ជា​ផ្នែក (ដោយ​មាន​ការ​ចូល​បន្ទាត់​ដើម្បី​ភាព​ច្បាស់) និង​លេខ​បន្ទាត់​នៅ​ខាង​ឆ្វេង៖

0 +
1 2
2 /NodeList/0/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Enqueue
3 ns3::PppHeader (
4   Point-to-Point Protocol: IP (0x0021))
6   ns3::Ipv4Header (
7     tos 0x0 ttl 64 id 0 protocol 17 offset 0 flags [none]
8     length: 1052 10.1.1.1 > 10.1.1.2)
9     ns3::UdpHeader (
10      length: 1032 49153 > 9)
11      Payload (size=1024)

ផ្នែកដំបូងនៃព្រឹត្តិការណ៍តាមដានដែលបានពង្រីកនេះ (បន្ទាត់ 0) គឺជាប្រតិបត្តិការ។ យើងមាននិមិត្តសញ្ញា + នៅទីនេះ ដែលត្រូវនឹងប្រតិបត្តិការនៃជួរសម្រាប់ការបញ្ជូន។ ផ្នែកទីពីរ (បន្ទាត់ទី 1) គឺជាពេលវេលាក្លែងធ្វើ ដែលបង្ហាញជាវិនាទី។ អ្នក​ប្រហែល​ជា​ចាំ​អ្វី​ដែល​យើង​បាន​សួរ កម្មវិធី UdpEchoClient ចាប់ផ្តើមផ្ញើកញ្ចប់ក្នុងរយៈពេលពីរវិនាទី។ នៅទីនេះយើងឃើញការបញ្ជាក់ថានេះពិតជាកើតឡើង។

ផ្នែកបន្ទាប់នៃឧទាហរណ៍ដាន (ពីបន្ទាត់ទី 2) បង្ហាញប្រភពដានណាមួយដែលបង្កើតព្រឹត្តិការណ៍នេះ (បង្ហាញពីការតាមដានលំហឈ្មោះ)។ អ្នក​អាច​គិត​អំពី​ចន្លោះ​ឈ្មោះ​ដាន​ដូច​ជា​អ្នក​នឹង​ប្រើ​ចន្លោះ​ឈ្មោះ​ប្រព័ន្ធ​ឯកសារ។ ឫសគល់នៃលំហឈ្មោះគឺ បញ្ជី NodeList. វា​ត្រូវ​នឹង​កុងដង់​ដែល​បាន​គ្រប់គ្រង​ក្នុង​កូដ ns-3 សំខាន់។ វាមានថ្នាំងទាំងអស់ដែលត្រូវបានបង្កើតនៅក្នុងស្គ្រីប។ ដូចជាប្រព័ន្ធឯកសារអាចមានថតនៅឫសរបស់វា បញ្ជី NodeList យើងអាចមានថ្នាំងជាច្រើន។ ដូច្នេះ បន្ទាត់ /NodeList/0 សំដៅលើថ្នាំង null នៅក្នុង NodeList ដែលជាធម្មតាយើងគិតថាជា "node 0" ។ ថ្នាំងនីមួយៗមានបញ្ជីឧបករណ៍ដែលត្រូវបានដំឡើង។ បញ្ជីនេះមានទីតាំងនៅបន្ទាប់ក្នុង namespace ។ អ្នកអាចមើលឃើញថាព្រឹត្តិការណ៍ដាននេះមកពី បញ្ជីឧបករណ៍/0ដែលជាឧបករណ៍ null ដែលបានដំឡើងនៅក្នុង node ។

ខ្សែអក្សររងបន្ទាប់, $ ns3 :: PointToPointNetDeviceប្រាប់ឧបករណ៍មួយណានៅទីតាំងសូន្យ៖ បញ្ជីឧបករណ៍នៃលេខសូន្យ។ សូមចាំថាប្រតិបត្តិការ + បានរកឃើញនៅក្នុងបន្ទាត់ 0 មានន័យថាធាតុមួយត្រូវបានបន្ថែមទៅជួរបញ្ជូនរបស់ឧបករណ៍។ នេះត្រូវបានឆ្លុះបញ្ចាំងនៅក្នុងផ្នែកចុងក្រោយនៃ "ផ្លូវបទ"៖ TxQueue/Enqueue.

ផ្នែកដែលនៅសល់នៅក្នុងដានគួរតែមានលក្ខណៈវិចារណញាណយុត្តិធម៌។ បន្ទាត់ 3-4 បង្ហាញថាកញ្ចប់ព័ត៌មានត្រូវបានរុំព័ទ្ធក្នុងពិធីការពីចំណុចមួយទៅចំណុចមួយ។ បន្ទាត់ 5-7 បង្ហាញថាកញ្ចប់ព័ត៌មានមានបឋមកថាកំណែ IP4 ហើយមានប្រភពមកពីអាសយដ្ឋាន IP 10.1.1.1 និងត្រូវបានបម្រុងទុកសម្រាប់ 10.1.1.2. ជួរទី 8-9 បង្ហាញថាកញ្ចប់ព័ត៌មាននេះមានបឋមកថា UDP ហើយចុងក្រោយបន្ទាត់ទី 10 បង្ហាញថាបន្ទុកគឺ 1024 បៃដែលរំពឹងទុក។

បន្ទាត់បន្ទាប់នៅក្នុងឯកសារដានបង្ហាញថាកញ្ចប់ព័ត៌មានដូចគ្នាត្រូវបានទាញចេញពីជួរបញ្ជូននៅលើថ្នាំងដូចគ្នា។

បន្ទាត់ទីបីនៅក្នុងឯកសារដានបង្ហាញថាកញ្ចប់ព័ត៌មានត្រូវបានទទួលដោយឧបករណ៍បណ្តាញនៅលើម៉ាស៊ីនមេម៉ាស៊ីនមេអេកូ។ ខ្ញុំបានផលិតឡើងវិញនូវព្រឹត្តិការណ៍ខាងក្រោម។

0 r
1 2.25732
2 /NodeList/1/DeviceList/0/$ns3::PointToPointNetDevice/MacRx
3   ns3::Ipv4Header (
4     tos 0x0 ttl 64 id 0 protocol 17 offset 0 flags [none]
5     length: 1052 10.1.1.1 > 10.1.1.2)
6     ns3::UdpHeader (
7       length: 1032 49153 > 9)
8       Payload (size=1024)

ចំណាំថាប្រតិបត្តិការតាមដានឥឡូវនេះគឺ r ហើយពេលវេលាក្លែងធ្វើត្រូវបានកើនឡើងដល់ 2,25732 វិនាទី។ ប្រសិនបើអ្នកធ្វើតាមការណែនាំដោយប្រុងប្រយ័ត្ន នេះមានន័យថាអ្នកបានចាកចេញពី DataRate និង Link Delay របស់ឧបករណ៍បណ្តាញតាមតម្លៃលំនាំដើមរបស់វា។ ភាពតានតឹងនេះគួរតែស៊ាំដូចដែលអ្នកបានឃើញនៅក្នុងផ្នែកមុន។

ធាតុឈ្មោះលំហប្រភពដាន (ជួរទី 2) ត្រូវបានកែប្រែដើម្បីឆ្លុះបញ្ចាំងថាព្រឹត្តិការណ៍នេះមានប្រភពមកពីថ្នាំង 1 (/បញ្ជី NodeList/1) ហើយកញ្ចប់ព័ត៌មានត្រូវបានទទួលដោយប្រភពដាន (/MacRx) វាគួរតែមានភាពងាយស្រួលសម្រាប់អ្នកក្នុងការតាមដានចលនារបស់កញ្ចប់ព័ត៌មានតាមរយៈ topology ដោយមើលដានដែលនៅសល់ក្នុងឯកសារ។

5.3.2 PCAP ដាន

ឧបករណ៍ជំនួយឧបករណ៍ ns-3 ក៏អាចត្រូវបានប្រើដើម្បីបង្កើតឯកសារដានក្នុងទម្រង់ .pcap ផងដែរ។ អក្សរកាត់ pcap (ជាធម្មតាត្រូវបានសរសេរជាអក្សរតូច) តំណាងឱ្យការចាប់យកកញ្ចប់ព័ត៌មាន ហើយជាការពិត API ដែលរួមបញ្ចូលការកំណត់ទម្រង់ឯកសារ .pcap ។ កម្មវិធីពេញនិយមបំផុតដែលអាចអាន និងបង្ហាញទម្រង់នេះគឺ Wireshark (ពីមុនហៅថា Ethereal) ទោះយ៉ាងណាក៏ដោយ មានឧបករណ៍វិភាគដានចរាចរណ៍ជាច្រើនដែលប្រើទម្រង់កញ្ចប់ព័ត៌មាននេះ។ យើងលើកទឹកចិត្តអ្នកប្រើប្រាស់ឱ្យប្រើឧបករណ៍ជាច្រើនដែលមានដើម្បីវិភាគដាន pcap ។ នៅក្នុងមេរៀននេះ យើងនឹងផ្តោតលើការមើលដាន pcap ដោយប្រើ tcpdump.

ការបើកដំណើរការ pcap tracing ត្រូវបានធ្វើដោយបន្ទាត់មួយនៃកូដ។

pointToPoint.EnablePcapAll ("myfirst");

បិទភ្ជាប់បន្ទាត់នៃកូដនេះបន្ទាប់ពីលេខកូដតាមដាន ASCII ដែលយើងទើបតែបានបញ្ចូល scratch/myfirst.cc. ចំណាំថាយើងគ្រាន់តែឆ្លងកាត់ខ្សែអក្សរ "myfirst" មិនមែន "myfirst.pcap" ឬអ្វីស្រដៀងគ្នានោះទេ។ នេះគឺដោយសារតែប៉ារ៉ាម៉ែត្រគឺជាបុព្វបទ មិនមែនជាឈ្មោះឯកសារពេញលេញទេ។ ក្នុងអំឡុងពេលនៃការក្លែងធ្វើ ជំនួយការពិតជានឹងបង្កើតឯកសារតាមដានសម្រាប់ឧបករណ៍ពីចំណុចមួយទៅចំណុចនីមួយៗ។ ឈ្មោះឯកសារនឹងត្រូវបានសាងសង់ដោយប្រើបុព្វបទ លេខថ្នាំង លេខឧបករណ៍ និងបច្ច័យ "។pcap"។

សម្រាប់ឧទាហរណ៍ស្គ្រីបរបស់យើង យើងនឹងឃើញឯកសារដែលមានឈ្មោះ "myfirst-0-0.pcap"ហើយ"myfirst-1-0.pcap" ដែលជាដាន pcap សម្រាប់ node 0-device 0 និង node 1-device 0 រៀងគ្នា។ នៅពេលដែលអ្នកបានបន្ថែមបន្ទាត់កូដដើម្បីបើកដំណើរការ pcap tracing អ្នកអាចដំណើរការស្គ្រីបតាមរបៀបធម្មតា៖

$ ./waf --run scratch/myfirst

ប្រសិនបើអ្នករកមើលនៅក្នុងថតកម្រិតកំពូលនៃការចែកចាយរបស់អ្នក អ្នកគួរតែឃើញឯកសារបី៖ ឯកសារតាមដាន ASCII myfirst.trឯកសារដែលយើងបានសិក្សាពីមុនមក myfirst-0-0.pcap и myfirst-1-0.pcap - ឯកសារ pcap ថ្មីដែលយើងទើបតែបង្កើត។

ការអានលទ្ធផលជាមួយ tcpdump

សម្រាប់ពេលនេះ វិធីងាយស្រួលបំផុតដើម្បីមើលឯកសារ pcap គឺត្រូវប្រើ tcpdump ។

$ tcpdump -nn -tt -r myfirst-0-0.pcap
reading from file myfirst-0-0.pcap, link-type PPP (PPP)
2.000000 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, length 1024
2.514648 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, length 1024
tcpdump -nn -tt -r myfirst-1-0.pcap
reading from file myfirst-1-0.pcap, link-type PPP (PPP)
2.257324 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, length 1024
2.257324 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, length 1024

នៅក្នុងកន្លែងចាក់សំរាម myfirst-0-0.pcap (ឧបករណ៍អតិថិជន) អ្នកអាចមើលឃើញកញ្ចប់អេកូត្រូវបានផ្ញើបន្ទាប់ពី 2 វិនាទីនៃការក្លែងធ្វើ។ ប្រសិនបើអ្នកក្រឡេកមើលកន្លែងចាក់សំរាមទីពីរ (myfirst-1-0.pcap) អ្នកនឹងឃើញថាកញ្ចប់ព័ត៌មានត្រូវបានទទួលនៅ 2,257324 វិនាទី។ អ្នក​នឹង​ឃើញ​នៅ​ក្នុង​ការ​បោះចោល​ទី​ពីរ​ដែល​កញ្ចប់​ត្រូវ​បាន​ត្រឡប់​មក​វិញ​នៅ​ម៉ោង 2.257324 វិនាទី ហើយ​ទីបំផុត​កញ្ចប់​ព័ត៌មាន​ត្រូវ​បាន​ទទួល​វិញ​ដោយ​ម៉ាស៊ីនភ្ញៀវ​ក្នុង​ការ​បោះចោល​លើក​ទី​មួយ​នៅ​ម៉ោង 2.514648 វិនាទី។

ការអានលទ្ធផលជាមួយ Wireshark

ប្រសិនបើអ្នកមិនសូវស្គាល់ Wiresharkមានគេហទំព័រមួយដែលអ្នកអាចទាញយកកម្មវិធី និងឯកសារ៖ http://www.wireshark.org/. Wireshark គឺជា GUI ដែលអាចត្រូវបានប្រើដើម្បីបង្ហាញឯកសារដានទាំងនេះ។ ប្រសិនបើអ្នកមាន Wireshark អ្នកអាចបើកឯកសារដានណាមួយ ហើយបង្ហាញមាតិកាដូចជាអ្នកបានចាប់យកកញ្ចប់ព័ត៌មានដោយប្រើ packet sniffer។

ប្រភព: www.habr.com