clang-format | Format fbsource with clang-format 21.

nlutsenko · meta-codesync[bot] · commit e6e5e8fabf71 · 2025-10-26T23:40:59.000-07:00
Reviewed By: ChristianK275

Differential Revision: D85317706

fbshipit-source-id: b399c5c4b75252999442b7d7d2778e7a241b0025
diff --git a/contrib/dynamic_embedding/src/tde/bind.cpp b/contrib/dynamic_embedding/src/tde/bind.cpp
@@ -38,13 +38,14 @@ TORCH_LIBRARY(tde, m) {
   m.class_<FetchHandle>("FetchHandle").def("wait", &FetchHandle::Wait);
 
   m.class_<PS>("PS")
-      .def(torch::init<
-           std::string,
-           c10::intrusive_ptr<LocalShardList>,
-           int64_t,
-           int64_t,
-           std::string,
-           int64_t>())
+      .def(
+          torch::init<
+              std::string,
+              c10::intrusive_ptr<LocalShardList>,
+              int64_t,
+              int64_t,
+              std::string,
+              int64_t>())
       .def("fetch", &PS::Fetch)
       .def("evict", &PS::Evict);
 }
diff --git a/contrib/dynamic_embedding/src/tde/details/cacheline_id_transformer_impl.h b/contrib/dynamic_embedding/src/tde/details/cacheline_id_transformer_impl.h
@@ -40,9 +40,10 @@ inline CachelineIDTransformer<
     : num_groups_(
           ((capacity == 0 ? 2 * num_embedding : capacity) + group_size_ - 1) /
           group_size_) /*capacity by default is 2 * num_embedding */,
