mark error branches unlikely (cpp20) (#53)

* mark error branches unlikely (cpp20) * simplify unique_ptr free callback * set build target to rustc target * also update toolchain.cmake for test and example * Bump version
Congyuwang · Feb 21, 2024 · 3d1453d · 3d1453d
1 parent a000a6d
commit 3d1453d
Show file tree

Hide file tree

Showing 9 changed files with 70 additions and 92 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,11 +1,11 @@
 cmake_minimum_required(VERSION 3.9)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 
 # read toolchain file before project
 set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/toolchain.cmake)
 
 # define project
-project(socket_manager LANGUAGES C CXX VERSION 0.5.2)
+project(socket_manager LANGUAGES C CXX VERSION 0.5.3)
 
 # set default build type as shared
 option(BUILD_SHARED_LIBS "Build using shared libraries" ON)

diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "tokio-socket-manager"
-version = "0.5.2"
+version = "0.5.3"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

diff --git a/examples/echo_server/toolchain.cmake b/examples/echo_server/toolchain.cmake
@@ -10,6 +10,13 @@ SET(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
 
+# set target to rustc target
+EXECUTE_PROCESS(COMMAND bash "-c" "rustc -vV | sed -n 's|host: ||p'"
+                OUTPUT_VARIABLE TARGET
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+SET(CMAKE_C_COMPILER_TARGET ${TARGET})
+SET(CMAKE_CXX_COMPILER_TARGET ${TARGET})
+
 if (APPLE)
     MESSAGE(STATUS "Using LLVM/Clang from Homebrew")
     SET(CMAKE_C_COMPILER   $ENV{HOMEBREW_PREFIX}/opt/llvm/bin/clang)

diff --git a/socket_manager/connection.cc b/socket_manager/connection.cc
@@ -1,23 +1,21 @@
 #include "socket_manager/connection.h"
+#include "error.h"
 #include "socket_manager/common/notifier.h"
 #include "socket_manager_c_api.h"
-#include <stdexcept>
 
 namespace socket_manager {
 
 Connection::Connection(SOCKET_MANAGER_C_API_Connection *inner)
     : notifier(std::make_shared<NoopNotifier>()),
-      inner(inner, [](SOCKET_MANAGER_C_API_Connection *ptr) {
-        socket_manager_connection_free(ptr);
-      }) {}
+      inner(inner, socket_manager_connection_free) {}
 
 void Connection::start(std::shared_ptr<MsgReceiverAsync> msg_receiver,
                        std::shared_ptr<Notifier> send_notifier,
                        size_t msg_buffer_size,
                        unsigned long long read_msg_flush_interval,
                        unsigned long long write_flush_interval) {
 
-  if (msg_receiver == nullptr) {
+  if (msg_receiver == nullptr) [[unlikely]] {
     throw std::runtime_error("msg_receiver should not be nullptr");
   }
   // keep the msg_receiver alive.
@@ -30,17 +28,13 @@ void Connection::start(std::shared_ptr<MsgReceiverAsync> msg_receiver,
   // start the connection.
   // calling twice `connection_start` will throw exception.
   char *err = nullptr;
-  if (0 != socket_manager_connection_start(inner.get(),
-                                           SOCKET_MANAGER_C_API_OnMsgObj{
-                                               this->receiver.get(),
-                                           },
-                                           msg_buffer_size,
-                                           read_msg_flush_interval,
-                                           write_flush_interval, &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_connection_start(
+      inner.get(),
+      SOCKET_MANAGER_C_API_OnMsgObj{
+          this->receiver.get(),
+      },
+      msg_buffer_size, read_msg_flush_interval, write_flush_interval, &err);
+  CHECK_RET(ret, err);
 }
 
 std::string Connection::peer_address() {
@@ -59,11 +53,8 @@ std::string Connection::local_address() {
 
 void Connection::close() {
   char *err = nullptr;
-  if (0 != socket_manager_connection_close(inner.get(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_connection_close(inner.get(), &err);
+  CHECK_RET(ret, err);
 }
 
 } // namespace socket_manager
diff --git a/socket_manager/error.h b/socket_manager/error.h
@@ -0,0 +1,6 @@
+#define CHECK_RET(ret, err)                                                    \
+  if (0 != ret) [[unlikely]] {                                                 \
+    const std::string err_str(err);                                            \
+    free(err);                                                                 \
+    throw std::runtime_error(err_str);                                         \
+  }
diff --git a/socket_manager/msg_sender.cc b/socket_manager/msg_sender.cc
@@ -1,54 +1,39 @@
 #include "socket_manager/msg_sender.h"
-#include <stdexcept>
+#include "error.h"
 
 namespace socket_manager {
 
 void MsgSender::send_block(std::string_view data) {
   char *err = nullptr;
-  if (0 != socket_manager_msg_sender_send_block(inner.get(), data.data(),
-                                                data.length(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_msg_sender_send_block(inner.get(), data.data(),
+                                                 data.length(), &err);
+  CHECK_RET(ret, err);
 }
 
 void MsgSender::send_nonblock(std::string_view data) {
   char *err = nullptr;
-  if (0 != socket_manager_msg_sender_send_nonblock(inner.get(), data.data(),
-                                                   data.length(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_msg_sender_send_nonblock(inner.get(), data.data(),
+                                                    data.length(), &err);
+  CHECK_RET(ret, err);
 }
 
 long MsgSender::send_async(std::string_view data) {
   char *err = nullptr;
-  long const bytes_sent = socket_manager_msg_sender_send_async(
+  const long bytes_sent = socket_manager_msg_sender_send_async(
       inner.get(), data.data(), data.length(),
       SOCKET_MANAGER_C_API_Notifier{conn->notifier.get()}, &err);
-  if (err != nullptr) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  CHECK_RET(err, err);
   return bytes_sent;
 }
 
 void MsgSender::flush() {
   char *err = nullptr;
-  if (0 != socket_manager_msg_sender_flush(inner.get(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_msg_sender_flush(inner.get(), &err);
+  CHECK_RET(ret, err);
 }
 
 MsgSender::MsgSender(SOCKET_MANAGER_C_API_MsgSender *inner,
                      const std::shared_ptr<Connection> &conn)
-    : conn(conn), inner(inner, [](SOCKET_MANAGER_C_API_MsgSender *ptr) {
-        socket_manager_msg_sender_free(ptr);
-      }) {}
+    : conn(conn), inner(inner, socket_manager_msg_sender_free) {}
 
 } // namespace socket_manager
diff --git a/socket_manager/socket_manager.cc b/socket_manager/socket_manager.cc
@@ -1,6 +1,6 @@
 #include "socket_manager/socket_manager.h"
+#include "error.h"
 #include "socket_manager_c_api.h"
-#include <stdexcept>
 #include <string_view>
 
 namespace socket_manager {
@@ -20,11 +20,7 @@ void init_logger(void (*tracer)(SOCKET_MANAGER_C_API_LogData),
                  SOCKET_MANAGER_C_API_TraceLevel log_print_level) {
   char *err = nullptr;
   socket_manager_logger_init(tracer, tracer_max_level, log_print_level, &err);
-  if (err != nullptr) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  CHECK_RET(err, err);
 }
 
 SocketManager::SocketManager(const std::shared_ptr<ConnCallback> &conn_cb,
@@ -36,61 +32,40 @@ SocketManager::SocketManager(const std::shared_ptr<ConnCallback> &conn_cb,
   inner = std::unique_ptr<
       SOCKET_MANAGER_C_API_SocketManager,
       std::function<void(SOCKET_MANAGER_C_API_SocketManager *)>>(
-      inner_ptr, [](SOCKET_MANAGER_C_API_SocketManager *ptr) {
-        socket_manager_free(ptr);
-      });
-  if (err != nullptr) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+      inner_ptr, socket_manager_free);
+  CHECK_RET(err, err);
 }
 
 void SocketManager::listen_on_addr(const std::string &addr) {
   char *err = nullptr;
-  if (0 != socket_manager_listen_on_addr(inner.get(), addr.c_str(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_listen_on_addr(inner.get(), addr.c_str(), &err);
+  CHECK_RET(ret, err);
 }
 
 void SocketManager::connect_to_addr(const std::string &addr, uint64_t delay) {
   char *err = nullptr;
-  if (0 !=
-      socket_manager_connect_to_addr(inner.get(), addr.c_str(), delay, &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret =
+      socket_manager_connect_to_addr(inner.get(), addr.c_str(), delay, &err);
+  CHECK_RET(ret, err);
 }
 
 void SocketManager::cancel_listen_on_addr(const std::string &addr) {
   char *err = nullptr;
-  if (0 !=
-      socket_manager_cancel_listen_on_addr(inner.get(), addr.c_str(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret =
+      socket_manager_cancel_listen_on_addr(inner.get(), addr.c_str(), &err);
+  CHECK_RET(ret, err);
 }
 
 void SocketManager::abort(bool wait) {
   char *err = nullptr;
-  if (0 != socket_manager_abort(inner.get(), wait, &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_abort(inner.get(), wait, &err);
+  CHECK_RET(ret, err);
 }
 
 void SocketManager::join() {
   char *err = nullptr;
-  if (0 != socket_manager_join(inner.get(), &err)) {
-    const std::string err_str(err);
-    free(err);
-    throw std::runtime_error(err_str);
-  }
+  int ret = socket_manager_join(inner.get(), &err);
+  CHECK_RET(ret, err);
 }
 
 } // namespace socket_manager
diff --git a/tests/test_find_package/toolchain.cmake b/tests/test_find_package/toolchain.cmake
@@ -10,6 +10,13 @@ SET(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
 
+# set target to rustc target
+EXECUTE_PROCESS(COMMAND bash "-c" "rustc -vV | sed -n 's|host: ||p'"
+                OUTPUT_VARIABLE TARGET
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+SET(CMAKE_C_COMPILER_TARGET ${TARGET})
+SET(CMAKE_CXX_COMPILER_TARGET ${TARGET})
+
 if (APPLE)
     MESSAGE(STATUS "Using LLVM/Clang from Homebrew")
     SET(CMAKE_C_COMPILER   $ENV{HOMEBREW_PREFIX}/opt/llvm/bin/clang)

diff --git a/toolchain.cmake b/toolchain.cmake
@@ -10,6 +10,13 @@ SET(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
 
+# set target to rustc target
+EXECUTE_PROCESS(COMMAND bash "-c" "rustc -vV | sed -n 's|host: ||p'"
+                OUTPUT_VARIABLE TARGET
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+SET(CMAKE_C_COMPILER_TARGET ${TARGET})
+SET(CMAKE_CXX_COMPILER_TARGET ${TARGET})
+
 if (APPLE)
     MESSAGE(STATUS "Using LLVM/Clang from Homebrew")
     SET(CMAKE_C_COMPILER   $ENV{HOMEBREW_PREFIX}/opt/llvm/bin/clang)