ns-3.26手册：网络仿真与核心概念

manual

需积分: 27 54 浏览量更新于2024-07-20 1 收藏 1011KB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"NS3.26手册manual.pdf" NS3是一个开源的网络模拟器，用于研究和教育目的，它允许用户模拟各种网络协议和系统。该手册是NS3项目的官方文档，版本为3.26，发布于2016年10月4日。文档以英文编写，涵盖了NS3的主要功能和使用方法。 1. **组织结构** NS3的组织结构包括了模块化的代码设计，便于理解和使用。手册的组织与软件结构相呼应，帮助用户逐步了解NS3的各个方面。 2. **随机变量** 在NS3中，随机变量是模拟网络行为的重要工具，它们用于模拟如数据包传输时间、丢包率等网络现象的不确定性。 3. **哈希函数** 哈希函数在NS3中可能用于创建唯一标识或快速查找，它们在处理大量数据时特别有用。 4. **事件和模拟器** NS3的核心是事件驱动的模拟器，它管理事件的发生顺序，并根据事件调度器执行相应的操作。 5. **回调** 回调机制允许用户在特定事件发生时插入自定义的行为，增加了模拟的灵活性。 6. **对象模型** NS3采用面向对象的设计，每个网络组件（如节点、链路）都是一个对象，具有属性和方法。 7. **配置和属性** 用户可以通过配置文件或代码设置对象的属性，来调整模拟参数。 8. **对象命名** NS3支持对象命名系统，方便在代码中引用和管理对象。 9. **日志** 日志功能用于记录模拟过程中的信息，有助于调试和分析结果。 10. **追踪** 跟踪系统允许用户指定感兴趣的变量进行追踪，生成的数据可用于后续分析。 11. **数据收集** NS3提供了数据收集机制，用于汇总和处理模拟过程中产生的信息。 12. **统计框架** 统计框架支持对模拟结果进行统计分析，包括平均值、标准差等。 13. **实时模拟** NS3支持实时模拟，允许模拟与实际时间同步，这对于验证实时系统尤其有用。 14. **助手类** 助手类简化了常见的模拟任务，如网络拓扑创建、协议安装等。 15. **使用Gnuplot绘图** NS3提供了一个Gnuplot类，可以直接生成模拟结果的图形表示。 16. **Python接口** NS3支持通过Python运行模拟，提供了更灵活的脚本选项。 17. **测试** 文档中包含了关于如何编写和运行测试用例的信息，确保代码的正确性。 18. **支持** 提供了获取项目支持和社区参与的相关信息。 19. **源代码** 文档还涵盖了NS3的源代码结构和编译指南。 20. **参考文献** 包含了有关NS3开发和使用的相关参考资料。 21. **索引** 为方便查阅，手册附带了详细的索引。 NS3手册不仅介绍了基本概念，还提供了详细的示例和指导，是学习和使用NS3进行网络模拟的宝贵资源。对于网络协议研究者、软件开发者以及教学人员来说，理解并掌握这些知识点至关重要。

资源详情

资源推荐

ns-3 Manual, Release ns-3.26

These functions are declared and implemented as C++ templates to handle automatically the wide variety of C++ event

handler signatures used in the wild. For example, to schedule an event to execute 10 seconds in the future, and invoke

a C++ method or function with speciﬁc arguments, you might write this:

void handler (int arg0, int arg1)

{

std::cout << "handler called with argument arg0=" << arg0 << " and

arg1=" << arg1 << std::endl;

}

Simulator::Schedule(Seconds(10), &handler, 10, 5);

Which will output:

handler called with argument arg0=10 and arg1=5

Of course, these C++ templates can also handle transparently member methods on C++ objects:

To be completed: member method example

Notes:

• the ns-3 Schedule methods recognize automatically functions and methods only if they take less than 5 argu-

ments. If you need them to support more arguments, please, ﬁle a bug report.

• Readers familiar with the term ‘fully-bound functors’ will recognize the Simulator::Schedule methods as a way

to automatically construct such objects.

2. Common scheduling operations

The Simulator API was designed to make it really simple to schedule most events. It provides three variants to do so

(ordered from most commonly used to least commonly used):

• Schedule methods which allow you to schedule an event in the future by providing the delay between the current

simulation time and the expiration date of the target event.

• ScheduleNow methods which allow you to schedule an event for the current simulation time: they will execute

_after_ the current event is ﬁnished executing but _before_ the simulation time is changed for the next event.

• ScheduleDestroy methods which allow you to hook in the shutdown process of the Simulator to cleanup simu-

lation resources: every ‘destroy’ event is executed when the user calls the Simulator::Destroy method.

3. Maintaining the simulation context

