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 ვაფთან ერთად აშენება
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 ინსტალაციის განვითარების ვერსიების ასლების შერჩევა და შეკრება. მესამე არის დამატებითი build ინსტრუმენტების გამოყენება ns-3-ისთვის მეტი გაფართოების ჩასატვირთად. ჩვენ განვიხილავთ თითოეულს, რადგან ინსტრუმენტები ოდნავ განსხვავებულია.

Linux-ის გამოცდილ მომხმარებლებს შეიძლება გაუკვირდეთ, რატომ არ არის მოწოდებული ns-3 პაკეტის სახით, როგორც სხვა ბიბლიოთეკების უმეტესობა, რომლებიც იყენებენ პაკეტის მენეჯერს? მიუხედავად იმისა, რომ არსებობს ორობითი პაკეტები Linux-ის სხვადასხვა დისტრიბუციისთვის (მაგ. Debian), მომხმარებელთა უმეტესობა მთავრდება ბიბლიოთეკების რედაქტირებით და თავად უწევთ ns-3-ის აღდგენას, ამიტომ წყაროს კოდი ხელმისაწვდომია. ამ მიზეზით, ჩვენ ყურადღებას გავამახვილებთ წყაროდან ინსტალაციაზე.

უმეტეს აპლიკაციებისთვის ns-3 უფლებები root არ არის საჭირო, რეკომენდებულია არაპრივილეგირებული მომხმარებლის ანგარიშის გამოყენება.

3.2 წინაპირობები

ხელმისაწვდომი ns-3 ბიბლიოთეკების მთელ კომპლექტს აქვს რიგი დამოკიდებულებები მესამე მხარის ბიბლიოთეკებზე, მაგრამ უმეტესწილად ns-3 შეიძლება აშენდეს და გამოიყენოს რამდენიმე ჩვეულებრივი (ხშირად ნაგულისხმევად დაინსტალირებული) კომპონენტის მხარდაჭერით: C++ შემდგენელი, პითონი, წყარო კოდის რედაქტორი (მაგალითად, vim, emacs ან Eclipse) და, თუ გამოიყენება განვითარების საცავი, Git ვერსიის კონტროლის სისტემები. პირველად მომხმარებელთა უმეტესობას არ დასჭირდება ფიქრი, თუ მათი კონფიგურაცია იტყობინება, რომ ზოგიერთი ns-3 მოწინავე ფუნქცია აკლია, მაგრამ მათთვის, ვისაც სურს სრული ინსტალაცია, პროექტი უზრუნველყოფს ვიკი, რომელიც მოიცავს გვერდებს უამრავი სასარგებლო რჩევითა და ხრიკით. ერთ-ერთი ასეთი გვერდია ინსტალაციის გვერდი, სხვადასხვა სისტემის ინსტალაციის ინსტრუქციებით, ხელმისაწვდომია: https://www.nsnam.org/wiki/Installation.

ამ ვიკის წინაპირობების განყოფილება განმარტავს, თუ რომელი პაკეტებია საჭირო საერთო ns-3 ვარიანტების მხარდასაჭერად და ასევე შეიცავს ბრძანებებს, რომლებიც გამოიყენება Linux-ის ან macOS-ის საერთო გემოვნებაზე მათი ინსტალაციისთვის.

შეგიძლიათ ისარგებლოთ ამ შესაძლებლობით და დაათვალიეროთ ns-3 ვიკი გვერდი ან მთავარი ვებგვერდი: https://www.nsnam.org, რადგან იქ ბევრი ინფორმაციაა. ns-3-ის უახლესი ვერსიით დაწყებული (ns-3.29), ns-3-ის გასაშვებად საჭიროა შემდეგი ინსტრუმენტები:

ხელსაწყოების პაკეტი/ვერსია

• C++ შემდგენელი
  clang++ ან g++ (g++ ვერსია 4.9 ან უფრო მაღალი)
• Python
  python2 ვერსია >= 2.7.10, ან python3 ვერსია >=3.4
• წასვლა
  ნებისმიერი უახლესი ვერსია (ns-3-ზე წვდომისთვის GitLab.com-ზე)
• tar
  ნებისმიერი უახლესი ვერსია (ns‑3 გამოშვების გასახსნელად)
