ns-3 3.12手册：全面介绍对象模型与随机变量

下载需积分: 10 | PDF格式 | 586KB | 更新于2024-07-29 | 164 浏览量 | 举报

NS-3 Manual 是一份详细的文档，针对ns-3仿真器的用户提供了全面的功能介绍，特别是对于版本3.12。该手册主要分为几个关键部分，旨在帮助用户理解和掌握ns-3项目的各个方面。 **1. 组织结构** 章节1介绍了ns-3的组织架构，它可能概述了项目的设计原则、模块划分以及在整个仿真软件生态系统中的定位。 **2. 随机变量（Random Variables）** 这部分是手册的核心，涉及随机变量的使用和管理。首先提供了一个快速概览，解释了随机变量在ns-3中的基本概念和作用。随后，讨论了如何设置种子值和独立复制以确保实验结果的一致性。`ClassRandomVariable`是基础类，其公共API定义了随机变量的操作接口。分类包括不同类型随机变量（如离散、连续等），以及它们的语义，即如何在模拟环境中应用。此外，还介绍了如何使用其他伪随机数生成器（PRNG），以及更高级的使用技巧和如何发布研究结果。 **3. 回调（Callbacks）** 这部分讨论了回调函数的动机和背景，强调它们在ns-3中的重要性，特别是在事件驱动的仿真中，用于处理对象生命周期的各个阶段。 **4. 对象模型** ns-3采用面向对象设计，章节4深入探讨了对象行为、基类、内存管理（包括`classPtr`）、对象工厂以及如何进行向下转型。 **5. 属性（Attributes）** 属性系统是ns-3对象配置的关键部分。本节讲解了对象概述、智能指针的使用，以及如何扩展和定制属性。添加新的类类型到属性系统，以及配置存储（ConﬁgStore）的设置方法都在这一部分详细介绍。 **6. 对象命名（Object Names）** 为了方便管理和调试，手册介绍了如何为对象分配和操作名称，以跟踪和识别特定的对象实例。 **7. 日志与记录（Logging）** 这部分阐述了日志系统的重要性，以及如何在ns-3中设置和控制记录级别，以获取有用的信息用于调试和性能分析。 **8. 跟踪（Tracing）** 跟踪是ns-3的一个强大工具，用于深入了解仿真过程。8.1介绍了跟踪的动机，随后是追踪概述、如何使用Tracing API和Trace Helpers，以及追踪实现的细节。 **9. 实时特性（Real Time）** 最后，章节9关注ns-3的实时特性，可能讨论了如何在时间敏感的仿真环境中正确配置和利用这些功能。 NS-3 Manual提供了详尽的指南，帮助用户掌握ns-3的各种核心功能和用法，从基础概念到高级技术，以确保用户能有效利用这个强大的网络模拟平台进行研究和教学工作。

ns-3 Manual, Release ns-3.12

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

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

It is not required that ns-3 objects inherit from these class, but those that do get special properties. Classes deriving

from class Object get the following properties.

• the ns-3 type and attribute system (see Attributes)

• an object aggregation system

• a smart-pointer reference counting system (class Ptr)

Classes that derive from class ObjectBase get the ﬁrst two properties above, but do not get smart pointers. Classes

that derive from class SimpleRefCount: get only the smart-pointer reference counting system.

In practice, class Object is the variant of the three above that the ns-3 developer will most commonly encounter.

4.3 Memory management and class Ptr

Memory management in a C++ program is a complex process, and is often done incorrectly or inconsistently. We have

settled on a reference counting design described as follows.

All objects using reference counting maintain an internal reference count to determine when an object can safely

delete itself. Each time that a pointer is obtained to an interface, the object’s reference count is incremented by calling

Ref(). It is the obligation of the user of the pointer to explicitly Unref() the pointer when done. When the

reference count falls to zero, the object is deleted.

• When the client code obtains a pointer from the object itself through object creation, or via GetObject, it does

not have to increment the reference count.

• When client code obtains a pointer from another source (e.g., copying a pointer) it must call Ref() to increment

the reference count.

• All users of the object pointer must call Unref() to release the reference.

The burden for calling Unref() is somewhat relieved by the use of the reference counting smart pointer class de-

scribed below.

Users using a low-level API who wish to explicitly allocate non-reference-counted objects on the heap, using operator

new, are responsible for deleting such objects.

4.3.1 Reference counting smart pointer (Ptr)

Calling Ref() and Unref() all the time would be cumbersome, so ns-3 provides a smart pointer class Ptr similar

to Boost::intrusive_ptr. This smart-pointer class assumes that the underlying type provides a pair of Ref

and Unref methods that are expected to increment and decrement the internal refcount of the object instance.

This implementation allows you to manipulate the smart pointer as if it was a normal pointer: you can compare it with

zero, compare it against other pointers, assign zero to it, etc.

It is possible to extract the raw pointer from this smart pointer with the GetPointer() and PeekPointer()

methods.

If you want to store a newed object into a smart pointer, we recommend you to use the CreateObject template functions

to create the object and store it in a smart pointer to avoid memory leaks. These functions are really small convenience

functions and their goal is just to save you a small bit of typing.

16 Chapter 4. Object model

剩余114页未读，继续阅读

dextor_eming

粉丝: 0

ns-3 3.12手册：全面介绍对象模型与随机变量

ns-3 model

网络ns2仿真实验分析(RED、丢包率、端到端延迟、吞吐量)附源码

ns-3-中文教程

ns-3-manual

ns-3-manual_ns3_

ns-3-manual.pdf

ns-3-manual_r3.21

ns-3-manual、model-library、tutorial

ns3-manual

ns-umts-extensions.zip_BCCH_UMTS PHY_ns-3_ns-allinone-2.31_umts

最新资源