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

ជំពូក 1,2

3 ការចាប់ផ្តើម
3.1 ទិដ្ឋភាពទូទៅ
3.2 តម្រូវការជាមុន
3.2.1 ការទាញយកការចេញផ្សាយ ns-3 ជាបណ្ណសារប្រភព
3.3 ការទាញយក ns-3 ដោយប្រើ Git
3.3.1 កំពុងផ្ទុក ns-3 ដោយប្រើ Bake
3.4 សភា ns-3
3.4.1 អាគារជាមួយ build.py
3.4.2 អាគារជាមួយដុតនំ
3.4.3 បង្កើតជាមួយ Waf
3.5 ការធ្វើតេស្ត ns-3
3.6 ដំណើរការស្គ្រីប
3.6.1 អាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា
3.6.2 ការបំបាត់កំហុស
3.6.3 ថតការងារ

ជំពូកទី 3

ការចាប់ផ្តើម

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

3.1 ទិដ្ឋភាពទូទៅ

ឧបករណ៍ក្លែងធ្វើ ns-3 ត្រូវបានបង្កើតឡើងជាប្រព័ន្ធនៃបណ្ណាល័យកម្មវិធីសហការ។ កំឡុងពេលជួបប្រជុំគ្នា កូដនៃកម្មវិធីអ្នកប្រើប្រាស់ត្រូវបានភ្ជាប់ជាមួយបណ្ណាល័យទាំងនេះ។ ភាសាសរសេរកម្មវិធី C++ ឬ Python ត្រូវបានប្រើដើម្បីសរសេរកម្មវិធីផ្ទាល់ខ្លួន។

Ns-3 ត្រូវបានចែកចាយជាកូដប្រភព ដែលមានន័យថាប្រព័ន្ធគោលដៅត្រូវតែមានបរិយាកាសអភិវឌ្ឍន៍កម្មវិធី ដើម្បីសាងសង់បណ្ណាល័យជាមុនសិន ហើយបន្ទាប់មកបង្កើតកម្មវិធីអ្នកប្រើប្រាស់។ ជាគោលការណ៍ ns-3 អាចត្រូវបានចែកចាយជាបណ្ណាល័យដែលត្រៀមរួចជាស្រេចសម្រាប់ប្រព័ន្ធជាក់លាក់មួយ ហើយនៅពេលអនាគតពួកគេអាចត្រូវបានចែកចាយតាមរបៀបនេះ។ ប៉ុន្តែសព្វថ្ងៃនេះអ្នកប្រើប្រាស់ជាច្រើនពិតជាធ្វើការងាររបស់ពួកគេដោយការកែសម្រួល ns-3 ដោយខ្លួនឯង ដូច្នេះវាមានប្រយោជន៍ក្នុងការមានកូដប្រភពសម្រាប់បង្កើតបណ្ណាល័យ។ ប្រសិនបើអ្នកណាម្នាក់ចង់ទទួលយកការងារបង្កើតបណ្ណាល័យ និងកញ្ចប់ដែលត្រៀមរួចជាស្រេចសម្រាប់ប្រព័ន្ធប្រតិបត្តិការ សូមទាក់ទងបញ្ជីសំបុត្ររួម ns-អ្នកអភិវឌ្ឍន៍.

បន្ទាប់មក យើងនឹងមើលវិធីបីយ៉ាងក្នុងការទាញយក និងបង្កើត ns-3។ ទីមួយគឺត្រូវទាញយក និងបង្កើតការចេញផ្សាយជាផ្លូវការពីគេហទំព័រមេ។ ទីពីរគឺការជ្រើសរើសនិងការផ្គុំច្បាប់ចម្លងនៃកំណែអភិវឌ្ឍន៍នៃការដំឡើងមូលដ្ឋាន ns-3 ។ ទីបីគឺត្រូវប្រើឧបករណ៍សាងសង់បន្ថែមដើម្បីផ្ទុកផ្នែកបន្ថែមបន្ថែមទៀតសម្រាប់ ns-3 ។ យើងនឹងឆ្លងកាត់ឧបករណ៍នីមួយៗ ដោយសារឧបករណ៍មានភាពខុសគ្នាបន្តិចបន្តួច។

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

សម្រាប់កម្មវិធីភាគច្រើនសិទ្ធិ ns-3 ជា root មិនចាំបាច់ទេ វាត្រូវបានណែនាំឱ្យប្រើគណនីអ្នកប្រើប្រាស់ដែលគ្មានសិទ្ធិ។

3.2 តម្រូវការជាមុន

សំណុំទាំងមូលនៃបណ្ណាល័យ ns-3 ដែលអាចប្រើបានមានចំនួននៃការពឹងផ្អែកមួយចំនួនលើបណ្ណាល័យភាគីទីបី ប៉ុន្តែសម្រាប់ផ្នែកភាគច្រើន ns-3 អាចត្រូវបានសាងសង់ និងប្រើប្រាស់ដោយមានការគាំទ្រសម្រាប់សមាសធាតុទូទៅមួយចំនួន (ជាញឹកញាប់ត្រូវបានដំឡើងតាមលំនាំដើម)៖ កម្មវិធីចងក្រង C ++, Python ដែលជាកម្មវិធីនិពន្ធកូដប្រភព (ឧទាហរណ៍ លំនាំដើម, emacs ឬ លេបត្របាក់) ហើយប្រសិនបើឃ្លាំងអភិវឌ្ឍន៍ត្រូវបានប្រើ ប្រព័ន្ធគ្រប់គ្រងកំណែ Git ។ អ្នកប្រើប្រាស់លើកដំបូងភាគច្រើននឹងមិនចាំបាច់ព្រួយបារម្ភទេ ប្រសិនបើការកំណត់រចនាសម្ព័ន្ធរបស់ពួកគេរាយការណ៍ពីមុខងារកម្រិតខ្ពស់ ns-3 មួយចំនួនដែលបាត់ ប៉ុន្តែសម្រាប់អ្នកដែលចង់ដំឡើងពេញលេញ គម្រោងនេះផ្តល់នូវវិគីដែលរួមបញ្ចូលទំព័រជាមួយនឹងគន្លឹះ និងល្បិចមានប្រយោជន៍ជាច្រើន។ ទំព័រមួយនោះគឺជាទំព័រដំឡើង ដែលមានការណែនាំអំពីការដំឡើងសម្រាប់ប្រព័ន្ធផ្សេងៗ មាននៅ៖ https://www.nsnam.org/wiki/Installation.

ផ្នែកតម្រូវការជាមុននៃវិគីនេះពន្យល់ថាកញ្ចប់ណាមួយត្រូវបានទាមទារដើម្បីគាំទ្រជម្រើស ns-3 ទូទៅ ហើយថែមទាំងផ្តល់នូវពាក្យបញ្ជាដែលប្រើដើម្បីដំឡើងពួកវានៅលើរសជាតិទូទៅនៃលីនុច ឬ macOS ផងដែរ។

អ្នកអាចទាញយកប្រយោជន៍ពីឱកាសនេះដើម្បីរុករកទំព័រ ns-3 wiki ឬគេហទំព័រសំខាន់៖ https://www.nsnam.orgដោយសារតែមានព័ត៌មានជាច្រើននៅទីនោះ។ ចាប់ផ្តើមជាមួយនឹងកំណែចុងក្រោយបំផុតនៃ ns-3 (ns-3.29) ឧបករណ៍ខាងក្រោមត្រូវបានទាមទារដើម្បីដំណើរការ ns-3៖

កញ្ចប់ឧបករណ៍/កំណែ

• កម្មវិធីចងក្រង C++
  clang++ ឬ g++ (g++ កំណែ 4.9 ឬខ្ពស់ជាងនេះ)
• ពស់ថ្លាន់
  កំណែ python2 >= 2.7.10 ឬកំណែ python3 >=3.4
• Git
  កំណែចុងក្រោយបំផុតណាមួយ (ដើម្បីចូលប្រើ ns-3 នៅលើ GitLab.com)
• tar
  កំណែចុងក្រោយបំផុតណាមួយ (សម្រាប់ការពន្លាការចេញផ្សាយ ns-3)
• bunzip ២
  កំណែចុងក្រោយបំផុតណាមួយ (សម្រាប់ការពន្លាការចេញផ្សាយ ns-3)

ដើម្បីពិនិត្យមើលកំណែលំនាំដើមរបស់ Python សូមវាយ python -V. ដើម្បីពិនិត្យមើលកំណែ g++ សូមវាយ g++ -v. ប្រសិនបើឧបករណ៍ណាមួយបាត់ ឬចាស់ពេក សូមមើលការណែនាំអំពីការដំឡើងនៅលើទំព័រ ns-3 wiki ។