• bunzip2
  ნებისმიერი უახლესი ვერსია (ns‑3 გამოშვების გასახსნელად)

პითონის ნაგულისხმევი ვერსიის შესამოწმებლად, აკრიფეთ python -V. g++ ვერსიის შესამოწმებლად, აკრიფეთ g++ -v. თუ რაიმე ხელსაწყო აკლია ან ძალიან ძველია, გთხოვთ, იხილეთ ინსტალაციის სახელმძღვანელო ns-3 ვიკი გვერდზე.

ამიერიდან, ჩვენ ვივარაუდებთ, რომ მკითხველი მუშაობს Linux, MacOS ან Linux ემულატორზე და აქვს მინიმუმ ზემოთ ჩამოთვლილი ხელსაწყოები.

3.2.1 ns-3 გამოშვების წყაროს არქივის სახით ჩამოტვირთვა

ეს არის მოქმედების კურსი ახალი მომხმარებლისთვის, რომელსაც სურს ჩამოტვირთოთ და ექსპერიმენტი გაუწიოს ns-3-ის უახლესი გამოშვებისა და პაკეტის ვერსიებს. ns-3 გამოშვებები ქვეყნდება როგორც შეკუმშული წყაროს არქივები, რომლებსაც ზოგჯერ უწოდებენ ტარბოლი. ტარბოლი არის სპეციალური პროგრამული არქივის ფორმატი, რომელშიც რამდენიმე ფაილი გაერთიანებულია ერთად. არქივი ჩვეულებრივ შეკუმშულია. ns-3 ჩატვირთვის პროცესის მეშვეობით ტარბოლი მარტივია, თქვენ უბრალოდ უნდა აირჩიოთ გამოშვება, გადმოწეროთ და ამოალაგოთ იგი.

დავუშვათ, რომ თქვენ, როგორც მომხმარებელს, გსურთ შექმნათ ns-3 ადგილობრივ დირექტორიაში, რომელსაც ე.წ სამუშაო სივრცე. თქვენ შეგიძლიათ მიიღოთ გამოშვების სამუშაო ასლი Linux-ის კონსოლში შემდეგი შეყვანით (რა თქმა უნდა, შესაბამისი ვერსიის ნომრების ჩანაცვლებით)

$ 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/. ჯგუფი ნსნამი აერთიანებს ღია კოდის პროექტის მიერ გამოყენებულ სხვადასხვა საცავებს.

Git საცავების გამოყენების დასაწყებად უმარტივესი გზაა გარემოს ჩანგალი ან კლონირება ns-3-ალინონი. ეს არის სკრიპტების ნაკრები, რომელიც მართავს ყველაზე ხშირად გამოყენებული ns-3 ქვესისტემების ჩატვირთვასა და აწყობას. თუ თქვენ ახალი ხართ Git-ში, ტერმინები „ჩანგალი“ და „კლონი“ შესაძლოა თქვენთვის უცნობი იყოს; თუ ასეა, ჩვენ გირჩევთ უბრალოდ კლონიროთ (გააკეთოთ საკუთარი ასლი) GitLab.com-ზე განთავსებული საცავი ასე:

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

ამ ეტაპზე, თქვენი დირექტორია ns-3-ალინონი ოდნავ განსხვავდება ზემოთ აღწერილი გამოშვების არქივის დირექტორია. ეს უნდა გამოიყურებოდეს დაახლოებით ასე:

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

გთხოვთ გაითვალისწინოთ, რომ არსებობს სკრიპტი download.py, რომელიც დამატებით ამოიღებს ns-3 და თანმხლებ კოდს. აქ თქვენ გაქვთ არჩევანი: ჩამოტვირთეთ ns-3 განვითარების უახლესი სურათი:

$ python download.py

ან ამჯობინეთ ns-3 გამოშვება დროშის გამოყენებით -n გამოშვების ნომრის მითითება:

$ python download.py -n ns-3.29

ამ ნაბიჯის შემდეგ დირექტორიაში ns-3-ალინონი ჩამოიტვირთება დამატებითი საცავი ns-3, bake, pybindgen и ნეტანიმი.

