the-one-code-2

Posted on

[TOC]

ONE程序代码简析

INTERFACE

在INTERFACE 包中一共有五个.java文件，其和core中的NetworkInterface 文件一同构成了整个INTERFACE(ONE 的网络接口部分)

NetworkInterface

NetwordInterface 是ModuleCommunicationListener 接口的实现。

ConnectivityGrid

ConnectivityGrid 是继承 ConnectivityOptimizer 的类，ConnnectivityOptimizer是一个抽象类。

不是检测所有的interface ，而只找到那些离得足够近的interface，关于距离足够近，是看两个interface 是否在同一个cell或者相邻的cell中。一个要点是，这个类不支持任何的负坐标。

关于optimizer 的设置，其在default_setting.txt中为：

1
2
3
4
## Optimization settings -- these affect the speed of the simulation
## see World class for details.
Optimization.cellSizeMult = 5
Optimization.randomizeUpdateOrder = true

关于getNeighborCells 方法的实现：

1
2
3
4
5
6
7
private GridCell[] getNeighborCells(int row, int col) {
	return new GridCell[] {
		cells[row-1][col-1],cells[row-1][col],cells[row-1][col+1],//1st row
		cells[row][col-1],cells[row][col],cells[row][col+1],//2nd row
		cells[row+1][col-1],cells[row+1][col],cells[row+1][col+1]//3rd row
	};
}

可以看到，实际上找的是其自身以及八邻接。

对于cell，这里都是通过坐标来进行索引查找的。

ConnectivityOptimizer

抽象类，主要包括了如下五个抽象方法，都需要继承的子类进行具体实现：

  • addInterface(NetworkInterface ni);

    将一个network interface 加入到optimizer当中

  • addInterfaces(Collection interfaces)

    加入network interface 的 connections

  • updateLocation(NetworkInterface)

    更新network interface 的 地址

  • Collection getNearInterfaces(NetworkInterface ni)

    找到所有的可能的network interface 使得其能够与当前的Interface进行连接

  • Collection getAllInterfaces()

    找到所有属于当前connectivityOptimizer的interface

DistanceCapacityInterface

继承自Network Interface 。 通过interface 之间连接的距离长短来决定links 的能力。基于距离的传输速率在default_setting 中被transmit_speed 设置。

关于interface 直接进行连接

1
2
3
4
5
6
7
8
9
10
11
12
public void connect(NetworkInterface anotherInterface) {// 进行连接
	if (isScanning()
			&& anotherInterface.getHost().isRadioActive()
			&& isWithinRange(anotherInterface)
			&& !isConnected(anotherInterface)
			&& (this != anotherInterface)) {

		Connection con = new VBRConnection(this.host, this,
				anotherInterface.getHost(), anotherInterface);
		connect(con,anotherInterface);
	}
}

要进行连接的时候，必须要满足这样一些要求： host 是active 的，并且在范围之内且并没有连接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public int getTransmitSpeed(NetworkInterface ni) {
	double distance;
	double fractionIndex;
	double decimal;
	double speed;
	int index;

	/* distance to the other interface */
	distance = ni.getLocation().distance(this.getLocation());

	if (distance >= this.transmitRange) {
		return 0;
	}

	/* interpolate between the two speeds */
	fractionIndex = (distance / this.transmitRange) *
			(this.transmitSpeeds.length - 1);
	index = (int)(fractionIndex);
	decimal = fractionIndex - index;

	speed = this.transmitSpeeds[index] * (1-decimal) +
			this.transmitSpeeds[index + 1] * decimal;

	return (int)speed;
}

根据距离来判定当前传输的速率，如果超过范围，则为0，否则会根据当前的distance 和 transmitRange 来进行加权计算。

InterferenceLimitedInterface

同样继承自Network Interface，是一个简单的Network Interface 提供了一个可变的位速率，基于其它的传输stations（在range范围之内），其与distanceCapacityInterface 的不同在于其基于的是其它station 来决定其bit-rate 的。

其传输速率的计算基于如下方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
numberOfTransmissions = 0;
int numberOfActive = 1;
for (Connection con : this.connections) {
	if (con.getMessage() != null) {
		numberOfTransmissions++;
	}
	if (((InterferenceLimitedInterface)con.getOtherInterface(this)).
			isTransferring() == true) {
		numberOfActive++;
	}
}

int ntrans = numberOfTransmissions;
if ( numberOfTransmissions < 1) ntrans = 1;
if ( numberOfActive <2 ) numberOfActive = 2;

// Based on the equation of Gupta and Kumar - and the transmission speed
// is divided equally to all the ongoing transmissions
currentTransmitSpeed = (int)Math.floor((double)transmitSpeed /
		(Math.sqrt((1.0*numberOfActive) *
				Math.log(1.0*numberOfActive))) /
					ntrans );

也就是说，当前的transmitspeed为 : $speed = \frac{speed}{\sqrt{active \log(active)} ntrans}$

SimpleBroadcastInterface

这是一个很简单的Network Interface ，其提供了一个固定传输速率的服务，即直接简单广播。其余的和前面的interface 实现差不多。