ចាប់ពីពេលនេះតទៅ យើងសន្មត់ថាអ្នកអានកំពុងដំណើរការ Linux, MacOS ឬ Linux emulator ហើយយ៉ាងហោចណាស់មានឧបករណ៍ខាងលើ។

3.2.1 ការទាញយកការចេញផ្សាយ ns-3 ជាបណ្ណសារប្រភព

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

ឧបមាថាអ្នកក្នុងនាមជាអ្នកប្រើប្រាស់ចង់បង្កើត ns-3 នៅក្នុងថតមូលដ្ឋានដែលហៅថា កន្លែងធ្វើការ. អ្នកអាចទទួលបានច្បាប់ចម្លងនៃការចេញផ្សាយដោយបញ្ចូលដូចខាងក្រោមទៅក្នុងកុងសូលលីនុច (ជាការពិតណាស់ ការជំនួសលេខកំណែដែលសមរម្យ)

$ cd 
$ mkdir workspace 
$ cd workspace 
$ wget https://www.nsnam.org/release/ns-allinone-3.29.tar.bz2 
$ tar xjf ns-allinone-3.29.tar.bz2 

យកចិត្តទុកដាក់លើឧបករណ៍ប្រើប្រាស់ដែលបានប្រើខាងលើ wgetដែលជាឧបករណ៍បន្ទាត់ពាក្យបញ្ជាសម្រាប់ទាញយកវត្ថុពីអ៊ីនធឺណិត។ ប្រសិនបើអ្នកមិនទាន់បានដំឡើងវាទេ អ្នកអាចប្រើកម្មវិធីរុករករបស់អ្នកសម្រាប់រឿងនេះ។

ការធ្វើតាមជំហានទាំងនេះនឹងនាំអ្នកទៅកាន់ថតឯកសារ ns-allinone-3.29 នៅទីនោះ អ្នកគួរតែឃើញឯកសារ និងថតឯកសារជាច្រើន

$ cd ns-allinone-3.29
$ ls
bake constants.py ns-3.29 README
build.py netanim-3.108 pybindgen-0.17.0.post58+ngcf00cc0 util.py

ឥឡូវនេះអ្នកត្រៀមខ្លួនរួចរាល់ហើយក្នុងការសាងសង់ការចែកចាយមូលដ្ឋាន ns-3 ហើយអាចបន្តទៅផ្នែកនៅលើការកសាង ns-3 ។

3.3 ការទាញយក ns-3 ដោយប្រើ Git

លេខកូដ ns-3 មាននៅក្នុងឃ្លាំង Git នៅលើ GitLab.com នៅ https://gitlab.com/nsnam/. ក្រុម nsnam ប្រមូលផ្តុំនូវឃ្លាំងផ្សេងៗដែលប្រើដោយគម្រោងប្រភពបើកចំហ។

មធ្យោបាយងាយស្រួលបំផុតដើម្បីចាប់ផ្តើមប្រើប្រាស់ឃ្លាំង Git គឺដើម្បីបំបែក ឬក្លូនបរិស្ថាន ns-3-allinone. នេះគឺជាសំណុំនៃស្គ្រីបដែលគ្រប់គ្រងការផ្ទុក និងការផ្គុំប្រព័ន្ធរង ns-3 ដែលប្រើជាទូទៅបំផុត។ ប្រសិនបើអ្នកថ្មីចំពោះ Git ពាក្យ "fork" និង "clone" ប្រហែលជាមិនស៊ាំនឹងអ្នកទេ។ បើដូច្នេះ យើងសូមណែនាំឱ្យអ្នកគ្រាន់តែក្លូន (ធ្វើច្បាប់ចម្លងដោយខ្លួនឯង) ឃ្លាំងដែលមានទីតាំងនៅលើ GitLab.com ដូចនេះ៖

$ cd 
$ mkdir workspace 
$ cd workspace 
$ git clone https://gitlab.com/nsnam/ns-3-allinone.git 
$ cd ns-3-allinone 

នៅដំណាក់កាលនេះទិដ្ឋភាពនៃថតរបស់អ្នក។ ns-3-allinone ខុស​គ្នា​បន្តិច​ពី​បញ្ជី​ប័ណ្ណសារ​ចេញផ្សាយ​ដែល​បាន​ពិពណ៌នា​ខាងលើ។ វាគួរតែមើលទៅដូចនេះ៖

$ ls
build.py constants.py download.py README util.py

សូមចំណាំថាមានស្គ្រីប ទាញយក.pyដែលនឹងទាញយកបន្ថែម ns-3 និងកូដប្រភពដែលភ្ជាប់មកជាមួយ។ នៅទីនេះអ្នកមានជម្រើសមួយ៖ ទាញយករូបថតអភិវឌ្ឍន៍ ns-3 ចុងក្រោយបង្អស់៖

$ python download.py

ឬចូលចិត្តការចេញផ្សាយ ns-3 ដោយប្រើទង់ -n ដើម្បីចង្អុលបង្ហាញលេខចេញផ្សាយ៖

$ python download.py -n ns-3.29

បន្ទាប់ពីជំហាននេះទៅថត ns-3-allinone ឃ្លាំងបន្ថែមនឹងត្រូវបានទាញយក ns-3, ដុត, pybindgen и នេតានីម.

ការកត់សម្គាល់
នៅលើម៉ាស៊ីនដែលមាន Ubuntu16.04 ស្អាត ខ្ញុំត្រូវផ្លាស់ប្តូរពាក្យបញ្ជាទៅវា៖ $ sudo python3 download.py -n ns-3.29 (តទៅនេះកំណត់ចំណាំរបស់អ្នកបកប្រែ)។

3.3.1 កំពុងផ្ទុក ns-3 ដោយប្រើ Bake

វិធីសាស្រ្តទាំងពីរខាងលើ (បណ្ណសារប្រភព ឬឃ្លាំង ns-3-allinone តាមរយៈ Git) មានប្រយោជន៍សម្រាប់ការទទួលបានការដំឡើង ns-3 ដ៏សាមញ្ញបំផុតជាមួយនឹង addons ច្រើន (pybindgen ដើម្បីបង្កើតការចង Python និង នេតានីម សម្រាប់ចលនាបណ្តាញ) ។ ឃ្លាំងទីបីដែលផ្តល់តាមលំនាំដើមនៅក្នុង ns-3-allinone ត្រូវបានហៅ ដុត.

ដុត គឺជាឧបករណ៍សម្រាប់សំរបសំរួលការកសាងសូហ្វវែរពីឃ្លាំងជាច្រើន ដែលបង្កើតឡើងសម្រាប់គម្រោង ns-3 ។ ដុត អាចត្រូវបានប្រើដើម្បីទទួលបានកំណែអភិវឌ្ឍន៍នៃ ns-3 ក៏ដូចជាដើម្បីទាញយក និងបង្កើតផ្នែកបន្ថែមនៃកំណែមូលដ្ឋាននៃការចែកចាយ ns-3 ដូចជាបរិស្ថាន។ ការប្រតិបត្តិកូដផ្ទាល់, CradleNetwork Simulation Cradleសមត្ថភាពក្នុងការបង្កើតការចង Python ថ្មី និងកម្មវិធី ns-3 ផ្សេងៗ។

ការកត់សម្គាល់
CradleNetwork Simulation Cradle គឺជាក្របខ័ណ្ឌដែលអនុញ្ញាតឱ្យអ្នកប្រើជង់បណ្តាញ TCP/IP ពិតប្រាកដនៅខាងក្នុងម៉ាស៊ីនក្លែងធ្វើបណ្តាញ។

ប្រសិនបើអ្នករំពឹងថាការដំឡើង ns-3 របស់អ្នកនឹងមានមុខងារកម្រិតខ្ពស់ ឬបន្ថែម អ្នកអាចធ្វើតាមវិធីដំឡើងនេះ។

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

អ្នកក៏អាចទទួលបានច្បាប់ចម្លងចុងក្រោយបង្អស់ផងដែរ។ ដុតដោយបញ្ចូលពាក្យបញ្ជាខាងក្រោមទៅក្នុងកុងសូលលីនុចរបស់អ្នក (សន្មត់ថាអ្នកបានដំឡើង Git)៖

$ cd 
$ mkdir workspace 
$ cd workspace 
$ git clone https://gitlab.com/nsnam/bake.git

នៅពេលអ្នកដំណើរការពាក្យបញ្ជា git អ្នកគួរតែឃើញអ្វីមួយដូចតទៅ៖

