ns-3.8参考手册：2010年五月的ns-3项目指南

5星 · 超过95%的资源需积分: 9 88 浏览量更新于2024-08-01 收藏 2.07MB PDF 举报

NS-3 Reference Manual 是一个针对 NS-3（Network Simulator 3）项目的官方参考文档，适用于版本 ns-3.8，发布日期为2010年5月3日。NS-3 是一款广泛用于网络模拟研究的开源仿真器，它提供了一个强大的工具包，可以模拟各种类型的网络协议、设备和应用场景。 NS-3项目的主要文档形式包括： 1. NS-3 Tutorial：入门级教程，帮助用户了解和熟悉NS-3的基本用法和概念。 2. ns-3 Doxygen：公开API的详尽文档，包含了类、函数、方法等的详细描述和使用示例。 3. Reference Manual（本手册）：深入的技术文档，涵盖了核心模块的设计原理和高级用法，是开发者进行编程和调试的重要参考。 4. Testing and Validation manual：关于测试和验证方法的指南，确保软件质量和稳定性。 5. ns-3 Wiki：社区共享的知识库，包含用户贡献的案例、技巧和最佳实践。该手册采用GNU Texinfo格式编写，并在NS-3代码服务器上维护，同时提供了PDF和HTML版本供用户下载。所有文档更新需在ns-developers@isi.edu邮件列表中讨论，以保持同步和协作。 NS-3遵循GNU General Public License (GPLv2或更高版本)，这意味着用户可以根据此协议自由地分发和修改软件。然而，软件本身不提供任何明示或暗示的质保，包括适销性和特定用途的适用性，用户应仔细阅读GPLv2条款以获取更多信息。获取NS-3时，用户应该已经收到了GNU General Public License的副本，这标志着用户对软件的使用权利和义务。通过阅读和理解这份手册，开发人员和研究人员能够充分利用NS-3的强大功能，进行高效和精确的网络模拟研究。

Chapter 3: Callbacks ns-3 manual

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 void 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

{

public:

SpecificFunctor(T* p, int (T::*_pmi)(ARG arg))

{

m_p = p;

m_pmi = pmi;

}

virtual int operator() (ARG arg)

{

(*m_p.*m_pmi)(arg);

}

private:

void (T::*m_pmi)(ARG arg);

T* m_p;

};

12ns-3.6 3 May 2010

Chapter 3: Callbacks ns-3 manual

N.B. The previous code is not real ns-3 code. It is simplistic example code used only to

illustrate the concepts involved and to help you understand the system more. Do not expect

to ﬁnd this code anywhere in the ns-3 tree

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 mech-

anism. 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:

• callback type declaration: a way to declare a type of callback with a given signature,

and,

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

13ns-3.6 3 May 2010

Chapter 3: Callbacks ns-3 manual

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:

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.

Note1: Readers unfamiliar with C++ templates may consult this reference.

The Callback template requires one mandatory argument (the return type of the func-

tion 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, the compilation will fail.

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:

14ns-3.6 3 May 2010

Chapter 3: Callbacks ns-3 manual

virtual int operator() (ARG arg)

{

(*m_p.*m_pmi)(arg);

}

And so we needed to provide the two variables (m_p and m_pmi) when we made the

speciﬁc functor. The line,

two = MakeCallback (&MyCb::CbTwo, &cb);

does precisely that. In this case,

When two () is invoked,

int result = two (1.0);

I will result in a call the CbTwo member function (method) on the object pointed to by

&cb.

3.3.3 Building Null Callbacks

It is possible for callbacks to be null; hence it may be wise to check before using them.

There is a special construct for a null callback, which is preferable to simply passing "0" as

an argument; it is the MakeNullCallback<> construct:

two = MakeNullCallback<int, double> ();

NS_ASSERT (two.IsNull ());

Invoking a null callback is just like invoking a null function pointer: it will crash at

runtime.

3.4 Bound Callbacks

A very useful extension to the functor concept is that of a Bound Callback. Previously it

was mentioned that closures were originally function calls packaged up for later execution.

Notice that in all of the Callback descriptions above, there is no way to package up any pa-

rameters for use later – when the Callback is called via operator(). All of the parameters

are provided by the calling function.

What if it is desired to allow the client function (the one that provides the callback)

to provide some of the parameters? Alexandrescu calls the process of allowing a client

to specify one of the parameters binding. One of the parameters of operator() has been

bound (ﬁxed) by the client.

Some of our pcap tracing code provides a nice example of this. There is a function that

needs to be called whenever a packet is received. This function calls an object that actually

writes the packet to disk in the pcap ﬁle format. The signature of one of these functions

will be,

static void SniffEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

The static keyword means this is a static function which does not need a this pointer,

so it will be using C-style callbacks. We don’t want the calling code to have to know about

anything but the Packet. What we want there is just a call that looks like,

m_promiscSnifferTrace (m_currentPkt);

16ns-3.6 3 May 2010

剩余179页未读，继续阅读

yhpresario

粉丝: 0
资源: 1

ns-3.8参考手册：2010年五月的ns-3项目指南

ns-3 教程+手册（tutorial+manual）

ns3-manual

ns-3-manual_ns3_

ns3 manual and tutorial_ns3_wirelessnetwork_Simulation_

ns2说明文件ns_manual2007

_____NS-V1000_____.zip_AIZ_directlzi_manual_omron v1000

VanetMobiSim_1_0__Manual.rar_vanetmobisim

VanetMobiSim_1_0__Manual.rar_Windows编程_Windows_Unix_

VanetMobiSim_1_0__Manual.rar_CanuMobiSim_The Network_vehicular a

ns2-manual.pdf.gz_linux manual

最新资源

_NS-V1000_.zip_AIZ_directlzi_manual_omron v1000