There are two basic ways to schedule events, with and without context. What does this mean?

Simulator::Schedule (Time const &time, MEM mem_ptr, OBJ obj);

vs.

Simulator::ScheduleWithContext (uint32_t context, Time const &time, MEM mem_ptr, OBJ obj);

Readers who invest time and effort in developing or using a non-trivial simulation model will know the value of the

ns-3 logging framework to debug simple and complex simulations alike. One of the important features that is provided

by this logging framework is the automatic display of the network node id associated with the ‘currently’ running

event.

The node id of the currently executing network node is in fact tracked by the Simulator class. It can be accessed with

the Simulator::GetContext method which returns the ‘context’ (a 32-bit integer) associated and stored in the currently-

executing event. In some rare cases, when an event is not associated with a speciﬁc network node, its ‘context’ is set

to 0xffffffff.

12 Chapter 1. Contents

ns-3 Manual, Release ns-3.26

To associate a context to each event, the Schedule, and ScheduleNow methods automatically reuse the context of the

currently-executing event as the context of the event scheduled for execution later.

In some cases, most notably when simulating the transmission of a packet from a node to another, this behavior is

undesirable since the expected context of the reception event is that of the receiving node, not the sending node. To

avoid this problem, the Simulator class provides a speciﬁc schedule method: ScheduleWithContext which allows one

to provide explicitly the node id of the receiving node associated with the receive event.

XXX: code example

In some very rare cases, developers might need to modify or understand how the context (node id) of the ﬁrst event

is set to that of its associated node. This is accomplished by the NodeList class: whenever a new node is created,

the NodeList class uses ScheduleWithContext to schedule a ‘initialize’ event for this node. The ‘initialize’ event thus

executes with a context set to that of the node id and can use the normal variety of Schedule methods. It invokes

the Node::Initialize method which propagates the ‘initialize’ event by calling the DoInitialize method for each object

associated with the node. The DoInitialize method overridden in some of these objects (most notably in the Application

base class) will schedule some events (most notably Application::StartApplication) which will in turn scheduling

trafﬁc generation events which will in turn schedule network-level events.

Notes:

• Users need to be careful to propagate DoInitialize methods across objects by calling Initialize explicitely on

their member objects

• The context id associated with each ScheduleWithContext method has other uses beyond logging: it is used by

an experimental branch of ns-3 to perform parallel simulation on multicore systems using multithreading.

The Simulator::* functions do not know what the context is: they merely make sure that whatever context you specify

with ScheduleWithContext is available when the corresponding event executes with ::GetContext.

It is up to the models implemented on top of Simulator::* to interpret the context value. In ns-3, the network models

interpret the context as the node id of the node which generated an event. This is why it is important to call Sched-

uleWithContext in ns3::Channel subclasses because we are generating an event from node i to node j and we want to

make sure that the event which will run on node j has the right context.

1.4.3 Time

To be completed

1.4.4 Scheduler

To be completed

1.5 Callbacks

Some new users to ns-3 are unfamiliar with an extensively used programming idiom used throughout the code: the

ns-3 callback. This chapter provides some motivation on the callback, guidance on how to use it, and details on its

implementation.

1.5.1 Callbacks Motivation

Consider that you have two simulation models A and B, and you wish to have them pass information between them

during the simulation. One way that you can do that is that you can make A and B each explicitly knowledgeable

about the other, so that they can invoke methods on each other:

1.5. Callbacks 13

ns-3 Manual, Release ns-3.26

The basic mechanism that allows one to address the problem above is known as a callback. The ultimate goal is to

allow one piece of code to call a function (or method in C++) without any speciﬁc inter-module dependency.

This ultimately means you need some kind of indirection – you treat the address of the called function as a variable.

This variable is called a pointer-to-function variable. The relationship between function and pointer-to-function pointer

is really no different that that of object and pointer-to-object.

In C the canonical example of a pointer-to-function is a pointer-to-function-returning-integer (PFI). For a PFI taking

one int parameter, this could be declared like,:

int (

pfi)(int arg) = 0;

What you get from this is a variable named simply pfi that is initialized to the value 0. If you want to initialize this

pointer to something meaningful, you have to have a function with a matching signature. In this case:

int MyFunction (int arg) {}

If you have this target, you can initialize the variable to point to your function like:

pfi = MyFunction;

You can then call MyFunction indirectly using the more suggestive form of the call:

int result = (

pfi) (1234);

This is suggestive since it looks like you are dereferencing the function pointer just like you would dereference any

pointer. Typically, however, people take advantage of the fact that the compiler knows what is going on and will just

use a shorter form:

int result = pfi (1234);

Notice that the function pointer obeys value semantics, so you can pass it around like any other value. Typically, when

