diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/hos_client.cpp | 625 | ||||
| -rw-r--r-- | src/hos_client.h | 92 | ||||
| -rw-r--r-- | src/hos_common.h | 57 | ||||
| -rw-r--r-- | src/hos_hash.cpp | 97 | ||||
| -rw-r--r-- | src/hos_hash.h | 40 | ||||
| -rw-r--r-- | src/uthash.h | 1150 |
6 files changed, 331 insertions, 1730 deletions
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 */ |