通过 TCP 套接字发送包含指针的结构的最快方法

Question

请记住，我正在尝试构建亚毫秒级延迟敏感服务器。

因此，我想尽可能减少这个过程。 比如最小化 memcpy 调用。

事情就是这样。

假设，我有以下结构：

struct data {
  int sequence;
  ...
  size_t len;
  void* buf;
}

发送上述结构的最简单方法是：

send(fd, &data.sequence, sizeof(int));
...
send(fd, &data.len, sizeof(size_t));
send(fd, data.buf, data.len);

在大多数情况下，这并没有错。

但是当反复执行时，我注意到这样的代码会产生大量的开销。 （例如，每 2~3 毫秒执行一次）。

随着发出更多的send调用，程序会变慢。

据我测试，下面的代码工作得更快。

size_t sendBufLen = sizeof(int) + ... + sizeof(size_t) + data.len;
void* sendBuf = malloc(sendBufLen);
int sendBufIndex = 0;

memcpy(sendBuf, &data.sequence, sizeof(int));
sendBufIndex += sizeof(int);
...
memcpy(sendBuf + sendBufIndex, &data.len, sizeof(size_t));
sendBufIndex += sizeof(size_t);
memcpy(sendBuf + sendBufIndex, data.buf, data.len);

//finally send
send(fd, sendBuf, sendBufLen);
free(sendBuf);

所以我的问题是，

下面的代码实际上是为了在我的情况下更快地工作吗？

如果不是，那么导致误导结果的缺陷可能是什么？

在进行发送调用之前有没有更好的缓冲方法？

Answer 1

如果你有这样的结构

struct data {
  int sequence;
  ...
  size_t len;
  void* buf;
};

data my_data;

你可以这样发送：

send(fd, &my_data, sizeof(my_data) - sizeof(void*));
send(fd, my_data.buf, my_data.len);

此代码看起来不清楚，如果有人更改字段顺序，则会中断。 但是，它可能比其他方法更快。

还要确保您真正了解字段的位置和大小。 最好用#pragma pack(push, 1)包装你的结构，如下所示：

#pragma pack(push, 1)
struct data {
  int sequence;
  ...
  size_t len;
  void* buf;
};
#pragma pack(pop)