✨ feat(src): refactorfeature-refactor

8 files changed, 360 insertions, 1768 deletions

diff --git a/example/demo/conf/default.conf b/example/demo/conf/default.conf
index 3d95a693..66d82054 100644
--- a/example/demo/conf/default.conf
+++ b/example/demo/conf/default.conf
@@ -5,7 +5,7 @@ hos_accesskeyid="default"
 hos_secretkey="default"
 hos_log_path="./log/hoslog" #default
 hos_log_level=30 #default
-hos_poolsize=0 #default
+hos_poolsize=10 #default
 hos_thread_sum=32 #default
 hos_cache_size=102400 #default
 hos_cache_count=10 #default
diff --git a/example/demo/hos_write_demo.cpp b/example/demo/hos_write_demo.cpp
index 03fc5ad8..f27d973e 100644
--- a/example/demo/hos_write_demo.cpp
+++ b/example/demo/hos_write_demo.cpp
@@ -54,8 +54,6 @@ int file_to_buffer(const char *file, char *buffer, int size)
 
 void callback(bool result, const char *error, const char *bucket, const char *object, void *userdata)
 {
-    userdata_t *data = (userdata_t *)userdata;
-    clock_gettime(CLOCK_MONOTONIC, data->finished);
     return ;
 }
 
@@ -75,11 +73,11 @@ int main(int argc, char *argv[])
     struct stat buffer;    
     char *buf = NULL;
     size_t buf_size;
-    int mode = FILE_MODE;
     size_t fd = 0; 
     userdata_t data = {&finished};
-    hos_instance hos_instance = NULL;
     char object[1024];
+    hos_handle hh = NULL;
+    const char *bucket = "hos_test_bucket";
 
     if (stat(file_name, &buffer) == -1)
     {
@@ -96,54 +94,47 @@ int main(int argc, char *argv[])
     }
 
     printf("hos_init_instance start ...\n");
-    hos_instance = hos_get_instance();
-    if (hos_instance->result == false)
+    if (hos_verify_instance() == false)
     {
-        hos_instance = hos_init_instance(conf_file, module_name, 1, "hos_test_bucket");
+        if (hos_init_instance(conf_file, module_name, bucket) == false)
+        {
+            printf("error:hos_init_instance\n");
+            printf("error:%s\n", hos_get_init_instance_errmsg());
+            return -1;
+        }
     }
-    if (hos_instance->result == false) 
-    {
-        printf("error:hos_init_instance\n");
-        printf("error:%s", hos_instance->error_message);
-        return -1;
-    }  
     printf("hos_init_instance success ... \n");
 
-    mode = FILE_MODE;
-    printf("hos_write file start ...\n");
-    snprintf(object, 1023, "%s_write_file", file_name);
-    fd = hos_open_fd("hos_test_bucket", object, callback, NULL, 0, mode);
-    if (hos_write(fd, file_name, 0, 0) != HOS_CLIENT_OK)
-    {
-        printf("error: hos_write fialed!\n");
-    }
-    hos_close_fd(fd, 0);
-    printf("hos_write file end ...\n");
+    /*FILE MODE*/
+    printf("hos_upload_file start ...\n");
+    snprintf(object, 1023, "%s_upload_file", file_name);
+    hos_upload_file(bucket, file_name, callback, NULL);
+    printf("hos_upload_file end ...\n");
 
-    mode = BUFF_MODE;
-    printf("hos_write buff start ...\n");
-    snprintf(object, 1023, "%s_write_buff", file_name);
-    fd = hos_open_fd("hos_test_bucket", object, callback, NULL, 0, mode);
-    if (hos_write(fd, buf, buffer.st_size, 0) != HOS_CLIENT_OK)
-    {
-        printf("error: hos_write failed!\n");
-    }
-    hos_close_fd(fd, 0);
+    /*BUFF MODE*/
+    printf("hos_upload_buf start ...\n");
+    snprintf(object, 1023, "%s_upload_buff", file_name);
+    fd = hos_upload_buf(bucket, object, buf, buffer.st_size, callback, NULL);
     printf("hos_write buff end ...\n");
 
-    mode = BUFF_MODE | APPEND_MODE;
+    /*APPEND_MODE*/
     printf("hos_write buff start ...\n");
     snprintf(object, 1023, "%s_write_APPEND", file_name);
-    fd = hos_open_fd("hos_test_bucket", object, callback, NULL, 0, mode);
-    if (hos_write(fd, buf, buffer.st_size, 0) != HOS_CLIENT_OK)
+    int ret = hos_open_handle(bucket, object, callback, NULL, &hh);
+    if (ret != HOS_CLIENT_OK)
+    {
+        printf("error:errcode:%d\n", ret);
+        return -1;
+    }
+    if (hos_write(hh, buf, buffer.st_size) != HOS_CLIENT_OK)
     {
         printf("error: hos_write failed 1st!\n");
     }
-    if (hos_write(fd, buf, buffer.st_size, 0) != HOS_CLIENT_OK)
+    if (hos_write(hh, buf, buffer.st_size) != HOS_CLIENT_OK)
     {
         printf("error: hos_write failed 2nd!\n");
     }
-    hos_close_fd(fd, 0);
+    hos_close_handle(hh);
     printf("hos_write buff end ...\n");
 
     printf("hos_shutdown_instance start ...\n");
diff --git a/src/hos_client.cpp b/src/hos_client.cpp
index a589b26c..c3a9941e 100644
--- a/src/hos_client.cpp
+++ b/src/hos_client.cpp
@@ -43,12 +43,14 @@ extern "C"
     } while (0)
 #endif
 
-struct hos_instance_s g_hos_instance;
+#define FILE_MODE 0
+#define BUFF_MODE 1
+#define APPEND_MODE 2
+
+struct hos_info_s g_hos_instance;
 hos_client_handle_t g_hos_handle;//一个进程只允许有一个g_hos_handle
 static std::mutex m_client_lock;
 static std::mutex m_delete_lock;
-hos_fd_context_t **g_fd_context;
-size_t *g_fd_info; //fd 实际从1开始,每个线程有独立的fd
 static Aws::SDKOptions g_options;
 
 static inline size_t get_current_ms()
@@ -58,34 +60,31 @@ static inline size_t get_current_ms()
     return (timenow.tv_sec * 1000 + timenow.tv_nsec / 1000 / 1000 );
 }   
 
-static int hos_delete_fd(size_t fd, size_t thread_id)
+static void hos_destroy_handle(hos_handle handle)
 {
     std::lock_guard<std::mutex> locker(m_delete_lock);
-    hos_fd_context_t* context = find_context_by_fd(g_fd_context[thread_id], fd);
-    if (context == NULL)
+    if (handle == NULL)
     {
-        return HOS_PARAMETER_ERROR;
+        return;
     }
-
-    put_finished_callback callback = (put_finished_callback)context->callback;
+    put_finished_callback callback = (put_finished_callback)handle->callback;
     if (callback)
     {
-        callback(context->reslut, context->bucket, context->object, context->error, context->userdata);
+        callback(handle->reslut, handle->bucket, handle->object, handle->error, handle->userdata);
     }
-    if (context->bucket)
+    if (handle->bucket)
     {
-        free(context->bucket);
-        context->bucket = NULL;
-        }
-        if (context->object)
-        {
-            free(context->object);
-            context->object = NULL;
-        }
-        HASH_DEL(g_fd_context[thread_id], context);
-        free(context);
-    
-    return HOS_CLIENT_OK;
+        free(handle->bucket);
+        handle->bucket = NULL;
+    }
+    if (handle->object)
+    {
+        free(handle->object);
+        handle->object = NULL;
+    }
+    free(handle);
+
+    return ;
 }
 
 static void PutObjectAsyncFinished(const Aws::S3::S3Client* S3Client, 
@@ -94,92 +93,77 @@ static void PutObjectAsyncFinished(const Aws::S3::S3Client* S3Client,
     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context)
 {
     const char *error = NULL;
-    hos_fd_context_t *a_fd_context = NULL;
     hos_func_thread_t *hos_func = &g_hos_handle.hos_func;
     data_info_t *data_info = NULL;
     const Aws::String& uuid = context->GetUUID();
-    size_t thread_id, fd, stream_len;
+    size_t handle_addr = 0, stream_len = 0;
+    hos_handle_t *handle = NULL;
+
+    sscanf(uuid.c_str(), "%lu %lu", &handle_addr, &stream_len);
+    handle = (hos_handle_t *)handle_addr;
 
-    sscanf(uuid.c_str(), "%lu %lu %lu", &thread_id, &fd, &stream_len);
-    a_fd_context = find_context_by_fd(g_fd_context[thread_id], fd);
-    if (a_fd_context == NULL)
+    bool result = outcome.IsSuccess();
+    if (!result)
     {
+        error = outcome.GetError().GetMessage().c_str();
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__,
-           "error: Not find the info of [thread_id:%lu fd:%lu]", thread_id, fd);
+                                "error: [%s:%s] upload failed. error:%s", handle->bucket, handle->object, error);
 
-        if (hos_func->fs2_info.fs2_handle && hos_func->fs2_info.reserved)
+        if (hos_func->fs2_info.fs2_handle)
         {
-            data_info = (data_info_t *)hos_func->fs2_info.reserved;
-            data_info->tx_failed_pkts[thread_id]++;
-            data_info->tx_failed_bytes[thread_id] += stream_len;
+            data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+            atomic_add(&data_info->tx_failed_pkts, 1);
+            atomic_add(&data_info->tx_failed_bytes, stream_len);
         }
     }
     else
     {
-        bool result = outcome.IsSuccess();
-        if (!result)
+        if (hos_func->fs2_info.fs2_handle)
         {
-            error = outcome.GetError().GetMessage().c_str();
-            MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__,
-                                    "error: [%s:%s] upload failed. error:%s", a_fd_context->bucket, a_fd_context->object, error);
-
-            if (hos_func->fs2_info.fs2_handle && hos_func->fs2_info.reserved)
-            {
-                data_info = (data_info_t *)hos_func->fs2_info.reserved;
-                data_info->tx_failed_pkts[thread_id]++;
-                data_info->tx_failed_bytes[thread_id] += stream_len;
-            }
+            data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+            atomic_add(&data_info->tx_pkts, 1);
+            atomic_add(&data_info->tx_bytes, stream_len);
+            MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
+                                    "debug: [%s:%s] upload success. tx_pkts:%lu, tx_bytes:%lu",
+                                    handle->bucket, handle->object,
+                                    atomic_read(&data_info->tx_pkts), atomic_read(&data_info->tx_bytes));
         }
         else
         {
-            if (hos_func->fs2_info.fs2_handle && hos_func->fs2_info.reserved)
-            {
-                data_info = (data_info_t *)hos_func->fs2_info.reserved;
-                data_info->tx_pkts[thread_id]++;
-                data_info->tx_bytes[thread_id] += stream_len;
-                MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-                                        "debug: [%s:%s] upload success. tx_pkts:%lu, tx_bytes:%lu",
-                                        a_fd_context->bucket, a_fd_context->object,
-                                        data_info->tx_pkts[thread_id], data_info->tx_bytes[thread_id]);
-            }
-            else
-            {
-                MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-                                        "debug: [%s:%s] upload success. stream size:%lu", a_fd_context->bucket, a_fd_context->object, stream_len);
-            }
+            MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
+                                    "debug: [%s:%s] upload success. stream size:%lu", handle->bucket, handle->object, stream_len);
         }
-        a_fd_context->reslut = result;
-        a_fd_context->error = error;
+    }
+    handle->reslut = result;
+    handle->error = error;
 
-        if (a_fd_context->mode & APPEND_MODE)
+    if (handle->mode & APPEND_MODE)
+    {
+        //APPEND MODE 保留fd
+        atomic_add(&(handle->recive_cnt), 1);
+        if (handle->handle_status == HOS_HANDLE_CANCEL)
         {
-            //APPEND MODE 保留fd
-            atomic_add(&(a_fd_context->recive_cnt), 1);
-            if (a_fd_context->fd_status == HOS_FD_INJECT)
+            if (handle->position == handle->recive_cnt)
             {
-                if (a_fd_context->position == a_fd_context->recive_cnt)
-                {
-                    MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-                                            "debug: [%s:%s] upload completed. [thread:%lu fd:%lu] delete",
-                                            a_fd_context->bucket, a_fd_context->object, thread_id, a_fd_context->fd);
-                    hos_delete_fd(fd, thread_id);
-                }
+                MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
+                                        "debug: [%s:%s] upload completed. delete",
+                                        handle->bucket, handle->object);
+                hos_destroy_handle(handle);
             }
         }
-        else
-        {
-            //完整上传 删除fd
-            MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-                                    "debug: [%s:%s] upload completed. [thread:%lu fd:%lu] delete",
-                                    a_fd_context->bucket, a_fd_context->object, thread_id, a_fd_context->fd);
-            hos_delete_fd(fd, thread_id);
-        }
     }
-    atomic_sub(&g_hos_handle.task_num[thread_id], 1);
-    atomic_sub(&g_hos_handle.task_context[thread_id], stream_len);
+    else
+    {
+        //完整上传 删除fd
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
+                                "debug: [%s:%s] upload completed. handle destory", handle->bucket, handle->object);
+        hos_destroy_handle(handle);
+    }
+    atomic_sub(&g_hos_handle.task_num, 1);
+    atomic_sub(&g_hos_handle.task_context, stream_len);
 }
 
-static void hos_client_create()
+static bool hos_client_create()
 {
     hos_config_t *hos_conf = &g_hos_handle.hos_config;
     void *log = g_hos_handle.log;
@@ -187,8 +171,7 @@ static void hos_client_create()
     if (g_hos_handle.S3Client != NULL)
     {
         g_hos_handle.count++;
-        g_hos_instance.result = true;
-        return ;
+        return true;
     }
 
     Aws::InitAPI(g_options);
@@ -227,30 +210,18 @@ static void hos_client_create()
         Aws::ShutdownAPI(g_options);
         g_hos_instance.error_code = (size_t)outcome.GetError().GetErrorType() + 1;
         snprintf(g_hos_instance.error_message, HOS_ERROR_MESSAGE_SIZE, outcome.GetError().GetMessage().c_str());
-        g_hos_instance.result = false;
         MESA_HANDLE_RUNTIME_LOG(log, RLOG_LV_FATAL, "hos_client_create", "error: %s", g_hos_instance.error_message);
-        return;
+        return false;
     }
 
     g_hos_handle.buckets = outcome.GetResult().GetBuckets();
     g_hos_handle.count++;
-    g_hos_handle.executor = std::dynamic_pointer_cast<Aws::Utils::Threading::PooledThreadExecutor>(config.executor);
-    g_hos_handle.task_num = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    g_hos_handle.task_context = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-
-    g_fd_context = (hos_fd_context_t **)calloc(hos_conf->thread_num, sizeof(hos_fd_context_t *));
-    g_fd_info = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-
-    #if 0
-    if (g_hos_handle.hos_func.fd_thread == 0)
-    {
-        g_hos_handle.hos_func.fd_thread_status = 0;
-        pthread_create(&g_hos_handle.hos_func.fd_thread, NULL, hos_fd_manage, NULL);
-    }
-    #endif
+    //g_hos_handle.executor = std::dynamic_pointer_cast<Aws::Utils::Threading::PooledThreadExecutor>(config.executor);
+    g_hos_handle.task_num = 0;
+    g_hos_handle.task_context = 0;
 
     MESA_HANDLE_RUNTIME_LOG(log, RLOG_LV_DEBUG, "hos_client_create", "debug: hos s3client create success, url:%s.",endpoint);