Cloning into 'bake'...
remote: Enumerating objects: 2086, done. 
remote: Counting objects: 100% (2086/2086), done. 
remote: Compressing objects: 100% (649/649), done. 
remote: Total 2086 (delta 1404), reused 2078 (delta 1399) 
Receiving objects: 100% (2086/2086), 2.68 MiB | 3.82 MiB/s, done. 
Resolving deltas: 100% (1404/1404), done.

បន្ទាប់ពីពាក្យបញ្ជាបានបញ្ចប់ ក្លូន អ្នកគួរតែមានបញ្ជីឈ្មោះ ដុតមាតិកាដែលគួរមើលទៅដូចនេះ៖

$ cd bake
$ ls
bake bakeconf.xml bake.py doc examples generate-binary.py test TODO

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

1. ns-3.29៖ ម៉ូឌុលដែលត្រូវគ្នានឹងការចេញផ្សាយ; វានឹងទាញយកសមាសធាតុស្រដៀងគ្នាទៅនឹងការចេញផ្សាយនៅក្នុង tarball ។

2. ns-3-dev៖ ម៉ូឌុលស្រដៀងគ្នា ប៉ុន្តែប្រើកូដពីមែកធាងអភិវឌ្ឍន៍។

3. ns-allinone-3.29៖ ម៉ូឌុលដែលរួមបញ្ចូលមុខងារបន្ថែមផ្សេងទៀតដូចជា Click routing និង Network Simulation Cradle, Openflow សម្រាប់ ns-3។

4. ns-3-allinone៖ ស្រដៀងទៅនឹងកំណែចេញផ្សាយនៃម៉ូឌុល ដាក់​បញ្ចូល​គ្នា​តែមួយប៉ុន្តែសម្រាប់កូដអភិវឌ្ឍន៍។

ការកត់សម្គាល់
ចុច - ស្ថាបត្យកម្មកម្មវិធីម៉ូឌុលសម្រាប់បង្កើតរ៉ោតទ័រ។

Openflow គឺជាពិធីការសម្រាប់គ្រប់គ្រងដំណើរការនៃការដំណើរការទិន្នន័យដែលបានបញ្ជូនតាមបណ្តាញទិន្នន័យដោយរ៉ោតទ័រ និងឧបករណ៍ប្តូរ ដោយអនុវត្តបច្ចេកវិទ្យាបណ្តាញដែលកំណត់ដោយកម្មវិធី។

រូបថតនៃការអភិវឌ្ឍន៍បច្ចុប្បន្ន (មិនចេញផ្សាយ) ns-3 អាចរកបាននៅ៖https://gitlab.com/nsnam/ns-3-dev.git.

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

អ្នកអាចស្វែងរកកំណែចុងក្រោយបំផុតនៃកូដដោយរុករកបញ្ជីឃ្លាំង ឬដោយចូលទៅកាន់គេហទំព័រ ns-3 Releases៖https://www.nsnam.org/releases/ ហើយចុចលើតំណកំណែចុងក្រោយបំផុត។ ក្នុងឧទាហរណ៍នេះយើងនឹងបន្តជាមួយ ns-3.29 ។

ឥឡូវនេះ ដើម្បីទទួលបានសមាសធាតុ ns-3 ដែលយើងត្រូវការ យើងនឹងប្រើឧបករណ៍ ដុត. ចូរនិយាយពាក្យណែនាំពីរបីអំពីការងារ ដុត.

ដុតនំដំណើរការដោយផ្ទុកប្រភពកញ្ចប់ទៅក្នុងថត ប្រភព និងដំឡើងបណ្ណាល័យទៅក្នុងថតឯកសារ។ ដុត អាចត្រូវបានដំណើរការដោយយោងប្រព័ន្ធគោលពីរ ប៉ុន្តែប្រសិនបើអ្នកចង់ដំណើរការ ដុត មិន​មែន​មក​ពី​ថត​ដែល​វា​ត្រូវ​បាន​ទាញ​យក​នោះ​ទេ គួរតែ​បន្ថែម​ផ្លូវ​ទៅ ដុត ទៅកាន់ផ្លូវរបស់អ្នក (PATH environment variable) ឧទាហរណ៍ដូចខាងក្រោម (ឧទាហរណ៍សម្រាប់ Linux bash shell)។ ចូលទៅកាន់ថត "ដុតនំ" ហើយបន្ទាប់មកកំណត់អថេរបរិស្ថានខាងក្រោម៖

$ export BAKE_HOME=`pwd` 
$ export PATH=$PATH:$BAKE_HOME:$BAKE_HOME/build/bin 
$ export PYTHONPATH=$PYTHONPATH:$BAKE_HOME:$BAKE_HOME/build/lib

នេះនឹងដាក់កម្មវិធី bake.py ទៅ​ផ្លូវ​សែល ហើយ​នឹង​អនុញ្ញាត​ឱ្យ​កម្មវិធី​ផ្សេង​ទៀត​ស្វែង​រក​កម្មវិធី​ប្រតិបត្តិ និង​បណ្ណាល័យ​ដែល​វា​បាន​បង្កើត ដុត. ក្នុងករណីខ្លះនៃការប្រើប្រាស់ ដុតការកំណត់ PATH និង PYTHONPATH ដែលបានពិពណ៌នាខាងលើមិនត្រូវបានទាមទារទេ ប៉ុន្តែការស្ថាបនាពេញលេញនៃ ns-3-allinone (ជាមួយនឹងកញ្ចប់បន្ថែម) ជាធម្មតាទាមទារវា។

ចូលទៅកាន់ថតការងាររបស់អ្នក ហើយបញ្ចូលដូចខាងក្រោមក្នុងកុងសូល៖

$ ./bake.py configure -e ns-3.29

បន្ទាប់យើងនឹងសួរ ដុត ពិនិត្យមើលថាតើយើងមានឧបករណ៍គ្រប់គ្រាន់ដើម្បីផ្ទុកសមាសធាតុផ្សេងៗដែរឬទេ។ ចុច៖

$ ./bake.py check

អ្នកគួរតែឃើញអ្វីមួយដូចតទៅ៖

> Python - OK 
> GNU C++ compiler - OK 
> Mercurial - OK 
> Git - OK 
> Tar tool - OK 
> Unzip tool - OK 
> Make - OK 
> cMake - OK 
> patch tool - OK 
> Path searched for tools: /usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin ...

ជាពិសេស ឧបករណ៍ផ្ទុកឡើងដូចជា Mercurial, CVS, Git និង Bazaar មានសារៈសំខាន់ក្នុងជំហាននេះ ដោយសារពួកគេអនុញ្ញាតឱ្យយើងទទួលបានលេខកូដ។ នៅចំណុចនេះ សូមដំឡើងឧបករណ៍ដែលបាត់តាមរបៀបធម្មតាសម្រាប់ប្រព័ន្ធរបស់អ្នក (ប្រសិនបើអ្នកដឹងពីរបៀប) ឬទាក់ទងអ្នកគ្រប់គ្រងប្រព័ន្ធរបស់អ្នកសម្រាប់ជំនួយ។

បន្ទាប់មក សាកល្បងទាញយកកម្មវិធី៖

$ ./bake.py download

លទ្ធផលគួរតែជាអ្វីមួយដូចជា៖

>> Searching for system dependency setuptools - OK 
>> Searching for system dependency libgoocanvas2 - OK 
>> Searching for system dependency gi-cairo - OK 
>> Searching for system dependency pygobject - OK 
>> Searching for system dependency pygraphviz - OK 
>> Searching for system dependency python-dev - OK 
>> Searching for system dependency qt - OK 
>> Searching for system dependency g++ - OK 
>> Downloading pybindgen-0.19.0.post4+ng823d8b2 (target directory:pybindgen) - OK 
>> Downloading netanim-3.108 - OK 
>> Downloading ns-3.29 - OK

នេះនឹងមានន័យថាប្រភពបីត្រូវបានទាញយក។ ឥឡូវចូលទៅកាន់ថតប្រភព ហើយវាយ ls; អ្នកគួរតែមើល៖

$ cd source 
$ ls
netanim-3.108 ns-3.29 pybindgen

ឥឡូវ​នេះ​អ្នក​បាន​ត្រៀម​ខ្លួន​ជា​ស្រេច​ដើម្បី​បង្កើត​ការ​ចែកចាយ ns-3 ។

3.4 សភា ns-3

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

3.4.1 អាគារជាមួយ build.py

