【网络编程实践】2.1.2 实现 ttcp 程序

使用 ttcp 作为例子的理由

1. 使用了基本的sockets APIs：socket，listen， bind， accept，connect，read/recv，write/send，shutdown，close 等等
2. 协议带有格式，不只是字节流，相较于echo具有tcp分包处理等
3. ttcp 本身是由 tcp/ip 实现的程序，具有一些典型的行为。可以阅读其代码学习它的一些优秀实现
4. 协议简单，可以由多种语言实现，针对测试结果对比个语言实现的runtime开销
5. 无并发连接，client与server之间只有一个tcp socket

ttcp 用到的协议

这里粗箭头表示有效载荷的数据，以 1 为例： 这里的 len=8192 对应右侧 结构体 PayloadMessage::length 成员携带的数据，表示第二个成员的 data 的长度。 而length本身占4个字节，因此这一次发送数据长度为 8192+4 。
（注意这里的PayloadMessage::data成员是一个柔性数组，大小由运行时写入的数据为准，所以这里需要一个length成员记录data的长度）

可以注意到，ttcp发送数据会有一个Ack应答，相对于netcat只发送不接收而言，理论上讲ttcp检测出的带宽要慢于netcat测出的结果，特别对于网络有延迟的情况而言，发送数据和Ack都会有延迟产生。

代码：https://github.com/chenshuo/muduo.git

• 直线型的阻塞IO示例：
  • muduo/examples/ace/ttcp/ttcp_blocking.cc （C with sockets API）
  • recipes/tpc/ttcp.cc （C++ with a thin wrapper）
  • muduo-examples-in-go/examples/ace/ttcp/ttcp.go （Go）
• 非阻塞IO库示例：
  • muduo/examples/ace/ttcp/ttcp.cc

以上示例都不支持并发连接，前三个示例每个连接起一个线程来处理就可以支持并发，第四个在设计上收到最后一条消息就退出，将退出语句注释掉可以支持并发。

ttcp 代码分析 及 测试角度

C服务端（接收函数）注解：

// 选自 muduo/examples/ace/ttcp/ttcp_blocking.cc 接收函数。 C语言实现

/* 服务端：接收 */
void receive(const Options& opt)
{
  int sockfd = acceptOrDie(opt.port); // 接收连接

  struct SessionMessage sessionMessage = { 0, 0 };  // 接收消息，comment.h 中定义 8 字节
  if (read_n(sockfd, &sessionMessage, sizeof(sessionMessage)) != sizeof(sessionMessage)) // 保证完整的读取 8 字节
  {
    perror("read SessionMessage");
    exit(1);
  }
  /* sessionMessage.number 条消息，每条消息长 sessionMessage.length */ 
  sessionMessage.number = ntohl(sessionMessage.number); // 消息由网络字节序 转至 本机字节序
  sessionMessage.length = ntohl(sessionMessage.length);
  printf("receive number = %d\nreceive length = %d\n",  // 服务端打印预计接收的数据大小
         sessionMessage.number, sessionMessage.length);
  const int total_len = static_cast<int>(sizeof(int32_t) + sessionMessage.length);  // 准备缓冲区接收
        // 安全漏洞，对方发送的length值很大，造成缓冲区。 这里可以进行一个判断，限制最大length长度
  PayloadMessage* payload = static_cast<PayloadMessage*>(::malloc(total_len));
  assert(payload);

  for (int i = 0; i < sessionMessage.number; ++i) //  number 次消息循环读取
  {
    payload->length = 0;
    if (read_n(sockfd, &payload->length, sizeof(payload->length)) != sizeof(payload->length)) // 先读4字节的， 这里存放每条消息的长度
    {
      perror("read length");
      exit(1);
    }
    payload->length = ntohl(payload->length);
    assert(payload->length == sessionMessage.length); // 每次消息的 len 应该与 sessionMessage.len 一致
    /* 读消息 */
    if (read_n(sockfd, payload->data, payload->length) != payload->length)  // 读剩余的消息
    {
      perror("read payload data");
      exit(1);
    }
    /* 响应字段，返回本次收到的字节数 */
    int32_t ack = htonl(payload->length);
    if (write_n(sockfd, &ack, sizeof(ack)) != sizeof(ack))
    {
      perror("write ack");
      exit(1);
    }
  }
  ::free(payload);
  ::close(sockfd);
}

C++客户端（发送函数）代码注解：

// 选自 recipes/tpc/ttcp.cc 发送函数。 C++实现

void transmit(const Options& opt)
{
  InetAddress addr(opt.port); // 拿到地址的端口
  if (!InetAddress::resolve(opt.host.c_str(), &addr)) // 将主机名解析成ip地址
  {
    printf("Unable to resolve %s\n", opt.host.c_str());
    return;
  }

  printf("connecting to %s\n", addr.toIpPort().c_str());
  TcpStreamPtr stream(TcpStream::connect(addr));  // 连接
  if (!stream)
  {
    printf("Unable to connect %s\n", addr.toIpPort().c_str());
    perror("");
    return;
  }

  if (opt.nodelay)  // 禁用Nagle算法，即可以有多个 未确认的分组的报文（tcp应答ack）
  {
    stream->setTcpNoDelay(true);
  }
  printf("connected\n");
  double start = now();
  struct SessionMessage sessionMessage = { 0, 0 };
  sessionMessage.number = htonl(opt.number);
  sessionMessage.length = htonl(opt.length);
  if (stream->sendAll(&sessionMessage, sizeof(sessionMessage)) != sizeof(sessionMessage))
  {
    perror("write SessionMessage");
    return;
  }
  /* 构造 PayloadMessage */
  const int total_len = sizeof(int32_t) + opt.length;
  PayloadMessage* payload = static_cast<PayloadMessage*>(::malloc(total_len));
  std::unique_ptr<PayloadMessage, void (*)(void*)> freeIt(payload, ::free); // freeIt 自动析构 
  assert(payload);
  payload->length = htonl(opt.length);
  /* 构造数据，一个循环出现的字符串 */
  for (int i = 0; i < opt.length; ++i)
  {
    payload->data[i] = "0123456789ABCDEF"[i % 16];
  }

  double total_mb = 1.0 * opt.length * opt.number / 1024 / 1024;
  printf("%.3f MiB in total\n", total_mb);

  for (int i = 0; i < opt.number; ++i)
  {
    int nw = stream->sendAll(payload, total_len); // 发送数据给服务端
    assert(nw == total_len);

    int ack = 0;
    int nr = stream->receiveAll(&ack, sizeof(ack)); // 接收服务端返回数据
    assert(nr == sizeof(ack));
    ack = ntohl(ack);
    assert(ack == opt.length);  // 检查服务段收到的数据长度 与 本次发送的长度是否相等
  }

  double elapsed = now() - start; // 计算带宽
  printf("%.3f seconds\n%.3f MiB/s\n", elapsed, total_mb / elapsed);
}

多维性角度的性能测试研究：
在直线型的阻塞IO示例中提供了三种语言实现的服务端/客户端，我们可以从下面几种角度进行性能的测试。

• 从机器角度：选取不同的机器分别充当服务器/客户端的角色，进行性能测试。
• 从语言角度：选取不同的语言实现的服务器/客户端的角色，进行性能测试。
• 从消息角度：选取不同number与length的组合（如n*l 不变，参考反比例函数），进行性能测试。
• 除此之外，干扰性能的因素还有网络的拥堵情况，数据延迟等也可考虑在内。