-    g_hos_instance.result = true;
+    return true;
 }
 
 bool hos_verify_bucket(const char *bucket)
@@ -261,7 +232,7 @@ bool hos_verify_bucket(const char *bucket)
             "debug: bucket is null");
         return false;
     }   
-    if (g_hos_instance.result != true || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return false;
     }
@@ -289,7 +260,6 @@ bool hos_verify_bucket(const char *bucket)
 
 static void *fs2_statistics(void *ptr)
 {
-    size_t i = 0;
     size_t rx_pkts_sum = 0;
     size_t rx_bytes_sum = 0;
     size_t tx_pkts_sum = 0;
@@ -315,9 +285,7 @@ static void *fs2_statistics(void *ptr)
     size_t cache_last = 0;
     size_t req_overflow_last = 0;
     fs2_info_t *fs2_info = NULL; 
-    hos_config_t *hos_conf = &g_hos_handle.hos_config;
     hos_func_thread_t *hos_func = &g_hos_handle.hos_func;
-    size_t task_num = 0;
 
     while(1)
     {
@@ -336,20 +304,14 @@ static void *fs2_statistics(void *ptr)
         cache_sum = 0;
 
         fs2_info = &hos_func->fs2_info;
-        data_info_t *data_info = (data_info_t *)fs2_info->reserved;
-        for (i = 0; i < hos_conf->thread_num; i++)
-        {
-            rx_pkts_sum += data_info->rx_pkts[i];
-            rx_bytes_sum += data_info->rx_bytes[i];
-            tx_pkts_sum += data_info->tx_pkts[i];
-            tx_bytes_sum += data_info->tx_bytes[i];
-            tx_failed_bytes_sum += data_info->tx_failed_bytes[i];
-            tx_failed_pkts_sum += data_info->tx_failed_pkts[i];
-            cache_sum += data_info->cache[i];
-
-            task_num += atomic_read(&g_hos_handle.task_num[i]);
-        }
-        req_overflow_sum = atomic_read(&data_info->tx_req_num_overflow);
+        data_info_t *data_info = (data_info_t *)&fs2_info->data_info;
+        rx_pkts_sum += atomic_read(&data_info->rx_pkts);
+        rx_bytes_sum += atomic_read(&data_info->rx_bytes);
+        tx_pkts_sum += atomic_read(&data_info->tx_pkts);
+        tx_bytes_sum += atomic_read(&data_info->tx_bytes);
+        tx_failed_bytes_sum += atomic_read(&data_info->tx_failed_bytes);
+        tx_failed_pkts_sum += atomic_read(&data_info->tx_failed_pkts);
+        cache_sum += atomic_read(&data_info->cache);
 
         rx_pkts_interval = rx_pkts_sum - rx_pkts_last;
         rx_bytes_interval = rx_bytes_sum - rx_bytes_last;
@@ -433,7 +395,6 @@ static void hos_expand_fs2()
 {
     fs2_info_t *fs2_info = NULL;
     screen_stat_handle_t fs2_handle = NULL;
-    hos_config_t *hos_conf = &g_hos_handle.hos_config;
     hos_func_thread_t *hos_func = &g_hos_handle.hos_func;
     size_t i = 0;
 
@@ -460,15 +421,6 @@ static void hos_expand_fs2()
     fs2_info->line_ids[1] = FS_register(fs2_handle, FS_STYLE_LINE, FS_CALC_CURRENT, "total");
 
     hos_func->fs2_status = HOS_FS2_START;
-    data_info_t *data_info = (data_info_t *)calloc(1, sizeof(data_info_t));
-    fs2_info->reserved = (void *)data_info;
-    data_info->tx_pkts = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    data_info->tx_bytes = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    data_info->rx_pkts = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    data_info->rx_bytes = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    data_info->tx_failed_pkts = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    data_info->tx_failed_bytes = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
-    data_info->cache = (size_t *)calloc(hos_conf->thread_num, sizeof(size_t));
     FS_start(fs2_handle);
 
     pthread_create(&hos_func->fs2_thread, NULL, fs2_statistics, NULL);
@@ -476,8 +428,7 @@ static void hos_expand_fs2()
     return ;
 }
 
-static int hos_putobject_async(Aws::S3::Model::PutObjectRequest& request, size_t stream_len,
-    size_t thread_id, size_t fd, const char *bucket, const char *object)
+static int hos_putobject_async(hos_handle_t *handle, Aws::S3::Model::PutObjectRequest& request, size_t stream_len)
 {
     char buf[128];
     int ret = 0;
@@ -488,26 +439,22 @@ static int hos_putobject_async(Aws::S3::Model::PutObjectRequest& request, size_t
     //设置回调函数
     std::shared_ptr<Aws::Client::AsyncCallerContext> context = 
         Aws::MakeShared<Aws::Client::AsyncCallerContext>("");
-    sprintf(buf, "%lu %lu %lu", thread_id, fd, stream_len);
+    sprintf(buf, "%lu %lu", (size_t)handle, stream_len);
     context->SetUUID(buf);
 
     if (hos_conf->max_request_num && hos_conf->max_request_context && 
-        (atomic_read(&g_hos_handle.task_num[thread_id]) >= hos_conf->max_request_num ||
-        atomic_read(&g_hos_handle.task_context[thread_id]) >= hos_conf->max_request_context))
+        (atomic_read(&g_hos_handle.task_num) >= hos_conf->max_request_num ||
+        atomic_read(&g_hos_handle.task_context) >= hos_conf->max_request_context))
     {
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
             "debug: PutObjectAsync failed. [%s:%s]. task_num:%lu, task_context:%lu",
-            bucket, object, atomic_read(&g_hos_handle.task_num[thread_id]), atomic_read(&g_hos_handle.task_context[thread_id]));
-
+            handle->bucket, handle->object, g_hos_handle.task_num, g_hos_handle.task_context);
         if (hos_func->fs2_info.fs2_handle)
         {
-            if (hos_func->fs2_info.reserved)
-            {
-                data_info = (data_info_t *)hos_func->fs2_info.reserved;
-                data_info->tx_failed_pkts[thread_id]++;
-                data_info->tx_failed_bytes[thread_id] += stream_len;
+                data_info = (data_info_t *)&(hos_func->fs2_info.data_info);
+                atomic_add(&data_info->tx_failed_pkts, 1);
+                atomic_add(&data_info->tx_failed_bytes, stream_len);
                 atomic_add(&data_info->tx_req_num_overflow, 1);
-            }
         }        
 
         return HOS_SEND_FAILED;
@@ -517,34 +464,30 @@ static int hos_putobject_async(Aws::S3::Model::PutObjectRequest& request, size_t
     ret = S3Client.PutObjectAsync(request, PutObjectAsyncFinished, context);
     if (ret)
     {
-        atomic_add(&g_hos_handle.task_num[thread_id], 1);
-        atomic_add(&g_hos_handle.task_context[thread_id], stream_len);
+        atomic_add(&g_hos_handle.task_num, 1);
+        atomic_add(&g_hos_handle.task_context, stream_len);
         //不算真正成功，需要等到PutObjectAsyncFinished的结果
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-            "debug: PutObjectAsync success. [%s:%s]", bucket, object);
+            "debug: PutObjectAsync success. [%s:%s]", handle->bucket, handle->object);
         
         return HOS_CLIENT_OK;
     }
     else
     {
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-            "debug: PutObjectAsync failed. [%s:%s]", bucket, object);
+            "debug: PutObjectAsync failed. [%s:%s]", handle->bucket, handle->object);
 
         if (hos_func->fs2_info.fs2_handle)
         {
-            if (hos_func->fs2_info.reserved)
-            {
-                data_info = (data_info_t *)hos_func->fs2_info.reserved;
-                data_info->tx_failed_pkts[thread_id]++;
-                data_info->tx_failed_bytes[thread_id] += stream_len;
-            }
+            data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+            atomic_add(&data_info->tx_failed_pkts, 1);
+            atomic_add(&data_info->tx_failed_bytes, stream_len);
         }
         return HOS_SEND_FAILED;
     }
 }
 
-static int hos_putobject_sync(Aws::S3::Model::PutObjectRequest& request, size_t stream_len, size_t thread_id, size_t fd,
-    const char *bucket, const char *object)
+static int hos_putobject_sync(hos_handle_t *handle, Aws::S3::Model::PutObjectRequest& request, size_t stream_len)
 {
     hos_func_thread_t *hos_func = &g_hos_handle.hos_func;
     data_info_t *data_info = NULL;
@@ -553,19 +496,19 @@ static int hos_putobject_sync(Aws::S3::Model::PutObjectRequest& request, size_t
     Aws::S3::Model::PutObjectOutcome Outcome = S3Client.PutObject(request);
     if (Outcome.IsSuccess())
     {
-        if (hos_func->fs2_info.fs2_handle && hos_func->fs2_info.reserved)
+        if (hos_func->fs2_info.fs2_handle)
         {
-            data_info = (data_info_t *)hos_func->fs2_info.reserved;
-            data_info->tx_pkts[thread_id]++;
-            data_info->tx_bytes[thread_id] += stream_len;
+            data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+            atomic_add(&data_info->tx_pkts, 1);
+            atomic_add(&data_info->tx_bytes, stream_len);
             MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
                                     "debug: PutObject success. [%s:%s] tx_pkts:%lu, tx_bytes:%lu",
-                                    bucket, object, data_info->tx_pkts[thread_id], data_info->tx_bytes[thread_id]);
+                                    handle->bucket, handle->object, atomic_read(&data_info->tx_pkts), atomic_read(&data_info->tx_bytes));
         }
         else
         {
             MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-                                    "debug: PutObject success. [%s:%s]", bucket, object);
+                                    "debug: PutObject success. [%s:%s]", handle->bucket, handle->object);
         }
 
         return HOS_CLIENT_OK;
@@ -573,45 +516,57 @@ static int hos_putobject_sync(Aws::S3::Model::PutObjectRequest& request, size_t
     else
     {
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-            "debug: PutObject failed. [%s:%s] cause:%s", bucket, object, Outcome.GetError().GetMessage().c_str());
+            "debug: PutObject failed. [%s:%s] cause:%s", handle->bucket, handle->object, Outcome.GetError().GetMessage().c_str());
 
-        if (hos_func->fs2_info.fs2_handle && hos_func->fs2_info.reserved)
+        if (hos_func->fs2_info.fs2_handle)
         {
-            data_info = (data_info_t *)hos_func->fs2_info.reserved;
-            data_info->tx_failed_pkts[thread_id]++;
-            data_info->tx_failed_bytes[thread_id] += stream_len;
+            data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+            atomic_add(&data_info->tx_failed_pkts, 1);
+            atomic_add(&data_info->tx_failed_bytes, stream_len);
         }
 
         return (int)Outcome.GetError().GetErrorType() + 1;
     }
 }
 
-hos_instance hos_get_instance()
+bool hos_verify_instance()
 {
     if (g_hos_handle.S3Client != NULL)
     {
         g_hos_handle.count++;
-        g_hos_instance.result = true;
-        return &g_hos_instance;
+        return true;
     }
     memset(&g_hos_instance, 0, sizeof(g_hos_instance));
-    g_hos_instance.result = false;
-    return &g_hos_instance;
+    return false;
+}
+
+int hos_get_init_instance_errcode()
+{
+    return g_hos_instance.error_code;
+}
+
+const char *hos_get_init_instance_errmsg()
+{
+    return g_hos_instance.error_message;
+}
+
+const char *hos_get_url_prefix()
+{
+    return g_hos_instance.hos_url_prefix;
 }
 
-hos_instance hos_init_instance(const char *conf_path, const char *module, size_t thread_num, const char *bucket)
+bool hos_init_instance(const char *conf_path, const char *module, const char *bucket)
 {
     std::lock_guard<std::mutex> locker(m_client_lock);
     hos_config_t *hos_conf = &g_hos_handle.hos_config;
     char hos_url[1024];
 
-    if (conf_path == NULL || thread_num == 0 || module == NULL || bucket == NULL)
+    if (conf_path == NULL || module == NULL || bucket == NULL)
     {
-        g_hos_instance.result = false;
         g_hos_instance.error_code = HOS_PARAMETER_ERROR;
         snprintf(g_hos_instance.error_message, HOS_ERROR_MESSAGE_SIZE,
-            "param error:conf_path:%s, module:%s, thread_num:%lu, bucket:%s", conf_path, module, thread_num, bucket);
-        return &g_hos_instance;
+            "param error:conf_path:%s, module:%s, bucket:%s", conf_path, module, bucket);
+        return false;
     }
 
     MESA_load_profile_string_nodef(conf_path, module, "hos_serverip", hos_conf->ip, MAX_HOS_STRING_LEN);
@@ -634,25 +589,22 @@ hos_instance hos_init_instance(const char *conf_path, const char *module, size_t
         g_hos_handle.log = MESA_create_runtime_log_handle(hos_conf->log_path, hos_conf->log_level);
         if (g_hos_handle.log == NULL)
         {
-            g_hos_instance.result = false;
             g_hos_instance.error_code = HOS_RUNTIME_LOG_FAILED;
             snprintf(g_hos_instance.error_message, HOS_ERROR_MESSAGE_SIZE, "runtime log create failed.");
-            return &g_hos_instance;
+            return false;
         }
 
         snprintf(hos_url, sizeof(hos_url), "http://%s:%d/hos/", hos_conf->ip, hos_conf->port);
-        hos_conf->thread_num = thread_num;
-        hos_client_create();
-        if (g_hos_instance.result == true)
+        if (hos_client_create())
         {
+            //XXX  是否需要验证bucket
             if(hos_verify_bucket(bucket) == false)
             {
                 MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__, "error: bucket:%s not exist.", bucket);
                 hos_shutdown_instance();
-                g_hos_instance.result = false;
                 g_hos_instance.error_code = HOS_BUCKET_NOT_EXIST;
                 snprintf(g_hos_instance.error_message, HOS_ERROR_MESSAGE_SIZE, "bucket:%s not exits.", bucket);
-                return &g_hos_instance;
+                return false;
             }
             MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__, "debug:%s","Instance init completed");
             hos_expand_fs2();
@@ -660,22 +612,25 @@ hos_instance hos_init_instance(const char *conf_path, const char *module, size_t
             g_hos_instance.error_message[0]='\0';
             g_hos_instance.hos_url_prefix = (const char *)calloc(1, strlen(hos_url) + 1);
             memcpy((void *)g_hos_instance.hos_url_prefix, hos_url, strlen(hos_url));
+            return true;
+        }
+        else
+        {
+            return false;
         }
