解析ns2跟踪文件

Question

我正在使用NS 2.35，并试图确定我的路由算法的端到端延迟。

我认为任何有良好脚本编写经验的人都应该能够回答这个问题，遗憾的是，那个人不是我。

我有一个跟踪文件，它看起来像这样：

- -t 0.548 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1052 -a 0 -x {2.0 17.0 6 ------- null}
h -t 0.548 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1052 -a 0 -x {2.0 17.0 -1 ------- null}
+ -t 0.55 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1056 -a 0 -x {2.0 17.0 10 ------- null}
+ -t 0.555 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1057 -a 0 -x {2.0 17.0 11 ------- null}
r -t 0.556 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1047 -a 0 -x {2.0 17.0 1 ------- null}
+ -t 0.556 -s 7 -d 12 -p cbr -e 500 -c 0 -i 1047 -a 0 -x {2.0 17.0 1 ------- null}
- -t 0.556 -s 7 -d 12 -p cbr -e 500 -c 0 -i 1047 -a 0 -x {2.0 17.0 1 ------- null}

但这是我需要做的。

以+开头的行是在向网络中添加新数据包时。以r开头的行是当目的地接收到数据包时。-t之后的双类型数字是该事件发生的时间。最后，在-i之后是数据包的标识。

为了计算平均端到端延迟，我需要在-i之后找到每一行有特定id的行。然后，我需要计算r的时间戳减去+的时间戳。

所以我想可能有一个正则表达式被空格隔开。我可以把每个片段放入它们自己的变量中。然后我会检查15号(数据包ID)。

但我不知道从那里往哪里走，也不知道怎么把这一切放在一起。

我知道网络上有一些AWK脚本，但是它们都过时了，不符合当前的格式(我不知道如何改变它们)。

任何帮助都将不胜感激。

编辑：

这里是一个完整的数据包路由的例子，我正在寻找。我在这些包之间取了很多行，这样您就可以看到单个数据包事件。

# a packet is enqueued from node 2 going to node 7. It's ID is 1636. this was at roughly 1.75sec 
+ -t 1.74499999999998 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# at 2.1s, it left node 2. 
- -t 2.134 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# at 2.134 it hopped from 2 to 7 (not important)
h -t 2.134 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 -1 ------- null}
# at 2.182 it was received by node 7
r -t 2.182 -s 2 -d 7 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# it was the enqueued by node 7 to be sent to node 12
+ -t 2.182 -s 7 -d 12 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# slightly later it left node 7 on its was to node 12
- -t 2.1832 -s 7 -d 12 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# it hopped from 7 to 12 (not important)
h -t 2.1832 -s 7 -d 12 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 -1 ------- null}
# received by 12
r -t 2.2312 -s 7 -d 12 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# added to queue, heading to node 17
+ -t 2.2312 -s 12 -d 17 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# left for node 17
- -t 2.232 -s 12 -d 17 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}
# hopped to 17 (not important)
h -t 2.232 -s 12 -d 17 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 -1 ------- null}
# received by 17 notice the time delay
r -t 2.28 -s 12 -d 17 -p cbr -e 500 -c 0 -i 1636 -a 0 -x {2.0 17.0 249 ------- null}

脚本的理想输出将识别2.134作为开始时间，2.28作为结束，然后给我0.146秒的延迟。它将对所有数据包It执行此操作，并且只报告平均值。

有人要求我稍微扩展一下文件的工作方式，以及我所期望的内容。

该文件列出了大约10,000个数据包的说明。每个数据包可以处于不同的状态。重要的状态是+ (表示数据包已在路由器上排队)和r (表示数据包已被其目的地接收)。

有可能没有实际接收到已排队的数据包(因此是+条目)，而是将其丢弃。这意味着我们不能假设每个+条目都有一个r条目。

我试着测量的是平均端到端延迟。这意味着，如果您查看一个包，它将有一个时间，它被排队，一个时间，它被接收。我需要做这个计算才能发现它的端到端延迟。但是我也需要对9,999个其他数据包做这件事，才能得到一个平均值。

我想得更多了，以下是我认为算法需要如何工作的一般情况。

unimportant.

• go

• 删除不以+或r开头的所有行，因为它们通过所有的数据包in (即-i后面的数字，例如示例中的1052 )都是+，并将它们放入某种类型的组(可能是多个数组)。

• 每个组现在应该包含有关特定数据包的所有信息。

• 在组内，检查是否有+，理想情况下我们要的是第一个+。记录它的时间。

• 寻找更多的+行。看看他们的时间。可能原木有点乱七八糟。因此，有可能在simulation.

• If后面有一个+行，实际上在that.

• assuming中这个新的+行有一个更早的时间，然后用that.

• assuming更新时间变量--没有更多的+行，寻找一个r行。如果没有timestamp

• The received.

• subtract，那么数据包就被丢弃了，所以不要担心。对于您找到的每一条r线路，我们所需要做的就是找到一个拥有最新时间戳的r r线路，即数据包最终被放置在哪里--从r时间开始的+时间--这给了我们数据包旅行所需的时间。averaged.

• repeat

• 将此值添加到数组中，以便以后可以在每个数据包ID组上对此进程进行处理，然后将创建的延迟数组进行平均处理。

这是很多打字，但我认为这是我可以清楚地在我想要的。我希望我是一位大王，但我没有足够的时间去学习它来完成这个任务。

谢谢你的帮助，如果你有什么问题请告诉我。

Answer 1

正如Iain在对您的问题的评论中所说的，这里没有什么可以处理的，但是如果我理解您想要做的正确的事情，这样的事情应该会奏效：

awk '/^[+r]/{$1~/r/?r[$15]=$2:r[$15]?d[$15]=r[$15]-$2:1} END {for(p in d){sum+=r[p];num++}print sum/num}' trace.file

它跳过不是以'+‘或'r’开头的所有行。如果该行以'r‘开头，则会为r数组增加时间。否则，如果在r数组中找到元素，则计算延迟并将其添加到d数组中。最后，它遍历d数组中的元素，将总延迟和元素数相加，并由此计算平均值。在你的例子中，平均值是0。

主块末尾的:1就在这里，所以我可以使用一个三元表达式，而不是更冗长的if语句。

编辑:使用添加的条件的新表达式：

awk '/^[+r]/{$1~/r/?$3>r[$15]?r[$15]=$3:1:!a[$15]||$3<a[$15]?a[$15]=$3:1} END {for(i in r){sum+=r[i]-a[i];num++}print "Average delay", sum/num}'

或者作为awk文件

/^[+r]/ {
  if ($1 ~ /r/) {
    if ($3 > received[$15])
      received[$15] = $3;
  } else {
    if (!added[$15] || $3 < added[$15])
      added[$15] = $3;
  }
} END {
  for (packet in received) {
    sum += received[packet] - added[packet];
    num++
  }
  print "Average delay", sum/num
}

根据你的算法，1.745是开始的时间，而你写的是2.134。