feat(proto): add server-measured fields to DeviceProfileData (#45 step 1)

Append 5 optional fields to proto.DeviceProfileData (tags 8-12):
measured_flops, measured_flops_verified, measured_lat_ns,
measured_ul_bw_bps, measured_dl_bw_bps. Mirror in the C++ struct with
zero defaults, extend SerializeProto/DeserializeProto with has_*
guards, and have DebugString surface the new fields only when set.

Wire-compat: legacy clients/servers continue to round-trip the 7
required fields unchanged because the new fields are protobuf optional.
Locked in by test_device_profile_roundtrip (LegacyFieldsOnly,
LegacyPlusMeasured, DebugStringMentionsMeasuredWhenSet).

This is step 1 of the #45 plan. Steps 2-8 (DeviceMeasurementService,
probe opcodes, server wiring, env-var config, docs, integration tests)
follow.

Author: xly

csrc/backend/matrix_partition.cpp

@@ -697,6 +697,15 @@ std::string DeviceProfileData::DebugString() const {
   oss << "uuid: " << uuid << ", flops: " << flops << ", memory: " << memory
       << ", ul_bw: " << ul_bw << ", dl_bw: " << dl_bw << ", ul_lat: " << ul_lat
       << ", dl_lat: " << dl_lat;
+  if (measured_flops != 0 || measured_lat_ns != 0 || measured_ul_bw_bps != 0 ||
+      measured_dl_bw_bps != 0) {
+    oss << ", measured_flops: " << measured_flops
+        << ", measured_flops_verified: "
+        << (measured_flops_verified ? "true" : "false")
+        << ", measured_lat_ns: " << measured_lat_ns
+        << ", measured_ul_bw_bps: " << measured_ul_bw_bps
+        << ", measured_dl_bw_bps: " << measured_dl_bw_bps;
+  }
   return oss.str();
 }
 