-        return &g_hos_instance;
     }
     else
     {
-        g_hos_instance.result = false;
         g_hos_instance.error_code = HOS_CONF_ERROR;
         snprintf(g_hos_instance.error_message, HOS_ERROR_MESSAGE_SIZE, "hos param error:hos ip:%s, hos port:%u, accesskeyid:%s, secretkey:%s",
             hos_conf->ip, hos_conf->port, hos_conf->accesskeyid, hos_conf->secretkey);
-        return &g_hos_instance;
+        return false;
     }
 }
 
 int hos_create_bucket(const char *bucket)
 {
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
@@ -718,7 +673,7 @@ int hos_create_bucket(const char *bucket)
 }
 
 static int hos_upload_stream(const char *bucket, const char *object, const char *data, size_t data_len,
-    put_finished_callback callback, void *userdata, size_t thread_id)
+    put_finished_callback callback, void *userdata)
 {
     data_info_t *data_info = NULL;
     hos_config_t *hos_conf = &g_hos_handle.hos_config;
@@ -726,16 +681,16 @@ static int hos_upload_stream(const char *bucket, const char *object, const char
     int ret;
     int mode = 0;
 
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
 
-    if ((bucket == NULL) || (object == NULL) || (thread_id > hos_conf->thread_num))
+    if ((bucket == NULL) || (object == NULL))
     {
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, "hos_upload_stream",
-            "error: s3client:%s, bucket:%s, object:%s, thread_id:%lu, thread_num:%u",
-            g_hos_handle.S3Client?"not null":"null", bucket, object, thread_id, hos_conf->thread_num);
+            "error: s3client:%s, bucket:%s, object:%s",
+            g_hos_handle.S3Client?"not null":"null", bucket, object);
         return HOS_PARAMETER_ERROR;
     }
 
@@ -766,102 +721,99 @@ static int hos_upload_stream(const char *bucket, const char *object, const char
     //field_stat2 record
     if (hos_func->fs2_info.fs2_handle)
     {
-        if (hos_func->fs2_info.reserved)
-        {
-            data_info = (data_info_t *)hos_func->fs2_info.reserved;
-            data_info->rx_pkts[thread_id]++;
-            data_info->rx_bytes[thread_id] += data_len;
-        }
+        data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+        atomic_add(&data_info->rx_pkts, 1);
+        atomic_add(&data_info->rx_bytes, data_len);
     }
 
     //设置回调函数
-    size_t fd = ++g_fd_info[thread_id];
-    
-    hos_fd_context_t info = {fd, 0, (char *)bucket, (char *)object, (void *)callback, userdata, NULL, 0, 0, 0 };
-    add_fd_context(&g_fd_context[thread_id], &info);
+    hos_handle_t *handle = (hos_handle_t *)calloc(1, sizeof(hos_handle_t));
+    handle->bucket = (char *)calloc(1, strlen(bucket)+1);
+    memcpy(handle->bucket, bucket, strlen(bucket));
+    handle->object = (char *)calloc(1, strlen(object)+1);
+    memcpy(handle->object, object, strlen(object));
+    handle->callback = callback;
+    handle->userdata = userdata;
 
     if (hos_conf->pool_thread_size > 0)
     {
-        ret = hos_putobject_async(request, data_len, thread_id, fd, bucket, object);
+        ret = hos_putobject_async(handle, request, data_len);
     }
     else
     {
-        ret = hos_putobject_sync(request, data_len, thread_id, fd, bucket, object);
+        ret = hos_putobject_sync(handle, request, data_len);
     }
 
     return ret;
 }
 
-int hos_upload_file(const char *bucket, const char *file_path, put_finished_callback callback, void *userdata, size_t thread_id)
+int hos_upload_file(const char *bucket, const char *file_path, put_finished_callback callback, void *userdata)
 {
     struct stat buffer;
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
 
-    if ((bucket == NULL) || (file_path == NULL) || (thread_id > g_hos_handle.hos_config.thread_num))
+    if ((bucket == NULL) || (file_path == NULL))
     {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, "hos_upload_file",
-            "error: bucket:%s, file_path:%s, thread_id:%lu, thread_num:%u",
-            bucket, file_path, thread_id, g_hos_handle.hos_config.thread_num);
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__,
+            "error: bucket:%s, file_path:%s", bucket, file_path);
         return HOS_PARAMETER_ERROR;
     }
 
     if (stat(file_path, &buffer) == -1)
     {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, "hos_upload_file", "error: The file:%s not exist", file_path);
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__, "error: The file:%s not exist", file_path);
         return HOS_FILE_NOT_EXIST;
     }
-    return hos_upload_stream(bucket, file_path, NULL, buffer.st_size, callback, userdata, thread_id);
+    return hos_upload_stream(bucket, file_path, NULL, buffer.st_size, callback, userdata);
 }
 
-int hos_upload_buf(const char *bucket, const char *object, const char *buf, size_t buf_len, put_finished_callback callback, void *userdata, size_t thread_id)
+int hos_upload_buf(const char *bucket, const char *object, const char *buf, size_t buf_len, put_finished_callback callback, void *userdata)
 {
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
 
-    if ((bucket == NULL) || (object == NULL) || (buf == NULL) || (buf_len == 0)
-        || (thread_id > g_hos_handle.hos_config.thread_num))
+    if ((bucket == NULL) || (object == NULL) || (buf == NULL) || (buf_len == 0))
     {
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, "hos_upload_buf",
-            "bucket:%s, object:%s, buf:%s, buf_len:%lu, thread_id:%lu, thread_num:%u",
-            bucket, object, buf?"not null":"null", buf_len, thread_id, g_hos_handle.hos_config.thread_num);
+            "bucket:%s, object:%s, buf:%s, buf_len:%lu", bucket, object, buf?"not null":"null", buf_len);
         return HOS_PARAMETER_ERROR;
     }
-    return hos_upload_stream(bucket, object, buf, buf_len, callback, userdata, thread_id);
+    return hos_upload_stream(bucket, object, buf, buf_len, callback, userdata);
 }
 
-int hos_open_fd(const char *bucket, const char *object, put_finished_callback callback, void *userdata, size_t thread_id)
+int hos_open_handle(const char *bucket, const char *object, put_finished_callback callback, void *userdata, hos_handle handle)
 {
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
-    if ((bucket == NULL) || (object == NULL) || (thread_id > g_hos_handle.hos_config.thread_num) || strlen(bucket) == 0 || strlen(object) == 0)
+    if ((bucket == NULL) || (object == NULL) || strlen(bucket) == 0 || strlen(object) == 0)
     {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, "hos_open_fd", 
-            "error: bucket:%s, obejct:%s, thread_id:%lu",
-            (bucket == NULL)?"null":bucket, (object == NULL)?"null":object, thread_id);
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__, 
+            "error: bucket:%s, obejct:%s",
+            (bucket == NULL)?"null":bucket, (object == NULL)?"null":object);
         return HOS_PARAMETER_ERROR;
     }
-
-    size_t fd = ++g_fd_info[thread_id];
-    MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, "hos_open_fd", "debug: thread_id:%lu, fd:%lu", thread_id, fd);
     
-    hos_fd_context_t info = {fd, BUFF_MODE | APPEND_MODE, (char *)bucket, (char *)object, (void *)callback, userdata, 
-        NULL,/*cache*/ g_hos_handle.hos_config.cache_count, 0,/*position*/ 0,/*recive_cnt*/
-        (long)g_hos_handle.hos_config.cache_size,/*cache_rest*/ HOS_FD_REGISTER,/*fd_status*/};
-    add_fd_context(&g_fd_context[thread_id], &info);
+    handle = (hos_handle_t *)calloc(1, sizeof(hos_handle_t));
+    handle->bucket = (char *)calloc(1, strlen(bucket)+1);
+    memcpy(handle->bucket, bucket, strlen(bucket));
+    handle->object = (char *)calloc(1, strlen(object)+1);
+    memcpy(handle->object, object, strlen(object));
+    handle->callback = callback;
+    handle->userdata = userdata;
+    handle->handle_status = HOS_HANDLE_REGISTER;
 
-    return fd;
+    return HOS_CLIENT_OK;
 }
 
-int hos_write(size_t fd, const char *stream, size_t stream_len, size_t thread_id)
+int hos_write(hos_handle handle, const char *stream, size_t stream_len)
 {
-    hos_fd_context_t *a_fd_context = NULL;
     char num[128];
     int ret = 0;
     data_info_t *data_info = NULL;
@@ -869,26 +821,23 @@ int hos_write(size_t fd, const char *stream, size_t stream_len, size_t thread_id
     hos_func_thread_t *hos_func = &g_hos_handle.hos_func;
     size_t upload_len = 0;
 
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
 
-    if ((stream == NULL) || (thread_id > hos_conf->thread_num))
+    if (stream == NULL)
     {
         MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, 
-            "hos_write", "error: fd:%lu, stream:%s, stream_len:%lu, thread_id:%lu.",
-            fd, stream?"not null":"null", stream_len, thread_id);
+            "hos_write", "error: stream:%s, stream_len:%lu.",
+            stream?"not null":"null", stream_len);
         return HOS_PARAMETER_ERROR;
     }
-
-    a_fd_context = find_context_by_fd(g_fd_context[thread_id], fd);
-    if (a_fd_context == NULL)
+    if (handle == NULL)
     {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__, "error: fd info not find. thread_id:%lu, fd:%lu", thread_id, fd);
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__, "error: fd info not find.");
         return HOS_HASH_NOT_FIND;
     }
-    MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__, "debug: Get fd_context, thread_id:%lu, fd:%lu", thread_id, fd);
     
     // create and configure the asynchronous put object request.
     Aws::S3::Model::PutObjectRequest request;
@@ -896,157 +845,138 @@ int hos_write(size_t fd, const char *stream, size_t stream_len, size_t thread_id
     //field_stat2 record
     if (hos_func->fs2_info.fs2_handle)
     {
-        if (hos_func->fs2_info.reserved)
-        {
-            data_info = (data_info_t *)hos_func->fs2_info.reserved;
-            data_info->rx_pkts[thread_id]++;
-            data_info->rx_bytes[thread_id] += stream_len;
-        }
+        data_info = (data_info_t *)&hos_func->fs2_info.data_info;
+        atomic_add(&data_info->rx_pkts, 1);
+        atomic_add(&data_info->rx_bytes, stream_len);
     }
 
-    if (a_fd_context->cache == NULL)
+    if (handle->cache == NULL)
     {
-        //a_fd_context->cache = Aws::MakeShared<Aws::StringStream>("hos_write append mode");
-        a_fd_context->cache = std::make_shared<Aws::StringStream>();
+        handle->cache = std::make_shared<Aws::StringStream>();
     }
     Aws::String buffer(stream, stream_len);
-    *a_fd_context->cache << buffer;
-    a_fd_context->cache_rest -= stream_len;
-    if (data_info != NULL)
-        data_info->cache[thread_id] += stream_len;
-    if (a_fd_context->cache_count == 0 || --a_fd_context->cache_count)
+    *handle->cache << buffer;
+    handle->cache_rest -= stream_len;
+    atomic_add(&data_info->cache, stream_len);
+    if (handle->cache_count == 0 || --handle->cache_count)
     {
         //cache_count == 0,不设置cache_count的情况
         //cache_count > 0,设置cache_count的情况
-        if (a_fd_context->cache_rest > 0)
+        if (handle->cache_rest > 0)
         {
             return HOS_CLIENT_OK;
         }
     }
-    request.SetBody(a_fd_context->cache);
+    request.SetBody(handle->cache);
 
     // add headers
-    atomic_add(&(a_fd_context->position), 1);
-    snprintf(num, 128, "%lu", atomic_read(&(a_fd_context->position)));
+    atomic_add(&(handle->position), 1);
+    snprintf(num, 128, "%lu", atomic_read(&(handle->position)));
     Aws::Map<Aws::String, Aws::String> headers;
     headers["x-hos-upload-type"] = "append";
     headers["x-hos-position"] = num;
     request.SetMetadata(headers);
 
-    a_fd_context->cache->seekg(0, std::ios_base::end);
-    upload_len = a_fd_context->cache->tellg();
-    a_fd_context->cache->seekg(0, std::ios_base::beg);
+    handle->cache->seekg(0, std::ios_base::end);
+    upload_len = handle->cache->tellg();
+    handle->cache->seekg(0, std::ios_base::beg);
     MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__, "debug: x-hos-posotion:%s", num);
-    request.SetBucket(a_fd_context->bucket);
-    request.SetKey(a_fd_context->object);
+    request.SetBucket(handle->bucket);
+    request.SetKey(handle->object);
 
     if (hos_conf->pool_thread_size > 0)
     {
-        ret = hos_putobject_async(request, upload_len, thread_id, fd, a_fd_context->bucket, a_fd_context->object);
+        ret = hos_putobject_async(handle, request, upload_len);
     }
     else
     {
-        ret = hos_putobject_sync(request, upload_len, thread_id, fd, a_fd_context->bucket, a_fd_context->object);
+        ret = hos_putobject_sync(handle, request, upload_len);
     }
 
     //恢复fd 的cache设置
-    if (a_fd_context->mode & APPEND_MODE)
+    if (handle->mode & APPEND_MODE)
     {
-        if (data_info)
-            data_info->cache[thread_id] -= upload_len;
-        a_fd_context->cache.reset();
-        a_fd_context->cache = NULL;
-        a_fd_context->cache_rest = hos_conf->cache_size;
-        a_fd_context->cache_count = hos_conf->cache_count;
+        atomic_sub(&data_info->cache, upload_len);
+        handle->cache.reset();
+        handle->cache = NULL;
+        handle->cache_rest = hos_conf->cache_size;
+        handle->cache_count = hos_conf->cache_count;
     }
 
     return ret;
 }
 
-int hos_close_fd(size_t fd, size_t thread_id)
+int hos_close_handle(hos_handle handle)
 {
-    hos_fd_context_t *a_fd_context = NULL;
     char num[128];
     hos_config_t *hos_conf = &g_hos_handle.hos_config;
     size_t upload_len = 0;
 
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
 
-    if (thread_id > hos_conf->thread_num)
+    if (handle == NULL)
     {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, "hos_close_fd",
-            "error:fd:%lu, thread_id:%lu, thread_sum:%u.",
-            fd, thread_id, hos_conf->thread_num);
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_FATAL, __FUNCTION__,
+            "error: handle is null.");
         return HOS_PARAMETER_ERROR;
     }
-    a_fd_context = find_context_by_fd(g_fd_context[thread_id], fd);
-    if (a_fd_context == NULL)
-    {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG,
-            "hos_close_fd", "debug: not find the a_fd_context of [thread:%lu fd:%lu]",
-            thread_id, fd);
-        return HOS_CLIENT_OK; 
-    }
 
     //close fd 之前发送append的缓存中内容
