ns-3使用手册：入门到精通

需积分: 9 193 浏览量更新于2024-07-26 收藏 633KB PDF 举报

"ns3使用手册，是学习ns3模拟器的基础教程，涵盖了随机变量、回调机制、对象模型和属性等内容。" ns3是一个开源的网络模拟软件，它允许研究人员和开发者对各种网络协议和系统进行建模和仿真。这份ns3手册详细介绍了使用该工具所需的关键概念和技术。 1. **随机变量**：在ns3中，随机变量用于模拟网络中的不确定性和随机行为。快速概览部分提供了一个简短的介绍，背景部分深入到随机变量的理论基础。种子和独立复制章节讨论了如何确保重复实验的一致性。类RandomVariableStream解释了如何操作这些随机变量流，包括其公共API。接着，手册列出了各种类型的随机变量，并详细说明了RandomVariableStream对象的语义。如何使用其他伪随机数生成器（PRNG）以及设置流号也在这一章中讲解。出版结果和总结章节则强调了记录和验证模拟结果的重要性。 2. **回调（Callbacks）**：回调机制是ns3中事件驱动编程的核心。回调动机章节解释了为什么需要回调，背景部分进一步阐述了它们在网络模拟中的作用。使用Callback API的详细步骤在3.3节中给出，包括绑定回调和使用TracedCallbacks来跟踪特定事件。此外，手册还指出了ns-3中常见的回调位置和实现细节。 3. **对象模型**：这部分介绍了ns3的对象导向设计。对象行为和基类的讨论帮助理解ns3中对象的生命周期和交互方式。内存管理和classPtr章节详细解释了如何有效地管理对象内存。CreateObject和Create函数用于动态创建对象，而聚合功能支持不同对象之间的组合。示例和对象工厂章节提供了实际应用的例子，下转换（Downcasting）则涉及如何从基类指针安全地访问派生类的方法。 4. **属性（Attributes）**：属性是ns3中配置和控制对象的重要机制。对象概述介绍了属性的概念，而智能指针部分讨论了如何使用它们来管理对象引用。属性概述详细解释了属性系统的工作原理，包括读取和设置属性的方法。如何扩展属性允许用户为自己的类添加新的可配置特性，这在开发自定义模块时非常有用。这份手册不仅适合初学者，也对高级用户有参考价值，因为它深入到了ns3的核心机制，帮助读者更好地理解和使用这个强大的网络模拟工具。通过学习这些内容，读者可以构建复杂的网络模型，执行精确的性能分析，并根据需要调整和优化模拟参数。

ns-3 Manual, Release ns-3.15

This is not to say that objects should not know about one another if there is a hard dependency between them, but that

often the model can be made more ﬂexible if its interactions are less constrained at compile time.

This is not an abstract problem for network simulation research, but rather it has been a source of problems in previous

simulators, when researchers want to extend or modify the system to do different things (as they are apt to do in

research). Consider, for example, a user who wants to add an IPsec security protocol sublayer between TCP and IP:

------------ -----------

| TCP | | TCP |

------------ -----------

| becomes -> |

----------- -----------

| IP | | IPsec |

----------- -----------

-----------

| IP |

-----------

If the simulator has made assumptions, and hard coded into the code, that IP always talks to a transport protocol above,

the user may be forced to hack the system to get the desired interconnections. This is clearly not an optimal way to

design a generic simulator.

3.2 Callbacks Background

Note: Readers familiar with programming callbacks may skip this tutorial section.

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:

12 Chapter 3. Callbacks

ns-3 Manual, Release ns-3.15

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

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

3.2. Callbacks Background 13

ns-3 Manual, Release ns-3.15

Notice that there are two variables deﬁned in the class above. The m_p variable is the object pointer and m_pmi is the

variable containing the address of the function to execute.

Notice that when operator() is called, it in turn calls the method provided with the object pointer using the C++

PMI syntax.

To use this, one could then declare some model code that takes a generic functor as a parameter:

void LibraryFunction (Functor functor);

The code that will talk to the model would build a speciﬁc functor and pass it to LibraryFunction:

MyClass myClass;

SpecificFunctor<MyClass, int> functor (&myclass, MyClass::MyMethod);

