fix: code formate fix

Author: Shichang-Zhang

mooncake-integration/store/store_py.cpp

@@ -1571,8 +1571,7 @@ PYBIND11_MODULE(store, m) {
                const std::vector<std::vector<uintptr_t>>& all_buffer_ptrs,
                const std::vector<std::vector<size_t>>& all_sizes,
                bool aggregate_same_segment_task = false,
-               const std::optional<ReadConfigExt>& config_opt =
-                   std::nullopt) {
+               const std::optional<ReadConfigExt>& config_opt = std::nullopt) {
                 ReadConfigExt config = config_opt.value_or(ReadConfigExt{});
                 py::gil_scoped_release release;
                 if (self.use_dummy_client_) {

mooncake-store/include/client_rpc_types.h

@@ -107,7 +107,8 @@ struct WriteCommitRequest {
 
 YLT_REFL(WriteCommitRequest, key, pending_write_token);
 
-/** Drops a pending PreWrite allocation without committing (e.g. after TE failure). */
+/** Drops a pending PreWrite allocation without committing (e.g. after TE
+ * failure). */
 struct WriteRevokeRequest {
     std::string_view key;
     UUID pending_write_token;

mooncake-store/include/client_service.h

@@ -158,8 +158,7 @@ class ClientService {
      */
     virtual tl::expected<int64_t, ErrorCode> Get(
         const std::string& key, const std::vector<void*>& buffers,
-        const std::vector<size_t>& sizes,
-        const ReadConfigExt& config = {}) = 0;
+        const std::vector<size_t>& sizes, const ReadConfigExt& config = {}) = 0;
 
     /**
      * @brief Batch get data into user-provided buffers

mooncake-store/include/data_manager.h

@@ -202,7 +202,7 @@ class DataManager {
      *        Used when forward TE fails after PreWrite on the peer.
      */
     tl::expected<void, ErrorCode> WriteRevoke(std::string_view key,
-                                             const UUID& pending_write_token);
+                                              const UUID& pending_write_token);
 
     tl::expected<PinKeyResponse, ErrorCode> PinKey(
         std::string_view key, std::optional<UUID> tier_id = std::nullopt);
@@ -350,8 +350,9 @@ class DataManager {
         const std::vector<RemoteBufferDesc>& remote_buffers,
         Transport::TransferRequest::OpCode opcode);
 
-    tl::expected<std::vector<std::tuple<Transport::BatchID, size_t, std::string>>,
-                 ErrorCode>
+    tl::expected<
+        std::vector<std::tuple<Transport::BatchID, size_t, std::string>>,
+        ErrorCode>
     SubmitTeTransferBatches(void* transfer_ptr, size_t total_data_size,
                             const std::vector<RemoteBufferDesc>& remote_buffers,
                             Transport::TransferRequest::OpCode opcode);

mooncake-store/include/p2p_rpc_types.h

@@ -49,7 +49,8 @@ struct WriteConfigExt {
     RdmaDirectionMode rdma_direction_mode = RdmaDirectionMode::REVERSE;
 
     WriteConfigExt() = default;
-    /** Promotes legacy write-route-only config for variant overload resolution. */
+    /** Promotes legacy write-route-only config for variant overload resolution.
+     */
     WriteConfigExt(WriteRouteRequestConfig r) : route_config(std::move(r)) {}
 };
 YLT_REFL(WriteConfigExt, route_config, rdma_direction_mode);

mooncake-store/include/pyclient.h

@@ -44,15 +44,13 @@ class PyClient {
 
     virtual std::vector<int64_t> batch_get_into(
         const std::vector<std::string>& keys, const std::vector<void*>& buffers,
-        const std::vector<size_t>& sizes,
-        const ReadConfigExt& config = {}) = 0;
+        const std::vector<size_t>& sizes, const ReadConfigExt& config = {}) = 0;
 
     virtual std::vector<int> batch_get_into_multi_buffers(
         const std::vector<std::string>& keys,
         const std::vector<std::vector<void*>>& all_buffers,
         const std::vector<std::vector<size_t>>& all_sizes,
-        bool aggregate_same_segment_task,
-        const ReadConfigExt& config = {}) = 0;
+        bool aggregate_same_segment_task, const ReadConfigExt& config = {}) = 0;
 
     virtual int put_from(const std::string& key, void* buffer, size_t size,
                          const WriteConfig& config) = 0;

mooncake-store/include/real_client.h

@@ -406,8 +406,7 @@ class RealClient : public PyClient {
         const ReadConfigExt& config = {});
 
     std::vector<std::shared_ptr<BufferHandle>> batch_get_buffer_internal(
-        const std::vector<std::string>& keys,
-        const ReadConfigExt& config = {});
+        const std::vector<std::string>& keys, const ReadConfigExt& config = {});
 
     std::map<std::string, std::vector<Replica::Descriptor>>
     batch_get_replica_desc(const std::vector<std::string>& keys);

mooncake-store/src/centralized_client_service.cpp

@@ -242,7 +242,8 @@ CentralizedClientService::Query(const std::string& object_key,
     }
     std::chrono::steady_clock::time_point start_time =
         std::chrono::steady_clock::now();
-    auto result = master_client_.GetReplicaList(object_key, config.route_config);
+    auto result =
+        master_client_.GetReplicaList(object_key, config.route_config);
     if (!result) {
         LOG(ERROR) << "Failed to get replica list: " << result.error();
         return tl::unexpected(result.error());
@@ -262,8 +263,7 @@ CentralizedClientService::Query(const std::string& object_key,
 
 std::vector<tl::expected<std::unique_ptr<QueryResult>, ErrorCode>>
 CentralizedClientService::BatchQuery(
-    const std::vector<std::string>& object_keys,
-    const ReadConfigExt& config) {
+    const std::vector<std::string>& object_keys, const ReadConfigExt& config) {
     auto guard = AcquireInflightGuard();
     if (!guard.is_valid()) {
         LOG(ERROR) << "client is shutting down";
@@ -279,7 +279,8 @@ CentralizedClientService::BatchQuery(
         std::chrono::steady_clock::now();
     std::vector<std::string_view> key_views(object_keys.begin(),
                                             object_keys.end());
-    auto response = master_client_.BatchGetReplicaList(key_views, config.route_config);
+    auto response =
+        master_client_.BatchGetReplicaList(key_views, config.route_config);
 
     // Check if we got the expected number of responses
     if (response.size() != object_keys.size()) {

mooncake-store/src/data_manager.cpp

@@ -509,7 +509,8 @@ DataManager::PutViaTe(std::string_view key, std::vector<Slice>& slices) {
         return tl::unexpected(validate_result.error());
     }
 
-    // Local Put: allocation follows tier backend policy (not restricted to DRAM).
+    // Local Put: allocation follows tier backend policy (not restricted to
+    // DRAM).
     auto prewrite_result =
         PreWriteInternal(kctx, total_size, std::nullopt, false);
     if (!prewrite_result) {
@@ -882,8 +883,7 @@ tl::expected<UUID, ErrorCode> DataManager::WriteRemoteData(
 
     // Reverse RDMA path: still one RPC, but internally use the 3-phase write
     // model (PreWrite -> transfer -> WriteCommit). Target tier may be non-DRAM.
-    auto prewrite_result =
-        PreWriteInternal(kctx, total_size, tier_id, false);
+    auto prewrite_result = PreWriteInternal(kctx, total_size, tier_id, false);
     if (!prewrite_result) {
         timer.LogResponse("error_code=", prewrite_result.error());
         return tl::make_unexpected(prewrite_result.error());
@@ -926,10 +926,9 @@ tl::expected<PreWriteResponse, ErrorCode> DataManager::PreWrite(
     return PreWriteInternal(BuildKeyCtx(key), size_bytes, tier_id, true);
 }
 
-tl::expected<PreWriteResponse, ErrorCode>
-DataManager::PreWriteInternal(const KeyCtx& ctx, size_t size_bytes,
-                              std::optional<UUID> tier_id,
-                              bool enforce_dram_allocation) {
+tl::expected<PreWriteResponse, ErrorCode> DataManager::PreWriteInternal(
+    const KeyCtx& ctx, size_t size_bytes, std::optional<UUID> tier_id,
+    bool enforce_dram_allocation) {
     ScopedVLogTimer timer(1, "DataManager::PreWrite");
     timer.LogRequest("key=", ctx.key, "size_bytes=", size_bytes);
 
@@ -963,11 +962,11 @@ DataManager::PreWriteInternal(const KeyCtx& ctx, size_t size_bytes,
 
     auto handle = std::move(handle_result.value());
     // When enforce_dram_allocation is true (RPC PreWrite): only DRAM is wired
-    // for forward TE today; non-DRAM tiers TODO. Local Put / WriteRemoteData use
-    // false and skip this check.
-    if (enforce_dram_allocation &&
-        handle->loc.data.type != MemoryType::DRAM) {
-        timer.LogResponse("error_code=", ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
+    // for forward TE today; non-DRAM tiers TODO. Local Put / WriteRemoteData
+    // use false and skip this check.
+    if (enforce_dram_allocation && handle->loc.data.type != MemoryType::DRAM) {
+        timer.LogResponse("error_code=",
+                          ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
         return tl::make_unexpected(ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
     }
     auto list_it = shard.ordered_list.emplace(shard.ordered_list.end(),
@@ -1075,7 +1074,8 @@ tl::expected<PinKeyResponse, ErrorCode> DataManager::PinKeyInternal(
     RemoveExpiredPinnedKeyLocked(shard, ctx.key_string, now);
     auto record_it = shard.by_key.find(ctx.key_string);
     if (record_it != shard.by_key.end()) {
-        // PinKey forward path: DRAM-only for now; non-DRAM replica handling TODO.
+        // PinKey forward path: DRAM-only for now; non-DRAM replica handling
+        // TODO.
         if (record_it->second.handle->loc.data.type != MemoryType::DRAM) {
             timer.LogResponse("error_code=",
                               ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
@@ -1103,7 +1103,8 @@ tl::expected<PinKeyResponse, ErrorCode> DataManager::PinKeyInternal(
     auto handle = std::move(handle_result.value());
     // PinKey forward path: DRAM-only for now; non-DRAM replica handling TODO.
     if (handle->loc.data.type != MemoryType::DRAM) {
-        timer.LogResponse("error_code=", ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
+        timer.LogResponse("error_code=",
+                          ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
         return tl::make_unexpected(ErrorCode::UNAVAILABLE_IN_CURRENT_MODE);
     }
     auto list_it = shard.ordered_list.emplace(shard.ordered_list.end(),
@@ -1275,8 +1276,8 @@ DataManager::SubmitTeTransferInternal(
             std::move(buffer_result.value());
     }
 
-    auto batches_result = SubmitTeTransferBatches(
-        transfer_ptr, total_data_size, remote_buffers, opcode);
+    auto batches_result = SubmitTeTransferBatches(transfer_ptr, total_data_size,
+                                                  remote_buffers, opcode);
     if (!batches_result) {
         return tl::unexpected(batches_result.error());
     }