-    if ((a_fd_context->mode & BUFF_MODE) && (a_fd_context->mode & APPEND_MODE))
+    if ((handle->mode & BUFF_MODE) && (handle->mode & APPEND_MODE))
     {
-        if (a_fd_context->cache_rest != (long)hos_conf->cache_size && a_fd_context->cache != NULL)
+        if (handle->cache_rest != (long)hos_conf->cache_size && handle->cache != NULL)
         {
             // Create and configure the asynchronous put object request.
             Aws::S3::Model::PutObjectRequest request;
-            request.SetBucket(a_fd_context->bucket);
-            request.SetKey(a_fd_context->object);
-            request.SetBody(a_fd_context->cache);
+            request.SetBucket(handle->bucket);
+            request.SetKey(handle->object);
+            request.SetBody(handle->cache);
 
             // add headers
-            atomic_add(&(a_fd_context->position), 1);
-            snprintf(num, 128, "%lu", atomic_read(&(a_fd_context->position)));
+            atomic_add(&(handle->position), 1);
+            snprintf(num, 128, "%lu", atomic_read(&(handle->position)));
             Aws::Map<Aws::String, Aws::String> headers;
             headers["x-hos-upload-type"] = "append";
             headers["x-hos-position"] = num;
             request.SetMetadata(headers);
-            a_fd_context->cache->seekg(0, std::ios_base::end);
-            upload_len = a_fd_context->cache->tellg();
-            a_fd_context->cache->seekg(0, std::ios_base::beg);
+            handle->cache->seekg(0, std::ios_base::end);
+            upload_len = handle->cache->tellg();
+            handle->cache->seekg(0, std::ios_base::beg);
 
             if (hos_conf->pool_thread_size > 0)
             {
-                hos_putobject_async(request, upload_len, thread_id, fd, a_fd_context->bucket, a_fd_context->object);
+                hos_putobject_async(handle, request, upload_len);
             }
             else
             {
-                hos_putobject_sync(request, upload_len, thread_id, fd, a_fd_context->bucket, a_fd_context->object);
+                hos_putobject_sync(handle, request, upload_len);
             }
-            data_info_t *data_info = (data_info_t *)(g_hos_handle.hos_func.fs2_info.reserved);
-            if (data_info)
-                data_info->cache[thread_id] = 0;
+            atomic_set(&g_hos_handle.hos_func.fs2_info.data_info.cache, 0);
         }
     }
-    a_fd_context->fd_status = HOS_FD_INJECT;
-    a_fd_context->cache.reset();
-    a_fd_context->cache = NULL;
-    a_fd_context->cache_rest = hos_conf->cache_size;
-    a_fd_context->cache_count = hos_conf->cache_count;
+    handle->handle_status = HOS_HANDLE_CANCEL;
+    handle->cache.reset();
+    handle->cache = NULL;
+    handle->cache_rest = hos_conf->cache_size;
+    handle->cache_count = hos_conf->cache_count;
 
     if (hos_conf->pool_thread_size == 0)
     {
         //同步模式，立即释放fd
-        hos_delete_fd(fd, thread_id);
+        hos_destroy_handle(handle);
     }
     else
     {
         //异步APPEND 模式,判断是否可以释放
         //异步其他模式，在PutObjectAsyncFinished出释放fd
-        if (a_fd_context->mode == (BUFF_MODE | APPEND_MODE) && a_fd_context->position == a_fd_context->recive_cnt)
+        if (handle->mode == (BUFF_MODE | APPEND_MODE) && handle->position == handle->recive_cnt)
         {
             MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__,
-                                    "debug: [%s:%s] upload completed. [thread:%lu fd:%lu] delete",
-                                    a_fd_context->bucket, a_fd_context->object, thread_id, a_fd_context->fd);
-            hos_delete_fd(fd, thread_id);
+                                    "debug: [%s:%s] upload completed. handle delete", handle->bucket, handle->object);
+            hos_destroy_handle(handle);
         }
     }
 
@@ -1057,30 +987,23 @@ int hos_shutdown_instance()
 {
     std::lock_guard<std::mutex> locker(m_client_lock);
     size_t i = 0;
-    hos_config_t *hos_conf = &g_hos_handle.hos_config;
     hos_func_thread_t *hos_func = &g_hos_handle.hos_func;
-    size_t task_num = 0;
 
-    if (g_hos_instance.result == false || g_hos_handle.S3Client == NULL)
+    if (g_hos_handle.S3Client == NULL)
     {
         return HOS_INSTANCE_NOT_INIT;
     }
 
     if (g_hos_handle.count > 0 && --g_hos_handle.count)
     {
-        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, "hos_shutdown_instance", "debug: hos client count:%lu.", g_hos_handle.count);
+        MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__, "debug: hos client count:%lu.", g_hos_handle.count);
         return HOS_CLIENT_OK;
     }
 
     //先等待所有的task完成
     while(1)
     {
-        task_num = 0;
-        for (uint32_t i = 0; i < g_hos_handle.hos_config.thread_num; i++)
-        {
-            task_num += atomic_read(&g_hos_handle.task_num[i]);
-        }
-        if (task_num == 0)
+        if (atomic_read(&g_hos_handle.task_num) == 0)
             break;
         usleep(500 * 1000);
     }
@@ -1104,27 +1027,6 @@ int hos_shutdown_instance()
                 FS_stop(fs2_handle);
                 *fs2_handle = NULL;
             }
-            if (hos_func->fs2_info.reserved)
-            {
-                data_info_t *data_info = (data_info_t *)hos_func->fs2_info.reserved;
-                if (data_info->rx_pkts)
-                    free(data_info->rx_pkts);
-                if (data_info->rx_bytes)
-                    free(data_info->rx_bytes);
-                if (data_info->tx_pkts)
-                    free(data_info->tx_pkts);
-                if (data_info->tx_bytes)
-                    free(data_info->tx_bytes);
-                if (data_info->tx_failed_bytes)
-                    free(data_info->tx_failed_bytes);
-                if (data_info->tx_failed_pkts)
-                    ;
-                free(data_info->tx_failed_pkts);
-                if (data_info->cache)
-                    free(data_info->cache);
-                free(hos_func->fs2_info.reserved);
-                hos_func->fs2_info.reserved = NULL;
-            }
             if (hos_func->fs2_info.line_ids)
             {
                 free(hos_func->fs2_info.line_ids);
@@ -1140,35 +1042,8 @@ int hos_shutdown_instance()
 
     delete g_hos_handle.S3Client;
     g_hos_handle.S3Client = NULL;
-    if (g_hos_handle.task_num != NULL)
-    {
-        free(g_hos_handle.task_num);
-        g_hos_handle.task_num = NULL;
-    }
-    if (g_hos_handle.task_context != NULL)
-    {
-        free(g_hos_handle.task_context);
-        g_hos_handle.task_context = NULL;
-    }
     MESA_HANDLE_RUNTIME_LOG(g_hos_handle.log, RLOG_LV_DEBUG, __FUNCTION__, "debug: delete s3client.");
 
-    if (g_fd_info)
-    {
-        free(g_fd_info);
-        g_fd_info = NULL;
-    }
-
-    for (i = 0; i < hos_conf->thread_num; i++)
-    {
-        delete_all(&g_fd_context[i]);
-    }
-
-    if (g_fd_context)
-    {
-        free(g_fd_context);
-        g_fd_context = NULL;
-    }
-
     Aws::ShutdownAPI(g_options);
     MESA_destroy_runtime_log_handle(g_hos_handle.log);
     g_hos_handle.log = NULL;
diff --git a/src/hos_client.h b/src/hos_client.h
index f1e5e51d..e31372f5 100644
--- a/src/hos_client.h
+++ b/src/hos_client.h
@@ -6,20 +6,9 @@
 #ifndef __HOS_CLIENT_INIT__
 #define __HOS_CLIENT_INIT__
 
-/*hos instance */
-typedef struct hos_instance_s{
-  bool result;
-  int  error_code;
-  char error_message[1024];
-  const char *hos_url_prefix;
-}* hos_instance;
-
 #define HOS_CLIENT_OK 0
 
-/* fd mode */
-#define FILE_MODE   0x00
-#define BUFF_MODE   0x01
-#define APPEND_MODE 0x02    /* 默认不追加 */
+typedef struct hos_handle_s* hos_handle;
 
 /* hos 错误码 */
 enum hoserrors
@@ -84,71 +73,70 @@ enum s3errors
 
 typedef void (*put_finished_callback)(bool result, const char *bucket, const char *object, const char *errmsg, void *userdata);
 
-
 /*************************************************************************************
  * 函数名：   hos_init_instance
  * 输入参数： conf_path 配置文件路径
- *           thread_num 线程数    
- * 返回值：   hos 实例创建结果
+ *           const char *bucket, 上传的bucket
+ * 返回值：   bool 初始化结果
 *************************************************************************************/
-hos_instance hos_init_instance(const char *conf_path, const char *module, size_t thread_num, const char *bucket);
+bool hos_init_instance(const char *conf_path, const char *module, const char *bucket);
 /*************************************************************************************
- * 函数名： hos_get_instance
- * 返回值： hos_instance 成功，result 为true
+ * 函数名： hos_verify_instance
+ * 返回值： bool 验证instance结果
 *************************************************************************************/
-hos_instance hos_get_instance();
+bool hos_verify_instance();
 /*************************************************************************************
  * 函数名： hos_upload_file
- * 参数：   hos_instance instance    非空句柄
- *          const char * bucket         桶名称
- *          const char * file_path         上传对象路径
- *          put_finished_callback callback upload操作结束时调用的回调函数
- *          void *userdata              用户自定义数据
- *          size_t thread_id            当前线程id
- * 返回值   int                         成功返回0，失败返回hoserros错误码
+ * 参数:    const char * bucket             桶名称
+ *          const char * file_path          上传对象路径
+ *          put_finished_callback callback  upload操作结束时调用的回调函数
+ *          void *userdata                  用户自定义数据
+ * 返回值   int                              成功返回0，失败返回hoserros错误码
 *************************************************************************************/
-int hos_upload_file(const char *bucket, const char *file_path, put_finished_callback callback, void* userdata, size_t thread_id);
+
+/* 只可以获取hos_init_instance */
+const char *hos_get_init_instance_errmsg();
+int hos_get_init_instance_errcode();
+const char *hos_get_url_prefix();
+
+int hos_upload_file(const char *bucket, const char *file_path, put_finished_callback callback, void* userdata);
 /*************************************************************************************
  * 函数名： hos_upload_buf
- * 参数：   hos_instance instance    非空句柄
- *          const char * bucket         桶名称
- *          const char * object         上传对象名称
- *          const char *buf             上传的buf
- *          size_t buf_len              上传的buf的长度
- *          put_finished_callback callback upload操作结束时调用的回调函数
- *          void *userdata              用户自定义数据
- *          size_t thread_id            当前线程id
- * 返回值   int                         成功返回0，失败返回hoserros错误码
+ * 参数：   hos_instance instance           非空句柄
+ *          const char * bucket             桶名称
+ *          const char * object             上传对象名称
+ *          const char *buf                 上传的buf
+ *          size_t buf_len                  上传的buf的长度
+ *          put_finished_callback callback  upload操作结束时调用的回调函数
+ *          void *userdata                  用户自定义数据
+ *          size_t thread_id                当前线程id
+ * 返回值   int                              成功返回0，失败返回hoserros错误码
 *************************************************************************************/
-int hos_upload_buf(const char *bucket, const char *object, const char *buf, size_t buf_len, put_finished_callback callback, void *userdata, size_t thread_id);
+int hos_upload_buf(const char *bucket, const char *object, const char *buf, size_t buf_len, put_finished_callback callback, void *userdata);
 /*************************************************************************************
  * 函数名： hos_open_fd
- * 参数：   const char * bucket         桶名称
- *          const char * object         上传对象名称
- *          put_finished_callback callback upload操作结束时调用的回调函数
- *          void *data                  用户回调函数自定义数据
- *          size_t thread_id            线程ID
- *          int mode                    模式 (FILE OR BUFFER, APPEND OR NOT)
- * 返回值   int                         成功返回fd(fd >=3)，失败返回hoserros错误码
+ * 参数：   const char * bucket               桶名称
+ *          const char * object               上传对象名称
+ *          put_finished_callback callback    upload操作结束时调用的回调函数
+ *          void *data                        用户回调函数自定义数据
+ * 返回值   hos_handle                         失败返回NULL
 *************************************************************************************/
-int hos_open_fd(const char *bucket, const char *object, put_finished_callback callback, void *userdata, size_t thread_id);
+int hos_open_handle(const char *bucket, const char *object, put_finished_callback callback, void *userdata, hos_handle *handle);
 /*************************************************************************************
  * 函数名： hos_write
- * 参数：   size_t fd                     hos_open_fd返回的fd
+ * 参数：    hos_handle handle           hos_open_handle 返回的handle
  *          const char * stream         待上传的数据
  *          size_t stream               待上传的数据长度
- *          size_t thread_id            线程ID
  *          size_t position             append模式下的每段内容编号
  * 返回值   int                         成功返回0，失败返回hoserror
 *************************************************************************************/
-int hos_write(size_t fd, const char *stream, size_t stream_len, size_t thread_id);
+int hos_write(hos_handle handle, const char *stream, size_t stream_len);
 /*************************************************************************************
- * 函数名： hos_close_fd
- * 参数：   size_t fd                   fd
- *          size_t thread_id            线程ID
+ * 函数名： hos_close_handle
+ * 参数：   hos_handle handle            hos_open_handle 返回的handle
  * 返回值   int                         成功返回0，失败返回hoserros错误码
 *************************************************************************************/
-int hos_close_fd(size_t fd, size_t thread_id);
+int hos_close_handle(hos_handle handle);
 /*************************************************************************************
  * 函数名： hos_shutdown_instance
  * 返回值   int                         成功返回0，失败返回hoserros错误码
diff --git a/src/hos_common.h b/src/hos_common.h
index 8d4425f7..5e29d0d5 100644
--- a/src/hos_common.h
+++ b/src/hos_common.h
@@ -4,7 +4,6 @@
 #include <netinet/in.h>
 #include <mutex>
 #include "field_stat2.h"
-#include "hos_hash.h"
 #include <aws/core/Aws.h>
 #include <aws/s3/S3Client.h>
 #include <aws/core/auth/AWSCredentials.h>
@@ -14,10 +13,12 @@
 #define atomic_add(x,y) __sync_add_and_fetch((x),(y))
 #define atomic_read(x) __sync_add_and_fetch((x),0)
 #define atomic_sub(x,y) __sync_sub_and_fetch((x),(y))
+#define atomic_set(x,y) __sync_lock_test_and_set((x),y)
 #else 
 #define atomic_add(x,y) ((*(x))+=(y))
 #define atomic_read(x) 	(*(x))
 #define atomic_sub(x,y) ((*(x))-=(y))
+#define atomic_set(x,y)   ((*(x))=(y))
 #endif 
 
 #define MAX_HOS_STRING_LEN 1024
@@ -25,15 +26,22 @@
 #define MAX_HOS_CLIENT_FD_NUM 65535
 #define HOS_LOG_PATH "./tsglog/hoslog"
 
+/*hos instance */
+typedef struct hos_info_s{
+  int  error_code;
+  char error_message[1024];
+  const char *hos_url_prefix;
+}* hos_infot_t;
+
 typedef struct data_info_s
 {
-    size_t *tx_pkts;
-    size_t *tx_bytes;
-    size_t *rx_pkts;
-    size_t *rx_bytes;
-    size_t *tx_failed_pkts;
-    size_t *tx_failed_bytes;
-    size_t *cache;
+    size_t tx_pkts;
+    size_t tx_bytes;
+    size_t rx_pkts;
+    size_t rx_bytes;
+    size_t tx_failed_pkts;
+    size_t tx_failed_bytes;
+    size_t cache;
     size_t tx_req_num_overflow;
 }data_info_t;
 
@@ -42,7 +50,7 @@ typedef struct fs2_info_s
     screen_stat_handle_t fs2_handle;
     int *line_ids;
     int *column_ids;
-    void *reserved; //预留给每个fs2 handle用来存储自定义的数据
+    data_info_t data_info;
 }fs2_info_t;
 
 enum
