ProHoster > Blog > Pangangasiwa > Tutorial sa ns-3 network simulator. Kabanata 4

Tutorial sa ns-3 network simulator. Kabanata 4

Tutorial sa ns-3 network simulator. Kabanata 4
kabanata 1,2
kabanata 3

4 Pangkalahatang-ideya ng konsepto
4.1 Mga pangunahing abstraction
4.1.1 Node
4.1.2 Paglalapat
4.1.3 Channel
4.1.4 Net Device
4.1.5 Topological assistants
4.2 Unang ns-3 script
4.2.1 Boilerplate code
4.2.2 Mga Plug-in
4.2.3 ns3 namespace
4.2.4 Pag-log
4.2.5 Pangunahing function
4.2.6 Paggamit ng mga topology assistant
4.2.7 Paggamit ng Application
4.2.8 Simulator
4.2.9 Pagbuo ng iyong script
4.3 ns-3 Source code

Kabanata 4

Pangkalahatang-ideya ng konsepto

Ang unang bagay na kailangan nating gawin bago tayo magsimulang matuto o magsulat ng ns-3 code ay ipaliwanag ang ilang pangunahing konsepto at abstraction sa system. Karamihan sa mga ito ay maaaring mukhang halata sa ilan, ngunit inirerekumenda namin na maglaan ng oras upang basahin ang seksyong ito upang matiyak na nagsisimula ka sa isang matatag na pundasyon.

4.1 Mga pangunahing abstraction

Sa seksyong ito, titingnan natin ang ilang termino na karaniwang ginagamit sa web ngunit may partikular na kahulugan sa ns-3.

4.1.1 Node

Sa Internet jargon, ang isang computer device na kumokonekta sa isang network ay tinatawag na host o minsan ay end system. Dahil ang ns-3 ay isang network simulator at hindi isang Internet simulator, sadyang hindi namin ginagamit ang terminong host, dahil ito ay malapit na nauugnay sa Internet at sa mga protocol nito. Sa halip, gumagamit kami ng mas pangkalahatang termino, na ginagamit din ng iba pang mga simulator, na nagmula sa teorya ng graph: node (buko).

Sa ns-3, ang pinagbabatayan na abstraction ng isang computing device ay tinatawag na node. Ang abstraction na ito ay kinakatawan sa C++ ng Node class. Klase NodeNode (node) ay nagbibigay ng mga pamamaraan para sa pagmamanipula ng mga representasyon ng mga computing device sa mga simulation.

Dapat maintindihan mo Node tulad ng isang computer kung saan ka magdagdag ng functionality. Magdaragdag ka ng mga bagay tulad ng mga application, protocol stack, at peripheral card na may mga driver na nagbibigay-daan sa computer na gumawa ng kapaki-pakinabang na gawain. Ginagamit namin ang parehong pangunahing modelo sa ns-3.

4.1.2 Paglalapat

Sa pangkalahatan, nahahati ang software ng computer sa dalawang malawak na klase. Ang software ng system ay nag-aayos ng iba't ibang mapagkukunan ng computer tulad ng memorya, mga cycle ng processor, disk, network, atbp. ayon sa ilang modelo ng computing. Karaniwang hindi ginagamit ng system software ang mga mapagkukunang ito upang magsagawa ng mga gawain na direktang nakikinabang sa user. Ang isang user ay karaniwang nagpapatakbo ng isang application upang makamit ang isang partikular na layunin, na kumukuha at gumagamit ng mga mapagkukunan na kinokontrol ng software ng system.

Kadalasan ang linya ng paghihiwalay sa pagitan ng system at application software ay iginuhit sa mga pagbabago sa antas ng pribilehiyo na nangyayari sa mga bitag ng operating system. Ang ns-3 ay walang tunay na konsepto ng isang operating system at samakatuwid ay walang konsepto ng mga antas ng pribilehiyo o mga tawag sa system. Gayunpaman, mayroon kaming ideya para sa isang app. Tulad ng sa "tunay na mundo" na mga application ng software na tumatakbo sa mga computer upang magsagawa ng mga gawain, ang mga ns-3 application ay tumatakbo sa mga ns-3 node upang kontrolin ang mga simulation sa simulate na mundo.

Sa ns-3, ang pangunahing abstraction para sa isang user program na bumubuo ng ilang aktibidad para sa pagmomodelo ay isang application. Ang abstraction na ito ay kinakatawan sa C++ ng klase ng Application. Ang klase ng Application ay nagbibigay ng mga pamamaraan para sa pagmamanipula ng mga view ng aming bersyon sa antas ng user ng mga application sa mga simulation. Inaasahan ng mga developer na dalubhasa ang klase ng Application sa isang object-oriented programming sense upang lumikha ng mga bagong application. Sa tutorial na ito, gagamitin namin ang mga espesyalisasyon ng klase ng Application na tinatawag UdpEchoClientApplication ΠΈ UdpEchoServerApplication. Gaya ng maaari mong asahan, ang mga application na ito ay bumubuo ng isang set ng mga client/server application na ginagamit upang bumuo at mag-echo ng mga network packet.

4.1.3 Channel

Sa totoong mundo, maaari mong ikonekta ang isang computer sa isang network. Kadalasan ang media kung saan ipinapadala ang data sa mga network na ito ay tinatawag na mga channel. Kapag nagsaksak ka ng Ethernet cable sa isang saksakan sa dingding, ikinokonekta mo ang iyong computer sa isang Ethernet link. Sa simulate na mundo ng ns-3, ang isang node ay konektado sa isang bagay na kumakatawan sa isang channel ng komunikasyon. Dito, ang pangunahing abstraction ng subnetwork ng komunikasyon ay tinatawag na channel at kinakatawan sa C++ ng klase ng Channel.

klase ChannelChannel nagbibigay ng mga pamamaraan para sa pamamahala ng pakikipag-ugnayan ng mga subnet na bagay at pagkonekta ng mga node sa kanila. Ang mga channel ay maaari ding maging dalubhasa ng mga developer sa isang object-oriented na programming sense. Ang espesyalisasyon ng channel ay maaaring magmodelo ng isang bagay na kasing simple ng isang wire. Ang isang nakatuong channel ay maaari ding magmodelo ng mga kumplikadong bagay tulad ng isang malaking Ethernet switch o isang three-dimensional na espasyo na puno ng mga hadlang sa kaso ng mga wireless network.