សូមប្រយ័ត្ន! ជំហានសាងសង់នេះគឺអាចប្រើបានតែពីកំណែប័ណ្ណសារប្រភពដែលទទួលបានដូចបានរៀបរាប់ខាងលើ។ ហើយមិនត្រូវបានទាញយកតាមរយៈ git ឬដុតនំទេ។

នៅពេលធ្វើការជាមួយប័ណ្ណសារចេញផ្សាយ បាឡុងនៅ ns-3-allinone មានស្គ្រីបងាយស្រួលដែលអាចធ្វើឱ្យការប្រមូលផ្តុំសមាសធាតុកាន់តែងាយស្រួល។ វាត្រូវបានគេហៅថា build.py ។ កម្មវិធីនេះនឹងរៀបចំគម្រោងសម្រាប់អ្នកតាមរបៀបដែលមានប្រយោជន៍បំផុត។ ទោះជាយ៉ាងណាក៏ដោយ ចំណាំថាការដំឡើងកម្រិតខ្ពស់ និងធ្វើការជាមួយ ns-3 ជាធម្មតាពាក់ព័ន្ធនឹងការប្រើប្រាស់ប្រព័ន្ធបង្កើតផ្ទាល់ខ្លួនរបស់ ns-3 គឺ Waf ដែលនឹងត្រូវបានណែនាំនៅពេលក្រោយនៅក្នុងមេរៀននេះ។

ប្រសិនបើអ្នកបានទាញយកដោយប្រើ បាឡុងបន្ទាប់មកនៅក្នុងថតរបស់អ្នក។ ~/ កន្លែងធ្វើការ ថតដែលមានឈ្មោះអ្វីមួយដូចជា ns-allinone-3.29. បញ្ចូលដូចខាងក្រោម៖

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

នៅពេលគេហៅ build.py យើង​បាន​ប្រើ​អាគុយម៉ង់​បន្ទាត់​ពាក្យ​បញ្ជា ដើម្បី​បង្កើត​ឧទាហរណ៍ និង​ការ​សាកល្បង​ដែល​បាន​ប្រើ​ក្នុង​ការ​បង្រៀន​នេះ ដែល​មិន​ត្រូវ​បាន​បង្កើត​តាម​លំនាំដើម​ក្នុង ns-3 ទេ។ តាមលំនាំដើម កម្មវិធីក៏បង្កើតម៉ូឌុលដែលមានទាំងអស់ផងដែរ។ បន្ទាប់មក ប្រសិនបើអ្នកប្រាថ្នា អ្នកអាចបង្កើត ns-3 ដោយគ្មានឧទាហរណ៍ និងការធ្វើតេស្ត ឬដកម៉ូឌុលដែលមិនត្រូវការសម្រាប់ការងាររបស់អ្នក។

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

Waf: Leaving directory '/path/to/workspace/ns-allinone-3.29/ns-3.29/build'
'build' finished successfully (6m25.032s) 

Modules built:
antenna                aodv                     applications
bridge                 buildings                config-store
core                   csma                     csma-layout
dsdv                   dsr                      energy 
fd-net-device          flow-monitor             internet
internet-apps          lr-wpan                  lte
mesh                   mobility                 mpi
netanim (no Python)    network                  nix-vector-routing 
olsr                   point-to-point           point-to-point-layout 
propagation            sixlowpan                spectrum 
stats                  tap-bridge               test (no Python) 
topology-read          traffic-control          uan 
virtual-net-device     visualizer               wave 
wifi                   wimax 

Modules not built (see ns-3 tutorial for explanation):
brite                  click                    openflow 
Leaving directory ./ns-3.29

នៅក្នុងបីជួរចុងក្រោយនៃការចុះបញ្ជី យើងឃើញសារអំពីម៉ូឌុលដែលមិនត្រូវបានសាងសង់៖

Modules not built (see ns-3 tutorial for explanation):
brite                     click

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

3.4.2 អាគារជាមួយដុតនំ

ប្រសិនបើអ្នកបានប្រើ bake ខាងលើដើម្បីទទួលបានកូដប្រភពពីឃ្លាំងគម្រោង អ្នកអាចបន្តប្រើវាដើម្បីបង្កើត ns-3 ។ ចុច៖

$ ./bake.py build

ហើយអ្នកគួរតែឃើញអ្វីមួយដូចជា៖

>> Building pybindgen-0.19.0.post4+ng823d8b2 - OK 
>> Building netanim-3.108 - OK 
>> Building ns-3.29 - OK

ព័ត៌មានជំនួយ៖ អ្នក​ក៏​អាច​ធ្វើ​ទាំង​ជំហាន​ទាញ​យក និង​បង្កើត​ក្នុង​ពេល​តែ​មួយ​ដោយ​ហៅ​ទៅ "bake.py deploy"។

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

>> Building castxml - Problem 
> Problem: Optional dependency, module "castxml" failed
This may reduce the functionality of the final build.
However, bake will continue since "castxml" is not an essential dependency.
For more information call bake with -v or -vvv, for full verbose mode.

ទោះជាយ៉ាងណា, castxml ត្រូវការតែប្រសិនបើអ្នកចង់បង្កើតការចង Python ដែលបានធ្វើបច្ចុប្បន្នភាព។ សម្រាប់អ្នកប្រើប្រាស់ភាគច្រើនមិនចាំបាច់ប្រើវាទេ (យ៉ាងហោចណាស់រហូតដល់ពួកគេផ្លាស់ប្តូរ ns-3) ដូច្នេះការព្រមានបែបនេះអាចត្រូវបានមិនអើពើដោយសុវត្ថិភាពសម្រាប់ពេលនេះ។

ប្រសិនបើវាបរាជ័យ ពាក្យបញ្ជាខាងក្រោមនឹងផ្តល់ឱ្យអ្នកនូវការណែនាំអំពីការបាត់ភាពអាស្រ័យ៖

$ ./bake.py show

ភាពអាស្រ័យផ្សេងៗនៃកញ្ចប់ដែលអ្នកកំពុងព្យាយាមបង្កើតនឹងត្រូវបានរាយបញ្ជី។

3.4.3 បង្កើតជាមួយ Waf

រហូតមកដល់ចំណុចនេះ ដើម្បីចាប់ផ្តើមបង្កើត ns-3 យើងបានប្រើស្គ្រីបទាំងពីរ build.pyឬឧបករណ៍ ដុត. ឧបករណ៍ទាំងនេះមានប្រយោជន៍សម្រាប់ការកសាង ns-3 និងរក្សាបណ្ណាល័យ។ តាមពិតដើម្បីសាងសង់ ពួកគេដំណើរការឧបករណ៍សាងសង់ វ៉ា ពីថត ns-3 ។ វ៉ា ដំឡើងជាមួយកូដប្រភព ns-3 ។ អ្នក​ប្រើ​ភាគ​ច្រើន​បន្ត​ប្រើ ns‑3 យ៉ាង​រហ័ស​ដើម្បី​កំណត់​រចនា​សម្ព័ន្ធ និង​ការ​ផ្គុំ​ វ៉ា. ដូច្នេះ ដើម្បីបន្ត សូមចូលទៅកាន់ថត ns-3 ដែលអ្នកបានបង្កើតដំបូង។

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

$ ./waf clean 
$ ./waf configure --build-profile=optimized --enable-examples --enable-tests

នេះនឹងចាប់ផ្តើម វ៉ា នៅខាងក្រៅថតក្នុងស្រុក (សម្រាប់ភាពងាយស្រួលរបស់អ្នក) ។ ពាក្យ​បញ្ជា​ដំបូង​សម្អាត​ពី​ការ​បង្កើត​មុន នេះ​ជា​ធម្មតា​មិន​ចាំបាច់​ខ្លាំង​នោះ​ទេ ប៉ុន្តែ​វា​ជា​ការ​អនុវត្ត​ដ៏​ល្អ (សូម​មើល​ទម្រង់ build ខាងក្រោម​ផង​ដែរ); វានឹងលុបបណ្ណាល័យដែលបានបង្កើតពីមុន និងឯកសារវត្ថុដែលមាននៅក្នុងថត បង្កើត /. នៅពេលដែលគម្រោងត្រូវបានកំណត់រចនាសម្ព័ន្ធឡើងវិញ ហើយប្រព័ន្ធសាងសង់ពិនិត្យមើលភាពអាស្រ័យផ្សេងៗ អ្នកគួរតែឃើញលទ្ធផលស្រដៀងគ្នានឹងដូចខាងក្រោម៖