@@ -66,7 +74,7 @@ typedef struct hos_config_s
     uint32_t fs2_fmt;
     uint32_t log_level;
     uint32_t pool_thread_size;
-    uint32_t thread_num;
+    //uint32_t thread_num;
     uint32_t cache_size;
     uint32_t cache_count;
     uint32_t max_request_num;
@@ -94,18 +102,35 @@ typedef struct hos_client_handle_s
     Aws::S3::S3ClientMock *S3Client;
     #endif
     Aws::Vector<Aws::S3::Model::Bucket> buckets;
-    std::shared_ptr<Aws::Utils::Threading::PooledThreadExecutor> executor;
+    //std::shared_ptr<Aws::Utils::Threading::PooledThreadExecutor> executor;
     size_t count;  /* 记录了有多少个对象在使用hos */
     hos_config_t hos_config;
     hos_func_thread_t hos_func;
     void *log;
-    size_t *task_num;
-    size_t *task_context;
+    size_t task_num;
+    size_t task_context;
 }hos_client_handle_t;
 
-extern struct hos_instance_s g_hos_instance;
+typedef struct hos_handle_s
+{
+    int  mode;
+    //hos_client_handle handle; 
+    char *bucket;
+    char *object;
+    put_finished_callback callback;
+    void *userdata;
+    std::shared_ptr<Aws::IOStream> cache;
+    size_t cache_count;
+    size_t position;
+    size_t recive_cnt;
+    long cache_rest;
+    int handle_status;
+#define HOS_HANDLE_REGISTER 0
+#define HOS_HANDLE_CANCEL 1
+    bool reslut; /*PutObjectAsync result*/
+    const char *error; /*PutObjectAsync error message*/
+}hos_handle_t;
+
 extern hos_client_handle_t g_hos_handle;//一个进程只允许有一个g_hos_handle
-extern hos_fd_context_t **g_fd_context;
-extern size_t *g_fd_info; //fd 实际从1开始,每个线程有独立的fd
 
 #endif