Gagamitin namin ang mga espesyal na bersyon ng channel sa tutorial na ito na tinatawag CsmaChannelCsmaChannel, PointToPointChannelPointToPointChannel ΠΈ WifiChannelWifiChannel. CsmaChannel, halimbawa, nagmomodelo ng bersyon ng isang subnet ng komunikasyon na nagpapatupad ng kapaligiran ng komunikasyong maramihang pag-access sa carrier-sense. Ito ay nagbibigay sa amin ng Ethernet-like functionality.

4.1.4 Net Device

Dati, kung gusto mong ikonekta ang isang computer sa isang network, kailangan mong bumili ng isang partikular na network cable at isang hardware device na tinatawag (sa terminolohiya ng PC) isang peripheral card na kailangang i-install sa computer. Kung ang isang peripheral card ay nagpatupad ng ilang mga function ng networking, ang mga ito ay tinatawag na network interface card o network card. Ngayon, karamihan sa mga computer ay may pinagsamang network interface hardware at hindi nakikita ng mga user bilang mga hiwalay na device.

Ang isang network card ay hindi gagana nang walang software driver na kumokontrol sa hardware nito. Sa Unix (o Linux), ang isang piraso ng peripheral na kagamitan ay inuri bilang isang aparato. Ang mga device ay pinamamahalaan gamit ang mga device driver, at ang mga network device (NICs) ay pinamamahalaan gamit ang network device drivers (mga driver ng network device) at sama-samang tinatawag na mga network device (mga kagamitan sa net). Sa Unix at Linux, tinutukoy mo ang mga device sa network sa pamamagitan ng mga pangalan tulad ng eth0.

Sa ns-3, sinasaklaw ng abstraction ng network device ang parehong driver ng software at ang hardware na inemodelo. Sa simulation, ang isang network device ay "naka-install" sa isang node upang payagan itong makipag-ugnayan sa iba pang mga node sa pamamagitan ng mga channel. Tulad ng isang tunay na computer, ang isang node ay maaaring konektado sa maraming channel sa pamamagitan ng maraming device Mga NetDevice.

Ang abstraction ng network ng isang device ay kinakatawan ng klase sa C++ NetDevice. Klase NetDevice nagbibigay ng mga pamamaraan para sa pamamahala ng mga koneksyon sa Node at Channel object; at maaaring maging dalubhasa ng mga developer sa kahulugan ng object-oriented na programming. Sa tutorial na ito ay gagamit kami ng ilang espesyal na bersyon ng NetDevice na tinatawag CsmaNetDevice, PointToPointNetDevice ΠΈ WifiNetDevice. Tulad ng isang Ethernet network adapter na idinisenyo upang gumana sa isang network Ethernet, CsmaNetDevice dinisenyo upang magtrabaho kasama CsmaChannel, PointToPointNetDevice dinisenyo upang magtrabaho kasama PointToPointChannelAt WifiNetDevice - dinisenyo upang magtrabaho kasama WifiChannel.

4.1.5 Topological assistants

Sa isang tunay na network, makakahanap ka ng mga host computer na may mga network card na idinagdag (o built-in). Sa ns-3 sasabihin namin na makakakita ka ng mga node na may nakalakip na NetDevices. Sa isang malaking simulate na network, kakailanganin mong ayusin ang mga koneksyon sa pagitan ng maraming bagay Node, NetDevice ΠΈ channel.

Dahil sa pagkonekta sa NetDevices sa mga node, NetDevices sa mga link, pagtatalaga ng mga IP address, atbp. sa ns-3 ay isang karaniwang gawain, upang gawin itong mas madali hangga't maaari ay nagbibigay kami ng mga tinatawag na topology helper. Halimbawa, upang lumikha ng NetDevice, kailangan mong magsagawa ng maraming ns-3 kernel operations, magdagdag ng MAC address, i-install ang network device sa Node, i-configure ang protocol stack ng node, at pagkatapos ay ikonekta ang NetDevice sa Channel. Higit pang trabaho ang kakailanganin upang ikonekta ang maraming device sa mga multipoint na link at pagkatapos ay ikonekta ang mga indibidwal na network sa isang Internetworks network. Nagbibigay kami ng mga topology helper object na pinagsama ang maraming operasyong ito sa isang madaling gamitin na modelo para sa iyong kaginhawahan.

4.2 Unang ns-3 script

Kung na-install mo ang system tulad ng iminungkahing sa itaas, magkakaroon ka ng ns-3 release sa isang direktoryo na tinatawag na repos sa iyong home directory. Pumunta sa direktoryo pakawalan

Kung wala kang ganoong direktoryo, nangangahulugan ito na hindi mo tinukoy ang direktoryo ng output kapag binuo ang bersyon ng release ng ns-3, bumuo ng ganito:
$ ./waf configure β€”build-profile=release β€”out=build/release,
$ ./waf build

doon dapat mong makita ang isang istraktura ng direktoryo na katulad ng sumusunod:

AUTHORS       examples      scratch       utils       waf.bat*
bindings      LICENSE       src           utils.py    waf-tools
build         ns3           test.py*      utils.pyc   wscript
CHANGES.html  README        testpy-output VERSION     wutils.py
doc           RELEASE_NOTES testpy.supp   waf*        wutils.pyc

Pumunta sa direktoryo mga halimbawa/tutorial. Dapat mong makita ang isang file na matatagpuan doon na tinatawag una.cc. Ito ay isang script na lilikha ng isang simpleng point-to-point na koneksyon sa pagitan ng dalawang node at magpapadala ng isang packet sa pagitan ng mga node. Tingnan natin ang script na ito sa bawat linya; para magawa ito, buksan ang first.cc sa iyong paboritong editor.

4.2.1 Boilerplate code
Ang unang linya sa file ay ang editor mode line emacs. Sinasabi nito sa mga emac ang tungkol sa mga formatting convention (coding style) na ginagamit namin sa aming source code.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

Ito ay palaging isang kontrobersyal na isyu, kaya kailangan nating itakda ang rekord upang maalis ito kaagad. Ang proyekto ng ns-3, tulad ng karamihan sa malalaking proyekto, ay nagpatibay ng istilo ng coding na dapat sundin ng lahat ng naiambag na code. Kung gusto mong i-ambag ang iyong code sa proyekto, sa kalaunan ay kailangan mong sumunod sa ns-3 coding standard, gaya ng inilarawan sa file doc/codingstd.txt o ipinapakita sa web page ng proyekto: https://www.nsnam.org/develop/contributing-code/coding-style/.