Setting top to      : /home/ns3user/workspace/bake/source/ns-3-dev
Setting out to      : /home/ns3user/workspace/bake/source/ns-3-dev/build
Checking for 'gcc' (C compiler)        : /usr/bin/gcc 
Checking for cc version                : 7.3.0 
Checking for 'g++' (C++ compiler)      : /usr/bin/g++ 
Checking for compilation flag -march=native support : ok 
Checking for compilation flag -Wl,--soname=foo support : ok 
Checking for compilation flag -std=c++11 support       : ok 
Checking boost includes   : headers not found, please ,!provide a --boost-includes argument (see help) 
Checking boost includes   : headers not found, please ,!provide a --boost-includes argument (see help) 
Checking for program 'python'            : /usr/bin/python 
Checking for python version >= 2.3       : 2.7.15 python-config                                                                     : /usr/bin/python-config
Asking python-config for pyembed '--cflags --libs --ldflags' flags : yes
Testing pyembed configuration                                      : yes
Asking python-config for pyext '--cflags --libs --ldflags' flags   : yes
Testing pyext configuration                                        : yes

Checking for compilation flag -fvisibility=hidden support          : ok 
Checking for compilation flag -Wno-array-bounds support            : ok 
Checking for pybindgen location          : ../pybindgen ,!(guessed) 
Checking for python module 'pybindgen'   : 0.19.0. ,!post4+g823d8b2 
Checking for pybindgen version           : 0.19.0. ,!post4+g823d8b2 
Checking for code snippet                : yes 
Checking for types uint64_t and unsigned long equivalence : no 
Checking for code snippet                                 : no 
Checking for types uint64_t and unsigned long long equivalence     : yes 
Checking for the apidefs that can be used for Python bindings                       : gcc-LP64 
Checking for internal GCC cxxabi         : complete 
Checking for python module 'pygccxml'    : not found 
Checking for click location              : not found 
Checking for program 'pkg-config'        : /usr/bin/pkg- ,!config 
Checking for 'gtk+-3.0'                  : not found 
Checking for 'libxml-2.0'                : yes 
checking for uint128_t                   : not found 
checking for __uint128_t                 : yes 
Checking high precision implementation   : 128-bit integer ,!(default) 
Checking for header stdint.h             : yes 
Checking for header inttypes.h           : yes 
Checking for header sys/inttypes.h       : not found 
Checking for header sys/types.h          : yes 
Checking for header sys/stat.h           : yes 
Checking for header dirent.h             : yes 
Checking for header stdlib.h             : yes 
Checking for header signal.h             : yes 
Checking for header pthread.h            : yes 
Checking for header stdint.h             : yes 
Checking for header inttypes.h           : yes 
Checking for header sys/inttypes.h       : not found
Checking for library rt                  : yes 
Checking for header sys/ioctl.h          : yes 
Checking for header net/if.h             : yes 
Checking for header net/ethernet.h       : yes 
Checking for header linux/if_tun.h       : yes 
Checking for header netpacket/packet.h   : yes 
Checking for NSC location                : not found 
Checking for 'sqlite3'                   : not found 
Checking for header linux/if_tun.h       : yes 
Checking for python module 'gi'          : 3.26.1 
Checking for python module 'gi.repository.GObject'      : ok 
Checking for python module 'cairo'                      : ok 
Checking for python module 'pygraphviz'                 : 1.4rc1 
Checking for python module 'gi.repository.Gtk'          : ok 
Checking for python module 'gi.repository.Gdk'          : ok 
Checking for python module 'gi.repository.Pango'        : ok 
Checking for python module 'gi.repository.GooCanvas'    : ok 
Checking for program 'sudo'                             : /usr/bin/sudo 
Checking for program 'valgrind'                         : not found 
Checking for 'gsl' : not found python-config            : not found 
Checking for compilation flag -fstrict-aliasing support : ok 
Checking for compilation flag -fstrict-aliasing support : ok 
Checking for compilation flag -Wstrict-aliasing support : ok 
Checking for compilation flag -Wstrict-aliasing support : ok 
Checking for program 'doxygen'                          : /usr/bin/doxygen
---- Summary of optional ns-3 features:
Build profile : optimized
Build directory : 
BRITE Integration : not enabled (BRITE not enabled (see option --with- ,!brite)) 
DES Metrics event collection : not enabled (defaults to disabled) 
Emulation FdNetDevice        : enabled 
Examples                     : enabled 
File descriptor NetDevice    : enabled 
GNU Scientific Library (GSL) : not enabled (GSL not found) 
Gcrypt library               : not enabled
(libgcrypt not found: you can use ,!libgcrypt-config to find its location.) GtkConfigStore               : not enabled (library 'gtk+-3.0 >= 3.0' not fou   nd)
MPI Support                  : not enabled (option --enable-mpi not selected)
ns-3 Click Integration       : not enabled (nsclick not enabled (see option --with- ,!nsclick))
ns-3 OpenFlow Integration   : not enabled (Required boost libraries not found) 
Network Simulation Cradle    : not enabled (NSC not found (see option --with-nsc))
PlanetLab FdNetDevice         : not enabled (PlanetLab operating system not detected ,!(see option --force-planetlab)) PyViz visualizer : enabled 
Python API Scanning Support   : not enabled (Missing 'pygccxml' Python module)
Python Bindings : enabled 
Real Time Simulator           : enabled 
SQlite stats data output      : not enabled (library 'sqlite3' not found)
Tap Bridge                    : enabled 
Tap FdNetDevice               : enabled
Tests                         : enabled 
Threading Primitives          : enabled 
Use sudo to set suid bit   : not enabled (option --enable-sudo not selected)
XmlIo                         : enabled
'configure' finished successfully (6.387s)

សូមចំណាំផ្នែកចុងក្រោយនៃបញ្ជីខាងលើ។ ជម្រើស ns-3 មួយចំនួនមិនត្រូវបានបើកតាមលំនាំដើម ឬទាមទារការគាំទ្រប្រព័ន្ធដើម្បីដំណើរការបានត្រឹមត្រូវ។ ឧទាហរណ៍ ដើម្បីបើក XmlTo បណ្ណាល័យត្រូវតែមានវត្តមាននៅលើប្រព័ន្ធ libxml-2.0. ប្រសិនបើបណ្ណាល័យនេះមិនត្រូវបានរកឃើញ ហើយមុខងារ ns-3 ដែលត្រូវគ្នាមិនត្រូវបានបើកទេ សារនឹងត្រូវបានបង្ហាញ។ សូមចំណាំផងដែរថាវាអាចប្រើពាក្យបញ្ជា sudo ដើម្បីកំណត់ suid bit "កំណត់លេខសម្គាល់ក្រុមនៅពេលដំណើរការ" សម្រាប់កម្មវិធីជាក់លាក់។ វា​មិន​ត្រូវ​បាន​បើក​តាម​លំនាំដើម​ទេ ដូច្នេះ​ហើយ​មុខងារ​នេះ​លេច​ឡើង​ជា "មិន​បាន​បើក"។ ជាចុងក្រោយ ដើម្បីទទួលបានបញ្ជីជម្រើសដែលបានបើក សូមប្រើ វ៉ា ជាមួយប៉ារ៉ាម៉ែត្រ --check-config.

ឥឡូវ​យើង​ត្រឡប់​ទៅ​បង្កើត​បំបាត់​បញ្ហា​វិញ​ដែល​មាន​ឧទាហរណ៍ និង​ការ​សាកល្បង។

$ ./waf clean 
$ ./waf configure --build-profile=debug --enable-examples --enable-tests

ឥឡូវនេះប្រព័ន្ធសាងសង់ត្រូវបានតំឡើង ហើយអ្នកអាចបង្កើតកំណែបំបាត់កំហុសនៃកម្មវិធី ns-3 ដោយគ្រាន់តែវាយបញ្ចូល៖

$ ./waf

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

ដើម្បីពិនិត្យមើលទម្រង់ណាមួយដែលសកម្មសម្រាប់ការកំណត់រចនាសម្ព័ន្ធគម្រោងដែលបានផ្តល់ឱ្យ មានពាក្យបញ្ជាមួយ៖