შენიშვნა
სუფთა Ubuntu16.04 მანქანაზე დამჭირდა ბრძანების შეცვლა შემდეგზე: $ sudo python3 download.py -n ns-3.29 (შემდგომში მთარგმნელის შენიშვნები).

3.3.1 ns-3 ჩატვირთვა Bake-ის გამოყენებით

ზემოაღნიშნული ორი მეთოდი (წყაროს არქივი ან საცავი ns-3-ალინონი Git-ის მეშვეობით) სასარგებლოა უმარტივესი ns-3 ინსტალაციის მისაღებად მრავალი დამატებით(pybindgen პითონის კავშირების გენერირება და ნეტანიმი ქსელის ანიმაციისთვის). ns-3-allinone-ში ნაგულისხმევად მოწოდებული მესამე საცავი ეწოდება bake.

Bake არის მრავალი საცავიდან პროგრამული უზრუნველყოფის კოორდინირებული აგების ინსტრუმენტი, შემუშავებული ns-3 პროექტისთვის. Bake შეიძლება გამოყენებულ იქნას ns-3-ის განვითარების ვერსიების მისაღებად, ასევე ns-3 დისტრიბუციის საბაზისო ვერსიის გაფართოებების ჩამოტვირთვისა და ასაგებად, როგორიცაა გარემო. კოდის პირდაპირი შესრულება, CradleNetwork Simulation Cradle, პითონის ახალი საკინძების და სხვადასხვა ns-3 „აპლიკაციების“ შექმნის შესაძლებლობა.

შენიშვნა
CradleNetwork Simulation Cradle არის ჩარჩო, რომელიც საშუალებას გაძლევთ გამოიყენოთ რეალური TCP/IP ქსელის სტეკები ქსელის სიმულატორის შიგნით.

თუ ფიქრობთ, რომ თქვენს ns-3 ინსტალაციას ექნება მოწინავე ან დამატებითი ფუნქციები, შეგიძლიათ მიჰყვეთ ინსტალაციის ამ გზას.

ns-3-ის უახლეს გამოშვებებში Bake ტარის გამოშვებას დაემატა. გამოცემა მოიცავს კონფიგურაციის ფაილს, რომელიც საშუალებას გაძლევთ ჩამოტვირთოთ მიმდინარე პროგრამული უზრუნველყოფის ვერსიები გამოშვების დროს. ეს არის, მაგალითად, ვერსია Bake, რომელიც განაწილებულია გამოშვებით ns-3.29, შეიძლება გამოყენებულ იქნას კომპონენტების მოსაძიებლად ns-3 ან უფრო ადრეული გამოშვებისთვის, მაგრამ არ შეიძლება გამოყენებულ იქნას კომპონენტების მოსაძიებლად მოგვიანებით გამოშვებისთვის (თუ პაკეტის აღწერილობის ფაილია bakeconf.xml არ არის განახლებული).