Inirerekomenda namin na masanay ka sa hitsura at pakiramdam ng ns-3 code at ilapat ang pamantayang ito sa tuwing gagana ka sa aming code. Ang buong development team at mga kontribyutor ay sumang-ayon dito pagkatapos ng ilang pag-ungol. Pinapadali ng linya ng emacs mode sa itaas ang pag-format nang tama kung ginagamit mo ang editor ng emacs.

Ang ns-3 simulator ay lisensyado gamit GNU General Public License. Makikita mo ang naaangkop na GNU legal na header sa bawat ns-3 distribution file. Kadalasan ay makakakita ka ng abiso sa copyright para sa isa sa mga kalahok na institusyon sa proyekto ng ns-3 sa itaas ng teksto at may-akda ng GPL, na ipinapakita sa ibaba.

/* 
* This program is free software; you can redistribute it and/or modify 
* it under the terms of the GNU General Public License version 2 as 
* published by the Free Software Foundation; 
*
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU General Public License for more details. 
* 
* You should have received a copy of the GNU General Public License 
* along with this program; if not, write to the Free Software 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
*/

4.2.2 Mga Plug-in

Ang code mismo ay nagsisimula sa isang serye ng mga pahayag ng pagsasama (isama).

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"

Upang matulungan ang aming mga user ng high-level na scripting na makayanan ang malaking bilang ng mga file ng header na nasa system, pinapangkat namin ang mga ito ayon sa kanilang paggamit sa malalaking module. Nagbibigay kami ng isang file ng header na muling maglo-load ng lahat ng mga file ng header na ginamit sa isang partikular na module. Sa halip na hanapin kung ano mismo ang header na kailangan mo at posibleng makuha ang tamang listahan ng mga dependency, binibigyan ka namin ng kakayahang mag-download ng isang pangkat ng mga file sa napakahusay na granularity. Hindi ito ang pinaka mahusay na diskarte, ngunit tiyak na ginagawang mas madali ang pagsusulat ng mga script.

Ang bawat isa sa ns-3 kasama ang mga file ay inilalagay sa isang direktoryo na pinangalanan ns3 (bumuo ng subdirectory) upang maiwasan ang mga salungatan sa pangalan ng file sa panahon ng proseso ng pagbuo. file ns3/core-module.h tumutugma sa ns-3 module, na makikita mo sa direktoryo src/core sa release na iyong na-install. Sa listahan ng direktoryo na ito makikita mo ang isang malaking bilang ng mga file ng header. Kapag ginawa mo ang pagpupulong, Waf naglalagay ng mga pampublikong file ng header sa direktoryo ng ns3 sa isang subdirectory build/debug

Kung wala kang ganoong direktoryo, nangangahulugan ito na hindi mo tinukoy ang direktoryo ng output kapag binuo ang bersyon ng release ng ns-3, bumuo ng ganito:
$ ./waf configure --build-profile=debug --out=build/debug
$ ./waf build
o
$ ./waf configure --build-profile=optimized --out=build/optimized
$ ./waf build

o bumuo/na-optimize, depende sa iyong configuration. Waf ay awtomatikong bubuo din ng isang module na may kasamang file upang i-load ang lahat ng mga pampublikong header file. Dahil siyempre sinusunod mo ang gabay na ito sa relihiyon, nagawa mo na

$ ./waf -d debug --enable-examples --enable-tests configure

upang i-configure ang proyekto upang magpatakbo ng mga debug build na may kasamang mga halimbawa at pagsubok. Ginawa mo rin

$ ./waf

upang tipunin ang proyekto. Kaya ngayon kapag tumingin ka sa direktoryo ../../build/debug/ns3, pagkatapos ay makikita mo, bukod sa iba pa, ang mga file ng header ng apat na module na ipinapakita sa itaas. Maaari mong tingnan ang mga nilalaman ng mga file na ito at malaman na kasama nila ang lahat ng mga pampublikong file na ginagamit ng mga kaukulang module.

4.2.3 ns3 namespace

Susunod na linya sa script una.cc ay isang deklarasyon ng namespace.

using namespace ns3;

Ang ns-3 na proyekto ay ipinatupad sa isang C++ namespace na tinatawag na ns3. Pinagpangkat nito ang lahat ng deklarasyon na nauugnay sa ns-3 sa isang saklaw sa labas ng pandaigdigang namespace, na sana ay makakatulong sa pagsasama sa ibang code. Ang paggamit ng C++ operator ay nagpapakilala sa ns-3 namespace sa kasalukuyang (global) declarative na rehiyon. Ito ay isang magarbong paraan ng pagsasabi na pagkatapos ng deklarasyon na ito, hindi mo na kakailanganing i-type ang ns3::scope permission operator bago ang lahat ng iyong ns-3 code para magamit ito. Kung hindi ka pamilyar sa mga namespace, sumangguni sa halos anumang C++ textbook at ihambing ang ns3 namespace gamit ang std namespace at deklarasyon using namespace std; sa mga halimbawa ng pagtatrabaho sa output operator cout at mga batis.

4.2.4 Pag-log

Ang susunod na linya ng script ay,

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

Gagamitin namin ang pahayag na ito bilang isang maginhawang lugar upang talakayin ang aming sistema ng dokumentasyon doxygen. Kung titingnan mo ang website ng proyekto ng ns-3, makikita mo ang link ng Dokumentasyon sa navigation bar. Kung i-click mo ang link na ito, dadalhin ka sa aming pahina ng dokumentasyon. Mayroong link na "Pinakabagong Paglabas" na magdadala sa iyo sa dokumentasyon para sa pinakabagong stable na bersyon ng ns-3. Kung pipiliin mo ang link na "API Documentation," dadalhin ka sa pahina ng dokumentasyon ng ns-3 API.

Sa kaliwang bahagi ng pahina ay makikita mo ang isang graphical na representasyon ng istraktura ng dokumentasyon. Ang isang magandang lugar upang magsimula ay ang Modules ns-3 "libro" sa ns-3 navigation tree. Kung ibunyag mo Module, makikita mo ang isang listahan ng dokumentasyon ng ns-3 modules. Tulad ng tinalakay sa itaas, ang konsepto ng isang module dito ay direktang nauugnay sa mga file na kasama sa module sa itaas. Ang ns-3 logging subsystem ay tinalakay sa seksyon Gamit ang Logging Module, kaya babalikan natin ito mamaya sa tutorial na ito, ngunit maaari mong malaman ang tungkol sa pahayag sa itaas sa pamamagitan ng pagtingin sa module Ubodat saka binuksan ang libro Mga tool sa pag-debugat pagkatapos ay piliin ang pahina Pagtotroso. Mag-click sa Pagtotroso.

