《Steam 游戏平台:开发与商业化》8.3 网络可靠性工程

网络可靠性落在发送标志与消息上限上:可靠消息带单调消息号、经重传恰好一次按序投递,不可靠可能丢失,单消息上限 512KiB(k_cbMaxSteamNetworkingSocketsMessageSizeSend),连接断开后发送返回 NoConnection。本节讲可靠性的接口工程语义,lab 用 C++ mock 复现重传、丢包与消息号延续。

8.3 网络可靠性工程

8.2 讲了「会话与消息」,这一节把可靠性讲透:Steam 网络层的可靠性由发送标志、消息号与大小上限共同约束。可靠消息由 SDK 分配单调递增的消息号,重传后仍保证恰好一次、按序投递;不可靠消息可能丢;单条消息有 512 KiB 上限;连接断开后发送返回错误。接入工程要理解这些约束,才能设计不会「发爆」「发丢关键状态」的协议。

本卷所有接口口径以 Steamworks SDK v1.65(2026-07-23) 为准。本节摘录的签名对照该版本 public/steam/isteamnetworkingsockets.h 与 public/steam/steamnetworkingtypes.h。

本章与站内既有内容的分工

  • 8.2 讲 Messages 家族的会话与频道;本节讲可靠性的工程约束——消息号、重传、大小上限、断开语义。
  • 8.1 的连接状态机是本节的基础(断开后发送返回 NoConnection 即来自状态机)。
  • lab 用纯 C++ 复现「可靠重传 + 恰好一次按序」「不可靠丢包」「大小上限」「断开拒绝发送」,不依赖 Steam 客户端运行。

可靠发送:消息号与重传

可靠消息的核心是「恰好一次、按序」。v1.65 发送入口:

// isteamnetworkingsockets.h:SendMessageToConnection / ReceiveMessagesOnConnection(SDK v1.65 头文件摘录,已删减)
virtual EResult SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, int nSendFlags, int64 *pOutMessageNumber, bool *pbReliable ) = 0;
virtual int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;

工程语义:

  1. 消息号由 SDK 分配:pOutMessageNumber 输出本消息的编号(可靠消息才有意义),单调递增。接入工程用消息号做协议层确认(如「我收到 120,请从 121 继续」),不要在应用层再造一套序号。
  2. 可靠 = 重传直到确认:丢包后 SDK 自动重传,应用层只看到恰好一次、按序的交付。工程上「按序」意味着收端可能短暂落后(缺失的消息在重传路上),协议处理要容忍排序窗口。
  3. 可靠发送会排队:可靠消息在网络上可能累积。高频状态不要全发可靠,否则重传风暴会把管道塞满(这是联机工程最常见的失败模式)。

不可靠发送与丢包

不可靠消息是可靠性的「另一面」——不保证到达。v1.65 标志与上限:

// steamnetworkingtypes.h:k_nSteamNetworkingSend_Reliable / k_nSteamNetworkingSend_Unreliable / k_cbMaxSteamNetworkingSocketsMessageSizeSend(SDK v1.65 头文件摘录,已删减)
const int k_nSteamNetworkingSend_Unreliable = 0;
// Reliable message send. Can send up to k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message.
const int k_nSteamNetworkingSend_Reliable = 8;
const int k_cbMaxSteamNetworkingSocketsMessageSizeSend = 512 * 1024;

工程语义:

  1. 不可靠发送可能静默丢失:发送调用本身返回成功,但网络可能把消息丢掉。接入工程不要把不可靠消息用于「必须到达」的状态;位置、心跳、日志这类可替换数据用不可靠。
  2. 单消息 512 KiB 上限:k_cbMaxSteamNetworkingSocketsMessageSizeSend = 512 * 1024。超过上限的发送返回 k_EResultInvalidParam。大对象(地图、模型)要切片或走创意工坊内容管道,不要塞进网络消息。
  3. 混用策略:协议设计时把「关键且低频」划给可靠、「高频且可替换」划给不可靠。同一连接上两类消息并行是正常的。

断开语义与连接状态

连接断开后,发送行为由状态机决定。v1.65 语义:

// steamnetworkingtypes.h:ESteamNetworkingConnectionState 关键状态(SDK v1.65 头文件摘录,已删减)
k_ESteamNetworkingConnectionState_ClosedByPeer = 4,	// 对端关闭
k_ESteamNetworkingConnectionState_ProblemDetectedLocally = 5,	// 本端发现问题