ასევე შეგიძლიათ მიიღოთ უახლესი ასლი bakeთქვენს Linux კონსოლში შემდეგი ბრძანების შეყვანით (თუ ვივარაუდებთ, რომ დაინსტალირებული გაქვთ 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.

ბრძანების დასრულების შემდეგ კლონი თქვენ უნდა გქონდეთ დირექტორია დასახელებული bake, რომლის შინაარსი დაახლოებით ასე უნდა გამოიყურებოდეს:

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

გაითვალისწინეთ, რომ თქვენ ჩატვირთეთ რამდენიმე პითონის სკრიპტი, სახელად პითონის მოდული bake და XML კონფიგურაციის ფაილი. შემდეგი ნაბიჯი არის ამ სკრიპტების გამოყენება თქვენი არჩევანის ns-3 დისტრიბუციის ჩამოსატვირთად და შესაქმნელად. პერსონალიზაციის რამდენიმე მიზანი ხელმისაწვდომია:

1. ns-3.29: გამოშვების შესაბამისი მოდული; ის ჩამოტვირთავს ტარბოლში გამოშვების მსგავს კომპონენტებს;

2. ns-3-dev: მსგავსი მოდული, მაგრამ კოდის გამოყენებით განვითარების ხედან;

3. ns-ალინონი-3.29: მოდული, რომელიც მოიცავს სხვა დამატებით ფუნქციებს, როგორიცაა Click routing და Network Simulation Cradle, Openflow for ns-3.

4. ns-3-ალინონი: მოდულის გამოშვების ვერსიის მსგავსი ყველა ერთში, მაგრამ განვითარების კოდისთვის.

შენიშვნა
დაწკაპეთ — მოდულური პროგრამული არქიტექტურა მარშრუტიზატორების შესაქმნელად.

Openflow არის პროტოკოლი მარშრუტიზატორებისა და გადამრთველების მიერ მონაცემთა ქსელში გადაცემული მონაცემების დამუშავების პროცესის მართვისთვის, პროგრამული უზრუნველყოფით განსაზღვრული ქსელური ტექნოლოგიის დანერგვით.

მიმდინარე განვითარების სნეპშოტი (არაგამოშვებული) ns-3 შეგიძლიათ იხილოთ აქ:https://gitlab.com/nsnam/ns-3-dev.git.

დეველოპერები ცდილობენ შეინარჩუნონ ეს საცავი თანმიმდევრულ სამუშაო რეჟიმში, მაგრამ ისინი განვითარების ზონაშია და შეიცავს გამოუქვეყნებელ კოდს, ასე რომ, თუ არ აპირებთ ახალი ფუნქციების გამოყენებას, აირჩიეთ ოფიციალური გამოშვება.

თქვენ შეგიძლიათ იპოვოთ კოდის უახლესი ვერსია საცავების სიის დათვალიერებით, ან ns-3 Releases ვებ-გვერდზე გადასვლით:https://www.nsnam.org/releases/ და დააჭირეთ უახლესი ვერსიის ბმულს. ამ მაგალითში ჩვენ გავაგრძელებთ ns-3.29.

ახლა, ჩვენთვის საჭირო ns-3 კომპონენტების მისაღებად, ჩვენ გამოვიყენებთ ხელსაწყოს Bake. მოდით ვთქვათ რამდენიმე შესავალი სიტყვა ნაწარმოების შესახებ Bake.

Bake მუშაობს პაკეტის წყაროების დირექტორიაში ჩატვირთვით წყარო და ბიბლიოთეკების დაყენება build დირექტორიაში. Bake შეიძლება გაშვებული იყოს ორობითი მითითებით, მაგრამ თუ გსურთ გაშვება Bake არა იმ დირექტორიადან, რომელშიც ის გადმოწერილი იყო, მიზანშეწონილია დაამატოთ ბილიკი bake თქვენს გზაზე (PATH გარემოს ცვლადი), მაგალითად, შემდეგნაირად (მაგალითი Linux bash shell-ისთვის). გადადით "bake" დირექტორიაში და შემდეგ დააყენეთ შემდეგი გარემოს ცვლადები:

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

ეს განათავსებს პროგრამას bake.py shell გზაზე და საშუალებას მისცემს სხვა პროგრამებს იპოვონ შესრულებადი ფაილები და ბიბლიოთეკები, რომლებიც მან შექმნა bake. გამოყენების ზოგიერთ შემთხვევაში bake, ზემოთ აღწერილი PATH და PYTHONPATH პარამეტრი არ არის საჭირო, მაგრამ ns-3-allinone-ის სრული კონსტრუქცია (დამატებითი პაკეტებით) ჩვეულებრივ მოითხოვს ამას.

გადადით თქვენს სამუშაო დირექტორიაში და შეიყვანეთ შემდეგი კონსოლში:

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

შემდეგ ჩვენ ვიკითხავთ Bake შეამოწმეთ გვაქვს თუ არა საკმარისი ხელსაწყოები სხვადასხვა კომპონენტების ჩასატვირთად. აკრიფეთ:

$ ./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 ინსტრუმენტის გამოყენებით, რომელსაც ე.წ ვაფქვემოთ აღწერილი. მომხმარებლების უმეტესობა იმუშავებს ვაფ, მაგრამ არსებობს რამდენიმე მოსახერხებელი სკრიპტი, რომელიც დაგეხმარებათ დაიწყოთ ან მოაწყოთ უფრო რთული კონსტრუქციები. ასე რომ, გთხოვთ, სანამ წაიკითხავთ შესახებ ვაფ, შეხედეთ build.py და შეკრება bake.

3.4.1 შენობა build.py-ით

ყურადღება მშენებლობის ეს ეტაპი ხელმისაწვდომია მხოლოდ წყაროს არქივის ვერსიიდან, რომელიც მიღებულია ზემოთ აღწერილი; და არ არის გადმოწერილი git-ით ან bake-ით.

გამოშვების არქივთან მუშაობისას ტარბოლიIn ns-3-ალინონი არსებობს მოსახერხებელი სკრიპტი, რომელსაც შეუძლია გაადვილოს კომპონენტების აწყობა. მას build.py ჰქვია. ეს პროგრამა დააყენებს პროექტს თქვენთვის ყველაზე სასარგებლო გზით. თუმცა, გაითვალისწინეთ, რომ უფრო გაფართოებული დაყენება და მუშაობა ns-3-თან ჩვეულებრივ მოიცავს ns-3-ის საკუთარი build სისტემის, Waf-ის გამოყენებას, რომელიც მოგვიანებით იქნება წარმოდგენილი ამ სახელმძღვანელოში.

თუ გადმოწერე გამოყენებით ტარბოლი, შემდეგ თქვენს დირექტორიაში ~/სამუშაო სივრცე დირექტორია მსგავსი სახელით ns-ალინონი-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

Tooltip: ასევე შეგიძლიათ ერთდროულად შეასრულოთ როგორც ჩამოტვირთვის, ასევე აშენების ნაბიჯები "bake.py deploy" დარეკვით.

ყველა კომპონენტის აწყობა შეიძლება ვერ მოხერხდეს, მაგრამ შეკრება გაგრძელდება, თუ კომპონენტი არ არის საჭირო. მაგალითად, ბოლოდროინდელი პორტაბელურობის პრობლემა იყო ეს castxml შეიძლება აწყობილი იყოს ხელსაწყოთი bake არა ყველა პლატფორმაზე. ამ შემთხვევაში გამოჩნდება ასეთი შეტყობინება:

>> 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 საჭიროა მხოლოდ იმ შემთხვევაში, თუ გსურთ შექმნათ განახლებული პითონის ბმულები. მომხმარებლების უმეტესობისთვის ამის საჭიროება არ არის (ყოველ შემთხვევაში, სანამ არ შეცვლიან ns-3), ასე რომ, ასეთი გაფრთხილებების უგულებელყოფა შესაძლებელია.

თუ ის ვერ მოხერხდა, შემდეგი ბრძანება მოგცემთ მინიშნებას დაკარგული დამოკიდებულებების შესახებ:

$ ./bake.py show

ჩამოთვლილი იქნება პაკეტების სხვადასხვა დამოკიდებულებები, რომელთა აშენებას ცდილობთ.

3.4.3 ვაფთან ერთად აშენება

ამ მომენტამდე, ns-3-ის აგების დასაწყებად, ჩვენ ვიყენებდით რომელიმე სკრიპტს build.py, ან ინსტრუმენტი bake. ეს ინსტრუმენტები სასარგებლოა ns-3-ის შესაქმნელად და ბიბლიოთეკების შესანარჩუნებლად. სინამდვილეში, ასაშენებლად ისინი აწარმოებენ build-ის ხელსაწყოს ვაფ ns-3 დირექტორიადან. ვაფ დაინსტალირებულია ns-3 წყაროს კოდით. მომხმარებლების უმეტესობა სწრაფად გადადის პირდაპირ გამოყენებაზე ns‑3-ის კონფიგურაციისა და აწყობისთვის ვაფ. ასე რომ, გასაგრძელებლად გთხოვთ გადადით ns-3 დირექტორიაში, რომელიც თავდაპირველად შექმენით.

ეს არ არის მკაცრად საჭირო ამ დროს, მაგრამ სასარგებლო იქნება ცოტათი უკან დახევა და იმის ნახვა, თუ როგორ უნდა შეიტანოთ ცვლილებები პროექტის კონფიგურაციაში. ალბათ ყველაზე სასარგებლო კონფიგურაციის ცვლილება, რომელიც შეგიძლიათ გააკეთოთ, არის კოდის ოპტიმიზებული ვერსიის შექმნა. ნაგულისხმევად, თქვენ დააკონფიგურირეთ თქვენი პროექტი გამართვის ვერსიის შესაქმნელად. მოდით შევხედოთ პროექტს ოპტიმიზებული კონსტრუქციის შესაქმნელად. Waf-ს რომ ავუხსნათ, რომ მან უნდა გააკეთოს ოპტიმიზირებული ნაგებობები, რომლებიც მოიცავს მაგალითებსა და ტესტებს, თქვენ უნდა შეასრულოთ შემდეგი ბრძანებები:

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

ეს დაიწყება ვაფ ადგილობრივი დირექტორიას გარეთ (თქვენი მოხერხებულობისთვის). პირველი ბრძანება ასუფთავებს წინა აწყობას, ეს ჩვეულებრივ არ არის მკაცრად საჭირო, მაგრამ კარგი პრაქტიკაა (ასევე იხილეთ ქვემოთ build პროფილები); ეს წაშლის ადრე შექმნილ ბიბლიოთეკებს და დირექტორიაში მდებარე ობიექტების ფაილებს აშენება/. როდესაც პროექტი ხელახლა კონფიგურირებულია და 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-ის "ჯგუფის ID-ის დაყენება გაშვების დროს" დასაყენებლად. ის არ არის ჩართული ნაგულისხმევად და, შესაბამისად, ეს ფუნქცია გამოჩნდება როგორც "არ ჩართულია". დაბოლოს, ჩართული ვარიანტების სიის მისაღებად გამოიყენეთ ვაფ პარამეტრით --check-config.

ახლა მოდით დავბრუნდეთ და გადავიდეთ გამართვის კონსტრუქციაზე, რომელიც შეიცავს მაგალითებს და ტესტებს.

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

build სისტემა ახლა დაყენებულია და თქვენ შეგიძლიათ შექმნათ 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 configure --disable-python. აქ არის კიდევ რამდენიმე შესავალი რჩევა ვაფ.

აგების შეცდომების დამუშავება

ns-3 გამოშვებები ტესტირება ხდება C++-ის უახლეს შემდგენლებზე, რომლებიც ხელმისაწვდომია გამოშვების დროს საერთო Linux და MacOS დისტრიბუციებზე. თუმცა, დროთა განმავლობაში, ახალი დისტრიბუციები გამოდის ახალი შემდგენლებით და ეს ახალი შემდგენლები უფრო პედანტურია გაფრთხილებების მიმართ. ns-3 აკონფიგურირებს მის build-ს ისე, რომ ყველა გაფრთხილება შეცდომის სახით განიხილოს, ასე რომ, ხანდახან, თუ უახლეს სისტემაზე ძველ ვერსიას ატარებთ, შემდგენლის გაფრთხილებამ შეიძლება შეაჩეროს მშენებლობა.

მაგალითად, ადრე იყო გამოშვებული 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-error" ვარიანტი და უნდა იქნას გამოყენებული კონფიგურაციის დროს:

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

კონფიგურაცია ან შეკრება

ზოგიერთი ბრძანება ვაფ აქვს მნიშვნელობა მხოლოდ კონფიგურაციის ფაზაში და ზოგიერთი მოქმედებს მხოლოდ build ფაზაში. მაგალითად, თუ გსურთ გამოიყენოთ ns-3 ემულაციის ფუნქციები, შეგიძლიათ ჩართოთ ბიტის პარამეტრი სუიდი გამოყენებით sudo, როგორც ზემოთ იყო აღწერილი. ეს გადალახავს კონფიგურაციის საფეხურის ბრძანებებს და, ამრიგად, შეგიძლიათ შეცვალოთ კონფიგურაცია შემდეგი ბრძანების გამოყენებით, რომელიც ასევე შეიცავს მაგალითებს და ტესტებს.

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

თუ ამას აკეთებ ვაფ დაიწყება sudoემულაციის კოდის სოკეტის შექმნის პროგრამების შეცვლა ნებართვებით გასაშვებად root. In ვაფ არსებობს მრავალი სხვა ვარიანტი კონფიგურაციისა და მშენებლობის საფეხურებისთვის. თქვენი ვარიანტების შესასწავლად შეიყვანეთ:

$ ./waf --help

შემდეგ განყოფილებაში ჩვენ გამოვიყენებთ ტესტირებასთან დაკავშირებულ რამდენიმე ვარიანტს.

ასამბლეის პროფილები

ჩვენ უკვე ვნახეთ, თუ როგორ შეგიძლიათ კონფიგურაცია ვაფ შეკრებებისთვის გამართვის и ოპტიმიზირებულია:

$ ./waf --build-profile=debug

ასევე არის შუალედური შეკრების პროფილი, გაათავისუფლონ. ვარიანტი -d არის სინონიმი --build-profile. build პროფილი აკონტროლებს ლოგინგის, მტკიცების და შემდგენელის ოპტიმიზაციის გადამრთველების გამოყენებას:

როგორც ხედავთ, შესვლა და მტკიცება ხელმისაწვდომია მხოლოდ გამართვის ბილდებში. რეკომენდირებული პრაქტიკაა თქვენი სკრიპტის შემუშავება გამართვის რეჟიმში, შემდეგ განმეორებითი გაშვებების შესრულება (სტატისტიკის ან პარამეტრის ცვლილებებისთვის) ოპტიმიზირებული build-ის პროფილში.

თუ თქვენ გაქვთ კოდი, რომელიც უნდა გაშვებული იყოს მხოლოდ გარკვეულ პროფილებში, გამოიყენეთ Code Wrapper მაკრო:

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;)