Dapat mo na ngayong suriin ang dokumentasyon doxygen para sa modyul Pagtotroso. Sa listahan ng mga macro sa tuktok ng pahina makakakita ka ng entry para sa NS_LOG_COMPONENT_DEFINE. Bago i-click ang link, siguraduhing tingnan ang "Detalyadong Paglalarawan" ng module ng pagpaparehistro upang maunawaan kung paano ito gumagana sa pangkalahatan. Upang gawin ito, maaari kang mag-scroll pababa o piliin ang "Higit pa..." sa ibaba ng chart.

Kapag mayroon kang pangkalahatang ideya kung ano ang nangyayari, magpatuloy at tingnan ang dokumentasyon para sa partikular na NS_LOG_COMPONENT_DEFINE. Hindi ko dodoblehin ang dokumentasyon dito, ngunit upang ibuod, ang linyang ito ay nagdedeklara ng isang bahagi ng pagpaparehistro na tinatawag FirstScriptExample, na nagbibigay-daan sa iyong paganahin o huwag paganahin ang console logging ng mga mensahe sa pamamagitan ng pagtukoy sa isang pangalan.

4.2.5 Pangunahing function

Sa mga sumusunod na linya ng script makikita mo,

int 
main (int argc, char *argv[])
{

Ito ay simpleng deklarasyon ng pangunahing pag-andar ng iyong programa (script). Tulad ng anumang C++ na programa, kailangan mong tukuyin ang isang pangunahing function, ito ay isinasagawa muna. Walang espesyal dito. Ang iyong ns-3 script ay isang C++ program lang. Itinatakda ng sumusunod na linya ang resolution ng oras sa 1 nanosecond, na siyang default:

Time::SetResolution (Time::NS);

Time resolution, o simpleng resolution, ay ang pinakamaliit na time value na maaaring gamitin (ang pinakamaliit na representable na pagkakaiba sa pagitan ng dalawang beses). Maaari mong baguhin ang resolution nang eksaktong isang beses. Ang mekanismong nagbibigay ng kakayahang umangkop na ito ay kumukonsumo ng memorya, kaya kapag ang resolution ay tahasang naitakda, ililibre namin ang memorya, na pinipigilan ang mga karagdagang update. (Kung hindi mo tahasang itinakda ang resolution, ito ay magiging default sa isang nanosecond at ang memorya ay mapapalaya kapag nagsimula ang simulation.)

Ang sumusunod na dalawang linya ng script ay ginagamit upang paganahin ang dalawang bahagi ng pag-log na binuo sa mga application EchoClient ΠΈ EchoServer:

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO); LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);

Kung babasahin mo ang dokumentasyon para sa bahagi ng Pag-log, makikita mo na mayroong ilang antas ng pag-log/granularity na maaari mong paganahin sa bawat bahagi. Ang dalawang linya ng code na ito ay nagbibigay-daan sa pag-log ng debug sa antas ng INFO para sa mga echo client at server. Sa antas na ito, magpi-print ang application ng mga mensahe habang nagpapadala at tumatanggap ito ng mga packet sa panahon ng simulation.

Ngayon ay pupunta tayo sa negosyo ng paglikha ng topology at pagpapatakbo ng simulation. Gumagamit kami ng topology helper objects para gawing mas madali ang trabahong ito hangga't maaari.

4.2.6 Paggamit ng mga topology assistant

Ang susunod na dalawang linya ng code sa aming script ay talagang lilikha ng mga bagay na Node ns-3 na kakatawan sa mga computer sa simulation.

NodeContainer nodes;
nodes.Create (2);

Bago tayo magpatuloy, hanapin natin ang dokumentasyon para sa klase NodeContainer. Ang isa pang paraan upang makarating sa dokumentasyon para sa isang partikular na klase ay sa pamamagitan ng tab Klase sa mga pahina doxygen. Kung mayroon ka nang bukas na Doxygen, mag-scroll lang hanggang sa itaas ng page at piliin ang tab na Mga Klase. Dapat kang makakita ng bagong hanay ng mga tab, isa sa mga ito ay isang listahan ng mga klase. Sa ilalim ng tab na ito makikita mo ang isang listahan ng lahat ng ns-3 na klase. Mag-scroll pababa sa ns3::NodeContainer. Kapag nakakita ka ng klase, piliin ito para pumunta sa dokumentasyon para sa klase.

Tulad ng naaalala natin, ang isa sa aming mga pangunahing abstraction ay ang node. Kinakatawan nito ang computer kung saan kami magdaragdag ng mga bagay tulad ng mga protocol stack, application, at peripheral card. Katulong sa topology NodeContainer nagbibigay ng isang maginhawang paraan upang lumikha, pamahalaan at ma-access ang anumang mga bagay Node, na nilikha namin upang patakbuhin ang simulation. Ang unang linya sa itaas ay nagpapahayag lamang NodeContainer, na tinatawag naming mga node. Tinatawag ng pangalawang linya ang paraan ng Lumikha sa object ng mga node at hinihiling sa lalagyan na lumikha ng dalawang node. Gaya ng inilarawan sa doxygen, hinihiling ng container ang ns-3 system na lumikha ng dalawang bagay Node at nag-iimbak ng mga pointer sa mga bagay na ito sa loob.

Ang mga node na nilikha sa script ay wala pang ginagawa. Ang susunod na hakbang sa pagbuo ng topology ay pagkonekta sa aming mga node sa network. Ang pinakasimpleng anyo ng network na sinusuportahan namin ay isang point-to-point na koneksyon sa pagitan ng dalawang node. Gagawa kami ngayon ng ganoong koneksyon.

PointToPointHelper

