refactored client and server initialization methods

Author: JasonZhang517

mooncake-integration/transfer_engine/transfer_engine_py.cpp

@@ -675,6 +675,11 @@ void bind_coro_rpc_interface(py::module_ &m) {
         .def("initialize", &CoroRPCInterface::initialize,
              "listen_address"_a = "", "thread_count"_a = 0,
              "timeout_seconds"_a = 30, "pool_size"_a = 10)
+        .def("initialize_client", &CoroRPCInterface::initializeClient,
+             "pool_size"_a = 10, "timeout_seconds"_a = 30)
+        .def("initialize_server", &CoroRPCInterface::initializeServer,
+             "listen_address"_a, "thread_count"_a = 8,
+             "timeout_seconds"_a = 30, "pool_size"_a = 4)
         .def("start_server", &CoroRPCInterface::startServer)
         .def("start_server_async", &CoroRPCInterface::startServerAsync)
         .def("stop_server", &CoroRPCInterface::stopServer)

mooncake-transfer-engine/include/transport/coro_rpc_connector/cororpc_interface.h

@@ -47,6 +47,12 @@ class CoroRPCInterface {
                     size_t thread_count = 0, size_t timeout_seconds = 30,
                     size_t pool_size = 10);
 
+    // Convenience methods for common use cases
+    bool initializeClient(size_t pool_size = 10, size_t timeout_seconds = 30);
+    bool initializeServer(const std::string& listen_address, 
+                         size_t thread_count = 8, size_t timeout_seconds = 30,
+                         size_t pool_size = 4);
+
     bool startServer();
     bool startServerAsync();
     bool startServerImpl(bool is_async = true);

mooncake-transfer-engine/src/transport/coro_rpc_connector/cororpc_interface.cpp

@@ -38,6 +38,18 @@ bool CoroRPCInterface::initialize(const std::string& local_address,
     return impl_->communicator->initialize(config);
 }
 
+// Convenience method for client initialization
+bool CoroRPCInterface::initializeClient(size_t pool_size, size_t timeout_seconds) {
+    return initialize("", 0, timeout_seconds, pool_size);
+}
+
+// Convenience method for server initialization  
+bool CoroRPCInterface::initializeServer(const std::string& listen_address,
+                                       size_t thread_count, size_t timeout_seconds,
+                                       size_t pool_size) {
+    return initialize(listen_address, thread_count, timeout_seconds, pool_size);
+}
+
 bool CoroRPCInterface::startServer() {
     if (!impl_->communicator) return false;
     return impl_->communicator->startServer();

mooncake-transfer-engine/tests/communicator_bandwidth_test.py

@@ -59,7 +59,8 @@ def run_server(bind_url, data_size_mb=1):
 
     CoroRPCInterface = engine.CoroRPCInterface
     server = CoroRPCInterface()
-    server.initialize(bind_url, 8, 30, 4)
+    # Server使用专门的初始化方法
+    server.initialize_server(bind_url, thread_count=8)
     server.start_server_async() #start the server asynchronously
 
     # Start QPS statistics thread
@@ -85,7 +86,8 @@ def run_client(target_url, num_threads=8, data_size_mb=1):
 
     CoroRPCInterface = engine.CoroRPCInterface
     client = CoroRPCInterface()
-    client.initialize("", 0, 30, 100)
+    # Client使用专门的初始化方法，只需要提供pool_size
+    client.initialize_client(pool_size=100)
 
     # Start QPS statistics thread
     qps_thread = threading.Thread(target=print_qps)