ნაგულისხმევი, ვაფ ათავსებს build არტეფაქტებს build დირექტორიაში. თქვენ შეგიძლიათ მიუთითოთ სხვა გამომავალი დირექტორია ოფციის გამოყენებით - -out, მაგალითად:

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

ამის build პროფილებთან კომბინაციით, შეგიძლიათ მარტივად გადახვიდეთ კომპილაციის სხვადასხვა ვარიანტს შორის:

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

რაც საშუალებას გაძლევთ იმუშაოთ მრავალ ასამბლეასთან ყოველ ჯერზე უახლესი ასამბლეის გადაწერის გარეშე. სხვა პროფილზე გადართვისას, ვაფ შეადგენს მხოლოდ მას, ყველაფრის სრულად გადაკეთების გარეშე.

როდესაც თქვენ გადართავთ 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-დან ( გ ++). თუმცა, თქვენ შეგიძლიათ შეცვალოთ ის, რომელსაც იყენებთ ვაფ C++ შემდგენელი, 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 ჯერ აირჩევს საერთო ბიბლიოთეკების გამოყენებას build დირექტორიაში, შემდეგ მოძებნის ბიბლიოთეკებს ადგილობრივ გარემოში კონფიგურირებული ბიბლიოთეკების გზაზე. ასე რომ, სისტემაზე ბიბლიოთეკების დაყენებისას, კარგი პრაქტიკაა იმის შემოწმება, რომ გამოიყენება თუ არა სწორი ბიბლიოთეკები. მომხმარებლებს შეუძლიათ აირჩიონ ინსტალაცია სხვა პრეფიქსით, კონფიგურაციის დროს ოფციის გადაცემით --prefix, მაგალითად:

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

