ns-3 નેટવર્ક સિમ્યુલેટર ટ્યુટોરીયલ. પ્રકરણ 3

પ્રકરણ 1,2

3 શરૂ કરી રહ્યા છીએ
3.1 વિહંગાવલોકન
3.2 પૂર્વજરૂરીયાતો
3.2.1 સ્ત્રોત આર્કાઇવ તરીકે ns-3 રીલીઝ ડાઉનલોડ કરી રહ્યા છીએ
3.3 Git નો ઉપયોગ કરીને ns-3 ડાઉનલોડ કરી રહ્યું છે
3.3.1 બેકનો ઉપયોગ કરીને ns-3 લોડ કરી રહ્યું છે
3.4 એસેમ્બલી એનએસ-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 ઇન્સ્ટોલ કર્યું ન હોય. તે સપોર્ટેડ પ્લેટફોર્મ, પૂર્વજરૂરીયાતો, એનએસ-3 કેવી રીતે મેળવવું, એનએસ-3 કેવી રીતે બનાવવું અને તમારા બિલ્ડ અને સરળ પ્રોગ્રામ્સને કેવી રીતે ચકાસવું તે આવરી લે છે.

3.1 વિહંગાવલોકન

ns-3 સિમ્યુલેટર સહયોગી સોફ્ટવેર લાઇબ્રેરીઓની સિસ્ટમ તરીકે બનાવવામાં આવ્યું છે. એસેમ્બલી દરમિયાન, વપરાશકર્તા પ્રોગ્રામ્સનો કોડ આ પુસ્તકાલયો સાથે જોડાયેલ છે. C++ અથવા Python પ્રોગ્રામિંગ ભાષાઓનો ઉપયોગ કસ્ટમ પ્રોગ્રામ્સ લખવા માટે થાય છે.

Ns-3 એ સોર્સ કોડ તરીકે વિતરિત કરવામાં આવે છે, જેનો અર્થ છે કે લક્ષ્ય સિસ્ટમમાં સૌપ્રથમ પુસ્તકાલયો બનાવવા અને પછી વપરાશકર્તા પ્રોગ્રામ બનાવવા માટે સોફ્ટવેર ડેવલપમેન્ટ વાતાવરણ હોવું આવશ્યક છે. સૈદ્ધાંતિક રીતે, ns-3 ચોક્કસ સિસ્ટમ માટે તૈયાર પુસ્તકાલયો તરીકે વિતરિત કરી શકાય છે, અને ભવિષ્યમાં તેઓ આ રીતે વિતરિત થઈ શકે છે. પરંતુ આજકાલ ઘણા વપરાશકર્તાઓ ખરેખર ns-3 ને સંપાદિત કરીને તેમનું કાર્ય કરે છે, તેથી પુસ્તકાલયો બનાવવા માટે સ્રોત કોડ હોવો ઉપયોગી છે. જો કોઈ ઓપરેટિંગ સિસ્ટમ્સ માટે તૈયાર પુસ્તકાલયો અને પેકેજો બનાવવાનું કામ કરવા માંગે છે, તો કૃપા કરીને મેઇલિંગ લિસ્ટનો સંપર્ક કરો. એનએસ-ડેવલપર્સ.

આગળ, અમે ns-3 ડાઉનલોડ અને બિલ્ડ કરવાની ત્રણ રીતો જોઈશું. પ્રથમ મુખ્ય સાઇટ પરથી સત્તાવાર પ્રકાશન ડાઉનલોડ અને બિલ્ડ કરવાનું છે. બીજું મૂળભૂત ns-3 ઇન્સ્ટોલેશનના વિકાસ સંસ્કરણોની નકલોની પસંદગી અને એસેમ્બલી છે. ત્રીજું ns-3 માટે વધુ એક્સ્ટેન્શન લોડ કરવા માટે વધારાના બિલ્ડ ટૂલ્સનો ઉપયોગ કરવાનો છે. અમે દરેકમાંથી પસાર થઈશું કારણ કે સાધનો થોડા અલગ છે.

અનુભવી Linux વપરાશકર્તાઓ આશ્ચર્ય પામશે કે શા માટે ns-3 પેકેજ મેનેજરનો ઉપયોગ કરતી મોટાભાગની અન્ય પુસ્તકાલયોની જેમ પેકેજ તરીકે પ્રદાન કરવામાં આવતું નથી? વિવિધ લિનક્સ વિતરણો (દા.ત. ડેબિયન) માટે દ્વિસંગી પેકેજો હોવા છતાં, મોટાભાગના વપરાશકર્તાઓ પુસ્તકાલયોને સંપાદિત કરે છે અને પોતાને ns-3 પુનઃબીલ્ડ કરે છે, તેથી સ્રોત કોડ ઉપલબ્ધ કરાવવો સરળ છે. આ કારણોસર, અમે સ્ત્રોતમાંથી ઇન્સ્ટોલ કરવા પર ધ્યાન કેન્દ્રિત કરીશું.

