test_pthread_lock.c changed

HISTORY

@@ -1,4 +1,14 @@
 
+Version 1.84  2026-01-16
+  * fast_task_queue.h: add function free_queue_task_arg_offset
+  * add function double2str and double_to_comma_str
+
+Version 1.83  2025-11-15
+  * fast_task_queue.h: remove field finish_callback
+
+Version 1.82  2025-11-04
+  * set use_io_uring explicitly
+
 Version 1.81  2025-10-05
   * support Linux io_uring
   * free_queue support parameter: need_shrink and set task->shrinked

INSTALL

@@ -21,5 +21,5 @@ Debian, Ubuntu etc.:
 # the command lines as:
 
    git clone https://github.com/happyfish100/libfastcommon.git
-   cd libfastcommon; git checkout V1.0.81
+   cd libfastcommon; git checkout V1.0.84
    ./make.sh clean && ./make.sh && sudo ./make.sh install

debian/changelog

@@ -1,3 +1,21 @@
+libfastcommon (1.0.83-1) unstable; urgency=medium
+
+  * upgrade to 1.0.83-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 10:47:37 +0000
+
+libfastcommon (1.0.83-1) unstable; urgency=medium
+
+  * upgrade to 1.0.83-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 10:00:00 +0000
+
+libfastcommon (1.0.83-1) unstable; urgency=medium
+
+  * upgrade to 1.0.83-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 09:05:57 +0000
+
 libfastcommon (1.0.78-1) unstable; urgency=medium
 
   * upgrade to 1.0.78-1

libfastcommon.spec

@@ -3,7 +3,7 @@
 %define CommitVersion %(echo $COMMIT_VERSION)
 
 Name: libfastcommon
-Version: 1.0.81
+Version: 1.0.84
 Release: 1%{?dist}
 Summary: c common functions library extracted from my open source projects FastDFS
 License: LGPL
@@ -19,10 +19,10 @@ Requires: %__cp %__mv %__chmod %__grep %__mkdir %__install %__id
 
 %define kernel_major %(uname -r | cut -d'.' -f1)
 %define kernel_minor %(uname -r | cut -d'.' -f2)
-%define kernel_ver_int %(expr %{kernel_major} \* 100 + %{kernel_minor})
+%define kernel_ver_int %(expr %{kernel_major} \\* 100 + %{kernel_minor})
 %if %{kernel_ver_int} >= 514
-BuildRequires: liburing-devel >= 2.5
-Requires: liburing >= 2.5
+BuildRequires: liburing-devel >= 2.4
+Requires: liburing >= 2.4
 %endif
 
 %description

src/base64.c