თუ მოგვიანებით, აშენების შემდეგ, მომხმარებელი შეიყვანს ინსტალაციის ბრძანებას ./waf, გამოყენებული იქნება პრეფიქსი /opt/local.

გუნდი ./waf clean უნდა იქნას გამოყენებული პროექტის ხელახლა კონფიგურაციამდე, თუ ინსტალაცია გამოიყენებს ვაფ სხვა პრეფიქსის ქვეშ.

ამრიგად, ns-3-ის გამოსაყენებლად დარეკვა არ არის საჭირო ./waf install. მომხმარებელთა უმეტესობას არ დასჭირდება ეს ბრძანება, რადგან ვაფ აიღებს მიმდინარე ბიბლიოთეკებს build დირექტორიადან, მაგრამ ზოგიერთ მომხმარებელს ეს შეიძლება გამოადგეს, თუ მათი საქმიანობა მოიცავს ns-3 დირექტორიას გარეთ პროგრამებთან მუშაობას.

ვაფ სინგლი

ns-3 წყაროს ხის ზედა დონეზე არის მხოლოდ ერთი Waf სკრიპტი. როგორც კი დაიწყებთ მუშაობას, დიდ დროს გაატარებთ დირექტორიაში scratch/ ან უფრო ღრმადsrc/... და ამავე დროს უნდა გაიქცე ვაფ. შეგიძლიათ უბრალოდ გახსოვდეთ სად ხართ და გაიქცეთ ვაფ შემდეგნაირად:

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