Gumagawa kami ng isang point-to-point na koneksyon gamit ang isang pamilyar na pattern, gamit ang isang topology helper object upang gawin ang mababang antas ng trabaho na kinakailangan para sa koneksyon. Alalahanin na ang aming dalawang pangunahing abstraction NetDevice ΠΈ channel. Sa totoong mundo, ang mga terminong ito ay halos tumutugma sa mga peripheral card at network cable. Karaniwan, ang dalawang bagay na ito ay malapit na nauugnay sa isa't isa, at walang sinuman ang maaaring umasa sa pagbabahagi, halimbawa, ng mga device Ethernet sa isang wireless channel. Sinusunod ng aming mga topology helper ang malapit na ugnayang ito at samakatuwid ay gagamit ka ng isang bagay sa sitwasyong ito PointToPointHelper para sa pag-set up at pagkonekta ng mga bagay na ns-3 PointToPointNetDevice ΠΈ PointToPointChannel. Ang susunod na tatlong linya sa script:

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

Unang linya,

PointToPointHelper pointToPoint;

lumilikha ng isang halimbawa ng isang bagay sa stack PointToPointHelper. Mula sa pinakamataas na antas ng pananaw ang sumusunod na linya,

pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));

nagsasabi sa bagay PointToPointHelper gamitin ang halagang "5 Mbit/s" (limang megabit bawat segundo) bilang "DataRate'.

Mula sa isang mas partikular na punto ng view, ang string na "DataRate" ay tumutugma sa tinatawag nating attribute PointToPointNetDevice. Kung titingnan mo doxygen para sa klase ns3::PointToPointNetDevice at sa dokumentasyon para sa pamamaraan GetTypeId makakahanap ka ng listahan ng mga katangiang tinukoy para sa device. Kabilang sa mga ito ay ang katangian "DataRate" Karamihan sa mga bagay na ns-3 na nakikita ng gumagamit ay may mga katulad na listahan ng mga katangian. Ginagamit namin ang mekanismong ito upang madaling i-set up ang simulation nang walang recompilation, tulad ng makikita mo sa susunod na seksyon.

Kapareho ng "DataRate" sa PointToPointNetDevice, makikita mo ang attribute na "Delay" na nauugnay sa PointToPointChannel. Ang huling linya

pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

Siya ay nagsasalita PointToPointHelper gamitin ang halagang "2 ms" (dalawang millisecond) bilang ang halaga ng pagkaantala ng pagpapalaganap para sa point-to-point na link na kasunod nitong ginawa.

NetDeviceContainer

Sa sandaling mayroon kami sa script NodeContainer, na naglalaman ng dalawang node. Meron kami PointToPointHelper, na inihanda para sa paglikha ng mga bagay PointToPointNetDevices at pagkonekta sa kanila gamit ang isang bagay na PointToPointChannel. Tulad ng ginamit namin ang NodeContainer topology helper object upang lumikha ng mga node, magtatanong kami PointToPointHelper magsagawa ng trabaho para sa amin na may kaugnayan sa paggawa, pagsasaayos at pag-install ng aming mga device. Kailangan namin ng isang listahan ng lahat ng nilikha na mga bagay NetDevice, kaya ginagamit namin NetDeviceContainer upang iimbak ang mga ito sa parehong paraan na ginamit namin NodeContainer upang iimbak ang mga node na aming ginawa. Ang susunod na dalawang linya ng code,

NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);

kumpletong pag-setup ng device at channel. Idineklara ng unang linya ang lalagyan ng device na binanggit sa itaas, at ang pangalawa ang gumagawa ng pangunahing gawain. Pamamaraan I-install pasilidad PointToPointHelper tumatanggap NodeContainer bilang parameter. Sa loob NetDeviceContainer para sa bawat node na matatagpuan sa NodeContainer ay nilikha (para sa point-to-point na komunikasyon ay dapat mayroong eksaktong dalawa sa kanila) PointToPointNetDevice ay ginawa at nai-save sa lalagyan ng device. PointToPointChannel ay nilikha at dalawa ang nakakabit dito PointToPointNetDevices. Pagkatapos lumikha ng mga bagay, ang mga katangian ay naka-imbak sa PointToPointHelper, ay ginagamit upang simulan ang kaukulang mga katangian sa mga nilikhang bagay.

Pagkatapos tumawag pointToPoint.Install (nodes) magkakaroon tayo ng dalawang node, bawat isa ay may naka-install na point-to-point network device at isang point-to-point na link sa pagitan ng mga ito. Ang parehong mga aparato ay iko-configure upang magpadala ng data sa bilis na limang megabit bawat segundo na may pagkaantala sa paghahatid ng dalawang millisecond sa ibabaw ng channel.

InternetStackHelper

Mayroon na kaming mga node at device na naka-configure, ngunit ang aming mga node ay walang naka-install na protocol stack. Ang susunod na dalawang linya ng code ang bahala dito.

InternetStackHelper stack;
stack.Install (nodes);

InternetStackHelper - ay isang topology helper para sa Internet stack, katulad ng PointToPointHelper para sa point-to-point na mga device sa network. Pamamaraan I-install kinukuha ang NodeContainer bilang isang parameter. Kapag naisakatuparan, i-install nito ang Internet stack (TCP, UDP, IP, atbp.) sa bawat container node.

IPv4AddressHelper

Pagkatapos ay kailangan naming iugnay ang aming mga device sa mga IP address. Nagbibigay kami ng topology assistant para pamahalaan ang paglalaan ng IP address. Ang tanging API na nakikita ng user ay ang pagtatakda ng base IP address at netmask na gagamitin kapag ginagawa ang aktwal na pamamahagi ng address (ito ay ginagawa sa mas mababang antas sa loob ng helper). Ang susunod na dalawang linya ng code sa aming halimbawang script una.cc,

Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");

ideklara ang address helper object at sabihin dito na dapat itong magsimulang maglaan ng mga IP address mula sa network 10.1.1.0, gamit ang 255.255.255.0 bitmask upang matukoy. Bilang default, ang mga inilalaang address ay magsisimula sa isa at tataas nang monotoniko, kaya ang unang address na ilalaan mula sa base na ito ay magiging 10.1.1.1, pagkatapos ay 10.1.1.2, atbp. Sa katotohanan, sa mababang antas, naaalala ng sistema ng ns-3 ang lahat ng inilalaan na mga IP address at bumubuo ng isang nakamamatay na error kung hindi mo sinasadyang lumikha ng isang sitwasyon kung saan ang parehong address ay nabuo nang dalawang beses (sa pamamagitan ng paraan, ang error na ito ay mahirap i-debug).

Ang sumusunod na linya ng code,

Ipv4InterfaceContainer interfaces = address.Assign (devices);