$ ./waf --check-profile 
Waf: Entering directory `/path/to/ns-3-allinone/ns-3.29/build' 
Build profile: debug

សេណារីយ៉ូខាងលើ build.py ក៏គាំទ្រការជជែកវែកញែកផងដែរ។ --enable-examples и --enable-testsប៉ុន្តែជម្រើសផ្សេងទៀត។ វ៉ា វាមិនគាំទ្រដោយផ្ទាល់ទេ។ ឧទាហរណ៍ វានឹងមិនដំណើរការទេ៖

$ ./build.py --disable-python

ប្រតិកម្មនឹងមានដូចនេះ៖

build.py: error: no such option: --disable-python

ទោះយ៉ាងណាក៏ដោយ ប្រតិបត្តិករពិសេស - - អាចត្រូវបានប្រើដើម្បីឆ្លងកាត់ប៉ារ៉ាម៉ែត្របន្ថែមតាមរយៈ វ៉ាហ្វដូច្នេះជំនួសឱ្យពាក្យបញ្ជាខាងលើ ខាងក្រោមនឹងដំណើរការ៖

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

ព្រោះវាបង្កើតពាក្យបញ្ជាសំខាន់ ./waf កំណត់រចនាសម្ព័ន្ធ --disable-python. នេះគឺជាការណែនាំមួយចំនួនបន្ថែមទៀតអំពី វ៉ា.

ដោះស្រាយកំហុសក្នុងការសាងសង់

ការចេញផ្សាយ ns-3 ត្រូវបានសាកល្បងលើកម្មវិធីចងក្រង C ++ ចុងក្រោយបំផុតដែលមាននៅពេលចេញផ្សាយនៅលើការចែកចាយលីនុចទូទៅ និង MacOS ។ ទោះជាយ៉ាងណាក៏ដោយយូរ ៗ ទៅការចែកចាយថ្មីត្រូវបានចេញផ្សាយជាមួយនឹងអ្នកចងក្រងថ្មីហើយអ្នកចងក្រងថ្មីទាំងនេះមានទំនោរទៅរកការព្រមានកាន់តែច្រើន។ ns-3 កំណត់រចនាសម្ព័ន្ធការស្ថាបនារបស់វា ដើម្បីចាត់ទុកការព្រមានទាំងអស់ជាកំហុស ដូច្នេះជួនកាលប្រសិនបើអ្នកកំពុងដំណើរការកំណែចាស់នៅលើប្រព័ន្ធថ្មីជាង ការព្រមានអំពីអ្នកចងក្រងអាចបញ្ឈប់ការស្ថាបនា។

ឧទាហរណ៍ ពីមុនមានការចេញផ្សាយ ns‑3.28 សម្រាប់ Fedora 28 ដែលរួមបញ្ចូលកំណែធំថ្មី gcc (gcc-8) ការកសាងការចេញផ្សាយ ns-3.28 ឬកំណែមុនក្រោម Fedora 28 ជាមួយនឹងការដំឡើង Gtk2+ កំហុសខាងក្រោមនឹងកើតឡើង៖

/usr/include/gtk-2.0/gtk/gtkfilechooserbutton.h:59:8: error: unnecessary parentheses ,!in declaration of ‘__gtk_reserved1’ [-Werror=parentheses] void (*__gtk_reserved1);

នៅក្នុងការចេញផ្សាយដែលចាប់ផ្តើមពី ns-3.28.1, in វ៉ា ជម្រើសគឺអាចរកបានដើម្បីដោះស្រាយបញ្ហាទាំងនេះ។ វាបិទការកំណត់ទង់ "-Werror" នៅក្នុង g++ និង clang++ ។ នេះគឺជាជម្រើស "--disable-wrror" ហើយត្រូវតែអនុវត្តកំឡុងពេលកំណត់រចនាសម្ព័ន្ធ៖

$ ./waf configure --disable-werror --enable-examples --enable-tests

កំណត់រចនាសម្ព័ន្ធឬប្រមូលផ្តុំ

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

$ ./waf configure --enable-sudo --enable-examples --enable-tests

ប្រសិនបើអ្នកធ្វើបែបនេះ វ៉ា នឹងបើកដំណើរការ sudoដើម្បីផ្លាស់ប្តូរកម្មវិធីបង្កើតរន្ធកូដត្រាប់តាមដើម្បីដំណើរការដោយមានការអនុញ្ញាត ជា root។ នេះ វ៉ា មានជម្រើសជាច្រើនទៀតសម្រាប់ការកំណត់រចនាសម្ព័ន្ធ និងជំហានសាងសង់។ ដើម្បីរុករកជម្រើសរបស់អ្នក សូមបញ្ចូល៖

$ ./waf --help

នៅផ្នែកបន្ទាប់ យើងនឹងប្រើជម្រើសទាក់ទងនឹងការធ្វើតេស្តមួយចំនួន។

ទម្រង់ការជួបប្រជុំគ្នា។

យើងបានឃើញរួចហើយពីរបៀបដែលអ្នកអាចកំណត់រចនាសម្ព័ន្ធ វ៉ា សម្រាប់សន្និបាត បំបាត់កំហុស и ប្រសើរ:

$ ./waf --build-profile=debug

ក៏មានទម្រង់ការជួបប្រជុំគ្នាកម្រិតមធ្យមផងដែរ ចេញផ្សាយ. ជម្រើស -d គឺមានន័យដូចនឹង --build-profile. ទម្រង់ស្ថាបនាគ្រប់គ្រងការប្រើប្រាស់ការកត់ត្រា ការអះអាង និងកុងតាក់បង្កើនប្រសិទ្ធភាពកម្មវិធីចងក្រង៖

ដូចដែលអ្នកអាចឃើញ ការកត់ត្រា និងការអះអាងមាននៅក្នុងការបង្កើតបំបាត់កំហុសប៉ុណ្ណោះ។ ការអនុវត្តដែលបានណែនាំគឺដើម្បីបង្កើតស្គ្រីបរបស់អ្នកនៅក្នុងរបៀបបំបាត់កំហុស បន្ទាប់មកធ្វើការដំណើរការម្តងហើយម្តងទៀត (សម្រាប់ការផ្លាស់ប្តូរស្ថិតិ ឬប៉ារ៉ាម៉ែត្រ) នៅក្នុងទម្រង់ស្ថាបនាដែលបានកែលម្អ។

ប្រសិនបើអ្នកមានកូដដែលគួរដំណើរការតែក្នុងទម្រង់ស្ថាបនាជាក់លាក់ប៉ុណ្ណោះ សូមប្រើ Code Wrapper Macro៖

NS_BUILD_DEBUG (std::cout << "Part of an output line..." << std::flush; timer.Start ,!()); DoLongInvolvedComputation ();
NS_BUILD_DEBUG (timer.Stop (); std::cout << "Done: " << timer << std::endl;)

លំនាំដើម, វ៉ា កន្លែងបង្កើតវត្ថុបុរាណនៅក្នុងថតឯកសារសាងសង់។ អ្នកអាចបញ្ជាក់ថតលទ្ធផលផ្សេងដោយប្រើជម្រើស - -outឧទាហរណ៍:

$ ./waf configure --out=my-build-dir

ដោយការរួមបញ្ចូលវាជាមួយនឹងទម្រង់ស្ថាបនា អ្នកអាចប្តូរយ៉ាងងាយស្រួលរវាងជម្រើសចងក្រងផ្សេងៗគ្នា៖

$ ./waf configure --build-profile=debug --out=build/debug
$ ./waf build
... 
$ ./waf configure --build-profile=optimized --out=build/optimized 
$ ./waf build
...

ដែលអនុញ្ញាតឱ្យអ្នកធ្វើការជាមួយការជួបប្រជុំគ្នាជាច្រើនដោយមិនចាំបាច់សរសេរការជួបប្រជុំចុងក្រោយបង្អស់ឡើងវិញរាល់ពេល។ នៅពេលអ្នកប្តូរទៅទម្រង់ផ្សេងទៀត វ៉ា នឹងចងក្រងតែវា ដោយមិនចងក្រងឡើងវិញទាំងស្រុង។

នៅពេលអ្នកប្តូរទម្រង់សាងសង់តាមរបៀបនេះ អ្នកត្រូវប្រុងប្រយ័ត្នក្នុងការផ្តល់ជម្រើសនៃការកំណត់រចនាសម្ព័ន្ធដូចគ្នារាល់ពេល។ ការកំណត់អថេរបរិស្ថានជាច្រើននឹងជួយអ្នកជៀសវាងកំហុស៖

$ export NS3CONFIG="--enable-examples --enable-tests" 
$ export NS3DEBUG="--build-profile=debug --out=build/debug"
$ export NS3OPT=="--build-profile=optimized --out=build/optimized" 

$ ./waf configure $NS3CONFIG $NS3DEBUG
$ ./waf build 
... 
$ ./waf configure $NS3CONFIG $NS3OPT
$ ./waf build

អ្នកចងក្រង និងទង់

នៅក្នុងឧទាហរណ៍ខាងលើ វ៉ា ដើម្បីបង្កើត ns-3 ប្រើកម្មវិធីចងក្រង C ++ ពី GCC ( g ++) ទោះយ៉ាងណាក៏ដោយ អ្នកអាចផ្លាស់ប្តូរអ្វីដែលអ្នកប្រើ វ៉ា C++ compiler ដោយកំណត់អថេរបរិស្ថាន CXX ។ ឧទាហរណ៍ ដើម្បីប្រើកម្មវិធីចងក្រង C++ Clang, clang++,

$ CXX="clang++" ./waf configure 
$ ./waf build 

តាមរបៀបដូចគ្នាអ្នកអាចកំណត់រចនាសម្ព័ន្ធ វ៉ា ដើម្បីប្រើការចងក្រងចែកចាយដោយប្រើ distcc:

$ CXX="distcc g++" ./waf configure 
$ ./waf build

ព័ត៌មានបន្ថែមអំពី distcc និងការចងក្រងចែកចាយអាចរកបាននៅលើទំព័រគម្រោងក្នុងផ្នែកឯកសារ។ ដើម្បីបន្ថែមទង់អ្នកចងក្រងនៅពេលកំណត់រចនាសម្ព័ន្ធ ns-3 សូមប្រើអថេរបរិស្ថាន CXXFLAGS_EXTRA ។

ការកំណត់

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

ប្រសិនបើអ្នកប្រើប្រាស់ចូលចិត្តដំឡើងនៅខាងក្រៅថត build នោះពួកគេអាចដំណើរការពាក្យបញ្ជាបាន។ ./ វ៉ាហ្វាដំឡើង. បុព្វបទលំនាំដើមសម្រាប់ការដំឡើងគឺ / usr / ក្នុងស្រុកដូច្នេះ។ ./ វ៉ាហ្វាដំឡើង នឹងដំឡើងកម្មវិធីនៅក្នុង / usr / local / bin, បណ្ណាល័យនៅក្នុង / usr / local / lib និងឯកសារបឋមកថានៅក្នុង /usr/local/include. សិទ្ធិអ្នកប្រើប្រាស់ជាន់ខ្ពស់ជាធម្មតាត្រូវកំណត់ដោយបុព្វបទលំនាំដើម ដូច្នេះពាក្យបញ្ជាធម្មតានឹងមាន sudo ./waf ដំឡើង. នៅពេលបើកដំណើរការ Waf នឹងជ្រើសរើសដំបូងដើម្បីប្រើបណ្ណាល័យដែលបានចែករំលែកនៅក្នុងថតសាងសង់ បន្ទាប់មករកមើលបណ្ណាល័យតាមផ្លូវទៅកាន់បណ្ណាល័យដែលបានកំណត់រចនាសម្ព័ន្ធនៅក្នុងបរិស្ថានមូលដ្ឋាន។ ដូច្នេះនៅពេលដំឡើងបណ្ណាល័យនៅលើប្រព័ន្ធ វាគឺជាការអនុវត្តល្អដើម្បីពិនិត្យមើលថាបណ្ណាល័យត្រឹមត្រូវកំពុងត្រូវបានប្រើប្រាស់។ អ្នកប្រើប្រាស់អាចជ្រើសរើសដំឡើងជាមួយបុព្វបទផ្សេងដោយឆ្លងកាត់ជម្រើសកំឡុងពេលកំណត់រចនាសម្ព័ន្ធ --prefixឧទាហរណ៍:

./waf configure --prefix=/opt/local

ប្រសិនបើនៅពេលក្រោយបន្ទាប់ពីការស្ថាបនា អ្នកប្រើប្រាស់បញ្ចូលពាក្យបញ្ជាដំឡើង ./wafបុព្វបទនឹងត្រូវបានប្រើ /opt/local.

ក្រុមការងារ ./waf clean ត្រូវតែប្រើមុនពេលកំណត់រចនាសម្ព័ន្ធគម្រោងឡើងវិញ ប្រសិនបើការដំឡើងនឹងប្រើ វ៉ា នៅក្រោមបុព្វបទផ្សេង។

ដូច្នេះដើម្បីប្រើ ns-3 មិនចាំបាច់ហៅទេ។ ./waf install. អ្នកប្រើប្រាស់ភាគច្រើននឹងមិនត្រូវការពាក្យបញ្ជានេះទេ ដោយសារតែ វ៉ា នឹងយកបណ្ណាល័យបច្ចុប្បន្នចេញពីថតឯកសារ ប៉ុន្តែអ្នកប្រើប្រាស់មួយចំនួនអាចរកឃើញថាវាមានប្រយោជន៍ ប្រសិនបើសកម្មភាពរបស់ពួកគេពាក់ព័ន្ធនឹងការធ្វើការជាមួយកម្មវិធីនៅខាងក្រៅថត ns-3។

Waf នៅលីវ

នៅកម្រិតកំពូលនៃមែកធាងប្រភព ns-3 មានស្គ្រីប Waf តែមួយប៉ុណ្ណោះ។ នៅពេលអ្នកចាប់ផ្តើមធ្វើការ អ្នកនឹងចំណាយពេលច្រើនក្នុងថតឯកសារ scratch/ ឬកាន់តែជ្រៅទៅក្នុងsrc/... ហើយក្នុងពេលតែមួយត្រូវតែរត់ វ៉ា. អ្នកអាចចាំថាអ្នកនៅទីណា ហើយរត់ វ៉ា ដូចខងេ្រកម:

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

ប៉ុន្តែវានឹងជាការធុញទ្រាន់ និងងាយនឹងមានកំហុស ដូច្នេះមានដំណោះស្រាយប្រសើរជាងមុន។ វិធីសាមញ្ញមួយគឺត្រូវប្រើកម្មវិធីនិពន្ធអត្ថបទដូចជា emacs ឬ លំនាំដើមដែលក្នុងនោះវគ្គស្ថានីយពីរត្រូវបានបើក មួយត្រូវបានប្រើដើម្បីបង្កើត ns-3 ហើយទីពីរត្រូវបានប្រើដើម្បីកែសម្រួលកូដប្រភព។ ប្រសិនបើអ្នកមាន បាឡុងបន្ទាប់មក អថេរបរិស្ថានអាចជួយ៖

$ export NS3DIR="$PWD" 
$ function waff { cd $NS3DIR && ./waf $* ; } 

$ cd scratch 
$ waff build

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

3.5 ការធ្វើតេស្ត ns-3

អ្នកអាចដំណើរការការធ្វើតេស្តឯកតានៃការចែកចាយ ns-3 ដោយដំណើរការស្គ្រីប ./test.py:

$ ./test.py

ការធ្វើតេស្តទាំងនេះត្រូវបានដំណើរការស្របជាមួយ វ៉ា. នៅទីបំផុត អ្នកគួរតែឃើញសារមួយដែលនិយាយថា៖

92 of 92 tests passed (92 passed, 0 failed, 0 crashed, 0 valgrind errors)

នេះជាសារសំខាន់សម្រាប់កំណត់អត្តសញ្ញាណការគាំង valgrind គាំង ឬកំហុសដែលបង្ហាញពីបញ្ហាជាមួយកូដ ឬភាពមិនស៊ីគ្នារវាងឧបករណ៍ និងកូដ។

អ្នកក៏នឹងឃើញលទ្ធផលចុងក្រោយពី វ៉ា និងអ្នកសាកល្បងដែលកំពុងដំណើរការការធ្វើតេស្តនីមួយៗ ដែលនឹងមើលទៅដូចនេះ៖

Waf: Entering directory `/path/to/workspace/ns-3-allinone/ns-3-dev/build' 
Waf: Leaving directory `/path/to/workspace/ns-3-allinone/ns-3-dev/build' 
'build' finished successfully (1.799s) 

Modules built:
aodv           applications          bridge
click          config-store          core
csma           csma-layout           dsdv
emu            energy                flow-monitor
internet       lte                   mesh
mobility       mpi                   netanim
network        nix-vector-routing    ns3tcp
ns3wifi        olsr                  openflow
point-to-point point-to-point-layout propagation
spectrum       stats                 tap-bridge
template       test                  tools
topology-read  uan                   virtual-net-device
visualizer     wifi                  wimax

PASS: TestSuite ns3-wifi-interference
PASS: TestSuite histogram 

...

PASS: TestSuite object
PASS: TestSuite random-number-generators
92 of 92 tests passed (92 passed, 0 failed, 0 crashed, 0 valgrind errors)

ពាក្យបញ្ជានេះជាធម្មតាត្រូវបានដំណើរការដោយអ្នកប្រើប្រាស់ដើម្បីផ្ទៀងផ្ទាត់យ៉ាងឆាប់រហ័សថាការចែកចាយ ns-3 ត្រូវបានបង្កើតឡើងយ៉ាងត្រឹមត្រូវ។ (ចំណាំថាលំដាប់នៃបន្ទាត់ "PASS: ... " ប្រហែលជាខុសគ្នា នេះគឺជារឿងធម្មតា។ អ្វីដែលសំខាន់នោះគឺបន្ទាត់សង្ខេបនៅចុងបញ្ចប់នៃរបាយការណ៍បង្ហាញថាការធ្វើតេស្តទាំងអស់បានកន្លងផុតទៅ គ្មានការធ្វើតេស្តណាមួយបរាជ័យ ឬគាំងទេ។ ) និង វ៉ានិង test.py នឹងដំណើរការស្របគ្នានៅទូទាំងស្នូលដំណើរការដែលមានរបស់ម៉ាស៊ីន។

3.6 ដំណើរការស្គ្រីប

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

$ ./waf --run hello-simulator

Waf នឹងពិនិត្យជាដំបូងថាកម្មវិធីត្រូវបានសាងសង់ត្រឹមត្រូវ ហើយសាងសង់ប្រសិនបើចាំបាច់។ បន្ទាប់មក វ៉ា នឹងដំណើរការកម្មវិធីដែលបង្កើតលទ្ធផលដូចខាងក្រោម។

Hello Simulator

អបអរសាទរ! ឥឡូវនេះអ្នកគឺជាអ្នកប្រើប្រាស់ NS-3!

តើខ្ញុំគួរធ្វើដូចម្តេចប្រសិនបើខ្ញុំមិនឃើញលទ្ធផល?

ប្រសិនបើអ្នកឃើញសារ វ៉ាបង្ហាញថាការស្ថាបនាបានបញ្ចប់ដោយជោគជ័យ ប៉ុន្តែអ្នកមិនឃើញលទ្ធផលទេ។ "សួស្តី Simulator"បន្ទាប់មកមានលទ្ធភាពដែលនៅក្នុងផ្នែក [Build-with-Waf] អ្នកប្តូររបៀបសាងសង់របស់អ្នកទៅ ប្រសើរប៉ុន្តែខកខានប្តូរទៅរបៀបវិញ។ បំបាត់កំហុស. លទ្ធផលនៃកុងសូលទាំងអស់ដែលប្រើក្នុងមេរៀននេះប្រើសមាសធាតុ ns-3 ពិសេសដែលដំណើរការការកត់ត្រា និងត្រូវបានប្រើដើម្បីបោះពុម្ពសារផ្ទាល់ខ្លួនទៅកាន់កុងសូល។ លទ្ធផលពីសមាសភាគនេះត្រូវបានបិទដោយស្វ័យប្រវត្តិ នៅពេលដែលកូដដែលបានធ្វើឱ្យប្រសើរត្រូវបានចងក្រង - វាត្រូវបាន "ធ្វើឱ្យប្រសើរ" ។ ប្រសិនបើអ្នកមិនឃើញលទ្ធផល "Hello Simulator" សូមបញ្ចូលដូចខាងក្រោម៖

$ ./waf configure --build-profile=debug --enable-examples --enable-tests

ដើម្បីកំណត់រចនាសម្ព័ន្ធ វ៉ា ដើម្បីបង្កើតកំណែបំបាត់កំហុសនៃកម្មវិធី ns-3 ដែលរួមបញ្ចូលឧទាហរណ៍ និងការធ្វើតេស្ត។ បន្ទាប់មកអ្នកគួរតែបង្កើតកំណែបំបាត់កំហុសបច្ចុប្បន្ននៃកូដឡើងវិញដោយវាយបញ្ចូល

$ ./waf

ឥឡូវនេះប្រសិនបើអ្នកដំណើរការកម្មវិធី សួស្តី-ក្លែងធ្វើអ្នកគួរតែឃើញលទ្ធផលរំពឹងទុក។

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

ដើម្បីឆ្លងកាត់អាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជាទៅកម្មវិធី ns-3 សូមប្រើលំនាំខាងក្រោម៖

$ ./waf --run <ns3-program> --command-template="%s <args>"

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

$ ./waf --run '<ns3-program> --arg1=value1 --arg2=value2 ...'

ឧទាហរណ៍ដ៏មានសារៈប្រយោជន៍ពិសេសមួយទៀតគឺការដំណើរការឈុតសាកល្បងដោយជ្រើសរើស។ ចូរសន្មតថាមានឈុតសាកល្បងមួយហៅថា mytest (តាមពិតវាមិនមាន)។ ខាងលើយើងបានប្រើស្គ្រីប ./test.py ដើម្បីដំណើរការការធ្វើតេស្តមួយចំនួនស្របគ្នា ដែលហៅកម្មវិធីសាកល្បងម្តងហើយម្តងទៀត អ្នករត់ការសាកល្បង. ហៅ អ្នករត់ការសាកល្បង ដោយផ្ទាល់ដើម្បីដំណើរការការធ្វើតេស្តមួយ:

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

អាគុយម៉ង់នឹងត្រូវបានបញ្ជូនទៅកម្មវិធី អ្នករត់ការសាកល្បង. ដោយសារ mytest មិនមានទេ សារកំហុសនឹងត្រូវបានបង្កើត។ ដើម្បីបោះពុម្ពជម្រើសអ្នករត់ការសាកល្បងដែលមាន សូមបញ្ចូល៖

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

3.6.2 ការបំបាត់កំហុស

ដើម្បីដំណើរការកម្មវិធី ns-3 ក្រោមឧបករណ៍ប្រើប្រាស់ផ្សេងទៀត ដូចជាកម្មវិធីបំបាត់កំហុស (ឧទាហរណ៍ gdb) ឬឧបករណ៍សាកល្បងអង្គចងចាំ (ឧទាហរណ៍ វ៉ាល់ហ្គ្រីន) ប្រើទម្រង់ស្រដៀងគ្នា - -command-template = "…". ឧទាហរណ៍ ដើម្បីដំណើរការក្នុងកម្មវិធីបំបាត់កំហុស gdb កម្មវិធី hello-simulator ns-3 របស់អ្នកជាមួយនឹងអាគុយម៉ង់៖

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

ចំណាំថាឈ្មោះកម្មវិធី ns-3 ភ្ជាប់មកជាមួយអាគុយម៉ង់ - -runនិងឧបករណ៍ប្រើប្រាស់គ្រប់គ្រង (នៅទីនេះ gdb) គឺជានិមិត្តសញ្ញាទីមួយនៅក្នុងអាគុយម៉ង់ - -command-template. ជម្រើស - -args ជូនដំណឹង gdbថានៅសល់នៃបន្ទាត់ពាក្យបញ្ជាជាកម្មសិទ្ធិរបស់កម្មវិធី "ទាប" ។ (កំណែមួយចំនួន gdb មិនយល់ពីជម្រើស - -args. ក្នុងករណីនេះ យកអាគុយម៉ង់កម្មវិធីចេញពី - -command-template ហើយប្រើសំណុំពាក្យបញ្ជា gdb args.) យើងអាចផ្សំរូបមន្តនេះ និងរូបមន្តមុន ដើម្បីដំណើរការការសាកល្បងនៅក្រោមកម្មវិធីបំបាត់កំហុស៖

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

3.6.3 ថតការងារ

Waf គួរតែត្រូវបានដាក់ឱ្យដំណើរការពីទីតាំងរបស់វានៅផ្នែកខាងលើនៃដើមឈើ ns-3 ។ ថតឯកសារនេះក្លាយជាថតឯកសារដែលឯកសារលទ្ធផលនឹងត្រូវបានសរសេរ។ ប៉ុន្តែចុះយ៉ាងណាបើអ្នកចង់រក្សាទុកឯកសារទាំងនេះនៅខាងក្រៅមែកធាងប្រភព ns-3? ប្រើអាគុយម៉ង់ - -cwd:

$ ./waf --cwd=...

អ្នក​អាច​រក​ឃើញ​ថា​វា​កាន់​តែ​ងាយ​ស្រួល​ក្នុង​ការ​ទទួល​បាន​ឯកសារ​លទ្ធផល​នៅ​ក្នុង​ថត​ការ​ងារ​របស់​អ្នក​។ ក្នុងករណីនេះ សកម្មភាពប្រយោលខាងក្រោមអាចជួយបាន៖

$ function waff {
CWD="$PWD" 
cd $NS3DIR >/dev/null 
./waf --cwd="$CWD" $*
cd - >/dev/null 
}

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

បន្ត៖ ជំពូកទី ៤

ប្រភព: www.habr.com