When LibraryFunction is done, it executes the callback using the operator() on the generic functor it was

passed, and in this particular case, provides the integer argument:

void

LibraryFunction (Functor functor)

{

// Execute the library function

functor(1234);

}

Notice that LibraryFunction is completely decoupled from the speciﬁc type of the client. The connection is

made through the Functor polymorphism.

The Callback API in ns-3 implements object-oriented callbacks using the functor mechanism. This callback API, being

based on C++ templates, is type-safe; that is, it performs static type checks to enforce proper signature compatibility

between callers and callees. It is therefore more type-safe to use than traditional function pointers, but the syntax may

look imposing at ﬁrst. This section is designed to walk you through the Callback system so that you can be comfortable

using it in ns-3.

3.3 Using the Callback API

The Callback API is fairly minimal, providing only two services:

1. callback type declaration: a way to declare a type of callback with a given signature, and,

2. callback instantiation: a way to instantiate a template-generated forwarding callback which can forward any calls

to another C++ class member method or C++ function.

This is best observed via walking through an example, based on samples/main-callback.cc.

3.3.1 Using the Callback API with static functions

Consider a function:

static double

CbOne (double a, double b)

{

std::cout << "invoke cbOne a=" << a << ", b=" << b << std::endl;

return a;

}

Consider also the following main program snippet:

3.3. Using the Callback API 15

ns-3 Manual, Release ns-3.15

int main (int argc, char

argv[])

{

// return type: double

// first arg type: double

// second arg type: double

Callback<double, double, double> one;

}

This is an example of a C-style callback – one which does not include or need a this pointer. The function template

Callback is essentially the declaration of the variable containing the pointer-to-function. In the example above,

we explicitly showed a pointer to a function that returned an integer and took a single integer as a parameter, The

Callback template function is a generic version of that – it is used to declare the type of a callback.

Note: Readers unfamiliar with C++ templates may consult http://www.cplusplus.com/doc/tutorial/templates/.

The Callback template requires one mandatory argument (the return type of the function to be assigned to this

callback) and up to ﬁve optional arguments, which each specify the type of the arguments (if your particular callback

function has more than ﬁve arguments, then this can be handled by extending the callback implementation).

So in the above example, we have a declared a callback named “one” that will eventually hold a function pointer. The

signature of the function that it will hold must return double and must support two double arguments. If one tries to

pass a function whose signature does not match the declared callback, a compilation error will occur. Also, if one

tries to assign to a callback an incompatible one, compilation will succeed but a run-time NS_FATAL_ERROR will

be raised. The sample program src/core/examples/main-callback.cc demonstrates both of these error

cases at the end of the main() program.

Now, we need to tie together this callback instance and the actual target function (CbOne). Notice above that CbOne

has the same function signature types as the callback– this is important. We can pass in any such properly-typed

function to this callback. Let’s look at this more closely:

static double CbOne (double a, double b) {}

^ ^ ^

| ---| ------|

| | |

Callback<double, double, double> one;

You can only bind a function to a callback if they have the matching signature. The ﬁrst template argument is the

return type, and the additional template arguments are the types of the arguments of the function signature.

Now, let’s bind our callback “one” to the function that matches its signature:

// build callback instance which points to cbOne function

one = MakeCallback (&CbOne);

This call to MakeCallback is, in essence, creating one of the specialized functors mentioned above. The variable

declared using the Callback template function is going to be playing the part of the generic functor. The assign-

ment one = MakeCallback (&CbOne) is the cast that converts the specialized functor known to the callee to a

generic functor known to the caller.

Then, later in the program, if the callback is needed, it can be used as follows:

NS_ASSERT (!one.IsNull ());

// invoke cbOne function through callback instance

double retOne;

retOne = one (10.0, 20.0);

16 Chapter 3. Callbacks

剩余119页未读，继续阅读

infosecdownload

粉丝: 0
资源: 1

ns-3使用手册：入门到精通

NS3中文手册：入门指南与关键知识点详解

NS3-3.30官方学习文档：教程、手册和模型库

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

ns3 manual and tutorial_ns3_wirelessnetwork_Simulation_

NS2 Manual

ns-3 manual

ns3-manual

ns3_manual

The NS2 Manual

ns-3-manual_ns3_

最新资源