gumaganap ng aktwal na pagtatalaga ng address. Sa ns-3 nagtatatag kami ng koneksyon sa pagitan ng isang IP address at isang device gamit ang object IPv4Interface. Kung minsan kailangan natin ng listahan ng mga network device na ginawa ng assistant para magamit sa ibang pagkakataon, minsan kailangan natin ng listahan ng mga bagay IPv4Interface. IPv4InterfaceContainer nagbibigay ng functionality na ito.

Bumuo kami ng point-to-point na network, na may naka-install na mga stack at nakatalagang mga IP address. Ngayon kailangan namin ng mga application sa bawat node upang makabuo ng trapiko.

4.2.7 Paggamit ng Application

Ang isa pang pangunahing abstraction ng ns-3 system ay application (aplikasyon). Sa sitwasyong ito, gumagamit kami ng dalawang base na espesyalisasyon ng klase application Tumawag si ns-3 UdpEchoServerApplication ΠΈ UdpEchoClientApplication. Tulad ng sa mga nakaraang kaso, gumagamit kami ng mga auxiliary na bagay upang i-configure at pamahalaan ang mga batayang bagay. Dito ginagamit namin UdpEchoServerHelper ΠΈ UdpEchoClientHelper mga bagay upang gawing mas madali ang ating buhay.

UdpEchoServerHelper

Ang mga sumusunod na linya ng code sa aming first.cc na halimbawa ng script ay ginagamit upang i-configure ang isang UDP echo server application sa isa sa mga node na ginawa namin kanina.

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

Lumilikha ang unang linya ng code sa snippet sa itaas UdpEchoServerHelper. Gaya ng dati, hindi ito isang application mismo, ito ay isang bagay na tumutulong sa amin na lumikha ng mga tunay na aplikasyon. Ang isa sa aming mga convention ay upang ipasa ang mga kinakailangang katangian sa constructor ng helper object. Sa kasong ito, ang helper ay hindi maaaring gumawa ng anumang bagay na kapaki-pakinabang maliban kung ito ay bibigyan ng port number kung saan ang server ay makikinig para sa mga packet, ang numerong ito ay dapat ding malaman ng kliyente. Sa kasong ito, ipinapasa namin ang port number sa helper constructor. Ang tagabuo, sa turn, ay ginagawa lamang SetAttribute kasama ang naipasa na halaga. Sa ibang pagkakataon, kung ninanais, maaari mong gamitin ang SetAttribute upang magtakda ng ibang halaga para sa katangian ng Port.

Tulad ng maraming iba pang mga pantulong na bagay, ang bagay UdpEchoServerHelper may pamamaraan I-install. Ang pagsasagawa ng paraang ito ay epektibong lumilikha ng isang pangunahing aplikasyon ng echo server at nagbibigkis nito sa host. Kawili-wili, ang pamamaraan I-install tumatanggap NodeContainer bilang isang parameter tulad ng iba I-install mga pamamaraan na nakita natin.

Ang C++ implicit conversion na gumagana dito ay tumatagal ng resulta ng pamamaraan node.Get(1) (na nagbabalik ng matalinong pointer sa node object - Ptr ) at ginagamit ito sa constructor para sa anonymous na bagay NodeContainerna pagkatapos ay ipinapasa sa pamamaraan I-install. Kung hindi mo matukoy sa C++ code kung aling paraan ang signature ay pinagsama-sama at naisakatuparan, pagkatapos ay tumingin sa mga implicit na conversion.

Ngayon nakikita natin iyan echoServer.I-install tungkol sa pag-install ng application UdpEchoServerApplication sa natagpuan sa NodeContainerna ginagamit namin upang pamahalaan ang aming mga node, node na may index 1. Paraan I-install ay magbabalik ng container na naglalaman ng mga pointer sa lahat ng application (sa kasong ito, isa, dahil nagpasa kami ng anonymous NodeContainer, na naglalaman ng isang node) na nilikha ng katulong.

Kailangang tukuyin ng mga application kung kailan magsisimulang bumuo ng trapiko "simulan" at maaaring kailanganin pang tukuyin ang oras kung kailan ito ihihinto "tigil". Nagbibigay kami ng parehong mga pagpipilian. Ang mga oras na ito ay itinakda gamit ang mga pamamaraan ApplicationContainer simula ΠΈ Itigil. Ang mga pamamaraan na ito ay tumatanggap ng mga parameter ng uri oras. Sa kasong ito, gumagamit kami ng tahasang pagkakasunud-sunod ng mga conversion ng C++ upang kunin ang C++ double 1.0 at i-convert ito sa isang tns-3 Time object na gumagamit ng Seconds object upang i-convert sa segundo. Tandaan na ang mga panuntunan sa conversion ay maaaring kontrolin ng may-akda ng modelo, at ang C++ ay may sarili nitong mga panuntunan, kaya hindi ka palaging makakaasa sa mga parameter na kino-convert sa paraang inaasahan mo. Dalawang linya

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

ay magiging sanhi ng pagsisimula ng echo server application (awtomatikong i-on) isang segundo pagkatapos magsimula ang simulation at hihinto (i-off) pagkatapos ng sampung segundo ng simulation. Dahil sa katotohanang nagdeklara kami ng simulation event (application stop event), na isasagawa sa loob ng sampung segundo, kahit sampung segundo ng pagpapatakbo ng network ay i-simulate.

UdpEchoClientHelper

Aplikasyon ng Kliyente miss na-configure sa paraang halos katulad ng server. Mayroong isang batayang bagay UdpEchoClientApplication, na kinokontrol
UdpEchoClientHelper.

UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));;

Gayunpaman, para sa echo client kailangan naming magtakda ng limang magkakaibang katangian. Ang unang dalawang katangian ay itinakda sa oras ng paggawa UdpEchoClientHelper. Nagpapasa kami ng mga parameter na ginagamit (sa loob ng katulong) upang itakda ang mga katangian "RemoteAddress" ΠΈ "RemotePort" alinsunod sa aming kasunduan na ipasa ang mga kinakailangang parameter sa helper constructor.

Tandaan natin na ginamit natin IPv4InterfaceContainer upang subaybayan ang mga IP address na itinalaga namin sa aming mga device. Ang null interface sa lalagyan ng mga interface ay tumutugma sa IP address ng null node sa lalagyan ng mga node. Ang unang interface sa lalagyan ng mga interface ay tumutugma sa IP address ng unang node sa lalagyan ng mga node. Kaya, sa unang linya ng code (sa itaas), lumikha kami ng isang katulong at sasabihin dito na ang malayong address ng kliyente ay ang IP address na itinalaga sa node kung saan matatagpuan ang server. Sinasabi rin natin na kailangan nating ayusin ang mga packet na maipadala sa port nine.