@@ -297,9 +297,7 @@ char *base64_decode_auto(struct base64_context *context, const char *src, \
 
 	memcpy(pBuff, src, nSrcLen);
 	memset(pBuff + nSrcLen, context->pad_ch, nPadLen);
-
 	base64_decode(context, pBuff, nNewLen, dest, dest_len);
-
 	if (pBuff != tmpBuff)
 	{
 		free(pBuff);
@@ -387,14 +385,21 @@ char *base64_decode(struct base64_context *context, const char *src, \
       {
           *dest = '\0';
           *dest_len = 0;
-         fprintf(stderr, "Input to decode not an even multiple of " \
+          fprintf(stderr, "Input to decode not an even multiple of "
                   "4 characters; pad with %c\n", context->pad_ch);
           return dest;
       }
 
+      if (dummies > 2)
+      {
+          *dest = '\0';
+          *dest_len = 0;
+          fprintf(stderr, "pad char: %c count %d exceeds 2\n",
+                  context->pad_ch, dummies);
+          return dest;
+      }
+
       *dest_len = (pDest - dest) - dummies;
       *(dest + (*dest_len)) = '\0';
-
       return dest;
 }
-

src/fast_task_queue.c

@@ -28,7 +28,7 @@
 static int task_alloc_init(struct fast_task_info *task,
         struct fast_task_queue *queue)
 {
-    task->arg = (char *)task + ALIGNED_TASK_INFO_SIZE + queue->padding_size;
+    task->arg = (char *)task + free_queue_task_arg_offset(queue);
     task->send.ptr = &task->send.holder;
     task->send.ptr->size = queue->min_buff_size;
     if (queue->malloc_whole_block) {

src/fast_task_queue.h

@@ -37,7 +37,6 @@ struct nio_thread_data;
 struct fast_task_info;
 
 typedef int (*ThreadLoopCallback) (struct nio_thread_data *pThreadData);
-typedef int (*TaskFinishCallback) (struct fast_task_info *task);
 typedef void (*TaskCleanUpCallback) (struct fast_task_info *task);
 typedef int (*TaskInitCallback)(struct fast_task_info *task, void *arg);
 typedef void (*TaskReleaseCallback)(struct fast_task_info *task);
@@ -149,7 +148,6 @@ struct fast_task_info
         struct fc_list_head dlink;  //for polling queue
     } polling;  //for RDMA busy polling
     TaskContinueCallback continue_callback; //for continue stage
-    TaskFinishCallback finish_callback;
     struct nio_thread_data *thread_data;
     struct sf_network_handler *handler; //network handler for libserverframe nio
     struct fast_task_info *next;        //for free queue and deleted list
@@ -238,6 +236,11 @@ static inline int free_queue_alloc_connections(struct fast_task_queue *queue)
     return queue->allocator.info.element_total_count;
 }
 
+static inline int free_queue_task_arg_offset(struct fast_task_queue *queue)
+{
+    return ALIGNED_TASK_INFO_SIZE + queue->padding_size;
+}
+
 int free_queue_get_new_buffer_size(const int min_buff_size,
         const int max_buff_size, const int expect_size, int *new_size);
 

src/ioevent.c

@@ -46,29 +46,22 @@ int kqueue_ev_convert(int16_t event, uint16_t flags)
 #endif
 
 int ioevent_init(IOEventPoller *ioevent, const char *service_name,
-        const int size, const int timeout_ms, const int extra_events)
+        const bool use_io_uring, const int size, const int timeout_ms,
+        const int extra_events)
 {
-#if IOEVENT_USE_URING
-    int result;
-#else
     int bytes;
 
     ioevent->iterator.index = 0;
     ioevent->iterator.count = 0;
-#endif
-
     ioevent->service_name = service_name;
     ioevent->size = size;
     ioevent->extra_events = extra_events;
 
-#if IOEVENT_USE_EPOLL
-    ioevent->poll_fd = epoll_create(ioevent->size);
-    if (ioevent->poll_fd < 0) {
-        return errno != 0 ? errno : ENOMEM;
-    }
-    bytes = sizeof(struct epoll_event) * size;
-    ioevent->events = (struct epoll_event *)fc_malloc(bytes);
-#elif IOEVENT_USE_URING
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    ioevent->use_io_uring = use_io_uring;
+    if (use_io_uring) {
+        int result;
         if ((result=io_uring_queue_init(size, &ioevent->ring, 0)) < 0) {
             return -result;
         }
@@ -76,6 +69,17 @@ int ioevent_init(IOEventPoller *ioevent, const char *service_name,
         ioevent->submit_count = 0;
         ioevent->send_zc_logged = false;
         ioevent->send_zc_done_notify = false;
+    } else {
+#endif
+        ioevent->poll_fd = epoll_create(ioevent->size);
+        if (ioevent->poll_fd < 0) {
+            return errno != 0 ? errno : ENOMEM;
+        }
+        bytes = sizeof(struct epoll_event) * size;
+        ioevent->events = (struct epoll_event *)fc_malloc(bytes);
+#if IOEVENT_USE_URING
+    }
+#endif
 #elif IOEVENT_USE_KQUEUE
     ioevent->poll_fd = kqueue();
     if (ioevent->poll_fd < 0) {
@@ -93,13 +97,15 @@ int ioevent_init(IOEventPoller *ioevent, const char *service_name,
 #endif
 
 #if IOEVENT_USE_URING
-
-#else
+    if (!ioevent->use_io_uring) {
+#endif
         if (ioevent->events == NULL) {
             close(ioevent->poll_fd);
             ioevent->poll_fd = -1;
             return ENOMEM;
         }
+#if IOEVENT_USE_URING
+    }
 #endif
 
     ioevent_set_timeout(ioevent, timeout_ms);
@@ -109,8 +115,10 @@ int ioevent_init(IOEventPoller *ioevent, const char *service_name,
 void ioevent_destroy(IOEventPoller *ioevent)
 {
 #if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
         io_uring_queue_exit(&ioevent->ring);
-#else
+    } else {
+#endif
         if (ioevent->events != NULL) {
             free(ioevent->events);
             ioevent->events = NULL;
@@ -120,19 +128,17 @@ void ioevent_destroy(IOEventPoller *ioevent)
             close(ioevent->poll_fd);
             ioevent->poll_fd = -1;
         }
+#if IOEVENT_USE_URING
+    }
 #endif
 }
 
 int ioevent_attach(IOEventPoller *ioevent, const int fd,
         const int e, void *data)
 {
-#if IOEVENT_USE_EPOLL
-  struct epoll_event ev;
-  memset(&ev, 0, sizeof(ev));
-  ev.events = e | ioevent->extra_events;
-  ev.data.ptr = data;
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_ADD, fd, &ev);
-#elif IOEVENT_USE_URING
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
         struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
         if (sqe == NULL) {
             return ENOSPC;
@@ -141,6 +147,17 @@ int ioevent_attach(IOEventPoller *ioevent, const int fd,
         sqe->user_data = (long)data;
         ioevent->submit_count++;
         return 0;
+    } else {
+#endif
+        struct epoll_event ev;
+        memset(&ev, 0, sizeof(ev));
+        ev.events = e | ioevent->extra_events;
+        ev.data.ptr = data;
+        return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_ADD, fd, &ev);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   struct kevent ev[2];
   int n = 0;
@@ -162,13 +179,9 @@ int ioevent_attach(IOEventPoller *ioevent, const int fd,
 int ioevent_modify(IOEventPoller *ioevent, const int fd,
         const int e, void *data)
 {
-#if IOEVENT_USE_EPOLL
-  struct epoll_event ev;
-  memset(&ev, 0, sizeof(ev));
-  ev.events = e | ioevent->extra_events;
-  ev.data.ptr = data;
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_MOD, fd, &ev);
-#elif IOEVENT_USE_URING
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
         struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
         if (sqe == NULL) {
             return ENOSPC;
@@ -178,6 +191,17 @@ int ioevent_modify(IOEventPoller *ioevent, const int fd,
         sqe->user_data = (long)data;
         ioevent->submit_count++;
         return 0;
+    } else {
+#endif
+        struct epoll_event ev;
+        memset(&ev, 0, sizeof(ev));
+        ev.events = e | ioevent->extra_events;
+        ev.data.ptr = data;
+        return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_MOD, fd, &ev);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   struct kevent ev[2];
   int result;
@@ -212,9 +236,9 @@ int ioevent_modify(IOEventPoller *ioevent, const int fd,
 
 int ioevent_detach(IOEventPoller *ioevent, const int fd)
 {
-#if IOEVENT_USE_EPOLL
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_DEL, fd, NULL);
-#elif IOEVENT_USE_URING
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
         struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
         if (sqe == NULL) {
             return ENOSPC;
@@ -224,6 +248,13 @@ int ioevent_detach(IOEventPoller *ioevent, const int fd)
         sqe->flags = IOSQE_CQE_SKIP_SUCCESS;
         ioevent->submit_count++;
         return 0;
+    } else {
+#endif
+        return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_DEL, fd, NULL);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   struct kevent ev[1];
   int r, w;
@@ -242,10 +273,9 @@ int ioevent_detach(IOEventPoller *ioevent, const int fd)
 
 int ioevent_poll(IOEventPoller *ioevent)
 {
-#if IOEVENT_USE_EPOLL
-  return epoll_wait(ioevent->poll_fd, ioevent->events,
-          ioevent->size, ioevent->timeout);
-#elif IOEVENT_USE_URING
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
         int result;
         result = io_uring_wait_cqe_timeout(&ioevent->ring,
                 &ioevent->cqe, &ioevent->timeout);
@@ -254,6 +284,14 @@ int ioevent_poll(IOEventPoller *ioevent)
             return -1;
         }
         return 0;
+    } else {
+#endif
+        return epoll_wait(ioevent->poll_fd, ioevent->events,
+                ioevent->size, ioevent->timeout_ms);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   return kevent(ioevent->poll_fd, NULL, 0, ioevent->events,
           ioevent->size, &ioevent->timeout);

src/ioevent.h

@@ -25,10 +25,12 @@
 #define IOEVENT_TIMEOUT  (1 << 20)
 #define IOEVENT_NOTIFY   (1 << 21)  //for io_uring send_zc done callback
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
 #include <sys/epoll.h>
 #define IOEVENT_EDGE_TRIGGER EPOLLET
+#endif
 
+#if IOEVENT_USE_EPOLL
 #define IOEVENT_READ  EPOLLIN
 #define IOEVENT_WRITE EPOLLOUT
 #define IOEVENT_ERROR (EPOLLERR | EPOLLPRI | EPOLLHUP)
@@ -77,25 +79,30 @@ typedef struct ioevent_puller {
     const char *service_name;
     int size;  //max events (fd)
     int extra_events;
+
 #if IOEVENT_USE_URING
     struct io_uring ring;
     int submit_count;
     bool send_zc_logged;
     bool send_zc_done_notify; //if callback when send_zc done
-#else
+    bool use_io_uring;
+#endif
+
     int poll_fd;
     struct {
         int index;
         int count;
     } iterator;  //for deal event loop
-#endif
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
     struct epoll_event *events;
-    int timeout;  //in milliseconds
-#elif IOEVENT_USE_URING
+    int timeout_ms;   //for epoll
+#if IOEVENT_USE_URING
     struct io_uring_cqe *cqe;
     struct __kernel_timespec timeout;
+#endif
+    bool zero_timeout;
+
 #elif IOEVENT_USE_KQUEUE
     struct kevent *events;
     struct timespec timeout;
@@ -104,17 +111,11 @@ typedef struct ioevent_puller {
     timespec_t timeout;
 #endif
 
-#ifdef OS_LINUX
-    bool zero_timeout;
-#endif
-
 } IOEventPoller;
 
-#if IOEVENT_USE_EPOLL
+#if OS_LINUX
   #define IOEVENT_GET_EVENTS(ioevent, index) \
       (ioevent)->events[index].events
-#elif IOEVENT_USE_URING
-
 #elif IOEVENT_USE_KQUEUE
   #define IOEVENT_GET_EVENTS(ioevent, index)  kqueue_ev_convert( \
       (ioevent)->events[index].filter, (ioevent)->events[index].flags)
@@ -125,11 +126,9 @@ typedef struct ioevent_puller {
 #error port me
 #endif
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
   #define IOEVENT_GET_DATA(ioevent, index)  \
       (ioevent)->events[index].data.ptr
-#elif IOEVENT_USE_URING
-
 #elif IOEVENT_USE_KQUEUE
   #define IOEVENT_GET_DATA(ioevent, index)  \
       (ioevent)->events[index].udata
@@ -140,11 +139,9 @@ typedef struct ioevent_puller {
 #error port me
 #endif
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
   #define IOEVENT_CLEAR_DATA(ioevent, index)  \
       (ioevent)->events[index].data.ptr = NULL
-#elif IOEVENT_USE_URING
-
 #elif IOEVENT_USE_KQUEUE
   #define IOEVENT_CLEAR_DATA(ioevent, index)  \
       (ioevent)->events[index].udata = NULL
@@ -160,7 +157,8 @@ extern "C" {
 #endif
 
 int ioevent_init(IOEventPoller *ioevent, const char *service_name,
-        const int size, const int timeout_ms, const int extra_events);
+        const bool use_io_uring, const int size, const int timeout_ms,
+        const int extra_events);
 void ioevent_destroy(IOEventPoller *ioevent);
 
 int ioevent_attach(IOEventPoller *ioevent, const int fd,
@@ -174,16 +172,24 @@ static inline void ioevent_set_timeout(IOEventPoller *ioevent,
         const int timeout_ms)
 {
 #if IOEVENT_USE_EPOLL
-  ioevent->timeout = timeout_ms;
+    ioevent->timeout_ms = timeout_ms;
 #else
+#if IOEVENT_USE_URING
+    if (!ioevent->use_io_uring) {
+        ioevent->timeout_ms = timeout_ms;
+    } else {
+#endif
         ioevent->timeout.tv_sec = timeout_ms / 1000;
         ioevent->timeout.tv_nsec = 1000000 * (timeout_ms % 1000);
+
+#if IOEVENT_USE_URING
+    }
+#endif
 #endif
 
 #ifdef OS_LINUX
     ioevent->zero_timeout = (timeout_ms == 0);
 #endif
-
 }
 
 static inline int ioevent_poll_ex(IOEventPoller *ioevent, const int timeout_ms)

src/ioevent_loop.c

@@ -18,7 +18,7 @@
 #include "ioevent_loop.h"
 
 #if IOEVENT_USE_URING
-static int ioevent_process(IOEventPoller *ioevent)
+static int ioevent_process_by_uring(IOEventPoller *ioevent)
 {
     int result;
     unsigned head;
@@ -85,7 +85,7 @@ static int ioevent_process(IOEventPoller *ioevent)
     return 0;
 }
 
-#else
+#endif
 
 static void deal_ioevents(IOEventPoller *ioevent)
 {
@@ -109,7 +109,7 @@ static void deal_ioevents(IOEventPoller *ioevent)
 	}
 }
 
-static int ioevent_process(IOEventPoller *ioevent)
+static int ioevent_process_by_poll(IOEventPoller *ioevent)
 {
     int result;
 
@@ -130,8 +130,6 @@ static int ioevent_process(IOEventPoller *ioevent)
     return 0;
 }
 
-#endif
-
 static void deal_timeouts(FastTimerEntry *head)
 {
 	FastTimerEntry *entry;
@@ -147,12 +145,9 @@ static void deal_timeouts(FastTimerEntry *head)
         /* must set NULL because NOT in time wheel */
         current->prev = current->next = NULL;
 		pEventEntry = (IOEventEntry *)current;
-		if (pEventEntry != NULL)
-		{
         pEventEntry->callback(pEventEntry->fd, IOEVENT_TIMEOUT, current);
 	}
 }
-}
 
 int ioevent_loop(struct nio_thread_data *thread_data,
 	IOEventCallback recv_notify_callback, TaskCleanUpCallback
@@ -206,20 +201,38 @@ int ioevent_loop(struct nio_thread_data *thread_data,
 #endif
 
 #if IOEVENT_USE_URING
+        if (thread_data->ev_puller.use_io_uring) {
             if (thread_data->ev_puller.submit_count > 0) {
-            if ((result=ioevent_uring_submit(&thread_data->ev_puller)) != 0) {
+                if ((result=ioevent_uring_submit(&thread_data->
+                                ev_puller)) != 0)
+                {
                     logError("file: "__FILE__", line: %d, "
                             "io_uring_submit fail, errno: %d, error info: %s",
                             __LINE__, result, STRERROR(result));
                     return result;
                 }
             }
+        }
 #endif
 
         if (sched_pull) {
-            if ((result=ioevent_process(&thread_data->ev_puller)) != 0) {
+#if IOEVENT_USE_URING
+            if (thread_data->ev_puller.use_io_uring) {
+                if ((result=ioevent_process_by_uring(&thread_data->
+                                ev_puller)) != 0)
+                {
                     return result;
                 }
+            } else {
+#endif
+                if ((result=ioevent_process_by_poll(&thread_data->
+                                ev_puller)) != 0)
+                {
+                    return result;
+                }
+#if IOEVENT_USE_URING
+            }
+#endif
         }
 
         if (thread_data->busy_polling_callback != NULL) {
@@ -227,7 +240,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
         }
 
 		if (thread_data->deleted_list != NULL) {
-			count = 0;
+			//count = 0;
 			while (thread_data->deleted_list != NULL) {
 				task = thread_data->deleted_list;
 				thread_data->deleted_list = task->next;
@@ -241,7 +254,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
                     }
                 }
 				clean_up_callback(task);
-				count++;
+				//count++;
 			}
 			//logInfo("cleanup task count: %d", count);
 		}
@@ -280,7 +293,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
 
 int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
         int sock, short event, IOEventCallback callback,
-        const int timeout, const bool use_iouring)
+        const int timeout)
 {
 	int result;
 
@@ -288,7 +301,7 @@ int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
 	task->event.fd = sock;
 	task->event.callback = callback;
 #if IOEVENT_USE_URING
-    if (use_iouring) {
+    if (pThread->ev_puller.use_io_uring) {
         if (FC_URING_OP_TYPE(task) == IORING_OP_NOP) {
             if ((result=uring_prep_first_recv(task)) != 0) {
                 logError("file: "__FILE__", line: %d, "

src/ioevent_loop.h

@@ -36,7 +36,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
 
 int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
         int sock, short event, IOEventCallback callback,
-        const int timeout, const bool use_iouring);
+        const int timeout);
 
 int ioevent_reset(struct fast_task_info *task, int new_fd, short event);
 

src/multi_socket_client.c

@@ -46,6 +46,7 @@ int fast_multi_sock_client_init_ex(FastMultiSockClient *client,
         fms_client_get_current_time_ms_func get_current_time_ms_func,
         const int init_recv_buffer_size, const int timeout_ms)
 {
+    const bool use_io_uring = false;
     int result;
     int new_init_recv_buffer_size;
     int i;
@@ -66,7 +67,7 @@ int fast_multi_sock_client_init_ex(FastMultiSockClient *client,
     }
 
     if ((result=ioevent_init(&client->ioevent, "client",
-                    entry_count, timeout_ms, 0)) != 0)
+                    use_io_uring, entry_count, timeout_ms, 0)) != 0)
     {
         logError("file: "__FILE__", line: %d, "
                 "ioevent_init fail, errno: %d, error info: %s",

src/shared_func.c

@@ -3178,7 +3178,7 @@ key_t fc_ftok(const char *path, const int proj_id)
     return (((proj_id & 0xFF) << 24) | (hash_code & 0xFFFFFF));
 }
 
-static void add_thousands_separator(char *str, const int len)
+static int add_thousands_separator(char *str, const int len)
 {
     int new_len;
     int addings;
@@ -3191,7 +3191,7 @@ static void add_thousands_separator(char *str, const int len)
 
     if (len <= 3)
     {
-        return;
+        return len;
     }
 
     if (*str == '-')
@@ -3227,6 +3227,8 @@ static void add_thousands_separator(char *str, const int len)
             add_count++;
         }
     }
+
+    return new_len;
 }
 
 const char *int2str(const int n, char *buff, const bool thousands_separator)
@@ -4523,3 +4525,33 @@ int fc_compare_int64_ptr(const int64_t *n1, const int64_t *n2)
 {
     return fc_compare_int64(*n1, *n2);
 }
+
+const char *double2str(const double d, const int scale,
+        char *buff, const bool thousands_separator)
+{
+    int len;
+    int front_len;
+    int tail_len;
+    int new_len;
+    char *point;
+    char fragment[32];
+
+    len = fc_ftoa(d, scale, buff);
+    *(buff + len) = '\0';
+    if (!thousands_separator) {
+        return buff;
+    }
+
+    if (scale <= 0) {
+        add_thousands_separator(buff, len);
+        return buff;
+    }
+
+    tail_len = 1 + scale;
+    front_len = len - tail_len;
+    point = buff + front_len;
+    memcpy(fragment, point, tail_len + 1);
+    new_len = add_thousands_separator(buff, front_len);
+    memcpy(buff + new_len, fragment, tail_len + 1);
+    return buff;
+}

src/shared_func.h

@@ -1191,6 +1191,23 @@ static inline const char *long_to_comma_str(const int64_t n, char *buff)
     return long2str(n, buff, true);
 }
 
+/** convert double to string
+ *  parameters:
+ *  	d: the double number
+ *      scale: number of decimal places (round off)
+ *      buff: output buffer
+ *      thousands_separator: if add thousands separator
+ *  return: string buffer
+*/
+const char *double2str(const double d, const int scale,
+        char *buff, const bool thousands_separator);
+
+static inline const char *double_to_comma_str(const double d,
+        const int scale, char *buff)
+{
+    return double2str(d, scale, buff, true);
+}
+
 const char *bytes_to_human_str(const int64_t bytes, char *buff);
 
 /** if the string starts with the needle string
@@ -1636,16 +1653,29 @@ static inline int fc_ltostr_ex(int64_t n, char *buff, const int padding_len)
         return len;
     }
 
+#if defined(OS_LINUX) && defined(__GNUC__) && __GNUC__ >= 8
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+
     fill_len = padding_len - len;
     memmove(buff + fill_len, buff, len + 1);
     memset(buff, '0', fill_len);
+
+#if defined(OS_LINUX) && defined(__GNUC__) && __GNUC__ >= 8
+#pragma GCC diagnostic pop
+#endif
+
     return padding_len;
 }
 
 static inline int fc_ltostr(int64_t n, char *buff)
 {
-    const int padding_len = 0;
-    return fc_ltostr_ex(n, buff, padding_len);
+    int len;
+
+    len = fc_itoa(n, buff);
+    *(buff + len) = '\0';
+    return len;
 }
 
 static inline size_t fc_strlcpy(char *dest, const char *src, const size_t size)

src/tests/test_pthread_lock.c

@@ -28,16 +28,68 @@
 #include "fastcommon/fast_allocator.h"
 
 #define LOOP_COUNT (30 * 1000 * 1000)
+#define THREAD_COUNT  2
 #define barrier()  __asm__ __volatile__("" ::: "memory")
 
+static volatile int64_t sum;
+static pthread_mutex_t lock;
+
+static void *atomic_thread_func(void *arg)
+{
+	int k;
+	for (k=1; k<=LOOP_COUNT; k++) {
+        //__sync_synchronize();
+        //barrier();
+        __sync_add_and_fetch(&sum, k);
+	}
+
+    return NULL;
+}
+
+static void *mutex_thread_func(void *arg)
+{
+	int k;
+	for (k=1; k<=LOOP_COUNT; k++) {
+        pthread_mutex_lock(&lock);
+        sum += k;
+        pthread_mutex_unlock(&lock);
+	}
+
+    return NULL;
+}
+
+typedef void *(*thread_func)(void *arg);
+
+static int test(const char *caption, thread_func thread_run)
+{
+	int64_t start_time;
+    char time_buff[32];
+    pthread_t tids[THREAD_COUNT];
+    int i;
+	int result;
+
+    start_time = get_current_time_ms();
+    sum = 0;
+
+    for (i=0; i<THREAD_COUNT; i++) {
+        if ((result=pthread_create(tids + i, NULL, thread_run, NULL)) != 0) {
+            return result;
+        }
+    }
+
+    for (i=0; i<THREAD_COUNT; i++) {
+        pthread_join(tids[i], NULL);
+    }
+
+	printf("%s add, LOOP_COUNT: %s, sum: %"PRId64", time used: "
+            "%"PRId64" ms\n", caption, int_to_comma_str(LOOP_COUNT, time_buff),
+            sum, get_current_time_ms() - start_time);
+    return 0;
+}
+
 int main(int argc, char *argv[])
 {
 	int result;
-	int k;
-    int64_t sum;
-	int64_t start_time;
-    char time_buff[32];
-    pthread_mutex_t lock;
 
 	log_init();
 	srand(time(NULL));
@@ -49,33 +101,13 @@ int main(int argc, char *argv[])
         return result;
     }
 
-	start_time = get_current_time_ms();
-    sum = 0;
-	for (k=1; k<=LOOP_COUNT; k++) {
-        //__sync_synchronize();
-        //barrier();
-        __sync_add_and_fetch(&sum, k);
-	}
-
-	printf("atom add, LOOP_COUNT: %s, sum: %"PRId64", time used: "
-            "%"PRId64" ms\n", int_to_comma_str(LOOP_COUNT, time_buff),
-            sum, get_current_time_ms() - start_time);
-
     printf("lock 1: %d\n", pthread_mutex_lock(&lock));
     printf("lock 2: %d\n", pthread_mutex_lock(&lock));
     printf("unlock 1: %d\n", pthread_mutex_unlock(&lock));
     printf("unlock 2: %d\n", pthread_mutex_unlock(&lock));
 
-	start_time = get_current_time_ms();
-    sum = 0;
-	for (k=1; k<=LOOP_COUNT; k++) {
-        pthread_mutex_lock(&lock);
-        sum += k;
-        pthread_mutex_unlock(&lock);
-	}
+    test("atom", atomic_thread_func);
+    test("lock", mutex_thread_func);
 
-	printf("locked add, LOOP_COUNT: %s, sum: %"PRId64", time used: "
-            "%"PRId64" ms\n", int_to_comma_str(LOOP_COUNT, time_buff),
-            sum, get_current_time_ms() - start_time);
 	return 0;
 }