მაგრამ ეს იქნება დამღლელი და შეცდომებისადმი მიდრეკილი, ამიტომ უკეთესი გადაწყვეტილებები არსებობს. ერთი გავრცელებული გზაა ტექსტური რედაქტორის გამოყენება, როგორიცაა emacs ან vim, რომელშიც იხსნება ორი ტერმინალის სესია, ერთი გამოიყენება 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 სკრიპტის გაშვება

ჩვენ ჩვეულებრივ ვმართავთ სკრიპტებს კონტროლის ქვეშ ვაფ. ეს საშუალებას აძლევს build სისტემას უზრუნველყოს ბიბლიოთეკის საერთო გზების სწორად დაყენება და ბიბლიოთეკების ხელმისაწვდომობა გაშვების დროს. პროგრამის გასაშვებად, უბრალოდ გამოიყენეთ ვაფ პარამეტრით - -run. მოდით გავუშვათ ყველგან არსებული პროგრამის ns-3 ეკვივალენტი Hello worldშემდეგი აკრეფით:

$ ./waf --run hello-simulator

Waf ჯერ შეამოწმებს, რომ პროგრამა სწორად არის აგებული და საჭიროების შემთხვევაში ააშენებს. მერე ვაფ შეასრულებს პროგრამას, რომელიც გამოიმუშავებს შემდეგ გამომავალს.