工程语义:

  1. 断开后发送返回 NoConnection:连接已失效时调用 SendMessageToConnection 返回 k_EResultNoConnection,不再排队。接入工程要在协议层把这个返回值翻译成「重连或退出房间」。
  2. 重连后消息号延续:SDK 的消息号在重连后继续递增(同一连接上下文),不会重置。应用层确认号要能跨重连工作,不要假设从 0 重新开始。
  3. 状态机驱动重连:收到 SteamNetConnectionStatusChangedCallback_t 且状态为 ClosedByPeer/ProblemDetectedLocally 时,清理本端句柄并发起重连(限速退避),而不是继续发送。

接口签名对照

头文件条目语义
isteamnetworkingsockets.hISteamNetworkingSockets::SendMessageToConnection发送(输出消息号 + 可靠标志)
isteamnetworkingsockets.hISteamNetworkingSockets::ReceiveMessagesOnConnection接收消息
steamnetworkingtypes.hk_nSteamNetworkingSend_Reliable可靠发送(=8,重传 + 恰好一次按序)
steamnetworkingtypes.hk_nSteamNetworkingSend_Unreliable不可靠发送(=0,可能丢)
steamnetworkingtypes.hk_cbMaxSteamNetworkingSocketsMessageSizeSend单消息上限 512 KiB
steamnetworkingtypes.hESteamNetworkingConnectionState断开/问题状态(关闭语义)

数据口径与来源

  • 接口签名、消息号输出参数、大小上限常量:SDK v1.65 public/steam/isteamnetworkingsockets.h 与 public/steam/steamnetworkingtypes.h 可实证(本机镜像已核对)。
  • 具体丢包率、延迟、带宽:运行时数据,以官方当前为准。

以上接口口径撰写时对照 Steamworks SDK v1.65 头文件与 partner.steamgames.com 官方文档核对;登录后可见数据以官方当前为准。

可运行产物:C++ 最小验证

下面的仿真复现「网络可靠性工程」的接口工程语义:可靠发送分配单调消息号、单消息 512 KiB 上限拒绝超限、无丢包恰好一次按序投递、丢包后可靠消息重传仍恰好一次按序、不可靠消息丢失、断开后发送返回 NoConnection、重连后消息号延续不重置。它与 src/08-3-networking-reliability.cpp 逐字节一致,mock 签名对照 SDK v1.65 头文件:

// file: src/08-3-networking-reliability.cpp
// tier: L1
// verify: clang++ -std=c++20 -Wall -I. src/08-3-networking-reliability.cpp -o bin/08-3-networking-reliability && ./bin/08-3-networking-reliability
//
// mock:复现网络可靠性的接口工程语义——可靠/不可靠发送标志、单消息大小上限
// (k_cbMaxSteamNetworkingSocketsMessageSizeSend)、可靠消息重传与恰好一次按序、
// 不可靠消息丢失、连接断开后发送失败。
// 签名对照 SDK v1.65 steamnetworkingtypes.h 发送标志,非 Valve 实现。
#include "verify.h"

#include <string>
#include <vector>

namespace steam_repro {

// k_nSteamNetworkingSend_Reliable / Unreliable 对照 steamnetworkingtypes.h
const int kSendReliable = 8;
const int kSendUnreliable = 0;
// k_cbMaxSteamNetworkingSocketsMessageSizeSend 对照 steamnetworkingtypes.h
constexpr size_t kMaxMessageSizeSend = 512 * 1024;

// EResult 简化为负数便于断言
constexpr int kResultOK = 0;
constexpr int kResultInvalidParam = -1;
constexpr int kResultNoConnection = -2;

struct MockMessage {
  std::string data;
  int64_t msgNum = 0;
  bool retransmitted = false;
};

class MockReliableTransport {
 public:
  bool connect() {
    connected_ = true;
    return true;
  }
  void disconnect() { connected_ = false; }

  // ISteamNetworkingSockets::SendMessageToConnection:返回 EResult。
  // 可靠消息分配单调消息号;不可靠消息在丢包标记下直接丢弃。
  int send(const std::string& data, int flags) {
    if (data.size() > kMaxMessageSizeSend) return kResultInvalidParam;
    if (!connected_) return kResultNoConnection;
    if ((flags & kSendReliable) == 0) {
      if (dropNext_) {
        dropNext_ = false;
        return kResultOK;  // 不可靠消息被网络丢弃,但发送调用本身成功
      }
      rx_.push_back({data, 0, false});
      return kResultOK;
    }
    pending_.push_back({data, ++seq_, false});
    return kResultOK;
  }

  // 模拟网络丢包标记:下一条不可靠消息丢失
  void markNextUnreliableDrop() { dropNext_ = true; }