મોટાભાગની અરજીઓ માટે ns-3 અધિકારો રુટ ની જરૂર નથી, અનપ્રીવલેજ્ડ યુઝર એકાઉન્ટનો ઉપયોગ કરવાની ભલામણ કરવામાં આવે છે.

3.2 પૂર્વજરૂરીયાતો

ઉપલબ્ધ ns-3 લાઈબ્રેરીઓના સમગ્ર સેટમાં તૃતીય-પક્ષ લાઈબ્રેરીઓ પર સંખ્યાબંધ અવલંબન છે, પરંતુ મોટાભાગના ભાગ માટે ns-3 કેટલાક સામાન્ય (ઘણી વખત ડિફૉલ્ટ રૂપે ઇન્સ્ટોલ કરેલા) ઘટકોના સમર્થન સાથે બનાવી શકાય છે અને ઉપયોગમાં લઈ શકાય છે: એક C++ કમ્પાઈલર, પાયથોન, સ્ત્રોત કોડ સંપાદક (ઉદાહરણ તરીકે, વિમ, emacs અથવા ગ્રહણ) અને, જો ડેવલપમેન્ટ રીપોઝીટરીઝનો ઉપયોગ કરવામાં આવે છે, તો 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 અથવા ઉચ્ચ)
• પાયથોન
  python2 વર્ઝન >= 2.7.10, અથવા python3 વર્ઝન >=3.4
• ગિટ
  કોઈપણ નવીનતમ સંસ્કરણ (GitLab.com પર ns-3 ઍક્સેસ કરવા માટે)
• ટાર
  કોઈપણ નવીનતમ સંસ્કરણ (NS-3 રીલીઝને અનપેક કરવા માટે)