\ No newline at end of file
diff --git a/src/hos_hash.cpp b/src/hos_hash.cpp
deleted file mode 100644
index bb7e2538..00000000
--- a/src/hos_hash.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*************************************************************************
-    > File Name: uthash.cpp
-    > Author: pxz
-    > Created Time: Fri 18 Sep 2020 04:26:09 PM CST
- ************************************************************************/
-#include "hos_hash.h"
-
-void add_fd_context(hos_fd_context_t **handle, hos_fd_context_t *input)
-{
-    hos_fd_context_t *value = NULL;
-    HASH_FIND_INT(*handle, (int *)&input->fd, value);
-    if (value == NULL)
-    {
-        value = (hos_fd_context_t *)malloc(sizeof(hos_fd_context_t));
-        memcpy(value, input, sizeof(hos_fd_context_t));
-        value->object = (char *)calloc(1, strlen(input->object) + 1);
-        value->bucket = (char *)calloc(1, strlen(input->bucket) + 1);
-        memcpy(value->bucket, input->bucket, strlen(input->bucket));
-        memcpy(value->object, input->object, strlen(input->object));
-        HASH_ADD_INT(*handle, fd, value);
-    }
-    else
-    {
-        value->mode = input->mode;
-        if (value->object != NULL)
-        {
-            free(value->object);
-            value->object = NULL;
-        }
-        if (value->bucket != NULL)
-        {
-            free(value->bucket);
-            value->bucket = NULL;
-        }
-        value->object = (char *)calloc(1, strlen(input->object) + 1);
-        value->bucket = (char *)calloc(1, strlen(input->bucket) + 1);
-        memcpy(value->bucket, input->bucket, strlen(input->bucket));
-        memcpy(value->object, input->object, strlen(input->object));
-        value->callback = input->callback;
-        value->userdata = input->userdata;
-        value->cache = input->cache;
-        value->cache_count = input->cache_count;
-        value->cache_rest = input->cache_rest;
-        value->position = input->position;
-        value->recive_cnt = input->recive_cnt;
-        value->fd_status = value->fd_status;
-    }
-}
-
-hos_fd_context_t *find_context_by_fd(hos_fd_context_t *handle, size_t fd)
-{
-    hos_fd_context_t *value = NULL;
-    HASH_FIND_INT(handle, &fd, value);
-    return value;
-}
-
-void delete_context_by_fd(hos_fd_context_t **handle, size_t fd)
-{
-    hos_fd_context_t *value = NULL;
-
-    HASH_FIND_INT(*handle, &fd, value);
-    if (value)
-    {
-        if (value->bucket)
-        {
-            free(value->bucket);
-            value->bucket = NULL;
-        }
-        if (value->object)
-        {
-            free(value->object);
-            value->object = NULL;
-        }
-        HASH_DEL(*handle, value);
-        free(value);
-    }
-}
-
-void delete_all(hos_fd_context_t **handle)
-{
-    hos_fd_context_t *current, *tmp;
-    HASH_ITER(hh, *handle, current, tmp)
-    {
-        if (current->bucket)
-        {
-            free(current->bucket);
-            current->bucket = NULL;
-        }
-        if (current->object)
-        {
-            free(current->object);
-            current->object = NULL;
-        }
-        HASH_DEL(*handle, current);
-        free(current);
-    }
-}
diff --git a/src/hos_hash.h b/src/hos_hash.h
deleted file mode 100644
index 81208f3f..00000000
--- a/src/hos_hash.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*************************************************************************
-    > File Name: hos_hash.h
-    > Author: pxz
-    > Created Time: Fri 18 Sep 2020 05:00:04 PM CST
- ************************************************************************/
-#ifndef __HOS_HASH_H__
-#define __HOS_HASH_H__
-
-#include <aws/core/Aws.h>
-//#include "hos_client.h"
-#include "uthash.h"
-
-typedef struct hos_fd_context_s
-{
-    size_t fd;
-    int  mode;
-    //hos_client_handle handle; 
-    char *bucket;
-    char *object;
-    void *callback;
-    void *userdata;
-    std::shared_ptr<Aws::IOStream> cache;
-    size_t cache_count;
-    size_t position;
-    size_t recive_cnt;
-    long cache_rest;
-    int fd_status;
-#define HOS_FD_REGISTER 0
-#define HOS_FD_INJECT 1
-    bool reslut; /*PutObjectAsync result*/
-    const char *error; /*PutObjectAsync error message*/
-
-    UT_hash_handle hh;
-}hos_fd_context_t;
-
-void add_fd_context(hos_fd_context_t **handle, hos_fd_context_t *input);
-hos_fd_context_t *find_context_by_fd(hos_fd_context_t *handle, size_t fd);
-void delete_context_by_fd(hos_fd_context_t **handle, size_t fd);
-void delete_all(hos_fd_context_t **handle);
-#endif
diff --git a/src/uthash.h b/src/uthash.h
deleted file mode 100644
index 5e5866a3..00000000
--- a/src/uthash.h
+++ /dev/null
@@ -1,1150 +0,0 @@
-/*
-Copyright (c) 2003-2018, Troy D. Hanson     http://troydhanson.github.com/uthash/
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef UTHASH_H
-#define UTHASH_H
-
-#define UTHASH_VERSION 2.1.0
-
-#include <string.h>   /* memcmp, memset, strlen */
-#include <stddef.h>   /* ptrdiff_t */
-#include <stdlib.h>   /* exit */
-
-/* These macros use decltype or the earlier __typeof GNU extension.
-   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
-   when compiling c++ source) this code uses whatever method is needed
-   or, for VS2008 where neither is available, uses casting workarounds. */
-#if !defined(DECLTYPE) && !defined(NO_DECLTYPE)
-#if defined(_MSC_VER)   /* MS compiler */
-#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
-#define DECLTYPE(x) (decltype(x))
-#else                   /* VS2008 or older (or VS2010 in C mode) */
-#define NO_DECLTYPE
-#endif
-#elif defined(__BORLANDC__) || defined(__ICCARM__) || defined(__LCC__) || defined(__WATCOMC__)
-#define NO_DECLTYPE
-#else                   /* GNU, Sun and other compilers */
-#define DECLTYPE(x) (__typeof(x))
-#endif
-#endif
-
-#ifdef NO_DECLTYPE
-#define DECLTYPE(x)
-#define DECLTYPE_ASSIGN(dst,src)                                                 \
-do {                                                                             \
-  char **_da_dst = (char**)(&(dst));                                             \
-  *_da_dst = (char*)(src);                                                       \
-} while (0)
-#else
-#define DECLTYPE_ASSIGN(dst,src)                                                 \
-do {                                                                             \
-  (dst) = DECLTYPE(dst)(src);                                                    \
-} while (0)
-#endif
-
-/* a number of the hash function use uint32_t which isn't defined on Pre VS2010 */
-#if defined(_WIN32)
-#if defined(_MSC_VER) && _MSC_VER >= 1600
-#include <stdint.h>
-#elif defined(__WATCOMC__) || defined(__MINGW32__) || defined(__CYGWIN__)
-#include <stdint.h>
-#else
-typedef unsigned int uint32_t;
-typedef unsigned char uint8_t;
-#endif
-#elif defined(__GNUC__) && !defined(__VXWORKS__)
-#include <stdint.h>
-#else
-typedef unsigned int uint32_t;
-typedef unsigned char uint8_t;
-#endif
-
-#ifndef uthash_malloc
-#define uthash_malloc(sz) malloc(sz)      /* malloc fcn                      */
-#endif
-#ifndef uthash_free
-#define uthash_free(ptr,sz) free(ptr)     /* free fcn                        */
-#endif
-#ifndef uthash_bzero
-#define uthash_bzero(a,n) memset(a,'\0',n)
-#endif
-#ifndef uthash_strlen
-#define uthash_strlen(s) strlen(s)
-#endif
-
-#ifdef uthash_memcmp
-/* This warning will not catch programs that define uthash_memcmp AFTER including uthash.h. */
-#warning "uthash_memcmp is deprecated; please use HASH_KEYCMP instead"
-#else
-#define uthash_memcmp(a,b,n) memcmp(a,b,n)
-#endif
-
-#ifndef HASH_KEYCMP
-#define HASH_KEYCMP(a,b,n) uthash_memcmp(a,b,n)
-#endif
-
-#ifndef uthash_noexpand_fyi
-#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
-#endif
-#ifndef uthash_expand_fyi
-#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
-#endif
-
-#ifndef HASH_NONFATAL_OOM
-#define HASH_NONFATAL_OOM 0
-#endif
-
-#if HASH_NONFATAL_OOM
-/* malloc failures can be recovered from */
-
-#ifndef uthash_nonfatal_oom
-#define uthash_nonfatal_oom(obj) do {} while (0)    /* non-fatal OOM error */
-#endif
-
-#define HASH_RECORD_OOM(oomed) do { (oomed) = 1; } while (0)
-#define IF_HASH_NONFATAL_OOM(x) x
-
-#else
-/* malloc failures result in lost memory, hash tables are unusable */
-
-#ifndef uthash_fatal
-#define uthash_fatal(msg) exit(-1)        /* fatal OOM error */
-#endif
-
-#define HASH_RECORD_OOM(oomed) uthash_fatal("out of memory")
-#define IF_HASH_NONFATAL_OOM(x)
-
-#endif
-
-/* initial number of buckets */
-#define HASH_INITIAL_NUM_BUCKETS 32U     /* initial number of buckets        */
-#define HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */
-#define HASH_BKT_CAPACITY_THRESH 10U     /* expand when bucket count reaches */
-
-/* calculate the element whose hash handle address is hhp */
-#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
-/* calculate the hash handle from element address elp */
-#define HH_FROM_ELMT(tbl,elp) ((UT_hash_handle*)(void*)(((char*)(elp)) + ((tbl)->hho)))
-
-#define HASH_ROLLBACK_BKT(hh, head, itemptrhh)                                   \
-do {                                                                             \
-  struct UT_hash_handle *_hd_hh_item = (itemptrhh);                              \
-  unsigned _hd_bkt;                                                              \
-  HASH_TO_BKT(_hd_hh_item->hashv, (head)->hh.tbl->num_buckets, _hd_bkt);         \
-  (head)->hh.tbl->buckets[_hd_bkt].count++;                                      \
-  _hd_hh_item->hh_next = NULL;                                                   \
-  _hd_hh_item->hh_prev = NULL;                                                   \
-} while (0)
-
-#define HASH_VALUE(keyptr,keylen,hashv)                                          \
-do {                                                                             \
-  HASH_FCN(keyptr, keylen, hashv);                                               \
-} while (0)
-
-#define HASH_FIND_BYHASHVALUE(hh,head,keyptr,keylen,hashval,out)                 \
-do {                                                                             \
-  (out) = NULL;                                                                  \
-  if (head) {                                                                    \
-    unsigned _hf_bkt;                                                            \
-    HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _hf_bkt);                  \
-    if (HASH_BLOOM_TEST((head)->hh.tbl, hashval) != 0) {                         \
-      HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], keyptr, keylen, hashval, out); \
-    }                                                                            \
-  }                                                                              \
-} while (0)
-
-#define HASH_FIND(hh,head,keyptr,keylen,out)                                     \
-do {                                                                             \
-  (out) = NULL;                                                                  \
-  if (head) {                                                                    \
-    unsigned _hf_hashv;                                                          \
-    HASH_VALUE(keyptr, keylen, _hf_hashv);                                       \
-    HASH_FIND_BYHASHVALUE(hh, head, keyptr, keylen, _hf_hashv, out);             \
-  }                                                                              \
-} while (0)
-
-#ifdef HASH_BLOOM
-#define HASH_BLOOM_BITLEN (1UL << HASH_BLOOM)
-#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8UL) + (((HASH_BLOOM_BITLEN%8UL)!=0UL) ? 1UL : 0UL)
-#define HASH_BLOOM_MAKE(tbl,oomed)                                               \
-do {                                                                             \
-  (tbl)->bloom_nbits = HASH_BLOOM;                                               \
-  (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN);                 \
-  if (!(tbl)->bloom_bv) {                                                        \
-    HASH_RECORD_OOM(oomed);                                                      \
-  } else {                                                                       \
-    uthash_bzero((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                           \
-    (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE;                                     \
-  }                                                                              \
-} while (0)
-
-#define HASH_BLOOM_FREE(tbl)                                                     \
-do {                                                                             \
-  uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                              \
-} while (0)
-
-#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8U] |= (1U << ((idx)%8U)))
-#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8U] & (1U << ((idx)%8U)))
-
-#define HASH_BLOOM_ADD(tbl,hashv)                                                \
-  HASH_BLOOM_BITSET((tbl)->bloom_bv, ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U)))
-
-#define HASH_BLOOM_TEST(tbl,hashv)                                               \
-  HASH_BLOOM_BITTEST((tbl)->bloom_bv, ((hashv) & (uint32_t)((1UL << (tbl)->bloom_nbits) - 1U)))
-
-#else
-#define HASH_BLOOM_MAKE(tbl,oomed)
-#define HASH_BLOOM_FREE(tbl)
-#define HASH_BLOOM_ADD(tbl,hashv)
-#define HASH_BLOOM_TEST(tbl,hashv) (1)
-#define HASH_BLOOM_BYTELEN 0U
-#endif
-
-#define HASH_MAKE_TABLE(hh,head,oomed)                                           \
-do {                                                                             \
-  (head)->hh.tbl = (UT_hash_table*)uthash_malloc(sizeof(UT_hash_table));         \
-  if (!(head)->hh.tbl) {                                                         \
-    HASH_RECORD_OOM(oomed);                                                      \
-  } else {                                                                       \
-    uthash_bzero((head)->hh.tbl, sizeof(UT_hash_table));                         \
-    (head)->hh.tbl->tail = &((head)->hh);                                        \
-    (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;                      \
-    (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;            \
-    (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head);                  \
-    (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc(                    \
-        HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket));               \
-    (head)->hh.tbl->signature = HASH_SIGNATURE;                                  \
-    if (!(head)->hh.tbl->buckets) {                                              \
-      HASH_RECORD_OOM(oomed);                                                    \
-      uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                        \
-    } else {                                                                     \
-      uthash_bzero((head)->hh.tbl->buckets,                                      \
-          HASH_INITIAL_NUM_BUCKETS * sizeof(struct UT_hash_bucket));             \
-      HASH_BLOOM_MAKE((head)->hh.tbl, oomed);                                    \
-      IF_HASH_NONFATAL_OOM(                                                      \
-        if (oomed) {                                                             \
-          uthash_free((head)->hh.tbl->buckets,                                   \
-              HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));           \
-          uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                    \
-        }                                                                        \
-      )                                                                          \
-    }                                                                            \
-  }                                                                              \
-} while (0)
-
-#define HASH_REPLACE_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,replaced,cmpfcn) \
-do {                                                                             \
-  (replaced) = NULL;                                                             \
-  HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \
-  if (replaced) {                                                                \
-    HASH_DELETE(hh, head, replaced);                                             \
-  }                                                                              \
-  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn); \
-} while (0)
-
-#define HASH_REPLACE_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add,replaced) \
-do {                                                                             \
-  (replaced) = NULL;                                                             \
-  HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \
-  if (replaced) {                                                                \
-    HASH_DELETE(hh, head, replaced);                                             \
-  }                                                                              \
-  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add); \
-} while (0)
-
-#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced)                   \
-do {                                                                             \
-  unsigned _hr_hashv;                                                            \
-  HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv);                         \
-  HASH_REPLACE_BYHASHVALUE(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced); \
-} while (0)
-
-#define HASH_REPLACE_INORDER(hh,head,fieldname,keylen_in,add,replaced,cmpfcn)    \
-do {                                                                             \
-  unsigned _hr_hashv;                                                            \
-  HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv);                         \
-  HASH_REPLACE_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced, cmpfcn); \
-} while (0)
-
-#define HASH_APPEND_LIST(hh, head, add)                                          \
-do {                                                                             \
-  (add)->hh.next = NULL;                                                         \
-  (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);           \
-  (head)->hh.tbl->tail->next = (add);                                            \
-  (head)->hh.tbl->tail = &((add)->hh);                                           \
-} while (0)
-
-#define HASH_AKBI_INNER_LOOP(hh,head,add,cmpfcn)                                 \
-do {                                                                             \
-  do {                                                                           \
-    if (cmpfcn(DECLTYPE(head)(_hs_iter), add) > 0) {                             \
-      break;                                                                     \
-    }                                                                            \
-  } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next));           \
-} while (0)
-
-#ifdef NO_DECLTYPE
-#undef HASH_AKBI_INNER_LOOP
-#define HASH_AKBI_INNER_LOOP(hh,head,add,cmpfcn)                                 \
-do {                                                                             \
-  char *_hs_saved_head = (char*)(head);                                          \
-  do {                                                                           \
-    DECLTYPE_ASSIGN(head, _hs_iter);                                             \
-    if (cmpfcn(head, add) > 0) {                                                 \
-      DECLTYPE_ASSIGN(head, _hs_saved_head);                                     \
-      break;                                                                     \
-    }                                                                            \
-    DECLTYPE_ASSIGN(head, _hs_saved_head);                                       \
-  } while ((_hs_iter = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->next));           \
-} while (0)
-#endif
-
-#if HASH_NONFATAL_OOM
-
-#define HASH_ADD_TO_TABLE(hh,head,keyptr,keylen_in,hashval,add,oomed)            \
-do {                                                                             \
-  if (!(oomed)) {                                                                \
-    unsigned _ha_bkt;                                                            \
-    (head)->hh.tbl->num_items++;                                                 \
-    HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt);                  \
-    HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh, oomed);    \
-    if (oomed) {                                                                 \
-      HASH_ROLLBACK_BKT(hh, head, &(add)->hh);                                   \
-      HASH_DELETE_HH(hh, head, &(add)->hh);                                      \
-      (add)->hh.tbl = NULL;                                                      \
-      uthash_nonfatal_oom(add);                                                  \
-    } else {                                                                     \
-      HASH_BLOOM_ADD((head)->hh.tbl, hashval);                                   \
-      HASH_EMIT_KEY(hh, head, keyptr, keylen_in);                                \
-    }                                                                            \
-  } else {                                                                       \
-    (add)->hh.tbl = NULL;                                                        \
-    uthash_nonfatal_oom(add);                                                    \
-  }                                                                              \
-} while (0)
-
-#else
-
-#define HASH_ADD_TO_TABLE(hh,head,keyptr,keylen_in,hashval,add,oomed)            \
-do {                                                                             \
-  unsigned _ha_bkt;                                                              \
-  (head)->hh.tbl->num_items++;                                                   \
-  HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt);                    \
-  HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], hh, &(add)->hh, oomed);      \
-  HASH_BLOOM_ADD((head)->hh.tbl, hashval);                                       \
-  HASH_EMIT_KEY(hh, head, keyptr, keylen_in);                                    \
-} while (0)
-
-#endif
-
-
-#define HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh,head,keyptr,keylen_in,hashval,add,cmpfcn) \
-do {                                                                             \
-  IF_HASH_NONFATAL_OOM( int _ha_oomed = 0; )                                     \
-  (add)->hh.hashv = (hashval);                                                   \
-  (add)->hh.key = (char*) (keyptr);                                              \
-  (add)->hh.keylen = (unsigned) (keylen_in);                                     \
-  if (!(head)) {                                                                 \
-    (add)->hh.next = NULL;                                                       \
-    (add)->hh.prev = NULL;                                                       \
-    HASH_MAKE_TABLE(hh, add, _ha_oomed);                                         \
-    IF_HASH_NONFATAL_OOM( if (!_ha_oomed) { )                                    \
-      (head) = (add);                                                            \
-    IF_HASH_NONFATAL_OOM( } )                                                    \
-  } else {                                                                       \
-    void *_hs_iter = (head);                                                     \
-    (add)->hh.tbl = (head)->hh.tbl;                                              \
-    HASH_AKBI_INNER_LOOP(hh, head, add, cmpfcn);                                 \
-    if (_hs_iter) {                                                              \
-      (add)->hh.next = _hs_iter;                                                 \
-      if (((add)->hh.prev = HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev)) {     \
-        HH_FROM_ELMT((head)->hh.tbl, (add)->hh.prev)->next = (add);              \
-      } else {                                                                   \
-        (head) = (add);                                                          \
-      }                                                                          \
-      HH_FROM_ELMT((head)->hh.tbl, _hs_iter)->prev = (add);                      \
-    } else {                                                                     \
-      HASH_APPEND_LIST(hh, head, add);                                           \
-    }                                                                            \
-  }                                                                              \
-  HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, _ha_oomed);       \
-  HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE_INORDER");                    \
-} while (0)
-
-#define HASH_ADD_KEYPTR_INORDER(hh,head,keyptr,keylen_in,add,cmpfcn)             \
-do {                                                                             \
-  unsigned _hs_hashv;                                                            \
-  HASH_VALUE(keyptr, keylen_in, _hs_hashv);                                      \
-  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, keyptr, keylen_in, _hs_hashv, add, cmpfcn); \
-} while (0)
-
-#define HASH_ADD_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,cmpfcn) \
-  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn)
-
-#define HASH_ADD_INORDER(hh,head,fieldname,keylen_in,add,cmpfcn)                 \
-  HASH_ADD_KEYPTR_INORDER(hh, head, &((add)->fieldname), keylen_in, add, cmpfcn)
-
-#define HASH_ADD_KEYPTR_BYHASHVALUE(hh,head,keyptr,keylen_in,hashval,add)        \
-do {                                                                             \
-  IF_HASH_NONFATAL_OOM( int _ha_oomed = 0; )                                     \
-  (add)->hh.hashv = (hashval);                                                   \
-  (add)->hh.key = (char*) (keyptr);                                              \
-  (add)->hh.keylen = (unsigned) (keylen_in);                                     \
-  if (!(head)) {                                                                 \
-    (add)->hh.next = NULL;                                                       \
-    (add)->hh.prev = NULL;                                                       \
-    HASH_MAKE_TABLE(hh, add, _ha_oomed);                                         \
-    IF_HASH_NONFATAL_OOM( if (!_ha_oomed) { )                                    \
-      (head) = (add);                                                            \
-    IF_HASH_NONFATAL_OOM( } )                                                    \
-  } else {                                                                       \
-    (add)->hh.tbl = (head)->hh.tbl;                                              \
-    HASH_APPEND_LIST(hh, head, add);                                             \
-  }                                                                              \
-  HASH_ADD_TO_TABLE(hh, head, keyptr, keylen_in, hashval, add, _ha_oomed);       \
-  HASH_FSCK(hh, head, "HASH_ADD_KEYPTR_BYHASHVALUE");                            \
-} while (0)
-
-#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                            \
-do {                                                                             \
-  unsigned _ha_hashv;                                                            \
-  HASH_VALUE(keyptr, keylen_in, _ha_hashv);                                      \
-  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, keyptr, keylen_in, _ha_hashv, add);      \
-} while (0)
-
-#define HASH_ADD_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add)            \
-  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add)
-
-#define HASH_ADD(hh,head,fieldname,keylen_in,add)                                \
-  HASH_ADD_KEYPTR(hh, head, &((add)->fieldname), keylen_in, add)
-
-#define HASH_TO_BKT(hashv,num_bkts,bkt)                                          \
-do {                                                                             \
-  bkt = ((hashv) & ((num_bkts) - 1U));                                           \
-} while (0)
-
-/* delete "delptr" from the hash table.
- * "the usual" patch-up process for the app-order doubly-linked-list.
- * The use of _hd_hh_del below deserves special explanation.
- * These used to be expressed using (delptr) but that led to a bug
- * if someone used the same symbol for the head and deletee, like
- *  HASH_DELETE(hh,users,users);
- * We want that to work, but by changing the head (users) below
- * we were forfeiting our ability to further refer to the deletee (users)
- * in the patch-up process. Solution: use scratch space to
- * copy the deletee pointer, then the latter references are via that
- * scratch pointer rather than through the repointed (users) symbol.
- */
-#define HASH_DELETE(hh,head,delptr)                                              \
-    HASH_DELETE_HH(hh, head, &(delptr)->hh)
-
-#define HASH_DELETE_HH(hh,head,delptrhh)                                         \
-do {                                                                             \
-  struct UT_hash_handle *_hd_hh_del = (delptrhh);                                \
-  if ((_hd_hh_del->prev == NULL) && (_hd_hh_del->next == NULL)) {                \
-    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
-    uthash_free((head)->hh.tbl->buckets,                                         \
-                (head)->hh.tbl->num_buckets * sizeof(struct UT_hash_bucket));    \
-    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
-    (head) = NULL;                                                               \
-  } else {                                                                       \
-    unsigned _hd_bkt;                                                            \
-    if (_hd_hh_del == (head)->hh.tbl->tail) {                                    \
-      (head)->hh.tbl->tail = HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev);     \
-    }                                                                            \
-    if (_hd_hh_del->prev != NULL) {                                              \
-      HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev)->next = _hd_hh_del->next;   \
-    } else {                                                                     \
-      DECLTYPE_ASSIGN(head, _hd_hh_del->next);                                   \
-    }                                                                            \
-    if (_hd_hh_del->next != NULL) {                                              \
-      HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->next)->prev = _hd_hh_del->prev;   \
-    }                                                                            \
-    HASH_TO_BKT(_hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt);        \
-    HASH_DEL_IN_BKT((head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del);               \
-    (head)->hh.tbl->num_items--;                                                 \
-  }                                                                              \
-  HASH_FSCK(hh, head, "HASH_DELETE_HH");                                         \
-} while (0)
-
-/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
-#define HASH_FIND_STR(head,findstr,out)                                          \
-do {                                                                             \
-    unsigned _uthash_hfstr_keylen = (unsigned)uthash_strlen(findstr);            \
-    HASH_FIND(hh, head, findstr, _uthash_hfstr_keylen, out);                     \
-} while (0)
-#define HASH_ADD_STR(head,strfield,add)                                          \
-do {                                                                             \
-    unsigned _uthash_hastr_keylen = (unsigned)uthash_strlen((add)->strfield);    \
-    HASH_ADD(hh, head, strfield[0], _uthash_hastr_keylen, add);                  \
-} while (0)
-#define HASH_REPLACE_STR(head,strfield,add,replaced)                             \
-do {                                                                             \
-    unsigned _uthash_hrstr_keylen = (unsigned)uthash_strlen((add)->strfield);    \
-    HASH_REPLACE(hh, head, strfield[0], _uthash_hrstr_keylen, add, replaced);    \
-} while (0)
-#define HASH_FIND_INT(head,findint,out)                                          \
-    HASH_FIND(hh,head,findint,sizeof(int),out)
-#define HASH_ADD_INT(head,intfield,add)                                          \
-    HASH_ADD(hh,head,intfield,sizeof(int),add)
-#define HASH_REPLACE_INT(head,intfield,add,replaced)                             \
-    HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
-#define HASH_FIND_PTR(head,findptr,out)                                          \
-    HASH_FIND(hh,head,findptr,sizeof(void *),out)
-#define HASH_ADD_PTR(head,ptrfield,add)                                          \
-    HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
-#define HASH_REPLACE_PTR(head,ptrfield,add,replaced)                             \
-    HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
-#define HASH_DEL(head,delptr)                                                    \
-    HASH_DELETE(hh,head,delptr)
-
-/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
- * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
- */
-#ifdef HASH_DEBUG
-#include <stdio.h>   /* fprintf, stderr */
-#define HASH_OOPS(...) do { fprintf(stderr, __VA_ARGS__); exit(-1); } while (0)
-#define HASH_FSCK(hh,head,where)                                                 \
-do {                                                                             \
-  struct UT_hash_handle *_thh;                                                   \
-  if (head) {                                                                    \
-    unsigned _bkt_i;                                                             \
-    unsigned _count = 0;                                                         \
-    char *_prev;                                                                 \
-    for (_bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; ++_bkt_i) {           \
-      unsigned _bkt_count = 0;                                                   \
-      _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                            \
-      _prev = NULL;                                                              \
-      while (_thh) {                                                             \
-        if (_prev != (char*)(_thh->hh_prev)) {                                   \
-          HASH_OOPS("%s: invalid hh_prev %p, actual %p\n",                       \
-              (where), (void*)_thh->hh_prev, (void*)_prev);                      \
-        }                                                                        \
-        _bkt_count++;                                                            \
-        _prev = (char*)(_thh);                                                   \
-        _thh = _thh->hh_next;                                                    \
-      }                                                                          \
-      _count += _bkt_count;                                                      \
-      if ((head)->hh.tbl->buckets[_bkt_i].count !=  _bkt_count) {                \
-        HASH_OOPS("%s: invalid bucket count %u, actual %u\n",                    \
-            (where), (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count);         \
-      }                                                                          \
-    }                                                                            \
-    if (_count != (head)->hh.tbl->num_items) {                                   \
-      HASH_OOPS("%s: invalid hh item count %u, actual %u\n",                     \
-          (where), (head)->hh.tbl->num_items, _count);                           \
-    }                                                                            \
-    _count = 0;                                                                  \
-    _prev = NULL;                                                                \
-    _thh =  &(head)->hh;                                                         \
-    while (_thh) {                                                               \
-      _count++;                                                                  \
-      if (_prev != (char*)_thh->prev) {                                          \
-        HASH_OOPS("%s: invalid prev %p, actual %p\n",                            \
-            (where), (void*)_thh->prev, (void*)_prev);                           \
-      }                                                                          \
-      _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh);                         \
-      _thh = (_thh->next ? HH_FROM_ELMT((head)->hh.tbl, _thh->next) : NULL);     \
-    }                                                                            \
-    if (_count != (head)->hh.tbl->num_items) {                                   \
-      HASH_OOPS("%s: invalid app item count %u, actual %u\n",                    \
-          (where), (head)->hh.tbl->num_items, _count);                           \
-    }                                                                            \
-  }                                                                              \
-} while (0)
-#else
-#define HASH_FSCK(hh,head,where)
-#endif
-
-/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
- * the descriptor to which this macro is defined for tuning the hash function.
- * The app can #include <unistd.h> to get the prototype for write(2). */
-#ifdef HASH_EMIT_KEYS
-#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)                                   \
-do {                                                                             \
-  unsigned _klen = fieldlen;                                                     \
-  write(HASH_EMIT_KEYS, &_klen, sizeof(_klen));                                  \
-  write(HASH_EMIT_KEYS, keyptr, (unsigned long)fieldlen);                        \
-} while (0)
-#else
-#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
-#endif
-
-/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */
-#ifdef HASH_FUNCTION
-#define HASH_FCN HASH_FUNCTION
-#else
-#define HASH_FCN HASH_JEN
-#endif
-
-/* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */
-#define HASH_BER(key,keylen,hashv)                                               \
-do {                                                                             \
-  unsigned _hb_keylen = (unsigned)keylen;                                        \
-  const unsigned char *_hb_key = (const unsigned char*)(key);                    \
-  (hashv) = 0;                                                                   \
-  while (_hb_keylen-- != 0U) {                                                   \
-    (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++;                           \
-  }                                                                              \
-} while (0)
-
-
-/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
- * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
-#define HASH_SAX(key,keylen,hashv)                                               \
-do {                                                                             \
-  unsigned _sx_i;                                                                \
-  const unsigned char *_hs_key = (const unsigned char*)(key);                    \
-  hashv = 0;                                                                     \
-  for (_sx_i=0; _sx_i < keylen; _sx_i++) {                                       \
-    hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i];                       \
-  }                                                                              \
-} while (0)
-/* FNV-1a variation */
-#define HASH_FNV(key,keylen,hashv)                                               \
-do {                                                                             \
-  unsigned _fn_i;                                                                \
-  const unsigned char *_hf_key = (const unsigned char*)(key);                    \
-  (hashv) = 2166136261U;                                                         \
-  for (_fn_i=0; _fn_i < keylen; _fn_i++) {                                       \
-    hashv = hashv ^ _hf_key[_fn_i];                                              \
-    hashv = hashv * 16777619U;                                                   \
-  }                                                                              \
-} while (0)
-
-#define HASH_OAT(key,keylen,hashv)                                               \
-do {                                                                             \
-  unsigned _ho_i;                                                                \
-  const unsigned char *_ho_key=(const unsigned char*)(key);                      \
-  hashv = 0;                                                                     \
-  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
-      hashv += _ho_key[_ho_i];                                                   \
-      hashv += (hashv << 10);                                                    \
-      hashv ^= (hashv >> 6);                                                     \
-  }                                                                              \
-  hashv += (hashv << 3);                                                         \
-  hashv ^= (hashv >> 11);                                                        \
-  hashv += (hashv << 15);                                                        \
-} while (0)
-
-#define HASH_JEN_MIX(a,b,c)                                                      \
-do {                                                                             \
-  a -= b; a -= c; a ^= ( c >> 13 );                                              \
-  b -= c; b -= a; b ^= ( a << 8 );                                               \
-  c -= a; c -= b; c ^= ( b >> 13 );                                              \
-  a -= b; a -= c; a ^= ( c >> 12 );                                              \
-  b -= c; b -= a; b ^= ( a << 16 );                                              \
-  c -= a; c -= b; c ^= ( b >> 5 );                                               \
-  a -= b; a -= c; a ^= ( c >> 3 );                                               \
-  b -= c; b -= a; b ^= ( a << 10 );                                              \
-  c -= a; c -= b; c ^= ( b >> 15 );                                              \
-} while (0)
-
-#define HASH_JEN(key,keylen,hashv)                                               \
-do {                                                                             \
-  unsigned _hj_i,_hj_j,_hj_k;                                                    \
-  unsigned const char *_hj_key=(unsigned const char*)(key);                      \
-  hashv = 0xfeedbeefu;                                                           \
-  _hj_i = _hj_j = 0x9e3779b9u;                                                   \
-  _hj_k = (unsigned)(keylen);                                                    \
-  while (_hj_k >= 12U) {                                                         \
-    _hj_i +=    (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 )                      \
-        + ( (unsigned)_hj_key[2] << 16 )                                         \
-        + ( (unsigned)_hj_key[3] << 24 ) );                                      \
-    _hj_j +=    (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 )                      \
-        + ( (unsigned)_hj_key[6] << 16 )                                         \
-        + ( (unsigned)_hj_key[7] << 24 ) );                                      \
-    hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 )                         \
-        + ( (unsigned)_hj_key[10] << 16 )                                        \
-        + ( (unsigned)_hj_key[11] << 24 ) );                                     \
-                                                                                 \
-     HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                          \
-                                                                                 \
-     _hj_key += 12;                                                              \
-     _hj_k -= 12U;                                                               \
-  }                                                                              \
-  hashv += (unsigned)(keylen);                                                   \
-  switch ( _hj_k ) {                                                             \
-    case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); /* FALLTHROUGH */         \
-    case 10: hashv += ( (unsigned)_hj_key[9] << 16 );  /* FALLTHROUGH */         \
-    case 9:  hashv += ( (unsigned)_hj_key[8] << 8 );   /* FALLTHROUGH */         \
-    case 8:  _hj_j += ( (unsigned)_hj_key[7] << 24 );  /* FALLTHROUGH */         \
-    case 7:  _hj_j += ( (unsigned)_hj_key[6] << 16 );  /* FALLTHROUGH */         \
-    case 6:  _hj_j += ( (unsigned)_hj_key[5] << 8 );   /* FALLTHROUGH */         \
-    case 5:  _hj_j += _hj_key[4];                      /* FALLTHROUGH */         \
-    case 4:  _hj_i += ( (unsigned)_hj_key[3] << 24 );  /* FALLTHROUGH */         \
-    case 3:  _hj_i += ( (unsigned)_hj_key[2] << 16 );  /* FALLTHROUGH */         \
-    case 2:  _hj_i += ( (unsigned)_hj_key[1] << 8 );   /* FALLTHROUGH */         \
-    case 1:  _hj_i += _hj_key[0];                                                \
-  }                                                                              \
-  HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                             \
-} while (0)
-
-/* The Paul Hsieh hash function */
-#undef get16bits
-#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__)             \
-  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
-#define get16bits(d) (*((const uint16_t *) (d)))
-#endif
-
-#if !defined (get16bits)
-#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
-                       +(uint32_t)(((const uint8_t *)(d))[0]) )
-#endif
-#define HASH_SFH(key,keylen,hashv)                                               \
-do {                                                                             \
-  unsigned const char *_sfh_key=(unsigned const char*)(key);                     \
-  uint32_t _sfh_tmp, _sfh_len = (uint32_t)keylen;                                \
-                                                                                 \
-  unsigned _sfh_rem = _sfh_len & 3U;                                             \
-  _sfh_len >>= 2;                                                                \
-  hashv = 0xcafebabeu;                                                           \
-                                                                                 \
-  /* Main loop */                                                                \
-  for (;_sfh_len > 0U; _sfh_len--) {                                             \
-    hashv    += get16bits (_sfh_key);                                            \
-    _sfh_tmp  = ((uint32_t)(get16bits (_sfh_key+2)) << 11) ^ hashv;              \
-    hashv     = (hashv << 16) ^ _sfh_tmp;                                        \
-    _sfh_key += 2U*sizeof (uint16_t);                                            \
-    hashv    += hashv >> 11;                                                     \
-  }                                                                              \
-                                                                                 \
-  /* Handle end cases */                                                         \
-  switch (_sfh_rem) {                                                            \
-    case 3: hashv += get16bits (_sfh_key);                                       \
-            hashv ^= hashv << 16;                                                \
-            hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)]) << 18;              \
-            hashv += hashv >> 11;                                                \
-            break;                                                               \
-    case 2: hashv += get16bits (_sfh_key);                                       \
-            hashv ^= hashv << 11;                                                \
-            hashv += hashv >> 17;                                                \
-            break;                                                               \
-    case 1: hashv += *_sfh_key;                                                  \
-            hashv ^= hashv << 10;                                                \
-            hashv += hashv >> 1;                                                 \
-  }                                                                              \
-                                                                                 \
-  /* Force "avalanching" of final 127 bits */                                    \
-  hashv ^= hashv << 3;                                                           \
-  hashv += hashv >> 5;                                                           \
-  hashv ^= hashv << 4;                                                           \
-  hashv += hashv >> 17;                                                          \
-  hashv ^= hashv << 25;                                                          \
-  hashv += hashv >> 6;                                                           \
-} while (0)
-
-/* iterate over items in a known bucket to find desired item */
-#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,hashval,out)               \
-do {                                                                             \
-  if ((head).hh_head != NULL) {                                                  \
-    DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (head).hh_head));                     \
-  } else {                                                                       \
-    (out) = NULL;                                                                \
-  }                                                                              \
-  while ((out) != NULL) {                                                        \
-    if ((out)->hh.hashv == (hashval) && (out)->hh.keylen == (keylen_in)) {       \
-      if (HASH_KEYCMP((out)->hh.key, keyptr, keylen_in) == 0) {              \
-        break;                                                                   \
-      }                                                                          \
-    }                                                                            \
-    if ((out)->hh.hh_next != NULL) {                                             \
-      DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (out)->hh.hh_next));                \
-    } else {                                                                     \
-      (out) = NULL;                                                              \
-    }                                                                            \
-  }                                                                              \
-} while (0)
-
-/* add an item to a bucket  */
-#define HASH_ADD_TO_BKT(head,hh,addhh,oomed)                                     \
-do {                                                                             \
-  UT_hash_bucket *_ha_head = &(head);                                            \
-  _ha_head->count++;                                                             \
-  (addhh)->hh_next = _ha_head->hh_head;                                          \
-  (addhh)->hh_prev = NULL;                                                       \
-  if (_ha_head->hh_head != NULL) {                                               \
-    _ha_head->hh_head->hh_prev = (addhh);                                        \
-  }                                                                              \
-  _ha_head->hh_head = (addhh);                                                   \
-  if ((_ha_head->count >= ((_ha_head->expand_mult + 1U) * HASH_BKT_CAPACITY_THRESH)) \
-      && !(addhh)->tbl->noexpand) {                                              \
-    HASH_EXPAND_BUCKETS(addhh,(addhh)->tbl, oomed);                              \
-    IF_HASH_NONFATAL_OOM(                                                        \
-      if (oomed) {                                                               \
-        HASH_DEL_IN_BKT(head,addhh);                                             \
-      }                                                                          \
-    )                                                                            \
-  }                                                                              \
-} while (0)
-
-/* remove an item from a given bucket */
-#define HASH_DEL_IN_BKT(head,delhh)                                              \
-do {                                                                             \
-  UT_hash_bucket *_hd_head = &(head);                                            \
-  _hd_head->count--;                                                             \
-  if (_hd_head->hh_head == (delhh)) {                                            \
-    _hd_head->hh_head = (delhh)->hh_next;                                        \
-  }                                                                              \
-  if ((delhh)->hh_prev) {                                                        \
-    (delhh)->hh_prev->hh_next = (delhh)->hh_next;                                \
-  }                                                                              \
-  if ((delhh)->hh_next) {                                                        \
-    (delhh)->hh_next->hh_prev = (delhh)->hh_prev;                                \
-  }                                                                              \
-} while (0)
-
-/* Bucket expansion has the effect of doubling the number of buckets
- * and redistributing the items into the new buckets. Ideally the
- * items will distribute more or less evenly into the new buckets
- * (the extent to which this is true is a measure of the quality of
- * the hash function as it applies to the key domain).
- *
- * With the items distributed into more buckets, the chain length
- * (item count) in each bucket is reduced. Thus by expanding buckets
- * the hash keeps a bound on the chain length. This bounded chain
- * length is the essence of how a hash provides constant time lookup.
- *
- * The calculation of tbl->ideal_chain_maxlen below deserves some
- * explanation. First, keep in mind that we're calculating the ideal
- * maximum chain length based on the *new* (doubled) bucket count.
- * In fractions this is just n/b (n=number of items,b=new num buckets).
- * Since the ideal chain length is an integer, we want to calculate
- * ceil(n/b). We don't depend on floating point arithmetic in this
- * hash, so to calculate ceil(n/b) with integers we could write
- *
- *      ceil(n/b) = (n/b) + ((n%b)?1:0)
- *
- * and in fact a previous version of this hash did just that.
- * But now we have improved things a bit by recognizing that b is
- * always a power of two. We keep its base 2 log handy (call it lb),
- * so now we can write this with a bit shift and logical AND:
- *
- *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
- *
- */
-#define HASH_EXPAND_BUCKETS(hh,tbl,oomed)                                        \
-do {                                                                             \
-  unsigned _he_bkt;                                                              \
-  unsigned _he_bkt_i;                                                            \
-  struct UT_hash_handle *_he_thh, *_he_hh_nxt;                                   \
-  UT_hash_bucket *_he_new_buckets, *_he_newbkt;                                  \
-  _he_new_buckets = (UT_hash_bucket*)uthash_malloc(                              \
-           2UL * (tbl)->num_buckets * sizeof(struct UT_hash_bucket));            \
-  if (!_he_new_buckets) {                                                        \
-    HASH_RECORD_OOM(oomed);                                                      \
-  } else {                                                                       \
-    uthash_bzero(_he_new_buckets,                                                \
-        2UL * (tbl)->num_buckets * sizeof(struct UT_hash_bucket));               \
-    (tbl)->ideal_chain_maxlen =                                                  \
-       ((tbl)->num_items >> ((tbl)->log2_num_buckets+1U)) +                      \
-       ((((tbl)->num_items & (((tbl)->num_buckets*2U)-1U)) != 0U) ? 1U : 0U);    \
-    (tbl)->nonideal_items = 0;                                                   \
-    for (_he_bkt_i = 0; _he_bkt_i < (tbl)->num_buckets; _he_bkt_i++) {           \
-      _he_thh = (tbl)->buckets[ _he_bkt_i ].hh_head;                             \
-      while (_he_thh != NULL) {                                                  \
-        _he_hh_nxt = _he_thh->hh_next;                                           \
-        HASH_TO_BKT(_he_thh->hashv, (tbl)->num_buckets * 2U, _he_bkt);           \
-        _he_newbkt = &(_he_new_buckets[_he_bkt]);                                \
-        if (++(_he_newbkt->count) > (tbl)->ideal_chain_maxlen) {                 \
-          (tbl)->nonideal_items++;                                               \
-          if (_he_newbkt->count > _he_newbkt->expand_mult * (tbl)->ideal_chain_maxlen) { \
-            _he_newbkt->expand_mult++;                                           \
-          }                                                                      \
-        }                                                                        \
-        _he_thh->hh_prev = NULL;                                                 \
-        _he_thh->hh_next = _he_newbkt->hh_head;                                  \
-        if (_he_newbkt->hh_head != NULL) {                                       \
-          _he_newbkt->hh_head->hh_prev = _he_thh;                                \
-        }                                                                        \
-        _he_newbkt->hh_head = _he_thh;                                           \
-        _he_thh = _he_hh_nxt;                                                    \
-      }                                                                          \
-    }                                                                            \
-    uthash_free((tbl)->buckets, (tbl)->num_buckets * sizeof(struct UT_hash_bucket)); \
-    (tbl)->num_buckets *= 2U;                                                    \
-    (tbl)->log2_num_buckets++;                                                   \
-    (tbl)->buckets = _he_new_buckets;                                            \
-    (tbl)->ineff_expands = ((tbl)->nonideal_items > ((tbl)->num_items >> 1)) ?   \
-        ((tbl)->ineff_expands+1U) : 0U;                                          \
-    if ((tbl)->ineff_expands > 1U) {                                             \
-      (tbl)->noexpand = 1;                                                       \
-      uthash_noexpand_fyi(tbl);                                                  \
-    }                                                                            \
-    uthash_expand_fyi(tbl);                                                      \
-  }                                                                              \
-} while (0)
-
-
-/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
-/* Note that HASH_SORT assumes the hash handle name to be hh.
- * HASH_SRT was added to allow the hash handle name to be passed in. */
-#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
-#define HASH_SRT(hh,head,cmpfcn)                                                 \
-do {                                                                             \
-  unsigned _hs_i;                                                                \
-  unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize;               \
-  struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;            \
-  if (head != NULL) {                                                            \
-    _hs_insize = 1;                                                              \
-    _hs_looping = 1;                                                             \
-    _hs_list = &((head)->hh);                                                    \
-    while (_hs_looping != 0U) {                                                  \
-      _hs_p = _hs_list;                                                          \
-      _hs_list = NULL;                                                           \
-      _hs_tail = NULL;                                                           \
-      _hs_nmerges = 0;                                                           \
-      while (_hs_p != NULL) {                                                    \
-        _hs_nmerges++;                                                           \
-        _hs_q = _hs_p;                                                           \
-        _hs_psize = 0;                                                           \
-        for (_hs_i = 0; _hs_i < _hs_insize; ++_hs_i) {                           \
-          _hs_psize++;                                                           \
-          _hs_q = ((_hs_q->next != NULL) ?                                       \
-            HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);                   \
-          if (_hs_q == NULL) {                                                   \
-            break;                                                               \
-          }                                                                      \
-        }                                                                        \
-        _hs_qsize = _hs_insize;                                                  \
-        while ((_hs_psize != 0U) || ((_hs_qsize != 0U) && (_hs_q != NULL))) {    \
-          if (_hs_psize == 0U) {                                                 \
-            _hs_e = _hs_q;                                                       \
-            _hs_q = ((_hs_q->next != NULL) ?                                     \
-              HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);                 \
-            _hs_qsize--;                                                         \
-          } else if ((_hs_qsize == 0U) || (_hs_q == NULL)) {                     \
-            _hs_e = _hs_p;                                                       \
-            if (_hs_p != NULL) {                                                 \
-              _hs_p = ((_hs_p->next != NULL) ?                                   \
-                HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL);               \
-            }                                                                    \
-            _hs_psize--;                                                         \
-          } else if ((cmpfcn(                                                    \
-                DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_p)),             \
-                DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_q))              \
-                )) <= 0) {                                                       \
-            _hs_e = _hs_p;                                                       \
-            if (_hs_p != NULL) {                                                 \
-              _hs_p = ((_hs_p->next != NULL) ?                                   \
-                HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL);               \
-            }                                                                    \
-            _hs_psize--;                                                         \
-          } else {                                                               \
-            _hs_e = _hs_q;                                                       \
-            _hs_q = ((_hs_q->next != NULL) ?                                     \
-              HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);                 \
-            _hs_qsize--;                                                         \
-          }                                                                      \
-          if ( _hs_tail != NULL ) {                                              \
-            _hs_tail->next = ((_hs_e != NULL) ?                                  \
-              ELMT_FROM_HH((head)->hh.tbl, _hs_e) : NULL);                       \
-          } else {                                                               \
-            _hs_list = _hs_e;                                                    \
-          }                                                                      \
-          if (_hs_e != NULL) {                                                   \
-            _hs_e->prev = ((_hs_tail != NULL) ?                                  \
-              ELMT_FROM_HH((head)->hh.tbl, _hs_tail) : NULL);                    \
-          }                                                                      \
-          _hs_tail = _hs_e;                                                      \
-        }                                                                        \
-        _hs_p = _hs_q;                                                           \
-      }                                                                          \
-      if (_hs_tail != NULL) {                                                    \
-        _hs_tail->next = NULL;                                                   \
-      }                                                                          \
-      if (_hs_nmerges <= 1U) {                                                   \
-        _hs_looping = 0;                                                         \
-        (head)->hh.tbl->tail = _hs_tail;                                         \
-        DECLTYPE_ASSIGN(head, ELMT_FROM_HH((head)->hh.tbl, _hs_list));           \
-      }                                                                          \
-      _hs_insize *= 2U;                                                          \
-    }                                                                            \
-    HASH_FSCK(hh, head, "HASH_SRT");                                             \
-  }                                                                              \
-} while (0)
-
-/* This function selects items from one hash into another hash.
- * The end result is that the selected items have dual presence
- * in both hashes. There is no copy of the items made; rather
- * they are added into the new hash through a secondary hash
- * hash handle that must be present in the structure. */
-#define HASH_SELECT(hh_dst, dst, hh_src, src, cond)                              \
-do {                                                                             \
-  unsigned _src_bkt, _dst_bkt;                                                   \
-  void *_last_elt = NULL, *_elt;                                                 \
-  UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL;                         \
-  ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst));                 \
-  if ((src) != NULL) {                                                           \
-    for (_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) {    \
-      for (_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head;               \
-        _src_hh != NULL;                                                         \
-        _src_hh = _src_hh->hh_next) {                                            \
-        _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh);                         \
-        if (cond(_elt)) {                                                        \
-          IF_HASH_NONFATAL_OOM( int _hs_oomed = 0; )                             \
-          _dst_hh = (UT_hash_handle*)(void*)(((char*)_elt) + _dst_hho);          \
-          _dst_hh->key = _src_hh->key;                                           \
-          _dst_hh->keylen = _src_hh->keylen;                                     \
-          _dst_hh->hashv = _src_hh->hashv;                                       \
-          _dst_hh->prev = _last_elt;                                             \
-          _dst_hh->next = NULL;                                                  \
-          if (_last_elt_hh != NULL) {                                            \
-            _last_elt_hh->next = _elt;                                           \
-          }                                                                      \
-          if ((dst) == NULL) {                                                   \
-            DECLTYPE_ASSIGN(dst, _elt);                                          \
-            HASH_MAKE_TABLE(hh_dst, dst, _hs_oomed);                             \
-            IF_HASH_NONFATAL_OOM(                                                \
-              if (_hs_oomed) {                                                   \
-                uthash_nonfatal_oom(_elt);                                       \
-                (dst) = NULL;                                                    \
-                continue;                                                        \
-              }                                                                  \
-            )                                                                    \
-          } else {                                                               \
-            _dst_hh->tbl = (dst)->hh_dst.tbl;                                    \
-          }                                                                      \
-          HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt);      \
-          HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt], hh_dst, _dst_hh, _hs_oomed); \
-          (dst)->hh_dst.tbl->num_items++;                                        \
-          IF_HASH_NONFATAL_OOM(                                                  \
-            if (_hs_oomed) {                                                     \
-              HASH_ROLLBACK_BKT(hh_dst, dst, _dst_hh);                           \
-              HASH_DELETE_HH(hh_dst, dst, _dst_hh);                              \
-              _dst_hh->tbl = NULL;                                               \
-              uthash_nonfatal_oom(_elt);                                         \
-              continue;                                                          \
-            }                                                                    \
-          )                                                                      \
-          HASH_BLOOM_ADD(_dst_hh->tbl, _dst_hh->hashv);                          \
-          _last_elt = _elt;                                                      \
-          _last_elt_hh = _dst_hh;                                                \
-        }                                                                        \
-      }                                                                          \
-    }                                                                            \
-  }                                                                              \
-  HASH_FSCK(hh_dst, dst, "HASH_SELECT");                                         \
-} while (0)
-
-#define HASH_CLEAR(hh,head)                                                      \
-do {                                                                             \
-  if ((head) != NULL) {                                                          \
-    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
-    uthash_free((head)->hh.tbl->buckets,                                         \
-                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
-    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
-    (head) = NULL;                                                               \
-  }                                                                              \
-} while (0)
-
-#define HASH_OVERHEAD(hh,head)                                                   \
- (((head) != NULL) ? (                                                           \
- (size_t)(((head)->hh.tbl->num_items   * sizeof(UT_hash_handle))   +             \
-          ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket))   +             \
-           sizeof(UT_hash_table)                                   +             \
-           (HASH_BLOOM_BYTELEN))) : 0U)
-
-#ifdef NO_DECLTYPE
-#define HASH_ITER(hh,head,el,tmp)                                                \
-for(((el)=(head)), ((*(char**)(&(tmp)))=(char*)((head!=NULL)?(head)->hh.next:NULL)); \
-  (el) != NULL; ((el)=(tmp)), ((*(char**)(&(tmp)))=(char*)((tmp!=NULL)?(tmp)->hh.next:NULL)))
-#else
-#define HASH_ITER(hh,head,el,tmp)                                                \
-for(((el)=(head)), ((tmp)=DECLTYPE(el)((head!=NULL)?(head)->hh.next:NULL));      \
-  (el) != NULL; ((el)=(tmp)), ((tmp)=DECLTYPE(el)((tmp!=NULL)?(tmp)->hh.next:NULL)))
-#endif
-
-/* obtain a count of items in the hash */
-#define HASH_COUNT(head) HASH_CNT(hh,head)
-#define HASH_CNT(hh,head) ((head != NULL)?((head)->hh.tbl->num_items):0U)
-
-typedef struct UT_hash_bucket {
-   struct UT_hash_handle *hh_head;
-   unsigned count;
-
-   /* expand_mult is normally set to 0. In this situation, the max chain length
-    * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
-    * the bucket's chain exceeds this length, bucket expansion is triggered).
-    * However, setting expand_mult to a non-zero value delays bucket expansion
-    * (that would be triggered by additions to this particular bucket)
-    * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
-    * (The multiplier is simply expand_mult+1). The whole idea of this
-    * multiplier is to reduce bucket expansions, since they are expensive, in
-    * situations where we know that a particular bucket tends to be overused.
-    * It is better to let its chain length grow to a longer yet-still-bounded
-    * value, than to do an O(n) bucket expansion too often.
-    */
-   unsigned expand_mult;
-
-} UT_hash_bucket;
-
-/* random signature used only to find hash tables in external analysis */
-#define HASH_SIGNATURE 0xa0111fe1u
-#define HASH_BLOOM_SIGNATURE 0xb12220f2u
-
-typedef struct UT_hash_table {
-   UT_hash_bucket *buckets;
-   unsigned num_buckets, log2_num_buckets;
-   unsigned num_items;
-   struct UT_hash_handle *tail; /* tail hh in app order, for fast append    */
-   ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
-
-   /* in an ideal situation (all buckets used equally), no bucket would have
-    * more than ceil(#items/#buckets) items. that's the ideal chain length. */
-   unsigned ideal_chain_maxlen;
-
-   /* nonideal_items is the number of items in the hash whose chain position
-    * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
-    * hash distribution; reaching them in a chain traversal takes >ideal steps */
-   unsigned nonideal_items;
-
-   /* ineffective expands occur when a bucket doubling was performed, but
-    * afterward, more than half the items in the hash had nonideal chain
-    * positions. If this happens on two consecutive expansions we inhibit any
-    * further expansion, as it's not helping; this happens when the hash
-    * function isn't a good fit for the key domain. When expansion is inhibited
-    * the hash will still work, albeit no longer in constant time. */
-   unsigned ineff_expands, noexpand;
-
-   uint32_t signature; /* used only to find hash tables in external analysis */
-#ifdef HASH_BLOOM
-   uint32_t bloom_sig; /* used only to test bloom exists in external analysis */
-   uint8_t *bloom_bv;
-   uint8_t bloom_nbits;
-#endif
-
-} UT_hash_table;
-
-typedef struct UT_hash_handle {
-   struct UT_hash_table *tbl;
-   void *prev;                       /* prev element in app order      */
-   void *next;                       /* next element in app order      */
-   struct UT_hash_handle *hh_prev;   /* previous hh in bucket order    */
-   struct UT_hash_handle *hh_next;   /* next hh in bucket order        */
-   void *key;                        /* ptr to enclosing struct's key  */
-   unsigned keylen;                  /* enclosing struct's key len     */
-   unsigned hashv;                   /* result of hash-fcn(key)        */
-} UT_hash_handle;
-
-#endif /* UTHASH_H */