Hello Simulator

გილოცავ! ახლა თქვენ ხართ ns-3 მომხმარებელი!

რა უნდა გავაკეთო, თუ შედეგებს ვერ ვხედავ?

თუ ხედავთ შეტყობინებებს ვაფრაც მიუთითებს, რომ მშენებლობა წარმატებით დასრულდა, მაგრამ თქვენ ვერ ხედავთ გამომავალს "გამარჯობა სიმულატორი", მაშინ არის შესაძლებლობა, რომ [Build-with-Waf] განყოფილებაში გადაერთოთ თქვენი build-ის რეჟიმი ოპტიმიზირებულია, მაგრამ გამოტოვა რეჟიმზე დაბრუნება გამართვის. ამ სახელმძღვანელოში გამოყენებული კონსოლის ყველა გამომავალი იყენებს სპეციალურ 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 ამოწმებს, რომ build დასრულებულია, ადგენს ბიბლიოთეკის გაზიარებულ ბილიკებს, შემდეგ იყენებს მოწოდებულ ბრძანების სტრიქონის შაბლონს და ჩაანაცვლებს პროგრამის სახელს %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 პროგრამების გასაშვებად სხვა უტილიტაში, როგორიცაა debugger (მაგალითად, გდბ) ან მეხსიერების ტესტირების ხელსაწყო (მაგალითად, ვალგრინდი), გამოიყენეთ მსგავსი ფორმა - -command-template = "…". მაგალითად, გაშვება debugger-ში გდბ თქვენი hello-simulator ns-3 პროგრამა არგუმენტებით:

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

გაითვალისწინეთ, რომ ns-3 პროგრამის სახელი მოყვება არგუმენტს - -runდა მართვის პროგრამა (აქ გდბ) არის პირველი ნიშანი არგუმენტში - -command-template. ვარიანტი - -args იუწყება გდბრომ ბრძანების ხაზის დანარჩენი ნაწილი ეკუთვნის „ქვედა“ პროგრამას. (ზოგიერთი ვერსია გდბ არ მესმის ვარიანტი - -args. ამ შემთხვევაში, ამოიღეთ პროგრამის არგუმენტები - -command-template და გამოიყენეთ ბრძანებების ნაკრები გდბ 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-ს ზედა დონის დირექტორიადან და იქ ქმნის გამომავალ ფაილებს.

გაგრძელება: თავი 4

წყარო: www.habr.com