3 Iniziando il lavoro
3.1 Panoramica
3.2 Condizioni preliminari
3.2.1 Scaricare il rilascio di ns-3 come archivio di sorgenti
3.3 Scaricare ns-3 tramite Git
3.3.1 Scaricare ns-3 con Bake
3.4 Compilare ns-3
3.4.1 Compilazione con build.py
3.4.2 Compilazione con Bake
3.4.3 Compilazione con Waf
3.5 Testare ns-3
3.6 Eseguire lo script
3.6.1 Argomenti della riga di comando
3.6.2 Debugging
3.6.3 Directory di lavoro
Capitolo 3
Iniziando il lavoro
Questo capitolo ha lo scopo di preparare il lettore al lavoro, partendo da un computer su cui potrebbe non essere mai stata installata ns‑3. La discussione copre le piattaforme supportate, le condizioni preliminari, i metodi per ottenere ns‑3, i modi per compilare ns‑3 e i modi per verificare la propria compilazione ed eseguire programmi semplici.
3.1 Panoramica
Il simulatore ns‑3 è costruito come un sistema di librerie software collaborative. Durante la compilazione, il codice dei programmi utente viene collegato a queste librerie. Per scrivere programmi utente si utilizzano i linguaggi di programmazione C++ o Python.
Ns‑3 è distribuito come codice sorgente, il che significa che il sistema target deve avere un ambiente di sviluppo software per prima cosa compilare le librerie e poi compilare il programma utente. In linea di principio, ns‑3 potrebbe essere distribuito come librerie pronte per un sistema specifico, e in futuro potrebbero essere distribuite in questo modo. Ma attualmente molti utenti svolgono il loro lavoro modificando ns‑3 stesso, quindi è utile avere il codice sorgente per la compilazione delle librerie. Se qualcuno fosse interessato a lavorare alla creazione di librerie e pacchetti pronti per i sistemi operativi, per favore contatti la mailing list ns-developers.
Esamineremo tre metodi per scaricare e compilare ns‑3. Il primo consiste nel scaricare e costruire il rilascio ufficiale dal sito principale. Il secondo è selezionare e compilare copie delle versioni di sviluppo della configurazione di base di ns‑3. Il terzo è utilizzare strumenti di compilazione aggiuntivi per scaricare più estensioni per ns‑3. Passeremo in rassegna ciascuno, poiché gli strumenti differiscono leggermente.
Gli utenti esperti di Linux potrebbero chiedersi perché ns-3 non venga fornito come pacchetto, a differenza della maggior parte delle altre librerie che utilizzano un gestore di pacchetti. Anche se esistono pacchetti binari per diverse distribuzioni Linux (ad esempio Debian), la maggior parte degli utenti finisce per modificare le librerie e deve ricompilare ns-3 da sé, quindi la disponibilità del codice sorgente è comoda. Per questo motivo, ci concentreremo sull'installazione dal codice sorgente.
Per la maggior parte delle applicazioni, ns-3 non richiede privilegi. root Si consiglia di utilizzare un account utente non privilegiato.
3.2 Condizioni preliminari
L'intero insieme delle librerie disponibili di ns-3 ha una serie di dipendenze da librerie di terze parti, ma per la maggior parte, ns-3 può essere compilato e utilizzato con il supporto di diversi componenti comuni (spesso preinstallati di default): compilatore C++, Python, editor di codice sorgente (ad esempio, vim, emacs o Eclipse) e, se si utilizzano i repository di sviluppo, sistemi di controllo della versione Git. La maggior parte degli utenti principianti non deve preoccuparsi se la loro configurazione riporta alcune funzionalità aggiuntive di ns-3 mancanti, ma per chi desidera un'installazione completa, il progetto fornisce una wiki che include pagine con molti utili consigli e suggerimenti. Una di queste pagine è la pagina "Installazione" con istruzioni per l'installazione su diversi sistemi, disponibile all'indirizzo: .
La sezione "Requisiti preliminari" di questa pagina wiki spiega quali pacchetti sono necessari per supportare le opzioni comuni di ns-3 e fornisce anche i comandi utilizzati per installarli su varianti comuni di Linux o macOS.
Puoi sfruttare opportunità come esplorare la pagina wiki di ns-3 o il sito web principale: , poiché contiene molte informazioni. A partire dall'ultima versione di ns-3 (ns-3.29), per eseguire ns-3 sono necessari i seguenti strumenti:
Strumento Pacchetto/.versione
- Compilatore C++
clang++ o g++ (g++ versione 4.9 o superiore) - Python
python2 versione >= 2.7.10, o python3 versione >=3.4 - Git
qualunque versione recente (per accedere a ns-3 su GitLab.com) - tar
qualunque versione recente (per estrarre la release di ns-3) - bunzip2
qualunque versione recente (per estrarre la release di ns-3)
Per verificare la versione di Python installata di default, digita python -V. Per verificare la versione di g++, inserisci g++ -v. Se alcuni strumenti mancano o sono troppo vecchi, fai riferimento alla guida all'installazione nella pagina wiki di ns-3.
Da questo momento, presumiamo che il lettore stia lavorando su Linux, MacOS o un emulatore di ambiente Linux, e abbia almeno gli strumenti sopra menzionati.
3.2.1 Scaricare il rilascio di ns-3 come archivio di sorgenti
Questo è il modo in cui un nuovo utente può scaricare e sperimentare le ultime versioni di rilascio e pacchetti di ns-3. I rilasci di ns-3 sono pubblicati in archivi compressi di sorgenti, talvolta chiamati tarball. tarball — un formato particolare di archivio software in cui diversi file sono uniti insieme. L'archivio è di solito compresso. Il processo di download di ns-3 tramite tarball è semplice, devi solo scegliere il rilascio, scaricarlo e decomprimerlo.
Supponiamo che tu, come utente, voglia compilare ns-3 in una directory locale chiamata workspace. Puoi ottenere una copia di lavoro del rilascio inserendo nella console Linux quanto segue (ovviamente, sostituisci i numeri di versione appropriati)
$ 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 Fai attenzione all'utility utilizzata sopra wget, che è uno strumento da riga di comando per scaricare oggetti da Internet. Se non l'hai installato, puoi usare il browser per questo.
Seguendo questi passaggi, entrerai nella directory ns-allinone-3.29, dove dovresti vedere diversi file e directory
$ 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.pyOra sei pronto per compilare la distribuzione base di ns-3 e puoi procedere alla sezione dedicata alla compilazione di ns-3.
3.3 Scaricare ns-3 tramite Git
Il codice di ns-3 è disponibile nei repository Git su GitLab.com all'indirizzo . Il gruppo nsnam riunisce vari repository utilizzati dal progetto open source.
Il modo più semplice per iniziare a utilizzare i repository Git è fare un fork o clonare l'ambiente ns-3-allinone. Si tratta di un insieme di script che gestisce il download e la costruzione delle sottosistemi più utilizzati di ns-3. Se sei alle prime armi con Git, i termini "fork" e "clonazione" potrebbero non esserti familiari; se è così, ti consigliamo di clonare (creare una tua copia) il repository su GitLab.com come segue:
$ cd
$ mkdir workspace
$ cd workspace
$ git clone https://gitlab.com/nsnam/ns-3-allinone.git
$ cd ns-3-allinone A questo punto, la tua directory appare così ns-3-allinone è leggermente diverso dalla directory descritta sopra con l'archivio della versione. Dovrebbe apparire più o meno così:
$ ls
build.py constants.py download.py README util.pyFai attenzione alla presenza dello script download.py, che estrarrà ulteriormente ns-3 e il codice sorgente associato. Qui hai la scelta: caricare l'ultima snapshot di sviluppo di ns-3:
$ python download.pyoppure preferire la versione di ns-3, utilizzando il flag -n per specificare il numero della versione:
$ python download.py -n ns-3.29Dopo questo passaggio, nella directory ns-3-allinone verranno scaricati repository aggiuntivi ns-3, bake, pybindgen e netanim.
Nota
Su una macchina con Ubuntu 16.04 pulito, ho dovuto modificare il comando in questo modo: $ sudo python3 download.py -n ns-3.29 (qui e in seguito note del traduttore).
3.3.1 Scaricare ns-3 con Bake
I due metodi sopra menzionati (archivio sorgenti o repository ns-3-allinone tramite Git) sono utili per ottenere l'installazione più semplice di ns-3 con alcuni addon (pybindgen per generare binding Python e netanim per animare la rete). Il terzo repository, fornito di default in ns-3-allinone, si chiama bake.
Bake — è uno strumento per la costruzione coordinata di software da più repository, progettato per il progetto ns-3. Bake può essere usato per ottenere versioni di sviluppo di ns-3, nonché per scaricare e costruire estensioni della versione base della distribuzione ns-3, come l'ambiente Direct Code Execution, CradleNetwork Simulation Cradle, la possibilità di creare nuovi binding Python e diverse "app" di ns-3.
Nota
CradleNetwork Simulation Cradle è un framework che consente di utilizzare stack di rete reali TCP/IP all'interno del simulatore di rete.
Se pensi che la tua installazione di ns-3 debba avere funzionalità avanzate o aggiuntive, puoi seguire questo percorso di installazione.
Nelle ultime versioni di ns-3 Bake è stata aggiunta nel rilascio tar. Il rilascio include un file di configurazione che consente di scaricare versioni del software attuali al momento della creazione del rilascio. Cioè, ad esempio, la versione Bake, che viene distribuita con il rilascio di ns-3.29, può essere utilizzata per ottenere componenti per questo rilascio di ns-3 o precedenti, ma non può essere utilizzata per estrarre componenti per versioni successive (se il file di descrizione del pacchetto bakeconf.xml non è aggiornato).
Puoi anche ottenere la copia più recente bake, inserendo il seguente comando nella tua console Linux (a condizione che tu abbia installato Git):
$ cd
$ mkdir workspace
$ cd workspace
$ git clone https://gitlab.com/nsnam/bake.gitDurante l'esecuzione del comando git, dovresti vedere qualcosa di simile al seguente:
Clonazione in 'bake'...
remote: Enumerazione oggetti: 2086, fatto.
remote: Conteggio oggetti: 100% (2086/2086), fatto.
remote: Compressione oggetti: 100% (649/649), fatto.
remote: Totale 2086 (delta 1404), riutilizzati 2078 (delta 1399)
Ricezione oggetti: 100% (2086/2086), 2.68 MiB | 3.82 MiB/s, fatto.
Risoluzione dei delta: 100% (1404/1404), fatto.Dopo il completamento del comando clone dovresti avere una directory chiamata bake, il cui contenuto dovrebbe apparire approssimativamente così:
$ cd bake
$ ls
bake bakeconf.xml bake.py doc examples generate-binary.py test TODONota che hai scaricato diversi script Python, un modulo Python chiamato bake e un file di configurazione XML. Il passo successivo sarà utilizzare questi script per scaricare e compilare il pacchetto ns‑3 a tua scelta. Sono disponibili diverse opzioni di configurazione:
ns‑3.29: modulo corrispondente alla versione di rilascio; scaricherà componenti simili al rilascio nel tarball;
ns‑3-dev: modulo simile, ma utilizzando il codice dall'albero di sviluppo;
ns-allinone-3.29: modulo che include altre funzionalità aggiuntive, come la routing Click e il Network Simulation Cradle, Openflow per ns-3.
ns-3-allinone: simile alla versione di rilascio del modulo allinone, ma per il codice di sviluppo.
Nota
Click — architettura software modulare per la creazione di router.
Openflow è un protocollo per la gestione del flusso di dati che passa attraverso reti di data center implementato nei router e switch, realizzando tecnologie di rete programmabile.
L'attuale snapshot di sviluppo (non rilasciato) di ns‑3 può essere trovato all'indirizzo:.
Gli sviluppatori cercano di mantenere questi repository in uno stato di lavoro coerente, ma si trovano nell'area di sviluppo e contengono codice non rilasciato, quindi se non intendi utilizzare nuove funzionalità, scegli il rilascio ufficiale.
Puoi trovare l'ultima versione del codice esplorando l'elenco dei repository, oppure visitando la pagina web ‘ns‑3 Releases’: e facendo clic sul link dell'ultima versione. In questo esempio, continueremo con ns‑3.29.
Ora, per ottenere i componenti necessari di ns‑3, utilizziamo lo strumento Bake. Diciamo qualche parola introduttiva sul funzionamento Bake.
Bake funziona scaricando i codici sorgente dei pacchetti nella directory source e installando le librerie nella directory di build. Bake può essere avviato facendo riferimento al file binario, ma se desideri avviare Bake non dalla directory in cui è stato caricato, è consigliabile aggiungere il percorso a bake al tuo percorso (variabile d'ambiente PATH), ad esempio, come mostrato di seguito (esempio per la shell Linux bash). Vai nella directory "bake" e poi imposta le seguenti variabili d'ambiente:
$ export BAKE_HOME=`pwd`
$ export PATH=$PATH:$BAKE_HOME:$BAKE_HOME/build/bin
$ export PYTHONPATH=$PYTHONPATH:$BAKE_HOME:$BAKE_HOME/build/libQuesto posizionerà il programma bake.py nel percorso della shell e consentirà ad altri programmi di trovare i file eseguibili e le librerie create da bake. In alcuni casi d'uso bake, l'impostazione del PATH e del PYTHONPATH di cui sopra non è necessaria, ma per una compilazione completa di ns‑3-allinone (con pacchetti aggiuntivi) è generalmente richiesta.
Accedi alla directory di lavoro e digita nella console quanto segue:
$ ./bake.py configure -e ns-3.29Successivamente, ti chiederemo di Bake controllare se abbiamo gli strumenti necessari per scaricare vari componenti. Digita:
$ ./bake.py checkDovresti vedere qualcosa di simile a quanto segue:
> Python - OK
> GNU C++ compiler - OK
> Mercurial - OK
> Git - OK
> Tar tool - OK
> Unzip tool - OK
> Make - OK
> cMake - OK
> patch tool - OK
> Percorso cercato per gli strumenti: /usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin ...In particolare, gli strumenti di download come Mercurial, CVS, Git e Bazaar sono essenziali in questo passaggio, poiché ci permettono di ottenere il codice. In questa fase, installa gli strumenti mancanti nel modo abituale per il tuo sistema (se lo sai fare) o chiedi aiuto al tuo amministratore di sistema.
Dopo, prova a scaricare il software:
$ ./bake.py downloadil risultato dovrebbe essere qualcosa del tipo:
>> Ricerca della dipendenza di sistema setuptools - OK
>> Ricerca della dipendenza di sistema libgoocanvas2 - OK
>> Ricerca della dipendenza di sistema gi-cairo - OK
>> Ricerca della dipendenza di sistema pygobject - OK
>> Ricerca della dipendenza di sistema pygraphviz - OK
>> Ricerca della dipendenza di sistema python-dev - OK
>> Ricerca della dipendenza di sistema qt - OK
>> Ricerca della dipendenza di sistema g++ - OK
>> Scaricamento pybindgen-0.19.0.post4+ng823d8b2 (directory target:pybindgen) - OK
>> Scaricamento netanim-3.108 - OK
>> Scaricamento ns-3.29 - OKCiò significherà che sono stati scaricati tre sorgenti. Ora vai nella directory source e digita ls; dovresti vedere:
$ cd source
$ ls
netanim-3.108 ns-3.29 pybindgenOra sei pronto per compilare il pacchetto ns‑3.
3.4 Compilare ns-3
Come per il download di ns‑3, ci sono diversi modi per compilare ns‑3. Principalmente, vogliamo sottolineare che ns‑3 è compilato utilizzando uno strumento di compilazione chiamato Waf, descritto di seguito. La maggior parte degli utenti lavorerà con Waf, ma ci sono diversi scenari utili che possono aiutarvi a iniziare o organizzare assemblaggi più complessi. Pertanto, prima di leggere di Waf, dai un'occhiata al build.py e assemblare con bake.
3.4.1 Compilazione con build.py
Attenzione! Questo passaggio di assemblaggio è disponibile solo dalla versione dell'archivio sorgente ottenuta come descritto sopra; non da quella scaricata tramite git o bake.
Quando si lavora con l'archivio di rilascio tarball, in ns‑3‑allinone c'è uno script utile che può semplificare l'assemblaggio dei componenti. Si chiama build.py. Questo programma imposterà il progetto nel modo più utile per voi. Tuttavia, tenete presente che configurazioni più complesse e il lavoro con ns‑3 di solito includono l'uso del proprio sistema di build ns‑3, Waf, che sarà presentato più avanti in questa guida.
Se avete eseguito il download tramite tarball, allora nella vostra directory ~/workspace dovrebbe apparire una directory con un nome simile a ns-allinone-3.29. Digitare quanto segue:
$ ./build.py --enable-examples --enable-tests
la richiesta con informazioni sui protocolli, vedremo quanto segue: build.py abbiamo applicato argomenti della riga di comando per assemblare esempi e test utilizzati in questa guida, che di default non vengono assemblati in ns‑3. Per impostazione predefinita, il programma costruisce anche tutti i moduli disponibili. Poi, se lo desiderate, potete assemblare ns‑3 senza esempi e test o escludere i moduli che non sono necessari per il vostro lavoro.
Vedrete molti messaggi di output del compilatore visualizzati dallo script durante l'assemblaggio delle diverse parti scaricate. Inizialmente, lo script tenterà di assemblare l'animatore netanim, poi il generatore di binding pybindgen e, infine, ns‑3. Al termine del processo, dovreste vedere quanto segue:
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.29Negli ultimi tre righi del listing vediamo un messaggio sui moduli che non sono stati assemblati:
Modules not built (see ns-3 tutorial for explanation):
brite clickQuesto significa semplicemente che alcuni moduli ns-3, che dipendono da librerie esterne, potrebbero non essere stati compilati, o che la loro compilazione non è necessaria per questa configurazione. Non significa che il simulatore non si sia compilato o che i moduli compilati funzioneranno in modo errato.
3.4.2 Compilazione con Bake
Se precedentemente, per ottenere il codice sorgente dai repository di progetto, hai usato bake, puoi continuare a utilizzarlo anche per compilare ns-3. Digita:
$ ./bake.py builde dovresti vedere qualcosa del tipo:
>> Compilazione di pybindgen-0.19.0.post4+ng823d8b2 - OK
>> Compilazione di netanim-3.108 - OK
>> Compilazione di ns-3.29 - OKIndizio: puoi anche eseguire entrambi i passaggi, download e compilazione, chiamando «bake.py deploy».
Durante la compilazione di tutti i componenti possono verificarsi errori, ma la compilazione continuerà se il componente non è obbligatorio. Ad esempio, un recente problema di portabilità riguardava il fatto che castxml può essere compilato dallo strumento bake non su tutte le piattaforme. In questo caso apparirà un messaggio del tipo:
>> Compilazione di castxml - Problema
> Problema: Dipendenza facoltativa, il modulo "castxml" è fallito
Ciò potrebbe ridurre la funzionalità della compilazione finale.
Tuttavia, bake continuerà poiché "castxml" non è una dipendenza essenziale.
Per maggiori informazioni chiama bake con -v o -vvv, per la modalità verbosa completa.Tuttavia castxml necessari solo se desideri creare binding Python aggiornati. Per la maggior parte degli utenti, non è necessario (almeno fino a quando non iniziano a modificare ns-3), quindi tali avvisi possono essere ignorati in sicurezza al momento.
Se si verifica un errore, il comando successivo ti darà un suggerimento sulle dipendenze mancanti:
$ ./bake.py showVerranno elencate varie dipendenze dei pacchetti che stai tentando di compilare.
3.4.3 Compilazione con Waf
Fino ad ora, per iniziare la compilazione di ns-3, abbiamo utilizzato sia lo script build.py, sia lo strumento bake. Questi strumenti sono utili per compilare ns-3 e supportare le librerie. Infatti, per la compilazione, avviano lo strumento di compilazione Waf dalla directory ns-3. Waf è fornito insieme al codice sorgente di ns-3. La maggior parte degli utenti, per configurare e compilare ns-3, passa rapidamente all'uso diretto di Waf. Quindi, per continuare, passa per favore alla directory ns-3 che hai creato originalmente.
Al momento non è strettamente necessario, ma è utile fare una piccola digressione e vedere come apportare modifiche alla configurazione del progetto. Probabilmente, la modifica più utile della configurazione che puoi fare sarà creare una versione ottimizzata del codice. Per impostazione predefinita, hai configurato il tuo progetto per compilare la versione di debug. Esaminiamo il progetto per creare una compilazione ottimizzata. Per spiegare a Waf che deve creare compilazioni ottimizzate, inclusi esempi e test, dovrai eseguire i seguenti comandi:
$ .\/waf clean
$ .\/waf configure --build-profile=optimized --enable-examples --enable-testsQuesto avvierà Waf fuori dalla directory locale (per tua comodità). Il primo comando esegue una pulizia dalla precedente compilazione, che generalmente non è strettamente necessaria, ma è una buona pratica (vedi anche i profili di compilazione di seguito); questo rimuoverà le librerie e i file oggetto precedentemente creati presenti nella directory build\/. Quando il progetto è riconfigurato e il sistema di compilazione verifica le varie dipendenze, dovresti vedere un output simile al seguente:
Impostazione di top a : /home/ns3user/workspace/bake/source/ns-3-dev
Impostazione di uscita a : /home/ns3user/workspace/bake/source/ns-3-dev/build
Controllo di 'gcc' (compilatore C) : /usr/bin/gcc
Controllo della versione di cc : 7.3.0
Controllo di 'g++' (compilatore C++) : /usr/bin/g++
Controllo del flag di compilazione -march=native supporto : ok
Controllo del flag di compilazione -Wl,--soname=foo supporto : ok
Controllo del flag di compilazione -std=c++11 supporto : ok
Controllo degli include di boost : intestazioni non trovate, per favore,!fornire un argomento --boost-includes (vedi aiuto)
Controllo degli include di boost : intestazioni non trovate, per favore,!fornire un argomento --boost-includes (vedi aiuto)
Controllo del programma 'python' : /usr/bin/python
Controllo della versione di python >= 2.3 : 2.7.15 python-config : /usr/bin/python-config
Richiesta a python-config per le flag pyembed '--cflags --libs --ldflags' : sì
Test della configurazione pyembed : sì
Richiesta a python-config per le flag pyext '--cflags --libs --ldflags' : sì
Test della configurazione pyext : sì
Controllo del flag di compilazione -fvisibility=hidden supporto : ok
Controllo del flag di compilazione -Wno-array-bounds supporto : ok
Controllo della posizione di pybindgen : ../pybindgen ,!(stimato)
Controllo del modulo python 'pybindgen' : 0.19.0. ,!post4+g823d8b2
Controllo della versione di pybindgen : 0.19.0. ,!post4+g823d8b2
Controllo dello snippet di codice : sì
Controllo dell'equivalenza dei tipi uint64_t e unsigned long : no
Controllo dello snippet di codice : no
Controllo dell'equivalenza dei tipi uint64_t e unsigned long long : sì
Controllo degli apidefs utilizzabili per i binding Python : gcc-LP64
Controllo del cxxabi interno GCC : completo
Controllo del modulo python 'pygccxml' : non trovato
Controllo della posizione di click : non trovato
Controllo del programma 'pkg-config' : /usr/bin/pkg- ,!config
Controllo di 'gtk+-3.0' : non trovato
Controllo di 'libxml-2.0' : sì
controllo per uint128_t : non trovato
controllo per __uint128_t : sì
Controllo dell'implementazione ad alta precisione : intero a 128 bit ,!(predefinito)
Controllo dell'intestazione stdint.h : sì
Controllo dell'intestazione inttypes.h : sì
Controllo dell'intestazione sys/inttypes.h : non trovato
Controllo dell'intestazione sys/types.h : sì
Controllo dell'intestazione sys/stat.h : sì
Controllo dell'intestazione dirent.h : sì
Controllo dell'intestazione stdlib.h : sì
Controllo dell'intestazione signal.h : sì
Controllo dell'intestazione pthread.h : sì
Controllo dell'intestazione stdint.h : sì
Controllo dell'intestazione inttypes.h : sì
Controllo dell'intestazione sys/inttypes.h : non trovato
Controllo della libreria rt : sì
Controllo dell'intestazione sys/ioctl.h : sì
Controllo dell'intestazione net/if.h : sì
Controllo dell'intestazione net/ethernet.h : sì
Controllo dell'intestazione linux/if_tun.h : sì
Controllo dell'intestazione netpacket/packet.h : sì
Controllo della posizione di NSC : non trovato
Controllo di 'sqlite3' : non trovato
Controllo dell'intestazione linux/if_tun.h : sì
Controllo del modulo python 'gi' : 3.26.1
Controllo del modulo python 'gi.repository.GObject' : ok
Controllo del modulo python 'cairo' : ok
Controllo del modulo python 'pygraphviz' : 1.4rc1
Controllo del modulo python 'gi.repository.Gtk' : ok
Controllo del modulo python 'gi.repository.Gdk' : ok
Controllo del modulo python 'gi.repository.Pango' : ok
Controllo del modulo python 'gi.repository.GooCanvas' : ok
Controllo del programma 'sudo' : /usr/bin/sudo
Controllo del programma 'valgrind' : non trovato
Controllo di 'gsl' : non trovato python-config : non trovato
Controllo del flag di compilazione -fstrict-aliasing supporto : ok
Controllo del flag di compilazione -fstrict-aliasing supporto : ok
Controllo del flag di compilazione -Wstrict-aliasing supporto : ok
Controllo del flag di compilazione -Wstrict-aliasing supporto : ok
Controllo del programma 'doxygen' : /usr/bin/doxygen
---- Riepilogo delle funzionalità opzionali di ns-3:
Profilo di build : ottimizzato
Directory di build :
Integrazione BRITE : non abilitata (BRITE non abilitato (vedi opzione --with- ,!brite))
Raccolta eventi di metriche DES : non abilitata (predefinito disabilitato)
Emulazione FdNetDevice : abilitata
Esempi : abilitati
File descriptor NetDevice : abilitato
Libreria Scientifica GNU (GSL) : non abilitata (GSL non trovato)
Libreria Gcrypt : non abilitata
(libgcrypt non trovato: puoi usare ,!libgcrypt-config per trovare la sua posizione.) GtkConfigStore : non abilitata (libreria 'gtk+-3.0 >= 3.0' non trovata)
Supporto MPI : non abilitato (opzione --enable-mpi non selezionata)
Integrazione ns-3 Click : non abilitata (nsclick non abilitato (vedi opzione --with- ,!nsclick))
Integrazione ns-3 OpenFlow : non abilitata (Librerie boost richieste non trovate)
Cradle di simulazione di rete : non abilitato (NSC non trovato (vedi opzione --with-nsc))
PlanetLab FdNetDevice : non abilitato (sistema operativo PlanetLab non rilevato ,!(vedi opzione --force-planetlab)) Visualizzatore PyViz : abilitato
Supporto alla scansione dell'API Python : non abilitato (Modulo Python 'pygccxml' mancante)
Binding Python : abilitati
Simulatore in tempo reale : abilitato
Output dei dati statistici SQlite : non abilitato (libreria 'sqlite3' non trovata)
Tap Bridge : abilitato
Tap FdNetDevice : abilitato
Test : abilitati
Primitive di threading : abilitati
Usa sudo per impostare il bit suid : non abilitato (opzione --enable-sudo non selezionata)
XmlIo : abilitato
'configure' completato con successo (6.387s)Fai attenzione all'ultima parte del codice citato sopra. Alcune opzioni di ns-3 non sono incluse per impostazione predefinita o richiedono il supporto del sistema per funzionare correttamente. Ad esempio, per abilitare XmlTo, deve essere presente la libreria libxml-2.0. Se questa libreria non è stata trovata e la relativa funzione di ns-3 non è stata abilitata, verrà visualizzato un messaggio. Inoltre, tieni presente che esiste la possibilità di utilizzare il comando sudo per impostare il bit suid «impostazione ID gruppo durante l'esecuzione» per alcuni programmi. Non è abilitato per impostazione predefinita e quindi questa funzione appare come «non abilitata» («not enabled»). Infine, per ottenere un elenco delle opzioni abilitate, usa Waf con il parametro --check-config.
Ora torniamo e passiamo di nuovo alla build di debug che contiene esempi e test.
$ ./waf clean
$ ./waf configure --build-profile=debug --enable-examples --enable-testsIl sistema di build è ora configurato e puoi compilare le versioni di debug dei programmi ns-3 semplicemente digitando:
$ ./wafAnche se i passaggi descritti sopra ti hanno costretto a compilare parte del sistema ns-3 due volte, ora sai come modificare la configurazione e compilare codice ottimizzato.
Per verificare quale profilo è attivo per questa configurazione di progetto, esiste il comando:
$ ./waf --check-profile
Waf: Entrando nella directory `/path/to/ns-3-allinone/ns-3.29/build'
Profilo di build: debugLo scenario considerato sopra build.py supporta anche argomenti --enable-examples e --enable-tests, ma altre opzioni Waf non sono supportate direttamente. Ad esempio, questo non funzionerà:
$ ./build.py --disable-pythonla risposta sarà:
build.py: errore: nessuna tale opzione: --disable-pythonTuttavia, un operatore speciale -– può essere utilizzato per passare parametri aggiuntivi tramite waf, quindi invece di quanto sopra funzionerà il seguente comando:
$ ./build.py -- --disable-pythonpoiché genera il comando principale ./waf configure —disable-python. Ecco ulteriori suggerimenti introduttivi su Waf.
Gestione degli errori di compilazione
Le release di ns-3 sono state testate con gli ultimi compilatori C++ disponibili al momento del rilascio su distribuzioni comuni di Linux e MacOS. Tuttavia, nel tempo, vengono rilasciate nuove distribuzioni con nuovi compilatori, e questi compilatori più recenti tendono a essere più rigorosi riguardo agli avvisi. ns-3 configura la propria build per trattare tutti gli avvisi come errori, quindi a volte, se si utilizza una versione più vecchia su un sistema più nuovo, un avviso del compilatore può fermare la compilazione.
Ad esempio, in precedenza c'era il rilascio di ns-3.28 per Fedora 28, che includeva una nuova versione principale gcc (gcc-8). Compilando il rilascio di ns-3.28 o versioni precedenti su Fedora 28, con Gtk2+ installato, si verificherà l'errore:
/usr/include/gtk-2.0/gtk/gtkfilechooserbutton.h:59:8: error: unnecessary parentheses ,!in declaration of ‘__gtk_reserved1’ [-Werror=parentheses] void (*__gtk_reserved1);Nei rilasci a partire da ns-3.28.1, è Waf disponibile un'opzione per risolvere questi problemi. Essa disabilita l'impostazione del flag «-Werror» in g++ e clang++. Questa opzione è «—disable-werror», e deve essere applicata durante la configurazione:
$ ./waf configure --disable-werror --enable-examples --enable-testsConfigurare o costruire
Alcuni comandi Waf hanno senso solo nella fase di configurazione, mentre altri funzionano solo nella fase di costruzione. Ad esempio, se desideri utilizzare le funzionalità di emulazione di ns-3, puoi abilitare l'impostazione del bit suid utilizzando sudo, come descritto sopra. Questo annullerà i comandi della fase di configurazione, e così potrai modificare la configurazione utilizzando il seguente comando, che include anche esempi e test.
$ ./waf configure --enable-sudo --enable-examples --enable-testsSe lo fai, Waf eseguirà sudo, per modificare i programmi di creazione dei socket per l'emulazione per essere eseguiti con i diritti root. In Waf sono disponibili molte altre opzioni per le fasi di configurazione e costruzione. Per esplorare le opzioni, digita:
$ ./waf --helpNella sezione successiva utilizzeremo alcune opzioni relative ai test.
Profili di compilazione
Abbiamo già visto come configurare Waf per le compilazioni debug e ottimizzate:
$ ./waf --build-profile=debugC'è anche un profilo di compilazione intermedio, release. L'opzione -d è un sinonimo di --build-profile. Il profilo di compilazione gestisce l'uso del logging, delle affermazioni e delle chiavi di ottimizzazione del compilatore:
Come si può vedere, il logging e le asserzioni sono disponibili solo nelle build di debug. La pratica consigliata consiste nello sviluppare il proprio script in modalità di debug, quindi eseguire ripetutamente i test (per la statistica o per modificare i parametri) in una build ottimizzata.
Se hai codice che deve essere eseguito solo in determinati profili di build, utilizza il macro Code Wrapper Macro:
NS_BUILD_DEBUG (std::cout << "Parte di una riga di output..." << std::flush; timer.Start ,!()); DoLongInvolvedComputation (); NS_BUILD_DEBUG (timer.Stop (); std::cout << "Fatto: " << timer << std::endl;)Per impostazione predefinita, Waf posiziona gli artefatti di build nella directory di build. Puoi specificare una directory di output diversa utilizzando l'opzione - -out, per esempio:
$ .\/waf configure --out=my-build-dirCombinando questo con i profili di build, puoi facilmente passare tra diverse opzioni di compilazione:
$ .\/waf configure --build-profile=debug --out=build\/debug $ .\/waf build ... $ .\/waf configure --build-profile=optimized --out=build\/optimized $ .\/waf build ...Ciò ti consente di lavorare con più build senza dover riscrivere ogni volta l'ultima build. Quando passi a un altro profilo, Waf compila solo quello, senza una ricompilazione completa di tutto.
Quando cambi in questo modo i profili di build, devi prestare attenzione a fornire sempre gli stessi parametri di configurazione. Puoi evitare errori definendo diverse variabili di ambiente:
$ 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 buildCompilatori e flag
Negli esempi sopra Waf per la build di ns‑3 utilizza il compilatore C++ di GCC ( g++). Tuttavia, è possibile cambiare il compilatore Waf C++ utilizzato, definendo la variabile di ambiente CXX. Ad esempio, per utilizzare il compilatore C++ Clang, clang++,
$ CXX="clang++" .\/waf configure $ .\/waf build Allo stesso modo puoi configurare Waf per utilizzare la compilazione distribuita con distcc:
$ CXX="distcc g++" .\/waf configure $ .\/waf buildUlteriori informazioni su distcc e sulla compilazione distribuita possono essere trovate nella pagina del progetto nella sezione "Documentazione". Per aggiungere flag del compilatore durante la configurazione di ns‑3, utilizza la variabile di ambiente CXXFLAGS_EXTRA.
Installazione
Waf può essere utilizzato per installare le librerie in diverse posizioni del sistema. Per impostazione predefinita, le librerie e i file eseguibili compilati si trovano nella directory build, e poiché Waf conosce la posizione di queste librerie e file eseguibili, non è necessario installare le librerie altrove.
Se gli utenti preferiscono un'installazione al di fuori della directory di compilazione, possono eseguire il comando ./waf install. Per impostazione predefinita, il prefisso per l'installazione è /usr/local, quindi ./waf install installerà i programmi in /usr/local/bin, le librerie in /usr/local/lib e i file header in /usr/local/include. I diritti da superutente sono generalmente necessari per installare con il prefisso predefinito, quindi il comando tipico sarà sudo ./waf install. Durante l'esecuzione, Waf preferirà prima utilizzare le librerie comuni nella directory di compilazione e poi cercherà le librerie nel percorso delle librerie impostato nell'ambiente locale. Quindi, quando si installano librerie nel sistema, è buona prassi controllare che vengano utilizzate le librerie corrette. Gli utenti possono scegliere di installare con un altro prefisso passando durante la configurazione l'opzione --prefix, per esempio:
./waf configure --prefix=/opt/localSe in un secondo momento, dopo la compilazione, l'utente inserisce il comando di installazione .\/waf, verrà utilizzato il prefisso /opt/local.
Team ./waf clean dovrebbe essere utilizzato prima di riconfigurare il progetto, se l'installazione sarà effettuata Waf con un prefisso diverso.
Pertanto, per utilizzare ns‑3 non è necessario chiamare ./waf install. La maggior parte degli utenti non avrà bisogno di questo comando, poiché Waf prenderà le librerie correnti dalla directory di compilazione, ma alcuni utenti potrebbero trovarlo utile se la loro attività implica lavorare con programmi al di fuori della directory ns‑3.
Waf unico
Nella parte superiore dell'albero del codice sorgente di ns‑3 esiste solo uno script Waf. Una volta iniziato a lavorare, trascorrerai molto tempo nella directory scratch/ o più in profondità, insrc/... e magari avere la necessità di eseguire Waf. Puoi semplicemente tenere a mente dove ti trovi e avviare Waf nel seguente modo:
$ ../../../waf ...ma questo sarà noioso e soggetto a errori, quindi ci sono soluzioni migliori. Uno dei modi comuni è utilizzare un editor di testo, come emacs o vim, in cui si aprono due sessioni terminali, una usata per compilare ns‑3 e l'altra per modificare il codice sorgente. Se hai solo tarball, potrebbe aiutare la variabile d'ambiente:
$ export NS3DIR="$PWD"
$ function waff { cd $NS3DIR && ./waf $* ; }
$ cd scratch
$ waff buildPuò sembrare allettante aggiungere uno script waf triviale nella directory del modulo come esempio exec ../../waf. Per favore, non farlo. Questo confonde i principianti e, se eseguito male, porta a errori di compilazione difficili da rilevare. Le soluzioni mostrate sopra sono il percorso da seguire.
3.5 Testare ns-3
Puoi eseguire i test modulari della distribuzione ns-3 eseguendo lo script ./test.py:
$ ./test.pyQuesti test vengono eseguiti in parallelo con Waf. Alla fine dovresti vedere un messaggio che indica che
92 su 92 test superati (92 superati, 0 falliti, 0 crash, 0 errori valgrind)Questo è un messaggio importante per identificare guasti, crash o errori di valgrind, che indica problemi con il codice o incompatibilità tra strumenti e codice.
Vedrai anche l'output finale di Waf e del tester che esegue ciascun test, che apparirà all'incirca così:
Waf: Entrando nella directory `/path/to/workspace/ns-3-allinone/ns-3-dev/build'
Waf: Uscendo dalla directory `/path/to/workspace/ns-3-allinone/ns-3-dev/build'
'build' completato con successo (1.799s)
Moduli costruiti:
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 su 92 test superati (92 superati, 0 falliti, 0 crash, 0 errori valgrind)
Questo comando viene solitamente eseguito dagli utenti per una rapida verifica della correttezza della compilazione della distribuzione ns-3. (Nota che l'ordine delle righe «PASS: …» può differire, è normale. L'importante è che nell'ultima riga alla fine del rapporto tutte le verifiche siano risultate positive; nessun test è fallito o è andato in crash.) E Waf, e test.py parallelizzerà il lavoro sui core disponibili della macchina.
3.6 Eseguire lo script
Di solito eseguiamo script sotto il controllo Waf. Questo permette al sistema di build di garantire che i percorsi delle librerie condivise siano impostati correttamente e che le librerie siano disponibili durante l'esecuzione. Per eseguire il programma, basta usare Waf con il parametro - -run. Eseguiamo per ns-3 l'equivalente del programma onnipresente ciao mondo, digitando quanto segue:
$ ./waf --run hello-simulatorWaf verificherà innanzitutto che il programma sia stato compilato correttamente e, se necessario, eseguirà la compilazione. Poi Waf eseguirà il programma che produrrà il seguente output.
Hello SimulatorCongratulazioni! Ora sei un utente di ns‑3!
Cosa posso fare se non vedo il risultato?
Se vedi messaggi Waf, che indicano che la compilazione è stata completata con successo, ma non vedi l'output "Hello Simulator", è probabile che tu abbia cambiato la tua modalità di compilazione nella sezione [Compilazione-con-Waf] ottimizzate, ma hai saltato il passaggio per tornare alla modalità debug. Tutto l'output della console utilizzato in questo documento utilizza un componente speciale di ns‑3, che esegue la registrazione, ed è applicato per stampare messaggi personalizzati sulla console. L'output di questo componente è automaticamente disabilitato durante la compilazione di codice ottimizzato—è "ottimizzato". Se non vedi l'output "Hello Simulator", inserisci quanto segue:
$ .\/waf configure --build-profile=debug --enable-examples --enable-testsper configurare Waf la compilazione delle versioni di debug dei programmi ns‑3, che includono esempi e test. Poi devi ricompilare l'ultima versione di debug del codice, digitando
$ ./wafOra, se esegui il programma hello-simulator, dovresti vedere il risultato previsto.
3.6.1 Argomenti della riga di comando
Per passare argomenti della riga di comando al programma ns‑3, utilizza questo modello:
$ .\/waf --run --command-template="%s "Sostituisci con il nome del tuo programma e con gli argomenti. L'argomento - -command-template per Waf è, in sostanza, una ricetta per costruire la riga di comando effettiva Waf utilizzata per eseguire il programma. Waf verifica che la compilazione sia avvenuta e imposta i percorsi alla libreria comune, quindi, utilizzando il modello di riga di comando fornito e sostituendo il nome del programma al segnaposto %s, chiama il file eseguibile. Se questo tipo di sintassi ti sembra complicato, esiste una versione più semplice che include il programma ns‑3 e i suoi argomenti racchiusi tra virgolette singole:
$ .\/waf --run ' --arg1=value1 --arg2=value2 ...'Un altro esempio particolarmente utile è l'esecuzione selettiva di set di test. Supponiamo che ci sia un insieme di test (suite) mytest (in realtà non esiste). Prima abbiamo utilizzato lo script .\/test.py per eseguire in parallelo una serie di test, il che chiama ripetutamente il programma di test test-runner. Chiamata test-runner direttamente per eseguire un test:
$ .\/waf --run test-runner --command-template="%s --suite=mytest --verbose"I parametri verranno passati al programma test-runner. Poiché mytest non esiste, verrà generato un messaggio di errore. Per stampare i parametri disponibili di test-runner, digita:
$ .\/waf --run test-runner --command-template="%s --help"3.6.2 Debugging
Per eseguire programmi ns-3 sotto il controllo di un'altra utility, come un debugger (ad esempio, gdb) o uno strumento di verifica della memoria (ad esempio, valgrind), utilizza una forma analoga - -command-template = "…". Ad esempio, per eseguire nel debugger gdb il tuo programma hello-simulator ns-3 con parametri:
$ .\/waf --run=hello-simulator --command-template="gdb %s --args "Nota che il nome del programma ns-3 va con un argomento - -run, e l'utility di gestione (qui gdb) è il primo token nell'argomento - -command-template. L'opzione - -args riferiscono gdb, mentre il resto della riga di comando appartiene al programma "inferiore". (Alcune versioni gdb non comprendono l'opzione - -args. In questo caso, rimuovi i parametri del programma da - -command-template e utilizza un insieme di comandi gdb args.) Possiamo combinare questa ricetta con la precedente per eseguire un test sotto il debugger:
$ .\/waf --run test-runner --command-template="gdb %s --args --suite=mytest --verbose"3.6.3 Directory di lavoro
Waf deve essere eseguito dalla sua posizione nella parte superiore della directory di ns-3. Questa cartella diventa la directory di lavoro, dove verranno scritti i file di output. Ma cosa fare se desideri conservare questi file al di fuori della directory del codice sorgente di ns-3? Usa il parametro - -cwd:
$ .\/waf --cwd=...Potrebbe essere più comodo ottenere i file di output nella tua directory di lavoro. In questo caso, potrebbe aiutarti un'azione indiretta come questa:
$ function waff {
CWD="$PWD"
cd $NS3DIR >\/dev\/null
.\/waf --cwd="$CWD" $*
cd - >\/dev\/null
}Questa decorazione della versione precedente del comando mantiene la directory di lavoro attuale, passa alla directory Waf, e poi istruisce Waf di cambiare la directory di lavoro indietro in quella salvata prima di eseguire il programma nella directory di lavoro corrente. Menziamo il comando - -cwd per completezza, la maggior parte degli utenti esegue semplicemente Waf dalla directory di alto livello e genera lì i file di output.
Fonte: habr.com