• બનઝિપ2
  કોઈપણ નવીનતમ સંસ્કરણ (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 

ઉપરોક્ત ઉપયોગિતા પર ધ્યાન આપો વેગ, જે ઇન્ટરનેટ પરથી ઑબ્જેક્ટ્સ ડાઉનલોડ કરવા માટેનું કમાન્ડ લાઇન ટૂલ છે. જો તમે તેને ઇન્સ્ટોલ કર્યું નથી, તો તમે આ માટે તમારા બ્રાઉઝરનો ઉપયોગ કરી શકો છો.

આ પગલાંઓનું અનુસરણ તમને 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 Git નો ઉપયોગ કરીને ns-3 ડાઉનલોડ કરી રહ્યું છે

ns-3 કોડ GitLab.com પર Git રિપોઝીટરીઝમાં ઉપલબ્ધ છે https://gitlab.com/nsnam/. સમૂહ nsnam ઓપન સોર્સ પ્રોજેક્ટ દ્વારા ઉપયોગમાં લેવાતી વિવિધ રીપોઝીટરીઝને એકસાથે લાવે છે.

ગિટ રિપોઝીટરીઝનો ઉપયોગ શરૂ કરવાનો સૌથી સહેલો રસ્તો એ પર્યાવરણને ફોર્ક અથવા ક્લોન કરવાનો છે 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, ગરમીથી પકવવું, pybindgen и netanim.

નોંધણી
સ્વચ્છ Ubuntu16.04 સાથેના મશીન પર, મારે આમાં આદેશ બદલવાની જરૂર છે: $ sudo python3 download.py -n ns-3.29 (ત્યારબાદ અનુવાદકની નોંધો).

3.3.1 બેકનો ઉપયોગ કરીને ns-3 લોડ કરી રહ્યું છે

ઉપરોક્ત બે પદ્ધતિઓ (સ્રોત આર્કાઇવ અથવા રીપોઝીટરી ns-3-એલીનોન Git દ્વારા) બહુવિધ એડઓન્સ સાથે સરળ ns-3 ઇન્સ્ટોલેશન મેળવવા માટે ઉપયોગી છે(pybindgen પાયથોન બાઈન્ડીંગ જનરેટ કરવા અને netanim નેટવર્ક એનિમેશન માટે). ns-3-allinone માં મૂળભૂત રીતે પૂરી પાડવામાં આવેલ ત્રીજી રીપોઝીટરી કહેવાય છે ગરમીથી પકવવું.

ગરમીથી પકવવું ns-3 પ્રોજેક્ટ માટે વિકસિત, બહુવિધ ભંડારમાંથી સોફ્ટવેરના સંકલિત નિર્માણ માટેનું એક સાધન છે. ગરમીથી પકવવું ns-3 ની ડેવલપમેન્ટ આવૃત્તિઓ મેળવવા તેમજ ns-3 ડિસ્ટ્રિબ્યુશનના બેઝ વર્ઝનના એક્સટેન્શનને ડાઉનલોડ કરવા અને બિલ્ડ કરવા માટે વાપરી શકાય છે, જેમ કે પર્યાવરણ ડાયરેક્ટ કોડ એક્ઝેક્યુશન, CradleNetwork સિમ્યુલેશન પારણું, નવા પાયથોન બાઈન્ડિંગ્સ અને વિવિધ ns-3 “એપ્લિકેશનો” બનાવવાની ક્ષમતા.

નોંધણી
CradleNetwork Simulation Cradle એ એક ફ્રેમવર્ક છે જે તમને નેટવર્ક સિમ્યુલેટરની અંદર વાસ્તવિક TCP/IP નેટવર્ક સ્ટેક્સનો ઉપયોગ કરવાની મંજૂરી આપે છે.

જો તમે તમારા ns-3 સ્થાપનમાં અદ્યતન અથવા વધારાના લક્ષણોની અપેક્ષા રાખો છો, તો તમે આ સ્થાપન પાથને અનુસરી શકો છો.

નવીનતમ ns-3 પ્રકાશનોમાં ગરમીથી પકવવું ટાર રિલીઝમાં ઉમેરવામાં આવ્યું હતું. પ્રકાશનમાં એક રૂપરેખાંકન ફાઇલનો સમાવેશ થાય છે જે તમને પ્રકાશનના સમયે વર્તમાન સોફ્ટવેર સંસ્કરણોને ડાઉનલોડ કરવાની મંજૂરી આપે છે. તે છે, ઉદાહરણ તરીકે, સંસ્કરણ ગરમીથી પકવવું, જે પ્રકાશન ns-3.29 સાથે વિતરિત કરવામાં આવે છે, તેનો ઉપયોગ ns-3 અથવા તેના પહેલાના પ્રકાશન માટે ઘટકો પુનઃપ્રાપ્ત કરવા માટે થઈ શકે છે, પરંતુ પછીના પ્રકાશનો માટે ઘટકો પુનઃપ્રાપ્ત કરવા માટે તેનો ઉપયોગ કરી શકાતો નથી (જો પેકેજ વર્ણન ફાઇલ bakeconf.xml અપડેટ નથી).

તમે નવીનતમ નકલ પણ મેળવી શકો છો ગરમીથી પકવવુંતમારા 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.

આદેશ પૂર્ણ થયા પછી ક્લોન તમારી પાસે નામની ડિરેક્ટરી હોવી જોઈએ ગરમીથી પકવવું, જેનાં સમાવિષ્ટો કંઈક આના જેવા દેખાવા જોઈએ:

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

નોંધ કરો કે તમે ઘણી પાયથોન સ્ક્રિપ્ટો લોડ કરી છે, નામનું પાયથોન મોડ્યુલ ગરમીથી પકવવું અને XML રૂપરેખાંકન ફાઇલ. આગળનું પગલું એ તમારી પસંદગીના ns-3 વિતરણને ડાઉનલોડ કરવા અને બનાવવા માટે આ સ્ક્રિપ્ટોનો ઉપયોગ કરવાનું છે. કેટલાક કસ્ટમાઇઝેશન લક્ષ્યો ઉપલબ્ધ છે:

1. ns-3.29: પ્રકાશનને અનુરૂપ મોડ્યુલ; તે ટારબોલમાં પ્રકાશન જેવા ઘટકો ડાઉનલોડ કરશે;

2. ns-3-dev: સમાન મોડ્યુલ, પરંતુ વિકાસ વૃક્ષમાંથી કોડનો ઉપયોગ કરીને;

3. ns-allinone-3.29: એક મોડ્યુલ જેમાં અન્ય વધારાની સુવિધાઓ જેમ કે ક્લિક રૂટીંગ અને નેટવર્ક સિમ્યુલેશન ક્રેડલ, ns-3 માટે ઓપનફ્લોનો સમાવેશ થાય છે.

4. ns-3-એલીનોન: મોડ્યુલના પ્રકાશન સંસ્કરણ જેવું જ એક મા બધુ, પરંતુ વિકાસ કોડ માટે.

નોંધણી
ક્લિક કરો — રાઉટર બનાવવા માટે મોડ્યુલર સોફ્ટવેર આર્કિટેક્ચર.

ઓપનફ્લો એ રાઉટર્સ અને સ્વિચ દ્વારા ડેટા નેટવર્ક પર પ્રસારિત ડેટા પ્રોસેસિંગની પ્રક્રિયાને મેનેજ કરવા માટેનો પ્રોટોકોલ છે, જે સોફ્ટવેર-વ્યાખ્યાયિત નેટવર્ક તકનીકનો અમલ કરે છે.

વર્તમાન વિકાસ સ્નેપશોટ (બિન-પ્રકાશન) ns-3 અહીં મળી શકે છે:https://gitlab.com/nsnam/ns-3-dev.git.

વિકાસકર્તાઓ આ ભંડારોને સતત કાર્યકારી ક્રમમાં રાખવાનો પ્રયાસ કરે છે, પરંતુ તે વિકાસ ક્ષેત્રમાં છે અને તેમાં અપ્રકાશિત કોડ છે, તેથી જો તમે નવી સુવિધાઓનો ઉપયોગ કરવાની યોજના ન ધરાવતા હો, તો સત્તાવાર પ્રકાશન પસંદ કરો.

તમે રીપોઝીટરીઝની યાદી બ્રાઉઝ કરીને અથવા ns-3 રીલીઝ વેબ પેજ પર જઈને કોડનું નવીનતમ સંસ્કરણ શોધી શકો છો:https://www.nsnam.org/releases/ અને નવીનતમ સંસ્કરણ લિંક પર ક્લિક કરીને. આ ઉદાહરણમાં આપણે ns-3.29 સાથે ચાલુ રાખીશું.

હવે, અમને જરૂરી ns-3 ઘટકો મેળવવા માટે, અમે ટૂલનો ઉપયોગ કરીશું ગરમીથી પકવવું. ચાલો કામ વિશે થોડા પ્રારંભિક શબ્દો કહીએ ગરમીથી પકવવું.

બેક ડિરેક્ટરીમાં પેકેજ સ્ત્રોતો લોડ કરીને કામ કરે છે સ્ત્રોત અને બિલ્ડ ડિરેક્ટરીમાં લાઈબ્રેરીઓ ઈન્સ્ટોલ કરી રહ્યા છીએ. ગરમીથી પકવવું દ્વિસંગી સંદર્ભ દ્વારા ચલાવી શકાય છે, પરંતુ જો તમે ચલાવવા માંગો છો ગરમીથી પકવવું તે ડાયરેક્ટરીમાંથી નહીં કે જેમાં તે ડાઉનલોડ કરવામાં આવી હતી, તેમાં પાથ ઉમેરવાની સલાહ આપવામાં આવે છે ગરમીથી પકવવું તમારા પાથ પર (PATH પર્યાવરણ ચલ), ઉદાહરણ તરીકે નીચે મુજબ (લિનક્સ બેશ શેલ માટેનું ઉદાહરણ). "બેક" ડિરેક્ટરી પર જાઓ અને પછી નીચેના પર્યાવરણ ચલો સેટ કરો:

$ 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 ...

ખાસ કરીને, અપલોડ ટૂલ્સ જેમ કે મર્ક્યુરિયલ, સીવીએસ, ગિટ અને બજાર આ પગલામાં આવશ્યક છે કારણ કે તે અમને કોડ મેળવવાની મંજૂરી આપે છે. આ બિંદુએ, તમારી સિસ્ટમ માટે ગુમ થયેલ સાધનોને સામાન્ય રીતે ઇન્સ્ટોલ કરો (જો તમે જાણો છો કે કેવી રીતે) અથવા મદદ માટે તમારા સિસ્ટમ એડમિનિસ્ટ્રેટરનો સંપર્ક કરો.

આગળ, સૉફ્ટવેર ડાઉનલોડ કરવાનો પ્રયાસ કરો:

$ ./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 એસેમ્બલી એનએસ-3

એનએસ-3 ડાઉનલોડ કરવાની જેમ, એનએસ-3 બનાવવાની ઘણી રીતો છે. અમે જે મુખ્ય વસ્તુ પર ભાર મૂકવા માંગીએ છીએ તે એ છે કે ns-3 નામના બિલ્ડ ટૂલનો ઉપયોગ કરીને બનાવવામાં આવે છે વાફનીચે વર્ણવેલ. મોટાભાગના વપરાશકર્તાઓ સાથે કામ કરશે વાફ, પરંતુ તમને પ્રારંભ કરવામાં અથવા વધુ જટિલ બિલ્ડ્સને ગોઠવવામાં મદદ કરવા માટે કેટલીક સરળ સ્ક્રિપ્ટો છે. તેથી કૃપા કરીને, તમે તેના વિશે વાંચો તે પહેલાં વાફ, એક નજર નાખો build.py અને સાથે એસેમ્બલી ગરમીથી પકવવું.

3.4.1 build.py સાથે બિલ્ડીંગ

સાવધાન આ બિલ્ડ સ્ટેપ ફક્ત ઉપર વર્ણવ્યા મુજબ પ્રાપ્ત કરેલ સ્ત્રોત આર્કાઇવ સંસ્કરણમાંથી ઉપલબ્ધ છે; અને ગિટ અથવા બેક દ્વારા ડાઉનલોડ કરેલ નથી.

પ્રકાશન આર્કાઇવ સાથે કામ કરતી વખતે ટારબોલમાં ns-3-એલીનોન ત્યાં એક સરળ સ્ક્રિપ્ટ છે જે ઘટકોને એસેમ્બલ કરવાનું સરળ બનાવી શકે છે. તેને build.py કહેવાય છે. આ પ્રોગ્રામ તમારા માટે સૌથી ઉપયોગી રીતે પ્રોજેક્ટ સેટ કરશે. જો કે, નોંધ કરો કે ns-3 સાથે વધુ અદ્યતન સેટઅપ અને કામમાં સામાન્ય રીતે ns-3 ની પોતાની બિલ્ડ સિસ્ટમ, Waf નો ઉપયોગ કરવામાં આવે છે, જે આ ટ્યુટોરીયલમાં પછીથી રજૂ કરવામાં આવશે.

જો તમે ઉપયોગ કરીને ડાઉનલોડ કરો છો ટારબોલ, પછી તમારી ડિરેક્ટરીમાં ~/કાર્યક્ષેત્ર કંઈક નામ સાથે ડિરેક્ટરી ns-allinone-3.29. નીચેના દાખલ કરો:

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

જ્યારે બોલાવવામાં આવે છે build.py અમે આ ટ્યુટોરીયલમાં ઉપયોગમાં લેવાતા ઉદાહરણો અને પરીક્ષણો બનાવવા માટે આદેશ વાક્ય દલીલોનો ઉપયોગ કર્યો છે, જે ns-3 માં મૂળભૂત રીતે બાંધવામાં આવતા નથી. મૂળભૂત રીતે, પ્રોગ્રામ બધા ઉપલબ્ધ મોડ્યુલો પણ બનાવે છે. પછી, જો તમે ઈચ્છો, તો તમે ઉદાહરણો અને પરીક્ષણો વિના ns-3 બનાવી શકો છો, અથવા તમારા કાર્ય માટે જરૂરી ન હોય તેવા મોડ્યુલોને બાકાત કરી શકો છો.

તમે સ્ક્રિપ્ટ દ્વારા પ્રદર્શિત ઘણાં કમ્પાઇલર આઉટપુટ સંદેશાઓ જોશો કારણ કે તે તમે લોડ કરેલા વિવિધ ભાગો બનાવે છે. પ્રથમ સ્ક્રિપ્ટ એનિમેટર બનાવવાનો પ્રયાસ કરશે netanim, પછી બંધનકર્તા જનરેટર 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 ગરમીથી પકવવું સાથે મકાન

જો તમે પ્રોજેક્ટ રીપોઝીટરીઝમાંથી સોર્સ કોડ મેળવવા માટે ઉપરોક્ત બેકનો ઉપયોગ કર્યો હોય, તો તમે 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 જો તમે અપડેટ કરેલ પાયથોન બાઈન્ડીંગ બનાવવા માંગતા હોવ તો જ જરૂરી છે. મોટાભાગના વપરાશકર્તાઓ માટે આની કોઈ જરૂર નથી (ઓછામાં ઓછું જ્યાં સુધી તેઓ 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

આ લોન્ચ કરશે વાફ સ્થાનિક ડિરેક્ટરીની બહાર (તમારી સુવિધા માટે). પ્રથમ આદેશ અગાઉના બિલ્ડમાંથી સાફ કરે છે, આ સામાન્ય રીતે સખત જરૂરી નથી, પરંતુ તે સારી પ્રેક્ટિસ છે (નીચે બિલ્ડ પ્રોફાઇલ્સ પણ જુઓ); આ અગાઉ બનાવેલ લાઇબ્રેરીઓ અને ડિરેક્ટરીમાં સ્થિત ઑબ્જેક્ટ ફાઇલોને કાઢી નાખશે બિલ્ડ/. જ્યારે પ્રોજેક્ટ પુનઃરૂપરેખાંકિત થાય છે અને બિલ્ડ સિસ્ટમ વિવિધ નિર્ભરતાને તપાસે છે, ત્યારે તમારે નીચેના જેવું આઉટપુટ જોવું જોઈએ:

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 બીટ "રનટાઇમ પર સમૂહ ID સેટ કરો" સેટ કરવા માટે. તે ડિફૉલ્ટ રૂપે સક્ષમ નથી અને તેથી આ સુવિધા "સક્ષમ નથી" તરીકે દેખાય છે. છેલ્લે, સક્ષમ વિકલ્પોની સૂચિ મેળવવા માટે, ઉપયોગ કરો વાફ પરિમાણ સાથે --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

જો કે, વિશેષ ઓપરેટર - - દ્વારા વધારાના પરિમાણો પસાર કરવા માટે વાપરી શકાય છે wafતેથી ઉપરના બદલે નીચેનો આદેશ કામ કરશે:

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

કારણ કે તે મુખ્ય આદેશ જનરેટ કરે છે ./waf રૂપરેખાંકિત --disable-python. અહીં કેટલીક વધુ પ્રારંભિક ટીપ્સ વિશે છે વાફ.

બિલ્ડ ભૂલો સંભાળવી

સામાન્ય Linux અને MacOS વિતરણો પર પ્રકાશન સમયે ઉપલબ્ધ નવીનતમ C++ કમ્પાઇલર્સ પર ns-3 પ્રકાશનોનું પરીક્ષણ કરવામાં આવે છે. જો કે, સમય જતાં, નવા કમ્પાઈલરો સાથે નવા વિતરણો બહાર પાડવામાં આવે છે, અને આ નવા કમ્પાઈલરો ચેતવણીઓ વિશે વધુ પેડન્ટિક હોય છે. ns-3 તેના બિલ્ડને તમામ ચેતવણીઓને ભૂલો તરીકે ગણવા માટે રૂપરેખાંકિત કરે છે, તેથી કેટલીકવાર જો તમે નવી સિસ્ટમ પર જૂની આવૃત્તિ ચલાવી રહ્યા હોવ, તો કમ્પાઇલર ચેતવણી બિલ્ડને રોકી શકે છે.

ઉદાહરણ તરીકે, અગાઉ Fedora 3.28 માટે ns‑28 નું પ્રકાશન હતું, જેમાં એક નવું મુખ્ય સંસ્કરણ સામેલ હતું. જીસીસી (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 થી શરૂ થતા પ્રકાશનોમાં, માં વાફ આ સમસ્યાઓ ઉકેલવા માટે એક વિકલ્પ ઉપલબ્ધ છે. તે g++ અને clang++ માં "-Werror" ફ્લેગ સેટ કરવાનું અક્ષમ કરે છે. આ "--disable-werror" વિકલ્પ છે અને રૂપરેખાંકન દરમિયાન લાગુ થવો જોઈએ:

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

ગોઠવો અથવા એસેમ્બલ કરો

કેટલાક આદેશો વાફ માત્ર રૂપરેખાંકન તબક્કામાં જ અર્થ ધરાવે છે, અને કેટલાક માત્ર બિલ્ડ તબક્કામાં જ માન્ય છે. ઉદાહરણ તરીકે, જો તમે ns-3 ઇમ્યુલેશન સુવિધાઓનો ઉપયોગ કરવા માંગતા હો, તો તમે બીટ સેટિંગને સક્ષમ કરી શકો છો દક્ષિણ ઉપયોગ કરીને sudo, ઉપર વર્ણવ્યા પ્રમાણે. આ રૂપરેખાંકન પગલાં આદેશોને ઓવરરાઇડ કરશે, અને આમ તમે નીચેના આદેશનો ઉપયોગ કરીને રૂપરેખાંકન બદલી શકો છો, જેમાં ઉદાહરણો અને પરીક્ષણો પણ શામેલ છે.

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

જો તમે આ કરો છો વાફ લોન્ચ કરશે sudoપરવાનગીઓ સાથે ચલાવવા માટે ઇમ્યુલેશન કોડ સોકેટ બનાવટ કાર્યક્રમો બદલવા માટે રુટ. આ વાફ રૂપરેખાંકન અને બિલ્ડ સ્ટેપ્સ માટે અન્ય ઘણા વિકલ્પો ઉપલબ્ધ છે. તમારા વિકલ્પોનું અન્વેષણ કરવા માટે, દાખલ કરો:

$ ./waf --help

આગળના વિભાગમાં અમે કેટલાક પરીક્ષણ સંબંધિત વિકલ્પોનો ઉપયોગ કરીશું.

એસેમ્બલી પ્રોફાઇલ્સ

અમે પહેલાથી જ જોયું છે કે તમે કેવી રીતે ગોઠવી શકો છો વાફ એસેમ્બલીઓ માટે ડિબગ и ઓપ્ટીમાઇઝ્ડ:

$ ./waf --build-profile=debug

મધ્યવર્તી એસેમ્બલી પ્રોફાઇલ પણ છે, પ્રકાશન. વિકલ્પ -d નો પર્યાય છે --build-profile. બિલ્ડ પ્રોફાઇલ લોગીંગ, નિવેદનો અને કમ્પાઇલર ઓપ્ટિમાઇઝેશન સ્વીચોના ઉપયોગને નિયંત્રિત કરે છે:

જેમ તમે જોઈ શકો છો, લોગીંગ અને નિવેદનો ફક્ત ડીબગ બિલ્ડ્સમાં જ ઉપલબ્ધ છે. ભલામણ કરેલ પ્રેક્ટિસ એ છે કે તમારી સ્ક્રિપ્ટને ડીબગ મોડમાં વિકસાવો, પછી ઑપ્ટિમાઇઝ બિલ્ડ પ્રોફાઇલમાં પુનરાવર્તિત રન (આંકડા અથવા પરિમાણ ફેરફારો માટે) કરો.

જો તમારી પાસે કોડ છે જે ફક્ત અમુક બિલ્ડ પ્રોફાઇલ્સમાં જ ચાલવો જોઈએ, તો કોડ રેપર મેક્રોનો ઉપયોગ કરો:

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 બનાવવા માટે GCC ના C++ કમ્પાઇલરનો ઉપયોગ કરે છે ( જી ++). જો કે, તમે ઉપયોગ કરો છો તે બદલી શકો છો વાફ C++ કમ્પાઇલર, CXX પર્યાવરણ ચલ વ્યાખ્યાયિત કરીને. ઉદાહરણ તરીકે, C++ કમ્પાઇલર ક્લેંગ, ક્લેંગ++નો ઉપયોગ કરવા માટે,

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

એ જ રીતે તમે રૂપરેખાંકિત કરી શકો છો વાફ નો ઉપયોગ કરીને વિતરિત સંકલનનો ઉપયોગ કરો distcc:

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

distcc અને વિતરિત સંકલન વિશે વધુ માહિતી દસ્તાવેજીકરણ વિભાગમાં પ્રોજેક્ટ પૃષ્ઠ પર મળી શકે છે. ns-3 રૂપરેખાંકિત કરતી વખતે કમ્પાઇલર ફ્લેગ ઉમેરવા માટે, CXXFLAGS_EXTRA પર્યાવરણ વેરીએબલનો ઉપયોગ કરો.

સ્થાપન

વાફ સિસ્ટમ પર વિવિધ સ્થળોએ પુસ્તકાલયો સ્થાપિત કરવા માટે વાપરી શકાય છે. મૂળભૂત રીતે, સંકલિત પુસ્તકાલયો અને એક્ઝિક્યુટેબલ ડિરેક્ટરીમાં સ્થિત છે બિલ્ડ કરો, અને Waf આ લાઇબ્રેરીઓ અને એક્ઝિક્યુટેબલ્સનું સ્થાન જાણે છે, તેથી લાઇબ્રેરીઓને બીજે ક્યાંય ઇન્સ્ટોલ કરવાની જરૂર નથી.

જો વપરાશકર્તાઓ બિલ્ડ ડિરેક્ટરીની બહાર ઇન્સ્ટોલ કરવાનું પસંદ કરે છે, તો તેઓ આદેશ ચલાવી શકે છે ./waf ઇન્સ્ટોલ કરો. સ્થાપન માટે મૂળભૂત ઉપસર્ગ છે / યુએસઆર / સ્થાનિક, તેથી ./waf ઇન્સ્ટોલ કરો માં પ્રોગ્રામ્સ ઇન્સ્ટોલ કરશે / યુએસઆર / સ્થાનિક / બિન, માં પુસ્તકાલયો / usr / સ્થાનિક / lib અને હેડર ફાઇલો /usr/local/include. સુપરયુઝર અધિકારો સામાન્ય રીતે ડિફૉલ્ટ ઉપસર્ગ સાથે સેટ કરવાની જરૂર છે, તેથી એક લાક્ષણિક આદેશ હશે sudo ./waf ઇન્સ્ટોલ કરો. જ્યારે લૉન્ચ થશે, ત્યારે Waf સૌપ્રથમ બિલ્ડ ડિરેક્ટરીમાં શેર કરેલી લાઇબ્રેરીઓનો ઉપયોગ કરવાનું પસંદ કરશે, પછી સ્થાનિક વાતાવરણમાં રૂપરેખાંકિત લાઇબ્રેરીઓના પાથ સાથે લાઇબ્રેરીઓ શોધશે. તેથી જ્યારે સિસ્ટમ પર લાઈબ્રેરીઓ ઈન્સ્ટોલ કરી રહ્યા હોય, ત્યારે યોગ્ય લાઈબ્રેરીઓનો ઉપયોગ થઈ રહ્યો છે કે નહીં તે તપાસવું એ સારી પ્રથા છે. વપરાશકર્તાઓ રૂપરેખાંકન દરમિયાન વિકલ્પ પસાર કરીને અલગ ઉપસર્ગ સાથે ઇન્સ્ટોલ કરવાનું પસંદ કરી શકે છે --prefix, ઉદાહરણ તરીકે:

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

જો પાછળથી, બિલ્ડ પછી, વપરાશકર્તા ઇન્સ્ટોલેશન આદેશ દાખલ કરે છે ./waf, ઉપસર્ગનો ઉપયોગ કરવામાં આવશે /opt/local.

ટીમ ./waf clean જો ઇન્સ્ટોલેશન ઉપયોગ કરશે તો પ્રોજેક્ટને પુનઃરૂપરેખાંકિત કરતા પહેલા ઉપયોગ કરવો આવશ્યક છે વાફ એક અલગ ઉપસર્ગ હેઠળ.

આમ, ns-3 નો ઉપયોગ કરવા માટે કૉલ કરવાની જરૂર નથી ./waf install. મોટાભાગના વપરાશકર્તાઓને આ આદેશની જરૂર નથી કારણ કે વાફ બિલ્ડ ડાયરેક્ટરીમાંથી વર્તમાન લાઈબ્રેરીઓ પસંદ કરશે, પરંતુ કેટલાક વપરાશકર્તાઓને આ ઉપયોગી લાગી શકે છે જો તેમની પ્રવૃત્તિઓમાં ns-3 ડિરેક્ટરીની બહારના કાર્યક્રમો સાથે કામ કરવું સામેલ હોય.

વાફ સિંગલ

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)

વેલગ્રિન્ડ ક્રેશ, ક્રેશ અથવા ભૂલો ઓળખવા માટે આ એક મહત્વપૂર્ણ સંદેશ છે, જે કોડ સાથેની સમસ્યાઓ અથવા સાધનો અને કોડ વચ્ચેની અસંગતતા દર્શાવે છે.

તમે માંથી અંતિમ આઉટપુટ પણ જોશો વાફ અને દરેક ટેસ્ટ ચલાવતો ટેસ્ટર, જે કંઈક આના જેવો દેખાશે:

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 વપરાશકર્તા છો!

જો મને પરિણામો ન દેખાય તો મારે શું કરવું જોઈએ?

જો તમે સંદેશાઓ જુઓ છો વાફદર્શાવે છે કે બિલ્ડ સફળતાપૂર્વક પૂર્ણ થયું છે, પરંતુ તમને આઉટપુટ દેખાતું નથી "હેલો સિમ્યુલેટર", તો એવી શક્યતા છે કે [બિલ્ડ-વિથ-વાફ] વિભાગમાં તમે તમારા બિલ્ડ મોડને સ્વિચ કર્યું છે ઓપ્ટીમાઇઝ્ડ, પરંતુ મોડ પર પાછા સ્વિચ કરવાનું ચૂકી ગયું ડિબગ. આ ટ્યુટોરીયલમાં વપરાતા તમામ કન્સોલ આઉટપુટ ખાસ ns-3 ઘટકનો ઉપયોગ કરે છે જે લોગીંગ કરે છે અને કન્સોલ પર કસ્ટમ સંદેશાઓ છાપવા માટે વપરાય છે. જ્યારે ઑપ્ટિમાઇઝ કોડ કમ્પાઇલ કરવામાં આવે ત્યારે આ ઘટકમાંથી આઉટપુટ આપમેળે અક્ષમ થઈ જાય છે - તે "ઑપ્ટિમાઇઝ" છે. જો તમને "હેલો સિમ્યુલેટર" આઉટપુટ દેખાતું નથી, તો નીચેના દાખલ કરો:

$ ./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 ...'

બીજું ખાસ કરીને ઉપયોગી ઉદાહરણ ટેસ્ટ સ્યુટ્સને પસંદગીપૂર્વક ચલાવી રહ્યું છે. ચાલો માની લઈએ કે માયટેસ્ટ નામનો ટેસ્ટ સ્યુટ છે (હકીકતમાં ત્યાં નથી). ઉપર અમે સમાંતર સંખ્યાબંધ પરીક્ષણો ચલાવવા માટે ./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 પ્રોગ્રામ ચલાવવા માટે, જેમ કે ડીબગર (ઉદાહરણ તરીકે, જીડીબી) અથવા મેમરી ટેસ્ટ ટૂલ (ઉદાહરણ તરીકે, valgrind), સમાન સ્વરૂપનો ઉપયોગ કરો - -command-template = "…". ઉદાહરણ તરીકે, ડીબગરમાં ચલાવવા માટે જીડીબી દલીલો સાથે તમારો હેલો-સિમ્યુલેટર એનએસ-3 પ્રોગ્રામ:

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

નોંધ કરો કે ns-3 પ્રોગ્રામનું નામ દલીલ સાથે આવે છે - -run, અને મેનેજમેન્ટ યુટિલિટી (અહીં જીડીબી) એ દલીલમાં પ્રથમ ટોકન છે - -command-template. વિકલ્પ - -args જાણ જીડીબીકે બાકીની કમાન્ડ લાઇન "લોઅર" પ્રોગ્રામની છે. (કેટલાક સંસ્કરણો જીડીબી વિકલ્પ સમજાતો નથી - -args. આ કિસ્સામાં, પ્રોગ્રામ દલીલો દૂર કરો - -command-template અને આદેશ સમૂહનો ઉપયોગ કરો જીડીબી દલીલો.) ડીબગર હેઠળ ટેસ્ટ ચલાવવા માટે અમે આ રેસીપી અને પહેલાની રેસીપીને જોડી શકીએ છીએ:

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

3.6.3 કાર્યકારી નિર્દેશિકા

વાફને 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