@@ -733,6 +742,14 @@ SerializationBufferPtr DeviceProfileData::SerializeProto() const {
   profile_msg->set_ul_lat(ul_lat);
   profile_msg->set_dl_lat(dl_lat);
 
+  if (measured_flops != 0) profile_msg->set_measured_flops(measured_flops);
+  if (measured_flops_verified) profile_msg->set_measured_flops_verified(true);
+  if (measured_lat_ns != 0) profile_msg->set_measured_lat_ns(measured_lat_ns);
+  if (measured_ul_bw_bps != 0)
+    profile_msg->set_measured_ul_bw_bps(measured_ul_bw_bps);
+  if (measured_dl_bw_bps != 0)
+    profile_msg->set_measured_dl_bw_bps(measured_dl_bw_bps);
+
   // Serialize (no tensor data for DeviceProfileData)
   std::string proto_str = umsg.SerializeAsString();
   uint32_t proto_size = proto_str.size();
@@ -788,6 +805,20 @@ void DeviceProfileData::DeserializeProto(const void* data, size_t size) {
   dl_bw = profile_msg.dl_bw();
   ul_lat = profile_msg.ul_lat();
   dl_lat = profile_msg.dl_lat();
+
+  measured_flops =
+      profile_msg.has_measured_flops() ? profile_msg.measured_flops() : 0ULL;
+  measured_flops_verified = profile_msg.has_measured_flops_verified()
+                                ? profile_msg.measured_flops_verified()
+                                : false;
+  measured_lat_ns =
+      profile_msg.has_measured_lat_ns() ? profile_msg.measured_lat_ns() : 0ULL;
+  measured_ul_bw_bps = profile_msg.has_measured_ul_bw_bps()
+                           ? profile_msg.measured_ul_bw_bps()
+                           : 0ULL;
+  measured_dl_bw_bps = profile_msg.has_measured_dl_bw_bps()
+                           ? profile_msg.measured_dl_bw_bps()
+                           : 0ULL;
 }
 
 // ============================================================================

csrc/backend/server_base.h

@@ -202,13 +202,20 @@ typedef std::shared_ptr<DeviceRegisterRequest> DeviceRegisterRequestPtr;
 // Device profile data (client -> server)
 // Contains device performance characteristics and capabilities
 struct DeviceProfileData : public ISerializable {
-  uint64_t uuid;
-  uint64_t flops;
-  uint64_t memory;
-  uint64_t ul_bw;   // upload bandwidth
-  uint64_t dl_bw;   // download bandwidth
-  uint64_t ul_lat;  // upload latency
-  uint64_t dl_lat;  // download latency
+  uint64_t uuid = 0;
+  uint64_t flops = 0;
+  uint64_t memory = 0;
+  uint64_t ul_bw = 0;   // upload bandwidth
+  uint64_t dl_bw = 0;   // download bandwidth
+  uint64_t ul_lat = 0;  // upload latency
+  uint64_t dl_lat = 0;  // download latency
+
+  // Server-measured fields (#45). Zero means "not measured".
+  uint64_t measured_flops = 0;
+  bool measured_flops_verified = false;
+  uint64_t measured_lat_ns = 0;
+  uint64_t measured_ul_bw_bps = 0;
+  uint64_t measured_dl_bw_bps = 0;
 
   // ISerializable interface
   SerializationBufferPtr Serialize(

proto/global_api.proto

@@ -44,6 +44,14 @@ message DeviceProfileData {
     required uint64 dl_bw = 5;
     required uint64 ul_lat = 6;
     required uint64 dl_lat = 7;
+
+    // Server-measured fields (#45). Optional so legacy clients/servers
+    // round-trip without breakage; unset == "not measured".
+    optional uint64 measured_flops = 8;
+    optional bool   measured_flops_verified = 9;
+    optional uint64 measured_lat_ns = 10;
+    optional uint64 measured_ul_bw_bps = 11;
+    optional uint64 measured_dl_bw_bps = 12;
 }
 
 message ComputeGemmData {

tests/cpp/unit/zerocopy/CMakeLists.txt

@@ -62,6 +62,7 @@ add_zerocopy_test(test_aligned_buffer_pool)
 add_zerocopy_test(test_serialization_buffer)
 add_zerocopy_test(test_scatter_gather_buffer)
 add_zerocopy_test(test_matrix_partition)
+add_zerocopy_test(test_device_profile_roundtrip)
 
 # ============================================================================
 # CUDA Pinned Pool Test (uses CUDAToolkit from parent project)

tests/cpp/unit/zerocopy/test_device_profile_roundtrip.cpp

@@ -0,0 +1,85 @@
+// Issue #45 Step 1: DeviceProfileData carries server-measured fields.
+//
+// Locks in two contracts:
+//  - Legacy payloads (without measured_* fields) deserialize cleanly,
+//    leaving the new optional fields at their default value 0.
+//  - Round-tripping a struct with measured_* set preserves all 12 fields.
+
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include "backend/serialization_buffer.h"
+#include "backend/server_base.h"
+
+namespace {
+
+DeviceProfileData LegacyProfile() {
+  DeviceProfileData p{};
+  p.uuid = 0x1122334455667788ULL;
+  p.flops = 100000000000ULL;
+  p.memory = 16ULL * 1024 * 1024 * 1024;
+  p.ul_bw = 10ULL * 1024 * 1024 * 1024;
+  p.dl_bw = 10ULL * 1024 * 1024 * 1024;
+  p.ul_lat = 1000;
+  p.dl_lat = 1000;
+  return p;
+}
+
+TEST(DeviceProfileDataRoundtrip, LegacyFieldsOnly) {
+  DeviceProfileData src = LegacyProfile();
+  auto buf = src.Serialize();
+  ASSERT_TRUE(buf != nullptr);
+
+  DeviceProfileData dst{};
+  dst.Deserialize(buf->GetBuffer(), buf->GetSize());
+
+  EXPECT_EQ(dst.uuid, src.uuid);
+  EXPECT_EQ(dst.flops, src.flops);
+  EXPECT_EQ(dst.memory, src.memory);
+  EXPECT_EQ(dst.ul_bw, src.ul_bw);
+  EXPECT_EQ(dst.dl_bw, src.dl_bw);
+  EXPECT_EQ(dst.ul_lat, src.ul_lat);
+  EXPECT_EQ(dst.dl_lat, src.dl_lat);
+
+  // New optional fields default to 0 when sender omits them.
+  EXPECT_EQ(dst.measured_flops, 0ULL);
+  EXPECT_EQ(dst.measured_lat_ns, 0ULL);
+  EXPECT_EQ(dst.measured_ul_bw_bps, 0ULL);
+  EXPECT_EQ(dst.measured_dl_bw_bps, 0ULL);
+  EXPECT_FALSE(dst.measured_flops_verified);
+}
+
+TEST(DeviceProfileDataRoundtrip, LegacyPlusMeasured) {
+  DeviceProfileData src = LegacyProfile();
+  src.measured_flops = 95000000000ULL;
+  src.measured_flops_verified = true;
+  src.measured_lat_ns = 250000ULL;
+  src.measured_ul_bw_bps = 9ULL * 1024 * 1024 * 1024;
+  src.measured_dl_bw_bps = 8ULL * 1024 * 1024 * 1024;
+
+  auto buf = src.Serialize();
+  ASSERT_TRUE(buf != nullptr);
+
+  DeviceProfileData dst{};
+  dst.Deserialize(buf->GetBuffer(), buf->GetSize());
+
+  EXPECT_EQ(dst.uuid, src.uuid);
+  EXPECT_EQ(dst.measured_flops, src.measured_flops);
+  EXPECT_TRUE(dst.measured_flops_verified);
+  EXPECT_EQ(dst.measured_lat_ns, src.measured_lat_ns);
+  EXPECT_EQ(dst.measured_ul_bw_bps, src.measured_ul_bw_bps);
+  EXPECT_EQ(dst.measured_dl_bw_bps, src.measured_dl_bw_bps);
+}
+
+TEST(DeviceProfileDataRoundtrip, DebugStringMentionsMeasuredWhenSet) {
+  DeviceProfileData src = LegacyProfile();
+  src.measured_flops = 95000000000ULL;
+  src.measured_flops_verified = true;
+
+  const auto s = src.DebugString();
+  EXPECT_NE(s.find("measured_flops"), std::string::npos);
+  EXPECT_NE(s.find("95000000000"), std::string::npos);
+}
+
+}  // namespace