you use an asynchronous interface you will pass some entity like this to a function which will perform an action and

call back to let you know it completed. It calls back by following the indirection and executing the provided function.

In C++ you have the added complexity of objects. The analogy with the PFI above means you have a pointer to a

member function returning an int (PMI) instead of the pointer to function returning an int (PFI).

The declaration of the variable providing the indirection looks only slightly different:

int (MyClass::

pmi) (int arg) = 0;

This declares a variable named pmi just as the previous example declared a variable named pfi. Since the will be to

call a method of an instance of a particular class, one must declare that method in a class:

class MyClass {

public:

int MyMethod (int arg);

};

Given this class declaration, one would then initialize that variable like this:

pmi = &MyClass::MyMethod;

This assigns the address of the code implementing the method to the variable, completing the indirection. In order to

call a method, the code needs a this pointer. This, in turn, means there must be an object of MyClass to refer to. A

simplistic example of this is just calling a method indirectly (think virtual function):

1.5. Callbacks 15

ns-3 Manual, Release ns-3.26

int (MyClass::

pmi) (int arg) = 0; // Declare a PMI

pmi = &MyClass::MyMethod; // Point at the implementation code

MyClass myClass; // Need an instance of the class

(myClass.

pmi) (1234); // Call the method with an object ptr

Just like in the C example, you can use this in an asynchronous call to another module which will call back using a

method and an object pointer. The straightforward extension one might consider is to pass a pointer to the object and

the PMI variable. The module would just do:

(

objectPtr.

pmi) (1234);

to execute the callback on the desired object.

One might ask at this time, what’s the point? The called module will have to understand the concrete type of the calling

object in order to properly make the callback. Why not just accept this, pass the correctly typed object pointer and

do object->Method(1234) in the code instead of the callback? This is precisely the problem described above.

What is needed is a way to decouple the calling function from the called class completely. This requirement led to the

development of the Functor.

A functor is the outgrowth of something invented in the 1960s called a closure. It is basically just a packaged-up

function call, possibly with some state.

A functor has two parts, a speciﬁc part and a generic part, related through inheritance. The calling code (the code that

executes the callback) will execute a generic overloaded operator () of a generic functor to cause the callback to

be called. The called code (the code that wants to be called back) will have to provide a specialized implementation

of the operator () that performs the class-speciﬁc work that caused the close-coupling problem above.

With the speciﬁc functor and its overloaded operator () created, the called code then gives the specialized code

to the module that will execute the callback (the calling code).

The calling code will take a generic functor as a parameter, so an implicit cast is done in the function call to convert the

speciﬁc functor to a generic functor. This means that the calling module just needs to understand the generic functor

type. It is decoupled from the calling code completely.

The information one needs to make a speciﬁc functor is the object pointer and the pointer-to-method address.

The essence of what needs to happen is that the system declares a generic part of the functor:

template <typename T>

class Functor

{

public:

virtual int operator() (T arg) = 0;

};

The caller deﬁnes a speciﬁc part of the functor that really is just there to implement the speciﬁc operator() method:

template <typename T, typename ARG>

class SpecificFunctor : public Functor<ARG>

{

public:

SpecificFunctor(T

p, int (T::

_pmi)(ARG arg))

{

m_p = p;

m_pmi = _pmi;

}

virtual int operator() (ARG arg)

{

16 Chapter 1. Contents

剩余164页未读，继续阅读

龙吟在天

粉丝: 567
资源: 74

ns-3.26手册：网络仿真与核心概念

NS3 中文教程（tutorial 翻译）

NS3官方文档,ns3教程

ns-3-中文教程.pdf

ubuntu16.04安装ns3.26

ubuntu安装ns3.26

ns <- c(ns1, ns2, ..., nsN) nt <- c(nt1, nt2, ..., ntN) prop.test(ns, nt)是什么意思

"ns3/object.h"

libtiff-devel-4.0.3-27.ns7_4.mips64el

ns3/object.h

ns3/vector.h

fsdbextract source.fsdb -bt 10000ns -et 20000ns -o output.fsdb 切割波形只有

ns3.36.1github

用ns2运行olsr.tcl文件之后生成的.tr文件是空的

ns3里面pfifoHelper.SetRootQueueDisc参数是什么意思

unbound 添加NS记录

stm32f103 延时20ns_【STM32时间戳的妙用，ucos 时间戳】如何测量程序的运行时间，精度为ns级别...

ns3的fifth.cc

NS2中的802.11协议代码解析

按照以下需求配置dns服务器要求你的linux 负责baidu.comdns服务器名为 ns.baidu.com域中有如下的域名和ip地址对应关系ns.baidu.com 192.168.126.1

ns3中802.1Q协议在哪

最新资源