  // 网络泵:一次传输机会。loss=true 时,未重传过的可靠消息被扣下等待重传。
  void pump(bool loss) {
    std::vector<MockMessage> keep;
    for (MockMessage& m : pending_) {
      if (loss && !m.retransmitted) {
        m.retransmitted = true;
        retransmits_++;
        keep.push_back(m);
        continue;
      }
      rx_.push_back(m);
    }
    pending_ = keep;
  }

  // 取回已投递消息(对应 ReceiveMessagesOnConnection)
  int receive(std::string* out, int max) {
    int n = 0;
    std::vector<MockMessage> keep;
    for (const MockMessage& m : rx_) {
      if (n < max) {
        out[n++] = m.data;
      } else {
        keep.push_back(m);
      }
    }
    rx_ = keep;
    return n;
  }

  int64_t lastMessageNumber() const { return seq_; }
  int retransmitCount() const { return retransmits_; }
  bool hasPending() const { return !pending_.empty(); }

 private:
  bool connected_ = false;
  bool dropNext_ = false;
  int64_t seq_ = 0;
  int retransmits_ = 0;
  std::vector<MockMessage> pending_;
  std::vector<MockMessage> rx_;
};

}  // namespace steam_repro

int main() {
  using namespace steam_repro;
  MockReliableTransport t;
  t.connect();

  std::string out[16];

  // 1. 连接后发送可靠消息成功
  CHECK(t.send("msg-1", kSendReliable) == kResultOK);
  CHECK(t.lastMessageNumber() == 1);

  // 2. 消息号单调递增
  CHECK(t.send("msg-2", kSendReliable) == kResultOK);
  CHECK(t.send("msg-3", kSendReliable) == kResultOK);
  CHECK(t.lastMessageNumber() == 3);

  // 3. 单消息超过 512KiB 上限被拒
  std::string big(kMaxMessageSizeSend + 1, 'x');
  CHECK(t.send(big, kSendReliable) == kResultInvalidParam);

  // 4. 无丢包:一次泵全部按序投递
  t.pump(false);
  CHECK(!t.hasPending());
  CHECK(t.retransmitCount() == 0);
  int n = t.receive(out, 16);
  CHECK(n == 3);
  CHECK(out[0] == "msg-1" && out[1] == "msg-2" && out[2] == "msg-3");

  // 5. 取空后无残留
  CHECK(t.receive(out, 16) == 0);

  // 6. 丢包:可靠消息重传后仍恰好一次按序投递
  CHECK(t.send("r-a", kSendReliable) == kResultOK);
  CHECK(t.send("r-b", kSendReliable) == kResultOK);
  t.pump(true);   // 首轮丢包:r-a/r-b 被扣下重传
  CHECK(t.retransmitCount() == 2);
  CHECK(t.hasPending());
  t.pump(false);  // 次轮投递
  CHECK(!t.hasPending());
  n = t.receive(out, 16);
  CHECK(n == 2);
  CHECK(out[0] == "r-a" && out[1] == "r-b");

  // 7. 不可靠消息正常投递
  CHECK(t.send("u-ok", kSendUnreliable) == kResultOK);
  CHECK(t.receive(out, 16) == 1);
  CHECK(out[0] == "u-ok");

  // 8. 不可靠消息被标记丢失后不投递
  t.markNextUnreliableDrop();
  CHECK(t.send("u-lost", kSendUnreliable) == kResultOK);
  CHECK(t.receive(out, 16) == 0);

  // 9. 断开连接后发送失败
  t.disconnect();
  CHECK(t.send("x", kSendReliable) == kResultNoConnection);
  CHECK(t.send("y", kSendUnreliable) == kResultNoConnection);

  // 10. 重连后消息号延续(不重置),可靠性状态机继续
  CHECK(t.connect());
  CHECK(t.send("after-reconnect", kSendReliable) == kResultOK);
  CHECK(t.lastMessageNumber() == 6);

  return lab::report("08-3 网络可靠性工程");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 28/28 通过。

小结

  • 可靠消息带 SDK 分配的单调消息号,重传后恰好一次按序投递;应用层用消息号做确认。
  • 不可靠消息可能静默丢失,只用于可替换数据;可靠消息会排队,高频状态全发可靠会塞管道。
  • 单消息上限 512 KiB,超限返回 InvalidParam;大对象走创意工坊内容管道或切片。
  • 断开后发送返回 NoConnection;重连后消息号延续不重置,应用层确认号要能跨重连工作。

阅读导航:上一节:8.2 P2P 会话与消息 · 下一节:9.1 游戏服务器机制 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析·向量数据库与 AI 检索内核》 · 目录与学习路径(45 篇)
  2. 《大规模分布式计算深入解析》15.3 自研向量引擎:可执行骨架与工程缺口
  3. 《大规模分布式计算深入解析》14.1 Milvus:组件架构、段管理与检索链路