Ang katangiang "MaxPackets" ay nagsasabi sa kliyente ng maximum na bilang ng mga packet na maaari naming ipadala sa panahon ng simulation. Ang attribute na "Interval" ay nagsasabi sa kliyente kung gaano katagal maghihintay sa pagitan ng mga packet, at ang attribute na "PacketSize" ay nagsasabi sa kliyente kung gaano dapat kalaki ang payload ng packet. Sa kumbinasyon ng katangiang ito, sinasabi namin sa kliyente na magpadala ng isang solong 1024-byte na packet.

Tulad ng sa echo server, itinakda namin ang mga katangian ng echo client simula ΠΈ Itigil, ngunit dito sisimulan namin ang kliyente isang segundo pagkatapos na i-on ang server (dalawang segundo pagkatapos ng simula ng simulation).

4.2.8 Simulator

Sa puntong ito kailangan nating patakbuhin ang simulation. Ginagawa ito gamit ang global function Simulator::Tumakbo.

Simulator::Run ();

Noong tinawag natin dati ang mga pamamaraan,

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
... 
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));

talagang nag-iskedyul kami ng mga kaganapan sa simulator sa 1,0 segundo, 2,0 segundo, at dalawang kaganapan sa 10,0 segundo. Pagkatapos ng tawag Simulator::Tumakbo, magsisimulang tingnan ng system ang listahan ng mga nakaiskedyul na kaganapan at isakatuparan ang mga ito. Papaganahin muna nito ang isang kaganapan pagkatapos ng 1,0 segundo, na magti-trigger sa echo server application (ang kaganapang ito ay maaaring mag-iskedyul ng maraming iba pang mga kaganapan). Magpapagana ito ng event na naka-iskedyul sa t=2,0 segundo na maglulunsad ng echo client application. Muli, ang kaganapang ito ay maaaring magkaroon ng marami pang mga kaganapan na nakaplano. Ang pagpapatupad ng panimulang kaganapan sa echo client ay magsisimula sa yugto ng paglilipat ng data ng simulation sa pamamagitan ng pagpapadala ng packet sa server.

Ang pagkilos ng pagpapadala ng isang packet sa server ay magti-trigger ng isang hanay ng mga kaganapan na awtomatikong maiiskedyul sa likod ng mga eksena at na magpapatupad ng mga mekanika ng pagpapadala ng isang echo packet ayon sa mga parameter ng timing na itinakda namin sa script.

Bilang resulta, dahil isang packet lang ang ipinapadala namin (tandaan, ang attribute MaxPackets ay nakatakda sa isa), ang hanay ng mga kaganapan na pinasimulan ng nag-iisang client ping na ito ay magtatapos at ang simulation ay mapupunta sa standby mode. Kapag nangyari ito, ang mga natitirang nakaiskedyul na kaganapan ay ang mga kaganapan Itigil para sa server at kliyente. Kapag naisakatuparan ang mga kaganapang ito, wala nang natitirang mga kaganapan para sa karagdagang pagproseso at Simulator::Tumakbo ibabalik ang kontrol. Kumpleto na ang simulation.

Ang natitira na lang ay linisin ang sarili. Ginagawa ito sa pamamagitan ng pagtawag sa global function Simulator:: Wasakin. Dahil tinawag ang mga function ng helper (o mababang antas ng ns-3 code), na nakaayos upang ang mga kawit ay naipasok sa simulator upang sirain ang lahat ng mga bagay na nilikha. Hindi mo kailangang subaybayan ang alinman sa mga bagay na ito sa iyong sarili - ang kailangan mo lang gawin ay tumawag Simulator:: Wasakin at lumabas. Gagawin ng ns-3 system ang mahirap na gawaing ito para sa iyo. Ang natitirang mga linya ng aming unang ns-3 script, first.cc, gawin iyon:

Simulator::Destroy ();
return 0;
}

Kailan titigil ang simulator?

Ang ns-3 ay isang discrete event (DE) simulator. Sa naturang simulator, ang bawat kaganapan ay nauugnay sa oras ng pagpapatupad nito, at ang simulation ay nagpapatuloy sa pamamagitan ng pagproseso ng mga kaganapan sa pagkakasunud-sunod ng mga ito habang umuusad ang simulation. Ang mga kaganapan ay maaaring maging sanhi ng pag-iskedyul ng mga kaganapan sa hinaharap (halimbawa, ang isang timer ay maaaring mag-reschedule ng sarili nito upang tapusin ang pagbibilang sa susunod na agwat).

Ang mga paunang kaganapan ay karaniwang pinasimulan ng entity, halimbawa IPv6 ay mag-iskedyul ng pagtuklas ng mga serbisyo sa network, mga kahilingan ng kapitbahay, atbp. Iniiskedyul ng application ang unang kaganapan sa pagpapadala ng packet, at iba pa. Kapag naproseso ang isang kaganapan, maaari itong bumuo ng zero, isa, o higit pang mga kaganapan. Habang nagpapatuloy ang simulation, nagaganap ang mga kaganapan, magtatapos man o lumikha ng mga bago. Awtomatikong hihinto ang simulation kung walang laman ang queue ng event o may nakitang espesyal na event Itigil. Kaganapan Itigil nabuo ng function Simulator::Tumigil (stop time).

May isang tipikal na kaso kung saan ang Simulator::Stop ay talagang kinakailangan upang ihinto ang simulation: kapag may mga self-sustaining event. Ang mga kaganapang nakakapagpapanatili sa sarili (o umuulit) ay mga kaganapang palaging iniiskedyul. Bilang kinahinatnan, palagi nilang pinapanatili na hindi walang laman ang queue ng kaganapan. Mayroong maraming mga protocol at module na naglalaman ng mga umuulit na kaganapan, halimbawa:

β€’ FlowMonitor - pana-panahong pagsusuri para sa mga nawawalang packet;

β€’ RIPng – pana-panahong pag-broadcast ng mga pag-update ng routing table;

β€’ atbp.