-      cache_values_(reinterpret_cast<CacheValue*>(alignMalloc(
-          CachelineSize,
-          sizeof(CacheValue) * num_groups_ * group_size_))),
+      cache_values_(
+          reinterpret_cast<CacheValue*>(alignMalloc(
+              CachelineSize,
+              sizeof(CacheValue) * num_groups_ * group_size_))),
       bitmap_(num_embedding) {
   memset(
       cache_values_.get(), 0, sizeof(CacheValue) * num_groups_ * group_size_);
diff --git a/contrib/dynamic_embedding/src/tde/details/io_redis_test.cpp b/contrib/dynamic_embedding/src/tde/details/io_redis_test.cpp
@@ -43,12 +43,18 @@ TEST(TDE, IO_redis) {
       torch::kF32,
       [&](std::vector<torch::Tensor> val) {
         ASSERT_EQ(val.size(), 3);
-        ASSERT_TRUE(val[0].allclose(
-            torch::tensor({1, 2}, torch::TensorOptions().dtype(torch::kF32))));
-        ASSERT_TRUE(val[1].allclose(
-            torch::tensor({3, 4}, torch::TensorOptions().dtype(torch::kF32))));
-        ASSERT_TRUE(val[2].allclose(
-            torch::tensor({5, 9}, torch::TensorOptions().dtype(torch::kF32))));
+        ASSERT_TRUE(
+            val[0].allclose(
+                torch::tensor(
+                    {1, 2}, torch::TensorOptions().dtype(torch::kF32))));
+        ASSERT_TRUE(
+            val[1].allclose(
+                torch::tensor(
+                    {3, 4}, torch::TensorOptions().dtype(torch::kF32))));
+        ASSERT_TRUE(
+            val[2].allclose(
+                torch::tensor(
+                    {5, 9}, torch::TensorOptions().dtype(torch::kF32))));
 
         notification.Done();
       });
diff --git a/contrib/dynamic_embedding/src/tde/details/redis_io_v1.cpp b/contrib/dynamic_embedding/src/tde/details/redis_io_v1.cpp
@@ -92,9 +92,10 @@ struct DB {
 
 struct Prefix {
   constexpr static auto rule = LEXY_LIT("prefix=") >>
-      dsl::capture(dsl::token(dsl::identifier(
-          dsl::ascii::alpha_underscore,
-          dsl::ascii::alpha_digit_underscore)));
+      dsl::capture(dsl::token(
+          dsl::identifier(
+              dsl::ascii::alpha_underscore,
+              dsl::ascii::alpha_digit_underscore)));
   constexpr static auto value =
       lexy::callback<PrefixOpt>([](auto&& str) -> PrefixOpt {
         return PrefixOpt{std::string(str.data(), str.size())};
@@ -263,8 +264,9 @@ void RedisV1::StartThread() {
 void RedisV1::HeartBeat(redis::ContextPtr& connection) {
   for (uint32_t retry = 0; retry < opt_.retry_limit_; ++retry) {
     try {
-      auto reply = redis::ReplyPtr(reinterpret_cast<redisReply*>(
-          redisCommand(connection.get(), "PING")));
+      auto reply = redis::ReplyPtr(
+          reinterpret_cast<redisReply*>(
+              redisCommand(connection.get(), "PING")));
       TORCH_CHECK(
           reply && reply->type == REDIS_REPLY_STRING,
           "Ping should return string");
@@ -283,7 +285,7 @@ redis::ContextPtr RedisV1::Connect() const {
     connection =
         redis::ContextPtr(redisConnect(opt_.host_.c_str(), opt_.port_));
   } else {
-    struct timeval interval {};
+    struct timeval interval{};
     interval.tv_sec = opt_.timeout_ms_ / 1000;
     interval.tv_usec = opt_.timeout_ms_ % 1000 * 1000;
     connection = redis::ContextPtr(
@@ -299,21 +301,24 @@ redis::ContextPtr RedisV1::Connect() const {
   if (!opt_.password_.empty()) {
     redis::ReplyPtr reply;
     if (opt_.username_.empty()) {
-      reply = redis::ReplyPtr(reinterpret_cast<redisReply*>(
-          redisCommand(connection.get(), "AUTH %s", opt_.password_.c_str())));
+      reply = redis::ReplyPtr(
+          reinterpret_cast<redisReply*>(redisCommand(
+              connection.get(), "AUTH %s", opt_.password_.c_str())));
     } else {
-      reply = redis::ReplyPtr(reinterpret_cast<redisReply*>(redisCommand(
-          connection.get(),
-          "AUTH %s %s",
-          opt_.username_.c_str(),
-          opt_.password_.c_str())));
+      reply = redis::ReplyPtr(
+          reinterpret_cast<redisReply*>(redisCommand(
+              connection.get(),
+              "AUTH %s %s",
+              opt_.username_.c_str(),
+              opt_.password_.c_str())));
     }
     CheckStatus("auth error", connection, reply);
   }
 
   if (opt_.db_ != 0) {
-    auto reply = redis::ReplyPtr(reinterpret_cast<redisReply*>(
-        redisCommand(connection.get(), "SELECT %d", opt_.db_)));
+    auto reply = redis::ReplyPtr(
+        reinterpret_cast<redisReply*>(
+            redisCommand(connection.get(), "SELECT %d", opt_.db_)));
     CheckStatus("select db error", connection, reply);
   }
 
diff --git a/contrib/dynamic_embedding/src/tde/ps.h b/contrib/dynamic_embedding/src/tde/ps.h
@@ -50,10 +50,11 @@ class LocalShardList : public torch::CustomClassHolder {
       int64_t col_size,
       c10::intrusive_ptr<TensorList> tensors) {
     // col_start/col_size not used for now.
-    shards_.emplace_back(LocalShard{
-        .row_start_ = row_start,
-        .row_size_ = row_size,
-        .tensors_ = std::move(tensors)});
+    shards_.emplace_back(
+        LocalShard{
+            .row_start_ = row_start,
+            .row_size_ = row_size,
+            .tensors_ = std::move(tensors)});
   }
 
   Container::const_iterator begin() const {
diff --git a/torchrec/csrc/dynamic_embedding/bind.cpp b/torchrec/csrc/dynamic_embedding/bind.cpp
@@ -35,13 +35,14 @@ TORCH_LIBRARY(tde, m) {
   m.class_<FetchHandle>("FetchHandle").def("wait", &FetchHandle::wait);
 
   m.class_<PS>("PS")
-      .def(torch::init<
-           std::string,
-           c10::intrusive_ptr<LocalShardList>,
-           int64_t,
-           int64_t,
-           std::string,
-           int64_t>())
+      .def(
+          torch::init<
+              std::string,
+              c10::intrusive_ptr<LocalShardList>,
+              int64_t,
+              int64_t,
+              std::string,
+              int64_t>())
       .def("fetch", &PS::fetch)
       .def("evict", &PS::evict);
 }
diff --git a/torchrec/csrc/dynamic_embedding/details/redis/redis_io.cpp b/torchrec/csrc/dynamic_embedding/details/redis/redis_io.cpp
@@ -142,8 +142,9 @@ void Redis::start_thread() {
 void Redis::heartbeat(helper::ContextPtr& connection) {
   for (uint32_t retry = 0; retry < opt_.retry_limit; ++retry) {
     try {
-      auto reply = helper::ReplyPtr(reinterpret_cast<redisReply*>(
-          redisCommand(connection.get(), "PING")));
+      auto reply = helper::ReplyPtr(
+          reinterpret_cast<redisReply*>(
+              redisCommand(connection.get(), "PING")));
       TORCH_CHECK(
           reply && reply->type == REDIS_REPLY_STRING,
           "Ping should return string");
@@ -161,7 +162,7 @@ helper::ContextPtr Redis::connect() const {
   if (opt_.timeout_ms == 0) {
     connection = helper::ContextPtr(redisConnect(opt_.host.c_str(), opt_.port));
   } else {
-    struct timeval interval {};
+    struct timeval interval{};
     interval.tv_sec = opt_.timeout_ms / 1000;
     interval.tv_usec = opt_.timeout_ms % 1000 * 1000;
     connection = helper::ContextPtr(
@@ -177,21 +178,24 @@ helper::ContextPtr Redis::connect() const {
   if (!opt_.password.empty()) {
     helper::ReplyPtr reply;
     if (opt_.username.empty()) {
-      reply = helper::ReplyPtr(reinterpret_cast<redisReply*>(
-          redisCommand(connection.get(), "AUTH %s", opt_.password.c_str())));
+      reply = helper::ReplyPtr(
+          reinterpret_cast<redisReply*>(redisCommand(
+              connection.get(), "AUTH %s", opt_.password.c_str())));
     } else {
-      reply = helper::ReplyPtr(reinterpret_cast<redisReply*>(redisCommand(
-          connection.get(),
-          "AUTH %s %s",
-          opt_.username.c_str(),
-          opt_.password.c_str())));
+      reply = helper::ReplyPtr(
+          reinterpret_cast<redisReply*>(redisCommand(
+              connection.get(),
+              "AUTH %s %s",
+              opt_.username.c_str(),
+              opt_.password.c_str())));
     }
     check_status("auth error", connection, reply);
   }
 
   if (opt_.db != 0) {
-    auto reply = helper::ReplyPtr(reinterpret_cast<redisReply*>(
-        redisCommand(connection.get(), "SELECT %d", opt_.db)));
+    auto reply = helper::ReplyPtr(
+        reinterpret_cast<redisReply*>(
+            redisCommand(connection.get(), "SELECT %d", opt_.db)));
     check_status("select db error", connection, reply);
   }
 
diff --git a/torchrec/csrc/dynamic_embedding/ps.h b/torchrec/csrc/dynamic_embedding/ps.h
@@ -65,10 +65,11 @@ class LocalShardList : public torch::CustomClassHolder {
       int64_t col_size,
       std::vector<torch::Tensor> tensors) {
     // col_start/col_size not supported now.
-    shards_.emplace_back(LocalShard{
-        .row_start = row_start,
-        .row_size = row_size,
-        .tensors = std::move(tensors)});
+    shards_.emplace_back(
+        LocalShard{
+            .row_start = row_start,
+            .row_size = row_size,
+            .tensors = std::move(tensors)});
   }
 
   Container::const_iterator begin() const {
diff --git a/torchrec/inference/inference_legacy/src/BatchingQueue.cpp b/torchrec/inference/inference_legacy/src/BatchingQueue.cpp
@@ -97,13 +97,14 @@ void BatchingQueue::add(
                            promise = std::move(promise),
                            addedTime = addedTime](auto& queue) mutable {
     const auto batchSize = request->batch_size;
-    queue.push(QueryQueueEntry{
-        std::move(request),
-        RequestContext{
-            batchSize,
-            std::move(promise),
-            folly::RequestContext::saveContext()},
-        addedTime});
+    queue.push(
+        QueryQueueEntry{
+            std::move(request),
+            RequestContext{
+                batchSize,
+                std::move(promise),
+                folly::RequestContext::saveContext()},
+            addedTime});
   });
 }
 
@@ -165,10 +166,11 @@ void BatchingQueue::createBatch() {
           config_.batchingInterval))) {
       const auto requestsCount = requests.size();
 
-      batchingQueues_[roundRobinIdx++]->blockingWrite(BatchingQueueEntry{
-          .requests = std::move(requests),
-          .contexts = std::move(contexts),
-          .addedTime = *startTime});
+      batchingQueues_[roundRobinIdx++]->blockingWrite(
+          BatchingQueueEntry{
+              .requests = std::move(requests),
+              .contexts = std::move(contexts),
+              .addedTime = *startTime});
 
       observer_->addRequestsCount(requestsCount);
       observer_->recordBatchCreationLatency(
@@ -192,8 +194,9 @@ void BatchingQueue::createBatch() {
 
 void BatchingQueue::pinMemory(int gpuIdx) {
   at::cuda::CUDAGuard deviceGuard(gpuIdx);
-  at::cuda::CUDAStreamGuard streamGuard(at::cuda::getStreamFromPool(
-      /* isHighPriority */ FLAGS_batching_queue_use_high_pri_stream));
+  at::cuda::CUDAStreamGuard streamGuard(
+      at::cuda::getStreamFromPool(
+          /* isHighPriority */ FLAGS_batching_queue_use_high_pri_stream));
   if (config_.warmupFn) {
     config_.warmupFn();
   }
@@ -295,14 +298,15 @@ void BatchingQueue::pinMemory(int gpuIdx) {
 
         for (auto& [featureName, metadata] : config_.batchingMetadata) {
           const auto batchingFuncStart = std::chrono::steady_clock::now();
-          combineForwardArgs(batchingFuncs_[metadata.type]->batch(
-              featureName,
-              requests,
-              combinedBatchSize,
-              batchOffsetsLazy,
-              metadata.device == "cpu" ? c10::Device(c10::kCPU)
-                                       : c10::Device(c10::kCUDA, gpuIdx),
-              batchItemsLazy));
+          combineForwardArgs(
+              batchingFuncs_[metadata.type]->batch(
+                  featureName,
+                  requests,
+                  combinedBatchSize,
+                  batchOffsetsLazy,
+                  metadata.device == "cpu" ? c10::Device(c10::kCPU)
+                                           : c10::Device(c10::kCUDA, gpuIdx),
+                  batchItemsLazy));
           observer_->recordBatchingFuncLatency(
               getTimeElapsedMS(batchingFuncStart).count(), metadata.type);
         }
diff --git a/torchrec/inference/inference_legacy/src/GPUExecutor.cpp b/torchrec/inference/inference_legacy/src/GPUExecutor.cpp
@@ -166,11 +166,12 @@ void GPUExecutor::process(int idx) {
   c10::InferenceMode inferenceModeGuard;
   std::vector<c10::cuda::CUDAStream> streams;
   for (size_t i = 0; i < worldSize_; ++i) {
-    streams.push_back(at::cuda::getStreamFromPool(
-        /* isHighPriority */ i == rank_
-            ? FLAGS_gpu_executor_use_high_pri_stream_main_device
-            : FLAGS_gpu_executor_use_high_pri_stream_peer_device,
-        i));
+    streams.push_back(
+        at::cuda::getStreamFromPool(
+            /* isHighPriority */ i == rank_
+                ? FLAGS_gpu_executor_use_high_pri_stream_main_device
+                : FLAGS_gpu_executor_use_high_pri_stream_peer_device,
+            i));
   }
   at::cuda::CUDAMultiStreamGuard streamGuard(streams);
   at::cuda::CUDAGuard deviceGuard(rank_);
diff --git a/torchrec/inference/inference_legacy/tests/BatchingQueueTest.cpp b/torchrec/inference/inference_legacy/tests/BatchingQueueTest.cpp
@@ -95,9 +95,10 @@ TEST(BatchingQueueTest, Basic) {
       2 * (2 + 4), value->forwardArgs.at("cpu_features").toTensor().numel());
   ASSERT_EQ(
       value->forwardArgs.at("cpu_features").toTensor().device(), at::kCPU);
-  ASSERT_TRUE(at::allclose(
-      value->forwardArgs.at("cuda_features").toTensor().cpu(),
-      value->forwardArgs.at("cpu_features").toTensor()));
+  ASSERT_TRUE(
+      at::allclose(
+          value->forwardArgs.at("cuda_features").toTensor().cpu(),
+          value->forwardArgs.at("cpu_features").toTensor()));
 }
 
 TEST(BatchingQueueTest, MaxBatchSize) {
diff --git a/torchrec/inference/inference_legacy/tests/SingleGPUExecutorMultiGPUTest.cpp b/torchrec/inference/inference_legacy/tests/SingleGPUExecutorMultiGPUTest.cpp
@@ -46,8 +46,9 @@ c10::IValue execute(
   folly::Promise<std::unique_ptr<torchrec::PredictionResponse>> promise;
   auto future = promise.getSemiFuture();
 
-  executor.schedule(std::make_shared<torchrec::PredictionBatch>(
-      methodName, std::move(args), std::move(promise)));
+  executor.schedule(
+      std::make_shared<torchrec::PredictionBatch>(
+          methodName, std::move(args), std::move(promise)));
   return std::move(future).get()->predictions;
 }
 
@@ -92,10 +93,11 @@ TEST(TorchDeployGPUTest, SimpleModel_multiGPU) {
   std::vector<std::unique_ptr<torchrec::SingleGPUExecutor>> workExecutors;
   for (size_t i = 0; i < numGpu; i++) {
     const std::vector<size_t> interp_idxs = {static_cast<size_t>(i)};
-    workExecutors.push_back(std::make_unique<torchrec::SingleGPUExecutor>(
-        manager,
-        torchrec::SingleGPUExecutor::ExecInfos{{i, numGpu + i, models[i]}},
-        numGpu));
+    workExecutors.push_back(
+        std::make_unique<torchrec::SingleGPUExecutor>(
+            manager,
+            torchrec::SingleGPUExecutor::ExecInfos{{i, numGpu + i, models[i]}},
+            numGpu));
   }
 
   std::vector<torchrec::SingleGPUExecutor::ExecInfo> execInfos;
diff --git a/torchrec/inference/inference_legacy/tests/SingleGPUExecutorTest.cpp b/torchrec/inference/inference_legacy/tests/SingleGPUExecutorTest.cpp