Sa ganitong mga kaso Simulator::Tumigil kinakailangan upang ihinto nang tama ang simulation. Bukod pa rito, kapag ang ns-3 ay nasa emulation mode, ang RealtimeSimulator ay ginagamit upang i-synchronize ang simulation clock sa machine clock, at Simulator::Tumigil kinakailangan upang ihinto ang proseso.

Marami sa mga programa ng simulation sa aklat-aralin ay hindi tumatawag Simulator::Tumigil tahasan, dahil awtomatiko silang nagwawakas kapag naubos na ang mga naka-queue na kaganapan. Gayunpaman, tatanggapin din ng mga program na ito ang Simulator::Stop call. Halimbawa, ang sumusunod na karagdagang pahayag sa unang halimbawang programa ay mag-iskedyul ng tahasang paghinto sa 11 segundo:

+ Simulator::Stop (Seconds (11.0));
  Simulator::Run ();
  Simulator::Destroy ();
  return 0;
}

Hindi talaga babaguhin ng nasa itaas ang pag-uugali ng program na ito, dahil ang partikular na simulation na ito ay natural na nagtatapos pagkatapos ng 10 segundo. Ngunit kung babaguhin mo ang oras ng paghinto sa pahayag sa itaas mula 11 segundo hanggang 1 segundo, mapapansin mong huminto ang simulation bago tumama ang anumang output sa screen (dahil ang output ay nangyayari pagkatapos ng humigit-kumulang 2 segundo ng simulation time).

Mahalagang tumawag sa Simulator::Stop bago tumawag sa Simulator::Run; kung hindi, ang Simulator::Run ay maaaring hindi na ibalik ang kontrol sa pangunahing programa upang maisagawa ang paghinto!

4.2.9 Pagbuo ng iyong script

Ginawa naming walang halaga ang paggawa ng iyong mga simpleng script. Ang kailangan mo lang gawin ay ilagay ang iyong script sa scratch directory at awtomatiko itong mabubuo kung tatakbo ka Waf. Subukan Natin. Bumalik sa direktoryo sa pinakamataas na antas at kopyahin mga halimbawa/tutorial/first.cc sa catalog kumamot

$ cd ../.. 
$ cp examples/tutorial/first.cc scratch/myfirst.cc

Buuin ngayon ang iyong unang sample na script gamit ang waf:

$ ./waf

Dapat kang makakita ng mga mensahe na nagsasaad na ang iyong unang halimbawa ay matagumpay na nalikha.

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
[614/708] cxx: scratch/myfirst.cc -> build/debug/scratch/myfirst_3.o
[706/708] cxx_link: build/debug/scratch/myfirst_3.o -> build/debug/scratch/myfirst
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (2.357s)

Ngayon ay maaari mong patakbuhin ang halimbawa (tandaan na kung bubuo ka ng iyong programa sa scratch directory, dapat mo itong patakbuhin mula sa kumamot):

$ ./waf --run scratch/myfirst

Dapat mong makita ang katulad na output:

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

Dito makikita mo na ang build system ay nagpapatunay na ang file ay naitayo at pagkatapos ay pinapatakbo ito. Makikita mo ang bahaging entry sa echo client ay nagpapahiwatig na nagpadala ito ng isang solong 1024-byte na packet sa echo server 10.1.1.2. Nakikita mo rin ang bahagi ng pag-log sa echo server para sabihing nakatanggap ito ng 1024 bytes mula sa 10.1.1.1. Tahimik na nire-replay ng echo server ang packet at makikita mo sa log ng echo client na natanggap nito ang packet nito pabalik mula sa server.

4.3 ns-3 Source code

Ngayong nagamit mo na ang ilan sa mga ns-3 helper, maaari mong tingnan ang ilan sa source code na nagpapatupad ng functionality na ito. Maaaring matingnan ang pinakabagong code sa aming web server sa sumusunod na link: https://gitlab.com/nsnam/ns-3-dev.git. Doon ay makikita mo ang Mercurial summary page para sa aming ns-3 development tree. Sa tuktok ng pahina makikita mo ang ilang mga link,

summary | shortlog | changelog | graph | tags | files

Sige at piliin ang link ng mga file. Ito ang magiging hitsura ng pinakamataas na antas ng karamihan sa aming mga repositoryo:

drwxr-xr-x                               [up]
drwxr-xr-x                               bindings python  files
drwxr-xr-x                               doc              files
drwxr-xr-x                               examples         files
drwxr-xr-x                               ns3              files
drwxr-xr-x                               scratch          files
drwxr-xr-x                               src              files
drwxr-xr-x                               utils            files
-rw-r--r-- 2009-07-01 12:47 +0200 560    .hgignore        file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1886   .hgtags          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1276   AUTHORS          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 30961  CHANGES.html     file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 17987  LICENSE          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 3742   README           file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 16171  RELEASE_NOTES    file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 6      VERSION          file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 88110  waf              file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 28     waf.bat          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 35395  wscript          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 7673   wutils.py        file | revisions | annotate

Ang aming mga halimbawang script ay nasa direktoryo halimbawa. Kung nag-click ka sa mga halimbawa, makikita mo ang isang listahan ng mga subdirectory. Isa sa mga file sa subdirectory tutorial - first.cc. Kung nag-click ka sa una.cc makikita mo ang code na iyong natutunan.

Ang source code ay pangunahing matatagpuan sa direktoryo SRC. Maaari mong tingnan ang source code sa pamamagitan ng pag-click sa pangalan ng direktoryo o pag-click sa link ng mga file sa kanan ng pangalan ng direktoryo. Kung nag-click ka sa direktoryo ng src, makakakuha ka ng isang listahan ng mga subdirectory ng src. Kung pagkatapos ay mag-click ka sa pangunahing subdirectory, makakahanap ka ng isang listahan ng mga file. Ang unang file na makikita mo (sa oras ng pagsulat ng gabay na ito) ay ipalaglag.h. Kung mag-click ka sa link ipalaglag.h, ipapadala ka sa source file para sa ipalaglag.h, na naglalaman ng mga kapaki-pakinabang na macro para sa paglabas ng mga script kung may nakitang abnormal na mga kundisyon. Ang source code para sa mga katulong na ginamit namin sa kabanatang ito ay matatagpuan sa direktoryo src/Applications/helper. Huwag mag-atubiling sundutin ang puno ng direktoryo upang malaman kung saan at maunawaan ang istilo ng mga programang ns-3.

Pinagmulan: www.habr.com

Magdagdag ng komento