From 90d740856d0cce3a4d2fa2f2e7c91870a99973ce Mon Sep 17 00:00:00 2001 From: TheAssembler1 Date: Sat, 7 Jun 2025 14:06:17 -0700 Subject: [PATCH 1/2] start test refactor --- src/api/include/pdc.h | 3 +- src/api/pdc.c | 4 +- src/api/pdc_client_connect.c | 555 +++++++--------- src/commons/utils/include/pdc_timing.h | 411 +++++++----- src/commons/utils/pdc_timing.c | 592 ++++-------------- src/server/pdc_client_server_common.c | 249 ++++---- src/server/pdc_server.c | 70 +-- .../pdc_server_region/pdc_server_data.c | 292 ++++----- .../pdc_server_region_request_handler.h | 83 +-- src/tools/pdc_export.c | 60 +- src/tools/pdc_import.c | 18 +- 11 files changed, 986 insertions(+), 1351 deletions(-) diff --git a/src/api/include/pdc.h b/src/api/include/pdc.h index 714120dab..14a9c0f6f 100644 --- a/src/api/include/pdc.h +++ b/src/api/include/pdc.h @@ -40,8 +40,7 @@ #include "pdc_query.h" #include "pdc_analysis.h" #include "pdc_transform.h" - -int PDC_timing_report(const char *prefix); +#include "pdc_timing.h" /*********************/ /* Public Prototypes */ diff --git a/src/api/pdc.c b/src/api/pdc.c index 240141f1c..9202af0d3 100644 --- a/src/api/pdc.c +++ b/src/api/pdc.c @@ -111,7 +111,7 @@ PDCinit(const char *pdc_name) if (PDC_Client_init() < 0) PGOTO_ERROR(0, "PDC client init error"); #ifdef PDC_TIMING - PDC_timing_init(); + PDC_client_timing_init(); #endif ret_value = pdcid; @@ -127,7 +127,7 @@ PDC_class__close(struct _pdc_class *p) FUNC_ENTER(NULL); #ifdef PDC_TIMING - PDC_timing_finalize(); + PDC_client_timing_finalize(); #endif p->name = (char *)PDC_free(p->name); diff --git a/src/api/pdc_client_connect.c b/src/api/pdc_client_connect.c index fa1de6c26..72a454f6f 100644 --- a/src/api/pdc_client_connect.c +++ b/src/api/pdc_client_connect.c @@ -95,7 +95,7 @@ int pdc_nclient_per_server_g = 0; char pdc_client_tmp_dir_g[ADDR_MAX]; struct _pdc_server_info *pdc_server_info_g = NULL; -static int * debug_server_id_count = NULL; +static int *debug_server_id_count = NULL; int pdc_io_request_seq_id = PDC_SEQ_ID_INIT_VALUE; struct pdc_request *pdc_io_request_list_g = NULL; @@ -111,7 +111,7 @@ int nread_bb_g = 0; double read_bb_size_g = 0.0; static int mercury_has_init_g = 0; -static hg_class_t * send_class_g = NULL; +static hg_class_t *send_class_g = NULL; static hg_context_t *send_context_g = NULL; int query_id_g = 0; @@ -126,7 +126,7 @@ static hg_atomic_int32_t response_done_g; hg_atomic_int32_t bulk_transfer_done_g; // global variables for DART -static DART * dart_g; +static DART *dart_g; static dart_hash_algo_t dart_hash_algo_g = DART_HASH; static dart_object_ref_type_t dart_obj_ref_type_g = REF_PRIMARY_ID; @@ -390,8 +390,8 @@ PDC_Client_read_server_addr_from_file() perr_t ret_value = SUCCEED; int max_tries = 9, sleeptime = 1; int i = 0, is_server_ready = 0; - char * p; - FILE * na_config = NULL; + char *p; + FILE *na_config = NULL; char config_fname[PATH_MAX]; char n_server_string[PATH_MAX]; @@ -474,7 +474,7 @@ client_send_flush_obj_all_rpc_cb(const struct hg_cb_info *callback_info) hg_return_t ret_value = HG_SUCCESS; hg_handle_t handle; flush_obj_all_out_t output; - int * rpc_return; + int *rpc_return; FUNC_ENTER(NULL); @@ -530,7 +530,7 @@ client_send_flush_obj_rpc_cb(const struct hg_cb_info *callback_info) hg_return_t ret_value = HG_SUCCESS; hg_handle_t handle; flush_obj_out_t output; - int * rpc_return; + int *rpc_return; FUNC_ENTER(NULL); @@ -558,7 +558,7 @@ client_send_close_all_server_rpc_cb(const struct hg_cb_info *callback_info) hg_return_t ret_value = HG_SUCCESS; hg_handle_t handle; close_server_out_t output; - int * rpc_return; + int *rpc_return; FUNC_ENTER(NULL); @@ -942,7 +942,7 @@ PDC_Client_lookup_server(int server_id, int is_init) hg_return_t hg_ret; struct _pdc_client_lookup_args lookup_args; char self_addr[ADDR_MAX]; - char * target_addr_string; + char *target_addr_string; FUNC_ENTER(NULL); @@ -1217,14 +1217,14 @@ hg_test_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args; hg_bulk_t local_bulk_handle; uint32_t i; - void * buf = NULL; - void ** ids_buf; + void *buf = NULL; + void **ids_buf; uint32_t n_meta; uint64_t buf_sizes[2] = {0, 0}; - uint64_t * ids_buf_sizes; + uint64_t *ids_buf_sizes; uint32_t actual_cnt; - pdc_metadata_t * meta_ptr; - uint64_t * u64_arr_ptr; + pdc_metadata_t *meta_ptr; + uint64_t *u64_arr_ptr; uint32_t bulk_sgnum; FUNC_ENTER(NULL); @@ -1326,7 +1326,7 @@ PDC_Client_check_bulk(hg_context_t *hg_context) static const char * drc_strerror(int errnum) { - char * ret_value = NULL; + char *ret_value = NULL; const char *errstring = "UNDEFINED"; FUNC_ENTER(NULL); @@ -1355,7 +1355,7 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po { perr_t ret_value = SUCCEED; char na_info_string[NA_STRING_INFO_LEN]; - char * hostname; + char *hostname; pbool_t free_hostname = false; int local_server_id; /* Set the default mercury transport @@ -1365,13 +1365,13 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po * "cci+tcp" */ struct hg_init_info init_info = {0}; - char * default_hg_transport = "ofi+tcp"; - char * hg_transport; + char *default_hg_transport = "ofi+tcp"; + char *hg_transport; #ifdef PDC_HAS_CRAY_DRC uint32_t credential, cookie; drc_info_handle_t credential_info; char pdc_auth_key[256] = {'\0'}; - char * auth_key; + char *auth_key; int rc; #endif @@ -1571,7 +1571,7 @@ PDC_Client_init() { perr_t ret_value = SUCCEED; pdc_server_info_g = NULL; - char * tmp_dir; + char *tmp_dir; uint32_t port; int is_mpi_init = 0; @@ -1768,16 +1768,16 @@ static hg_return_t metadata_query_bulk_cb(const struct hg_cb_info *callback_info) { hg_return_t ret_value; - struct bulk_args_t * client_lookup_args; + struct bulk_args_t *client_lookup_args; hg_handle_t handle; metadata_query_transfer_out_t output; uint32_t n_meta; hg_op_id_t hg_bulk_op_id; hg_bulk_t local_bulk_handle = HG_BULK_NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; - const struct hg_info * hg_info = NULL; - struct bulk_args_t * bulk_args; - void * recv_meta; + const struct hg_info *hg_info = NULL; + struct bulk_args_t *bulk_args; + void *recv_meta; FUNC_ENTER(NULL); @@ -2187,7 +2187,7 @@ PDC_Client_add_tag(pdcid_t obj_id, const char *tag) hg_handle_t metadata_add_tag_handle; uint64_t meta_id; uint32_t server_id; - struct _pdc_obj_info * obj_prop; + struct _pdc_obj_info *obj_prop; struct _pdc_client_lookup_args lookup_args; metadata_add_tag_in_t in; @@ -2408,7 +2408,7 @@ PDC_Client_delete_metadata(char *delete_name, pdcid_t obj_delete_prop) { perr_t ret_value = SUCCEED; hg_return_t hg_ret = 0; - struct _pdc_obj_prop * delete_prop; + struct _pdc_obj_prop *delete_prop; metadata_delete_in_t in; int hash_name_value; uint32_t server_id; @@ -2468,7 +2468,7 @@ PDC_Client_query_metadata_name_only(const char *obj_name, pdc_metadata_t **out) struct _pdc_metadata_query_args **lookup_args; uint32_t server_id; uint32_t i, count = 0; - hg_handle_t * metadata_query_handle; + hg_handle_t *metadata_query_handle; FUNC_ENTER(NULL); @@ -2624,13 +2624,11 @@ PDC_Client_create_cont_id(const char *cont_name, pdcid_t cont_create_prop ATTRIB uint32_t hash_name_value; struct _pdc_client_lookup_args lookup_args; hg_handle_t rpc_handle; + PDC_TIMING_DECLARE(PDC_CLIENT_CONT_CREATE_RPC_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + PDC_TIMING_START(PDC_CLIENT_CONT_CREATE_RPC_TIME); if (cont_name == NULL) PGOTO_ERROR(FAIL, "Cannot create container with empty name"); @@ -2672,11 +2670,7 @@ PDC_Client_create_cont_id(const char *cont_name, pdcid_t cont_create_prop ATTRIB *cont_id = lookup_args.obj_id; ret_value = SUCCEED; -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCclient_cont_create_rpc += end - start; - pdc_timestamp_register(pdc_client_create_cont_timestamps, function_start, end); -#endif + PDC_TIMING_END(PDC_CLIENT_CONT_CREATE_RPC_TIME); done: fflush(stdout); @@ -2775,18 +2769,16 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj perr_t ret_value = SUCCEED; hg_return_t hg_ret; uint32_t server_id = 0; - struct _pdc_obj_prop * create_prop = NULL; + struct _pdc_obj_prop *create_prop = NULL; gen_obj_id_in_t in; uint32_t hash_name_value; struct _pdc_client_lookup_args lookup_args; hg_handle_t rpc_handle; + PDC_TIMING_DECLARE(PDC_CLIENT_OBJ_CREATE_RPC_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + PDC_TIMING_START(PDC_CLIENT_OBJ_CREATE_RPC_TIME); create_prop = PDC_obj_prop_get_info(obj_create_prop); @@ -2877,11 +2869,7 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj *meta_id = lookup_args.obj_id; ret_value = SUCCEED; -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCclient_obj_create_rpc += end - start; - pdc_timestamp_register(pdc_client_create_obj_timestamps, function_start, end); -#endif + PDC_TIMING_END(PDC_CLIENT_OBJ_CREATE_RPC_TIME); done: fflush(stdout); @@ -2936,7 +2924,7 @@ PDC_Client_close_all_server() if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_close_all_server(): Could not destroy handle"); } // End pdc_client_mpi_rank_g < pdc_server_num_g - } // End pdc_client_mpi_size_g >= pdc_server_num_g + } // End pdc_client_mpi_size_g >= pdc_server_num_g else { if (pdc_client_mpi_rank_g == 0) { for (i = 0; i < (uint32_t)pdc_server_num_g; i++) { @@ -2965,7 +2953,7 @@ PDC_Client_close_all_server() PGOTO_ERROR(FAIL, "PDC_Client_close_all_server(): Could not destroy handle"); } } // End of mpi_rank == 0 - } // End pdc_client_mpi_size_g < pdc_server_num_g + } // End pdc_client_mpi_size_g < pdc_server_num_g #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -2986,14 +2974,15 @@ PDC_Client_buf_unmap(pdcid_t remote_obj_id, pdcid_t remote_reg_id, struct pdc_re size_t unit; uint32_t data_server_id, meta_server_id; struct _pdc_buf_map_args unmap_args; + PDC_TIMING_DECLARE(PDC_CLIENT_BUF_OBJ_UNMAP_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_BUF_OBJ_UNMAP_RPC_WAIT_TIME); hg_handle_t client_send_buf_unmap_handle; FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + + PDC_TIMING_START(PDC_CLIENT_BUF_OBJ_UNMAP_RPC_TIME); + // Fill input structure in.remote_obj_id = remote_obj_id; in.remote_reg_id = remote_reg_id; @@ -3017,20 +3006,18 @@ PDC_Client_buf_unmap(pdcid_t remote_obj_id, pdcid_t remote_reg_id, struct pdc_re hg_ret = HG_Forward(client_send_buf_unmap_handle, client_send_buf_unmap_rpc_cb, &unmap_args, &in); if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_buf_unmap(): Could not start HG_Forward()"); -#ifdef PDC_TIMING - pdc_timings.PDCbuf_obj_unmap_rpc += MPI_Wtime() - start; -#endif + + PDC_TIMING_END(PDC_CLIENT_BUF_OBJ_UNMAP_RPC_TIME); + // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); -#ifdef PDC_TIMING - start = MPI_Wtime(); -#endif + + PDC_TIMING_START(PDC_CLIENT_BUF_OBJ_UNMAP_RPC_WAIT_TIME); + PDC_Client_check_response(&send_context_g); -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCbuf_obj_unmap_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_buf_obj_unmap_timestamps, function_start, end); -#endif + + PDC_TIMING_END(PDC_CLIENT_BUF_OBJ_UNMAP_RPC_WAIT_TIME); + if (unmap_args.ret != 1) PGOTO_ERROR(FAIL, "PDC_CLIENT: buf unmap failed..."); @@ -3148,28 +3135,27 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_all_in_t in; - hg_class_t * hg_class; + hg_class_t *hg_class; int i; hg_handle_t client_send_transfer_request_all_handle; struct _pdc_transfer_request_all_args transfer_args; char cur_time[64]; + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_WAIT_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_WAIT_TIME); FUNC_ENTER(NULL); -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] enter\n", cur_time, pdc_client_mpi_rank_g); -#endif - -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif if (!(access_type == PDC_WRITE || access_type == PDC_READ)) { ret_value = FAIL; LOG_ERROR("Invalid PDC type"); goto done; } + + PDC_TIMING_START(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_TIME); + in.n_objs = n_objs; in.access_type = access_type; in.total_buf_size = bulk_size; @@ -3211,15 +3197,10 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d PDC_Client_transfer_pthread_create(); -#ifdef PDC_TIMING - if (access_type == PDC_READ) { - pdc_timings.PDCtransfer_request_start_all_read_rpc += MPI_Wtime() - start; - } - else { - pdc_timings.PDCtransfer_request_start_all_write_rpc += MPI_Wtime() - start; - } - start = MPI_Wtime(); -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_TIME); + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_WAIT_TIME); if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_all(): Could not start HG_Forward()\n"); @@ -3228,27 +3209,14 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d PDC_Client_wait_pthread_progress(); -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] received response\n", cur_time, pdc_client_mpi_rank_g); -#endif - #ifdef ENABLE_MPI if (comm != 0) MPI_Barrier(comm); #endif -#ifdef PDC_TIMING - end = MPI_Wtime(); - if (access_type == PDC_READ) { - pdc_timings.PDCtransfer_request_start_all_read_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_start_all_read_timestamps, function_start, end); - } - else { - pdc_timings.PDCtransfer_request_start_all_write_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_start_all_write_timestamps, function_start, end); - } -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_WAIT_TIME); + for (i = 0; i < n_objs; ++i) { metadata_id[i] = transfer_args.metadata_id + i; } @@ -3257,11 +3225,6 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d HG_Destroy(client_send_transfer_request_all_handle); -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] leaving\n", cur_time, pdc_client_mpi_rank_g); -#endif - done: fflush(stdout); FUNC_LEAVE(ret_value); @@ -3274,15 +3237,14 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_metadata_query2_in_t in; - hg_class_t * hg_class; + hg_class_t *hg_class; hg_handle_t client_send_transfer_request_metadata_query2_handle; struct _pdc_transfer_request_metadata_query2_args transfer_args; + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + + PDC_TIMING_START(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); in.query_id = query_id; in.total_buf_size = total_buf_size; @@ -3319,11 +3281,7 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, HG_Destroy(client_send_transfer_request_metadata_query2_handle); -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCtransfer_request_metadata_query_rpc += end - start; - pdc_timestamp_register(pdc_client_transfer_request_metadata_query_timestamps, function_start, end); -#endif + PDC_TIMING_END(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); done: fflush(stdout); @@ -3338,15 +3296,15 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_metadata_query_in_t in; - hg_class_t * hg_class; + hg_class_t *hg_class; hg_handle_t client_send_transfer_request_metadata_query_handle; struct _pdc_transfer_request_metadata_query_args transfer_args; + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + + PDC_TIMING_START(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); + in.n_objs = n_objs; in.total_buf_size = total_buf_size; in.is_write = is_write; @@ -3386,11 +3344,7 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i HG_Destroy(client_send_transfer_request_metadata_query_handle); -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCtransfer_request_metadata_query_rpc += end - start; - pdc_timestamp_register(pdc_client_transfer_request_metadata_query_timestamps, function_start, end); -#endif + PDC_TIMING_END(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); done: fflush(stdout); @@ -3403,10 +3357,12 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_wait_all_in_t in; - hg_class_t * hg_class; + hg_class_t *hg_class; hg_handle_t client_send_transfer_request_wait_all_handle; struct _pdc_transfer_request_wait_all_args transfer_args; char cur_time[64]; + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_WAIT_TIME); FUNC_ENTER(NULL); @@ -3416,10 +3372,8 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u /* hg_progress_flag_g = -1; */ /* } */ -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + PDC_TIMING_START(PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_TIME); + in.n_objs = n_objs; in.total_buf_size = sizeof(pdcid_t) * n_objs; @@ -3445,10 +3399,9 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u hg_ret = HG_Forward(client_send_transfer_request_wait_all_handle, client_send_transfer_request_wait_all_rpc_cb, &transfer_args, &in); -#ifdef PDC_TIMING - pdc_timings.PDCtransfer_request_wait_all_rpc += MPI_Wtime() - start; - start = MPI_Wtime(); -#endif + PDC_TIMING_END(PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_TIME); + PDC_TIMING_START(PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_WAIT_TIME); + if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_wait_all(): Could not start HG_Forward()\n"); hg_atomic_set32(&atomic_work_todo_g, 1); @@ -3459,12 +3412,7 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u HG_Destroy(client_send_transfer_request_wait_all_handle); -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCtransfer_request_wait_all_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_wait_all_timestamps, function_start, end); -#endif - + PDC_TIMING_END(PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_WAIT_TIME); done: fflush(stdout); FUNC_LEAVE(ret_value); @@ -3479,25 +3427,29 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_in_t in; - hg_class_t * hg_class; + hg_class_t *hg_class; uint32_t meta_server_id; hg_size_t total_data_size; int i; hg_handle_t client_send_transfer_request_handle; struct _pdc_transfer_request_args transfer_args; char cur_time[64]; + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_WAIT_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_WAIT_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + if (!(access_type == PDC_WRITE || access_type == PDC_READ)) { ret_value = FAIL; LOG_ERROR("Invalid PDC type\n"); goto done; } + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_TIME); + LOG_DEBUG("rank = %d, data_server_id = %u\n", pdc_client_mpi_rank_g, data_server_id); in.access_type = access_type; in.remote_unit = unit; @@ -3540,15 +3492,10 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, hg_ret = HG_Forward(client_send_transfer_request_handle, client_send_transfer_request_rpc_cb, &transfer_args, &in); -#ifdef PDC_TIMING - if (access_type == PDC_READ) { - pdc_timings.PDCtransfer_request_start_read_rpc += MPI_Wtime() - start; - } - else { - pdc_timings.PDCtransfer_request_start_write_rpc += MPI_Wtime() - start; - } - start = MPI_Wtime(); -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_TIME); + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_WAIT_TIME); PDC_Client_transfer_pthread_create(); @@ -3564,17 +3511,9 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, PDC_Client_wait_pthread_progress(); -#ifdef PDC_TIMING - end = MPI_Wtime(); - if (access_type == PDC_READ) { - pdc_timings.PDCtransfer_request_start_read_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_start_read_timestamps, function_start, end); - } - else { - pdc_timings.PDCtransfer_request_start_write_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_start_write_timestamps, function_start, end); - } -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_WAIT_TIME); + *metadata_id = transfer_args.metadata_id; if (transfer_args.ret != 1) @@ -3636,6 +3575,10 @@ PDC_Client_transfer_request_wait(pdcid_t transfer_request_id, uint32_t data_serv hg_handle_t client_send_transfer_request_wait_handle; struct _pdc_transfer_request_wait_args transfer_args; char cur_time[64]; + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_WAIT_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_WAIT_TIME); FUNC_ENTER(NULL); @@ -3645,11 +3588,8 @@ PDC_Client_transfer_request_wait(pdcid_t transfer_request_id, uint32_t data_serv /* pthread_join(hg_progress_tid_g, NULL); */ /* hg_progress_flag_g = -1; */ /* } */ - -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_TIME); debug_server_id_count[data_server_id]++; @@ -3667,33 +3607,18 @@ PDC_Client_transfer_request_wait(pdcid_t transfer_request_id, uint32_t data_serv hg_ret = HG_Forward(client_send_transfer_request_wait_handle, client_send_transfer_request_wait_rpc_cb, &transfer_args, &in); -#ifdef PDC_TIMING - end = MPI_Wtime(); - if (access_type == PDC_READ) { - pdc_timings.PDCtransfer_request_wait_read_rpc += end - start; - } - else { - pdc_timings.PDCtransfer_request_wait_write_rpc += end - start; - } - start = MPI_Wtime(); -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_TIME); + + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_WAIT_TIME); if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request(): Could not start HG_Forward()\n"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); - -#ifdef PDC_TIMING - end = MPI_Wtime(); - if (access_type == PDC_READ) { - pdc_timings.PDCtransfer_request_wait_read_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_wait_read_timestamps, function_start, end); - } - else { - pdc_timings.PDCtransfer_request_wait_write_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_transfer_request_wait_write_timestamps, function_start, end); - } -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_WAIT_TIME); if (transfer_args.ret != 1) PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer request failed..."); @@ -3715,21 +3640,21 @@ PDC_Client_buf_map(pdcid_t local_region_id, pdcid_t remote_obj_id, size_t ndim, hg_return_t hg_ret = HG_SUCCESS; buf_map_in_t in; uint32_t data_server_id, meta_server_id; - hg_class_t * hg_class; + hg_class_t *hg_class; hg_uint32_t i, j; hg_uint32_t local_count; - void ** data_ptrs = NULL; - size_t * data_size = NULL; + void **data_ptrs = NULL; + size_t *data_size = NULL; size_t unit, unit_to; struct _pdc_buf_map_args map_args; hg_handle_t client_send_buf_map_handle; + PDC_TIMING_DECLARE(PDC_CLIENT_BUF_OBJ_MAP_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_BUF_OBJ_MAP_RPC_WAIT_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + + PDC_TIMING_START(PDC_CLIENT_BUF_OBJ_MAP_RPC_TIME); in.local_reg_id = local_region_id; in.remote_obj_id = remote_obj_id; @@ -3839,23 +3764,19 @@ PDC_Client_buf_map(pdcid_t local_region_id, pdcid_t remote_obj_id, size_t ndim, PGOTO_ERROR(FAIL, "PDC_Client_buf_map(): Could not create local bulk data handle"); hg_ret = HG_Forward(client_send_buf_map_handle, client_send_buf_map_rpc_cb, &map_args, &in); -#ifdef PDC_TIMING - pdc_timings.PDCbuf_obj_map_rpc += MPI_Wtime() - start; -#endif + + PDC_TIMING_END(PDC_CLIENT_BUF_OBJ_MAP_RPC_TIME); + if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_buf_map(): Could not start HG_Forward()"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); -#ifdef PDC_TIMING - start = MPI_Wtime(); -#endif + + PDC_TIMING_START(PDC_CLIENT_BUF_OBJ_MAP_RPC_WAIT_TIME); PDC_Client_check_response(&send_context_g); -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_timings.PDCbuf_obj_map_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_buf_obj_map_timestamps, function_start, end); -#endif + PDC_TIMING_END(PDC_CLIENT_BUF_OBJ_MAP_RPC_WAIT_TIME); + if (map_args.ret != 1) PGOTO_ERROR(FAIL, "PDC_CLIENT: buf map failed..."); @@ -3879,12 +3800,16 @@ PDC_Client_region_lock(pdcid_t remote_obj_id, struct _pdc_obj_info *object_info, region_lock_in_t in; struct _pdc_region_lock_args lookup_args; hg_handle_t region_lock_handle; + PDC_TIMING_DECLARE(PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_WAIT_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_WAIT_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_TIME, + PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_TIME); + server_id = ((pdc_metadata_t *)object_info->metadata)->data_server_id; meta_server_id = PDC_get_server_by_obj_id(remote_obj_id, pdc_server_num_g); // Compute local data server id @@ -3916,35 +3841,22 @@ PDC_Client_region_lock(pdcid_t remote_obj_id, struct _pdc_obj_info *object_info, ®ion_lock_handle); hg_ret = HG_Forward(region_lock_handle, client_region_lock_rpc_cb, &lookup_args, &in); -#ifdef PDC_TIMING - if (access_type == PDC_READ) { - pdc_timings.PDCreg_obtain_lock_read_rpc += MPI_Wtime() - start; - } - else { - pdc_timings.PDCreg_obtain_lock_write_rpc += MPI_Wtime() - start; - } -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_TIME, + PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_TIME); + if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_name_to_server(): Could not start HG_Forward()"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); -#ifdef PDC_TIMING - start = MPI_Wtime(); -#endif + + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_WAIT_TIME, + PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_WAIT_TIME); PDC_Client_check_response(&send_context_g); -#ifdef PDC_TIMING - end = MPI_Wtime(); - if (access_type == PDC_READ) { - pdc_timings.PDCreg_obtain_lock_read_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_obtain_lock_read_timestamps, function_start, end); - } - else { - pdc_timings.PDCreg_obtain_lock_write_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_obtain_lock_write_timestamps, function_start, end); - } -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_WAIT_TIME, + PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_WAIT_TIME); + // Now the return value is stored in lookup_args.ret if (lookup_args.ret == 1) { *status = TRUE; @@ -3975,12 +3887,16 @@ PDC_Client_region_release(pdcid_t remote_obj_id, struct _pdc_obj_info *object_in // size_t type_extent; struct _pdc_client_lookup_args lookup_args; hg_handle_t region_release_handle = HG_HANDLE_NULL; + PDC_TIMING_DECLARE(PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_WAIT_TIME); + PDC_TIMING_DECLARE(PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_WAIT_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - double start = MPI_Wtime(), end; - double function_start = start; -#endif + + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_TIME); + // Compute data server and metadata server ids. server_id = ((pdc_metadata_t *)object_info->metadata)->data_server_id; meta_server_id = PDC_get_server_by_obj_id(remote_obj_id, pdc_server_num_g); @@ -4009,34 +3925,20 @@ PDC_Client_region_release(pdcid_t remote_obj_id, struct _pdc_obj_info *object_in ®ion_release_handle); hg_ret = HG_Forward(region_release_handle, client_region_release_rpc_cb, &lookup_args, &in); -#ifdef PDC_TIMING - if (access_type == PDC_READ) { - pdc_timings.PDCreg_release_lock_read_rpc += MPI_Wtime() - start; - } - else { - pdc_timings.PDCreg_release_lock_write_rpc += MPI_Wtime() - start; - } - start = MPI_Wtime(); + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_TIME); -#endif if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_send_name_to_server(): Could not start HG_Forward()"); + PDC_TIMING_START_ACCESS(access_type, PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_WAIT_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_WAIT_TIME); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); -#ifdef PDC_TIMING - end = MPI_Wtime(); - if (access_type == PDC_READ) { - pdc_timings.PDCreg_release_lock_read_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_release_lock_read_timestamps, function_start, end); - } - else { - pdc_timings.PDCreg_release_lock_write_rpc_wait += end - start; - pdc_timestamp_register(pdc_client_release_lock_write_timestamps, function_start, end); - } -#endif + PDC_TIMING_END_ACCESS(access_type, PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_WAIT_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_WAIT_TIME); // Now the return value is stored in lookup_args.ret if (lookup_args.ret == 1) { *status = TRUE; @@ -4104,11 +4006,11 @@ PDC_Client_get_data_from_server_shm_cb(const struct hg_cb_info *callback_info) int shm_fd = -1; // file descriptor, from shm_open() uint32_t i = 0; - char * shm_base = NULL; // base address, from mmap() - char * shm_addr = NULL; + char *shm_base = NULL; // base address, from mmap() + char *shm_addr = NULL; uint64_t data_size = 1; - client_read_info_t * read_info = NULL; - struct pdc_request * elt = NULL; + client_read_info_t *read_info = NULL; + struct pdc_request *elt = NULL; struct pdc_region_info *target_region = NULL; #ifdef ENABLE_TIMING struct timeval pdc_timer_start; @@ -4199,8 +4101,8 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat uint64_t read_size = 1; hg_handle_t data_server_read_check_handle; int shm_fd; // file descriptor, from shm_open() - char * shm_base; // base address, from mmap() - char * shm_addr; + char *shm_base; // base address, from mmap() + char *shm_addr; #ifdef ENABLE_TIMING struct timeval pdc_timer_start; struct timeval pdc_timer_end; @@ -4335,8 +4237,8 @@ PDC_Client_data_server_read(struct pdc_request *request) data_server_read_in_t in; hg_handle_t data_server_read_handle; int server_id, n_client, n_update; - pdc_metadata_t * meta; - struct pdc_region_info * region; + pdc_metadata_t *meta; + struct pdc_region_info *region; FUNC_ENTER(NULL); @@ -4468,8 +4370,8 @@ PDC_Client_data_server_write_check(struct pdc_request *request, int *status) data_server_write_check_in_t in; hg_handle_t data_server_write_check_handle; int server_id; - pdc_metadata_t * meta; - struct pdc_region_info * region; + pdc_metadata_t *meta; + struct pdc_region_info *region; uint64_t write_size = 1; uint32_t i; @@ -4570,9 +4472,9 @@ PDC_Client_data_server_write(struct pdc_request *request) int server_ret; hg_handle_t data_server_write_handle; int server_id, n_client, n_update; - pdc_metadata_t * meta; - struct pdc_region_info * region; - void * buf; + pdc_metadata_t *meta; + struct pdc_region_info *region; + void *buf; int rnd; #ifdef ENABLE_TIMING @@ -4628,7 +4530,7 @@ PDC_Client_data_server_write(struct pdc_request *request) request->shm_base = mmap(0, region_size, PROT_READ | PROT_WRITE, MAP_SHARED, request->shm_fd, 0); if (request->shm_base == MAP_FAILED) PGOTO_ERROR(FAIL, "==PDC_CLIENT: Shared memory mmap failed, region size = %" PRIu64 "", region_size); - // close and shm_unlink? + // close and shm_unlink? #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_start, 0); @@ -4840,7 +4742,7 @@ PDC_Client_write_id(pdcid_t local_obj_id, struct pdc_region_info *region, void * struct _pdc_id_info *info; struct _pdc_obj_info *object; - pdc_metadata_t * meta; + pdc_metadata_t *meta; perr_t ret_value = SUCCEED; FUNC_ENTER(NULL); @@ -5071,7 +4973,7 @@ PDC_Client_add_objects_to_container(int nobj, pdcid_t *local_obj_ids, pdcid_t lo { perr_t ret_value = SUCCEED; int i; - uint64_t * obj_ids; + uint64_t *obj_ids; uint64_t cont_meta_id; struct _pdc_id_info *id_info = NULL; @@ -5097,7 +4999,7 @@ PDC_Client_del_objects_to_container(int nobj, pdcid_t *local_obj_ids, pdcid_t lo { perr_t ret_value = SUCCEED; int i; - uint64_t * obj_ids; + uint64_t *obj_ids; uint64_t cont_meta_id; struct _pdc_id_info *id_info = NULL; @@ -5125,7 +5027,7 @@ PDC_Client_add_tags_to_container(pdcid_t cont_id, char *tags) hg_return_t hg_ret = HG_SUCCESS; hg_handle_t rpc_handle; uint32_t server_id; - struct _pdc_id_info * info; + struct _pdc_id_info *info; struct _pdc_cont_info *object; uint64_t cont_meta_id; cont_add_tags_rpc_in_t add_tag_rpc_in; @@ -5380,12 +5282,12 @@ PDC_Client_query_name_read_entire_obj(int nobj, char **obj_names, void ***out_bu hg_handle_t rpc_handle; hg_bulk_t bulk_handle; uint32_t server_id; - uint64_t * buf_sizes, total_size; + uint64_t *buf_sizes, total_size; int i; query_read_obj_name_in_t bulk_rpc_in; // Reuse the existing args structure update_region_storage_meta_bulk_args_t cb_args; - struct pdc_request * request; + struct pdc_request *request; FUNC_ENTER(NULL); @@ -5672,7 +5574,7 @@ static region_list_t * PDC_get_storage_meta_from_io_list(pdc_data_server_io_list_t **list, region_storage_meta_t *storage_meta) { pdc_data_server_io_list_t *io_list_elt, *io_list_target = NULL; - region_list_t * ret_value = NULL; + region_list_t *ret_value = NULL; FUNC_ENTER(NULL); @@ -5698,7 +5600,7 @@ PDC_add_storage_meta_to_io_list(pdc_data_server_io_list_t **list, region_storage { pdc_data_server_io_list_t *io_list_elt, *io_list_target = NULL; - region_list_t * new_region; + region_list_t *new_region; int j; perr_t ret_value = SUCCEED; @@ -5765,7 +5667,7 @@ PDC_send_region_storage_meta_shm(uint32_t server_id, int n, region_storage_meta_ buf_sizes = n * sizeof(region_storage_meta_t); hg_ret = HG_Bulk_create(send_class_g, 1, (void **)&storage_meta, (const hg_size_t *)&buf_sizes, - HG_BULK_READ_ONLY, &bulk_handle); + HG_BULK_READ_ONLY, &bulk_handle); if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "Could not create bulk data handle"); @@ -5798,7 +5700,7 @@ PDC_Client_cp_data_to_local_server(int nobj, region_storage_meta_t **all_storage perr_t ret_value = SUCCEED; uint32_t ndim, server_id; uint64_t total_size = 0, cp_loc = 0; - void * buf = NULL; + void *buf = NULL; char shm_addr[ADDR_MAX]; int i, *total_obj = NULL, ntotal_obj = nobj, *recvcounts = NULL, *displs = NULL; region_storage_meta_t *all_region_storage_meta_1d = NULL, *my_region_storage_meta_1d = NULL; @@ -5910,8 +5812,8 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ { perr_t ret_value = SUCCEED; int i; - char * fname, *prev_fname; - FILE * fp_read = NULL; + char *fname, *prev_fname; + FILE *fp_read = NULL; uint32_t ndim; uint64_t req_start, req_count, storage_start, storage_count, file_offset, buf_size; size_t read_bytes; @@ -6012,15 +5914,15 @@ PDC_Client_query_multi_storage_info(int nobj, char **obj_names, region_storage_m hg_bulk_t bulk_handle; uint32_t server_id; - uint64_t * buf_sizes = NULL, total_size; + uint64_t *buf_sizes = NULL, total_size; int i, j, loc, iter, *n_obj_name_by_server = NULL; - int ** obj_names_server_seq_mapping = NULL, *obj_names_server_seq_mapping_1d; + int **obj_names_server_seq_mapping = NULL, *obj_names_server_seq_mapping_1d; int send_n_request = 0; - char *** obj_names_by_server = NULL; - char ** obj_names_by_server_2d = NULL; + char ***obj_names_by_server = NULL; + char **obj_names_by_server_2d = NULL; query_read_obj_name_in_t bulk_rpc_in; update_region_storage_meta_bulk_args_t cb_args; - struct pdc_request ** requests, *request; + struct pdc_request **requests, *request; FUNC_ENTER(NULL); @@ -6243,12 +6145,12 @@ PDC_Client_query_name_read_entire_obj_client_agg(int my_nobj, char **my_obj_name size_t *out_buf_sizes) { perr_t ret_value = SUCCEED; - char ** all_names = my_obj_names; - char * local_names_1d, *all_names_1d = NULL; - int * total_obj = NULL, i, ntotal_obj = my_nobj, *recvcounts = NULL, *displs = NULL; + char **all_names = my_obj_names; + char *local_names_1d, *all_names_1d = NULL; + int *total_obj = NULL, i, ntotal_obj = my_nobj, *recvcounts = NULL, *displs = NULL; size_t max_name_len = 64; region_storage_meta_t **all_storage_meta = NULL, **my_storage_meta = NULL; - region_storage_meta_t * my_storage_meta_1d = NULL, *res_storage_meta_1d = NULL; + region_storage_meta_t *my_storage_meta_1d = NULL, *res_storage_meta_1d = NULL; #ifdef ENABLE_TIMING struct timeval pdc_timer1; @@ -6539,7 +6441,7 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re *total_read_bytes += read_bytes; } // for each row - } // ndim=2 + } // ndim=2 else if (ndim == 3) { if (is_client_debug_g == 1) { @@ -6610,8 +6512,8 @@ PDC_add_kvtag(pdcid_t obj_id, pdc_kvtag_t *kvtag, int is_cont) uint32_t server_id; hg_handle_t metadata_add_kvtag_handle; metadata_add_kvtag_in_t in; - struct _pdc_obj_info * obj_prop; - struct _pdc_cont_info * cont_prop; + struct _pdc_obj_info *obj_prop; + struct _pdc_cont_info *cont_prop; struct _pdc_client_lookup_args lookup_args; FUNC_ENTER(NULL); @@ -6718,8 +6620,8 @@ PDC_get_kvtag(pdcid_t obj_id, char *tag_name, pdc_kvtag_t **kvtag, int is_cont) hg_handle_t metadata_get_kvtag_handle; metadata_get_kvtag_in_t in; struct _pdc_get_kvtag_args lookup_args; - struct _pdc_obj_info * obj_prop; - struct _pdc_cont_info * cont_prop; + struct _pdc_obj_info *obj_prop; + struct _pdc_cont_info *cont_prop; FUNC_ENTER(NULL); @@ -6779,12 +6681,12 @@ kvtag_query_bulk_cb(const struct hg_cb_info *hg_cb_info) hg_bulk_t origin_bulk_handle = hg_cb_info->info.bulk.origin_handle; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; uint32_t n_meta, actual_cnt; - void * buf = NULL; + void *buf = NULL; uint64_t buf_sizes[1]; uint32_t bulk_sgnum; - uint64_t * ids_buf_sizes; - void ** ids_buf; - uint64_t * u64_arr_ptr; + uint64_t *ids_buf_sizes; + void **ids_buf; + uint64_t *u64_arr_ptr; FUNC_ENTER(NULL); @@ -6837,14 +6739,14 @@ static hg_return_t kvtag_query_forward_cb(const struct hg_cb_info *callback_info) { hg_return_t ret_value; - struct bulk_args_t * bulk_arg; + struct bulk_args_t *bulk_arg; hg_handle_t handle; metadata_query_transfer_out_t output; uint32_t n_meta; hg_op_id_t hg_bulk_op_id; hg_bulk_t local_bulk_handle = HG_BULK_NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; - const struct hg_info * hg_info = NULL; + const struct hg_info *hg_info = NULL; FUNC_ENTER(NULL); @@ -7022,8 +6924,8 @@ PDCtag_delete(pdcid_t obj_id, char *tag_name, int is_cont) uint32_t server_id; hg_handle_t metadata_del_kvtag_handle; metadata_get_kvtag_in_t in; - struct _pdc_obj_info * obj_prop; - struct _pdc_cont_info * cont_prop; + struct _pdc_obj_info *obj_prop; + struct _pdc_cont_info *cont_prop; struct _pdc_client_lookup_args lookup_args; FUNC_ENTER(NULL); @@ -7265,7 +7167,7 @@ PDCobj_put_data(const char *obj_name, void *data, uint64_t size, pdcid_t cont_id perr_t ret; // pdc_metadata_t *meta; struct _pdc_cont_info *info = NULL; - struct _pdc_id_info * id_info = NULL; + struct _pdc_id_info *id_info = NULL; pdcid_t transfer_request; FUNC_ENTER(NULL); @@ -7371,7 +7273,7 @@ PDC_Client_del_metadata(pdcid_t obj_id, int is_cont) { perr_t ret_value = SUCCEED; uint64_t meta_id; - struct _pdc_obj_info * obj_prop; + struct _pdc_obj_info *obj_prop; struct _pdc_cont_info *cont_prop; FUNC_ENTER(NULL); @@ -7504,7 +7406,7 @@ hg_return_t PDC_recv_nhits(const struct hg_cb_info *callback_info) { hg_return_t ret_value = HG_SUCCESS; - send_nhits_t * in = (send_nhits_t *)callback_info->arg; + send_nhits_t *in = (send_nhits_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; FUNC_ENTER(NULL); @@ -7532,10 +7434,10 @@ PDC_send_data_query(pdc_query_t *query, pdc_query_get_op_t get_op, uint64_t *nhi { perr_t ret_value = SUCCEED; hg_return_t hg_ret = 0; - uint32_t * target_servers = NULL; + uint32_t *target_servers = NULL; int i, server_id, next_server = 0, prev_server = 0, ntarget = 0; hg_handle_t handle; - pdc_query_xfer_t * query_xfer; + pdc_query_xfer_t *query_xfer; struct _pdc_client_lookup_args lookup_args; struct _pdc_query_result_list *result; @@ -7623,12 +7525,12 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) { hg_return_t ret_value = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; - struct bulk_args_t * bulk_args = (struct bulk_args_t *)callback_info->arg; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; uint64_t nhits = 0; uint32_t ndim; int query_id, origin; - void * buf; + void *buf; pdc_int_ret_t out; FUNC_ENTER(NULL); @@ -7709,7 +7611,7 @@ PDC_Client_get_sel_data(pdcid_t obj_id, pdc_selection_t *sel, void *data) uint64_t meta_id, off; get_sel_data_rpc_in_t in; struct _pdc_client_lookup_args lookup_args; - struct _pdc_obj_info * obj_prop; + struct _pdc_obj_info *obj_prop; struct _pdc_query_result_list *result_elt; FUNC_ENTER(NULL); @@ -7781,11 +7683,11 @@ PDC_recv_read_coords_data(const struct hg_cb_info *callback_info) { hg_return_t ret_value = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; - struct bulk_args_t * bulk_args = (struct bulk_args_t *)callback_info->arg; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; uint64_t nhits = 0; int query_id, seq_id; - void * buf; + void *buf; pdc_int_ret_t out; FUNC_ENTER(NULL); @@ -7857,9 +7759,9 @@ report_avg_server_profiling_rst() { for (int i = 0; i < pdc_server_num_g; i++) { - double avg_srv_time = server_call_count_g[i] > 0 - ? (double)(server_time_total_g[i]) / (double)(server_call_count_g[i]) - : 0.0; + double avg_srv_time = server_call_count_g[i] > 0 + ? (double)(server_time_total_g[i]) / (double)(server_call_count_g[i]) + : 0.0; double srv_mem_usage = server_mem_usage_g[i] / 1024.0 / 1024.0; LOG_INFO("==PDC_CLIENT[%d]: server %d, avg profiling time: %.4f ms, memory usage: %.4f MB\n", pdc_client_mpi_rank_g, i, avg_srv_time / 1000.0, srv_mem_usage); @@ -7999,7 +7901,7 @@ static hg_return_t dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) { hg_return_t ret_value; - struct bulk_args_t * client_lookup_args; + struct bulk_args_t *client_lookup_args; hg_handle_t handle; dart_perform_one_server_out_t output; uint32_t n_meta; @@ -8008,8 +7910,8 @@ dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) hg_bulk_t local_bulk_handle = HG_BULK_NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; const struct hg_info *hg_info = NULL; - struct bulk_args_t * bulk_args; - void * recv_meta; + struct bulk_args_t *bulk_args; + void *recv_meta; FUNC_ENTER(NULL); @@ -8178,7 +8080,7 @@ dart_perform_on_servers(index_hash_result_t **hash_result, int num_servers, struct bulk_args_t *lookup_args = (struct bulk_args_t *)PDC_calloc(num_servers, sizeof(struct bulk_args_t)); uint64_t ret_value = 0; - hg_handle_t * dart_request_handles = (hg_handle_t *)PDC_calloc(num_servers, sizeof(hg_handle_t)); + hg_handle_t *dart_request_handles = (hg_handle_t *)PDC_calloc(num_servers, sizeof(hg_handle_t)); int num_requests = 0; uint32_t total_n_meta = 0; dart_op_type_t op_type = dart_in->op_type; @@ -8242,9 +8144,9 @@ PDC_Client_search_obj_ref_through_dart(dart_hash_algo_t hash_algo, char *query_s stopwatch_t timer; timer_start(&timer); - char * k_query = get_key(query_string, '='); - char * v_query = get_value(query_string, '='); - char * tok = NULL; + char *k_query = get_key(query_string, '='); + char *v_query = get_value(query_string, '='); + char *tok = NULL; dart_op_type_t dart_op; dart_determine_query_token_by_key_query(k_query, &tok, &dart_op); @@ -8406,7 +8308,6 @@ PDC_Client_insert_obj_ref_into_dart(dart_hash_algo_t hash_algo, char *attr_key, /******************** Collective Object Selection Query Starts *******************************/ -// #define ENABLE_MPI #ifdef ENABLE_MPI void diff --git a/src/commons/utils/include/pdc_timing.h b/src/commons/utils/include/pdc_timing.h index fd409732e..adabc68cf 100644 --- a/src/commons/utils/include/pdc_timing.h +++ b/src/commons/utils/include/pdc_timing.h @@ -31,165 +31,272 @@ #include #ifdef PDC_TIMING -typedef struct pdc_timing { - double PDCbuf_obj_map_rpc; - double PDCbuf_obj_unmap_rpc; - - double PDCreg_obtain_lock_write_rpc; - double PDCreg_obtain_lock_read_rpc; - - double PDCreg_release_lock_write_rpc; - double PDCreg_release_lock_read_rpc; - - double PDCbuf_obj_map_rpc_wait; - double PDCbuf_obj_unmap_rpc_wait; - - double PDCreg_obtain_lock_write_rpc_wait; - double PDCreg_obtain_lock_read_rpc_wait; - double PDCreg_release_lock_write_rpc_wait; - double PDCreg_release_lock_read_rpc_wait; - - double PDCtransfer_request_start_write_rpc; - double PDCtransfer_request_wait_write_rpc; - double PDCtransfer_request_start_read_rpc; - double PDCtransfer_request_wait_read_rpc; - - double PDCtransfer_request_start_write_rpc_wait; - double PDCtransfer_request_start_read_rpc_wait; - double PDCtransfer_request_wait_write_rpc_wait; - double PDCtransfer_request_wait_read_rpc_wait; - - double PDCtransfer_request_start_all_write_rpc; - double PDCtransfer_request_start_all_read_rpc; - double PDCtransfer_request_wait_all_rpc; - - double PDCtransfer_request_start_all_write_rpc_wait; - double PDCtransfer_request_start_all_read_rpc_wait; - double PDCtransfer_request_wait_all_rpc_wait; - - double PDCtransfer_request_metadata_query_rpc; - - double PDCclient_obj_create_rpc; - double PDCclient_cont_create_rpc; - -} pdc_timing; - -pdc_timing pdc_timings; - -typedef struct pdc_server_timing { - double PDCbuf_obj_map_rpc; - double PDCbuf_obj_unmap_rpc; - - double PDCreg_obtain_lock_write_rpc; - double PDCreg_obtain_lock_read_rpc; - double PDCreg_release_lock_write_rpc; - double PDCreg_release_lock_read_rpc; - double PDCreg_release_lock_bulk_transfer_write_rpc; - double PDCreg_release_lock_bulk_transfer_read_rpc; - double PDCreg_release_lock_bulk_transfer_inner_write_rpc; - double PDCreg_release_lock_bulk_transfer_inner_read_rpc; - - double PDCreg_transfer_request_start_write_rpc; - double PDCreg_transfer_request_start_read_rpc; - double PDCreg_transfer_request_wait_write_rpc; - double PDCreg_transfer_request_wait_read_rpc; - double PDCreg_transfer_request_start_write_bulk_rpc; - double PDCreg_transfer_request_inner_write_bulk_rpc; - double PDCreg_transfer_request_start_read_bulk_rpc; - double PDCreg_transfer_request_inner_read_bulk_rpc; - - double PDCreg_transfer_request_start_all_write_rpc; - double PDCreg_transfer_request_start_all_read_rpc; - double PDCreg_transfer_request_start_all_write_bulk_rpc; - double PDCreg_transfer_request_start_all_read_bulk_rpc; - double PDCreg_transfer_request_inner_write_all_bulk_rpc; - double PDCreg_transfer_request_inner_read_all_bulk_rpc; - double PDCreg_transfer_request_wait_all_rpc; - double PDCreg_transfer_request_wait_all_bulk_rpc; - - double PDCdata_server_write_out; - double PDCdata_server_read_from; - double PDCcache_write; - double PDCcache_read; - double PDCcache_flush; - double PDCcache_clean; - double PDCdata_server_write_posix; - double PDCdata_server_read_posix; - - double PDCserver_obj_create_rpc; - double PDCserver_cont_create_rpc; - - double PDCserver_restart; - double PDCserver_checkpoint; - double PDCserver_start_total; -} pdc_server_timing; - typedef struct pdc_timestamp { + // array of start times double *start; + // array of corresponding end times double *end; size_t timestamp_max_size; - size_t timestamp_size; + size_t timestamp_cur_size; } pdc_timestamp; -pdc_server_timing *pdc_server_timings; -pdc_timestamp * pdc_buf_obj_map_timestamps; -pdc_timestamp * pdc_buf_obj_unmap_timestamps; - -pdc_timestamp *pdc_obtain_lock_write_timestamps; -pdc_timestamp *pdc_obtain_lock_read_timestamps; -pdc_timestamp *pdc_release_lock_write_timestamps; -pdc_timestamp *pdc_release_lock_read_timestamps; -pdc_timestamp *pdc_release_lock_bulk_transfer_write_timestamps; -pdc_timestamp *pdc_release_lock_bulk_transfer_inner_write_timestamps; -pdc_timestamp *pdc_release_lock_bulk_transfer_read_timestamps; -pdc_timestamp *pdc_release_lock_bulk_transfer_inner_read_timestamps; - -pdc_timestamp *pdc_transfer_request_start_write_timestamps; -pdc_timestamp *pdc_transfer_request_start_read_timestamps; -pdc_timestamp *pdc_transfer_request_wait_write_timestamps; -pdc_timestamp *pdc_transfer_request_wait_read_timestamps; -pdc_timestamp *pdc_transfer_request_start_write_bulk_timestamps; -pdc_timestamp *pdc_transfer_request_inner_write_bulk_timestamps; -pdc_timestamp *pdc_transfer_request_start_read_bulk_timestamps; -pdc_timestamp *pdc_transfer_request_inner_read_bulk_timestamps; - -pdc_timestamp *pdc_transfer_request_start_all_write_timestamps; -pdc_timestamp *pdc_transfer_request_start_all_read_timestamps; -pdc_timestamp *pdc_transfer_request_start_all_write_bulk_timestamps; -pdc_timestamp *pdc_transfer_request_start_all_read_bulk_timestamps; -pdc_timestamp *pdc_transfer_request_wait_all_timestamps; -pdc_timestamp *pdc_transfer_request_inner_write_all_bulk_timestamps; -pdc_timestamp *pdc_transfer_request_inner_read_all_bulk_timestamps; - -pdc_timestamp *pdc_client_buf_obj_map_timestamps; -pdc_timestamp *pdc_client_buf_obj_unmap_timestamps; -pdc_timestamp *pdc_client_obtain_lock_write_timestamps; -pdc_timestamp *pdc_client_obtain_lock_read_timestamps; -pdc_timestamp *pdc_client_release_lock_write_timestamps; -pdc_timestamp *pdc_client_release_lock_read_timestamps; - -pdc_timestamp *pdc_client_transfer_request_start_write_timestamps; -pdc_timestamp *pdc_client_transfer_request_start_read_timestamps; -pdc_timestamp *pdc_client_transfer_request_wait_write_timestamps; -pdc_timestamp *pdc_client_transfer_request_wait_read_timestamps; - -pdc_timestamp *pdc_client_transfer_request_start_all_write_timestamps; -pdc_timestamp *pdc_client_transfer_request_start_all_read_timestamps; -pdc_timestamp *pdc_client_transfer_request_wait_all_timestamps; - -pdc_timestamp *pdc_client_create_cont_timestamps; -pdc_timestamp *pdc_client_create_obj_timestamps; - -pdc_timestamp *pdc_client_transfer_request_metadata_query_timestamps; - -int PDC_timing_init(); -int PDC_timing_finalize(); -int PDC_timing_report(const char *prefix); -int PDC_server_timing_init(); -int pdc_timestamp_register(pdc_timestamp *timestamp, double start, double end); -int PDC_server_timing_report(); +#ifndef IS_PDC_SERVER +typedef enum { + // Buffer object map/unmap + PDC_CLIENT_BUF_OBJ_MAP_RPC_TIME = 0, + PDC_CLIENT_BUF_OBJ_UNMAP_RPC_TIME, + PDC_CLIENT_BUF_OBJ_MAP_RPC_WAIT_TIME, + PDC_CLIENT_BUF_OBJ_UNMAP_RPC_WAIT_TIME, + + // Lock obtain/release (WRITE/READ) + PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_TIME, + PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_TIME, + + PDC_CLIENT_REG_OBTAIN_LOCK_WRITE_RPC_WAIT_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_WRITE_RPC_WAIT_TIME, + PDC_CLIENT_REG_OBTAIN_LOCK_READ_RPC_WAIT_TIME, + PDC_CLIENT_REG_RELEASE_LOCK_READ_RPC_WAIT_TIME, + + // Transfer request WRITE + PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_WRITE_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_WRITE_RPC_WAIT_TIME, + + // Transfer request READ + PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_READ_RPC_WAIT_TIME, + + // Transfer request ALL + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_WRITE_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_START_ALL_READ_RPC_WAIT_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_TIME, + PDC_CLIENT_TRANSFER_REQUEST_WAIT_ALL_RPC_WAIT_TIME, + + // Metadata and object/container creation + PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME, + PDC_CLIENT_OBJ_CREATE_RPC_TIME, + PDC_CLIENT_CONT_CREATE_RPC_TIME, + + // Enum size + PDC_CLIENT_TIMES_SIZE, +} pdc_client_timestamps_t; + +static const char *pdc_client_timestamps_str[] = { + // Buffer object map/unmap + "Client buf obj map rpc time", "Client buf obj unmap rpc time", "Client buf obj map rpc wait time", + "Client buf obj unmap rpc wait time", + + // Lock obtain/release (write/read) + "Client reg obtain lock write rpc time", "Client reg release lock write rpc time", + "Client reg obtain lock read rpc time", "Client reg release lock read rpc time", + + "Client reg obtain lock write rpc wait time", "Client reg release lock write rpc wait time", + "Client reg obtain lock read rpc wait time", "Client reg release lock read rpc wait time", + + // Transfer request write + "Client transfer request start write rpc time", "Client transfer request wait write rpc time", + "Client transfer request start write rpc wait time", "Client transfer request wait write rpc wait time", + + // Transfer request read + "Client transfer request start read rpc time", "Client transfer request wait read rpc time", + "Client transfer request start read rpc wait time", "Client transfer request wait read rpc wait time", + + // Transfer request all + "Client transfer request start all write rpc time", + "Client transfer request start all write rpc wait time", + "Client transfer request start all read rpc time", "Client transfer request start all read rpc wait time", + "Client transfer request wait all rpc time", "Client transfer request wait all rpc wait time", + + // Metadata and object/container creation + "Client transfer request metadata query rpc time", "Client obj create rpc time", + "Client cont create rpc time"}; + +extern pdc_timestamp *pdc_client_timestamps_g[PDC_CLIENT_TIMES_SIZE]; +extern double pdc_client_timings_g[PDC_CLIENT_TIMES_SIZE]; +#else // IS_PDC_SERVER +typedef enum { + // Buffer object map/unmap + PDC_SERVER_BUF_OBJ_MAP_RPC_TIME = 0, + PDC_SERVER_BUF_OBJ_UNMAP_RPC_TIME, + + // Lock obtain/release + PDC_SERVER_OBTAIN_LOCK_WRITE_TIME, + PDC_SERVER_OBTAIN_LOCK_READ_TIME, + PDC_SERVER_RELEASE_LOCK_WRITE_TIME, + PDC_SERVER_RELEASE_LOCK_READ_TIME, + PDC_SERVER_RELEASE_LOCK_BULK_TRANSFER_WRITE_TIME, + PDC_SERVER_RELEASE_LOCK_BULK_TRANSFER_INNER_WRITE_TIME, + PDC_SERVER_RELEASE_LOCK_BULK_TRANSFER_READ_TIME, + PDC_SERVER_RELEASE_LOCK_BULK_TRANSFER_INNER_READ_TIME, + + // Transfer request WRITE + PDC_SERVER_TRANSFER_REQUEST_START_WRITE_TIME, + PDC_SERVER_TRANSFER_REQUEST_START_READ_TIME, + PDC_SERVER_TRANSFER_REQUEST_WAIT_WRITE_TIME, + PDC_SERVER_TRANSFER_REQUEST_WAIT_READ_TIME, + PDC_SERVER_TRANSFER_REQUEST_START_WRITE_BULK_TIME, + PDC_SERVER_TRANSFER_REQUEST_INNER_WRITE_BULK_TIME, + PDC_SERVER_TRANSFER_REQUEST_START_READ_BULK_TIME, + PDC_SERVER_TRANSFER_REQUEST_INNER_READ_BULK_TIME, + + // Transfer request ALL + PDC_SERVER_TRANSFER_REQUEST_START_ALL_WRITE_TIME, + PDC_SERVER_TRANSFER_REQUEST_START_ALL_READ_TIME, + PDC_SERVER_TRANSFER_REQUEST_START_ALL_WRITE_BULK_TIME, + PDC_SERVER_TRANSFER_REQUEST_START_ALL_READ_BULK_TIME, + PDC_SERVER_TRANSFER_REQUEST_WAIT_ALL_TIME, + PDC_SERVER_TRANSFER_REQUEST_INNER_WRITE_ALL_BULK_TIME, + PDC_SERVER_TRANSFER_REQUEST_INNER_READ_ALL_BULK_TIME, + + // Enum size + PDC_SERVER_TIMES_SIZE +} pdc_server_timestamps_t; + +static const char *pdc_server_timestamps_str[] = { + // Buffer object map/unmap + "Server buf obj map rpc time", "Server buf obj unmap rpc time", + + // Lock obtain/release + "Server obtain lock write time", "Server obtain lock read time", "Server release lock write time", + "Server release lock read time", "Server release lock bulk transfer write time", + "Server release lock bulk transfer inner write time", "Server release lock bulk transfer read time", + "Server release lock bulk transfer inner read time", + + // Transfer request WRITE + "Server transfer request start write time", "Server transfer request start read time", + "Server transfer request wait write time", "Server transfer request wait read time", + "Server transfer request start write bulk time", "Server transfer request inner write bulk time", + "Server transfer request start read bulk time", "Server transfer request inner read bulk time", + + // Transfer request ALL + "Server transfer request start all write time", "Server transfer request start all read time", + "Server transfer request start all write bulk time", "Server transfer request start all read bulk time", + "Server transfer request wait all time", "Server transfer request inner write all bulk time", + "Server transfer request inner read all bulk time"}; + +extern double pdc_server_timings_g[PDC_SERVER_TIMES_SIZE]; +extern pdc_timestamp *pdc_server_timestamps_g[PDC_SERVER_TIMES_SIZE]; +#endif // IS_PDC_SERVER + +void pdc_timestamp_register(pdc_timestamp **_timestamp, double start, double end); + +#ifndef IS_PDC_SERVER +void PDC_client_timing_init(); +void PDC_client_timing_finalize(); +void PDC_client_timing_report(const char *prefix); +#else +void PDC_server_timing_init(); +void PDC_server_timing_finalize(); +void PDC_server_timing_report(const char *prefix); +#endif + +/** + * The enum_label is used to create unique variable + * names, allowing the macros to be used multiple times + * in the same function scope without collisions. + * + * It is also used to identify which timestamp linked list + * to append to for recording timing information. + * + * Note: The PDC_TIMING_DECLARE cannot be used + * multiple times within the same function scope with + * the same enum_label. + * + * PDC_TIMING_DECLARE creates the timing variables + * used by the corresponding calls to PDC_TIMING_START + * and PDC_TIMING_END. This separation is necessary + * because some timing measurements depend on conditions + * (e.g., PDC_READ vs. PDC_WRITE), and declaring the variables + * inside PDC_TIMING_START would limit their scope + * to that conditional block, making them inaccessible outside. + */ +#define PDC_TIMING_DECLARE_GENERAL(enum_label) \ + double __start_time_##enum_label = 0.0; \ + double __function_start_time_##enum_label = 0.0; +#define PDC_TIMING_START_GENERAL(enum_label) \ + do { \ + __start_time_##enum_label = MPI_Wtime(); \ + __function_start_time_##enum_label = __start_time_##enum_label; \ + } while (0) +#define PDC_TIMING_END_GENERAL(enum_label, client_or_server_timings_g, client_or_server_timestamps_g) \ + do { \ + double __end_time = MPI_Wtime(); \ + client_or_server_timings_g[enum_label] += __end_time - __start_time_##enum_label; \ + pdc_timestamp_register(&(client_or_server_timestamps_g[enum_label]), \ + __function_start_time_##enum_label, __end_time); \ + } while (0) +/** + * Starts the appropriate timing measurement based on access_type. + * + * Since some timing regions differ depending on whether the access + * type is PDC_READ or PDC_WRITE, this macro selects the correct + * enum_label accordingly, avoiding conditional scoping issues + * and keeping the timing calls consistent and clear. + */ +#define PDC_TIMING_START_ACCESS_GENERAL(access_type, read_label, write_label) \ + do { \ + if ((access_type) == PDC_READ) \ + PDC_TIMING_START(read_label); \ + else \ + PDC_TIMING_START(write_label); \ + } while (0) +/** + * Ends the appropriate timing measurement based on access_type. + * + * Matches the timing started by PDC_TIMING_START_ACCESS, + * ending the correct timing block depending on whether the access + * type is PDC_READ or PDC_WRITE. + */ +#define PDC_TIMING_END_ACCESS_GENERAL(access_type, read_label, write_label, client_or_server_timings_g, \ + client_or_server_timestamps_g) \ + do { \ + if ((access_type) == PDC_READ) \ + PDC_TIMING_END(read_label, client_or_server_timings_g, client_or_server_timestamps_g); \ + else \ + PDC_TIMING_END(write_label, client_or_server_timings_g, client_or_server_timestamps_g); \ + } while (0) + +#ifndef IS_PDC_SERVER +#define PDC_TIMING_DECLARE(enum_label) PDC_TIMING_DECLARE_GENERAL(enum_label) +#define PDC_TIMING_START(enum_label) PDC_TIMING_START_GENERAL(enum_label) +#define PDC_TIMING_END(enum_label) \ + PDC_TIMING_END_GENERAL(enum_label, pdc_client_timings_g, pdc_client_timestamps_g) +#define PDC_TIMING_START_ACCESS(access_type, read_label, write_label) \ + PDC_TIMING_START_ACCESS_GENERAL(access_type, read_label, write_label) +#define PDC_TIMING_END_ACCESS(access_type, read_label, write_label) \ + PDC_TIMING_END_ACCESS_GENERAL(access_type, read_label, write_label, pdc_client_timings_g, \ + pdc_client_timestamps_g) +#else +#define PDC_TIMING_DECLARE(enum_label) PDC_TIMING_DECLARE_GENERAL(enum_label) +#define PDC_TIMING_START(enum_label) PDC_TIMING_START_GENERAL(enum_label) +#define PDC_TIMING_END(enum_label) \ + PDC_TIMING_END_GENERAL(enum_label, pdc_server_timings_g, pdc_server_timestamps_g) +#define PDC_TIMING_START_ACCESS(access_type, read_label, write_label) \ + PDC_TIMING_START_ACCESS_GENERAL(access_type, read_label, write_label) +#define PDC_TIMING_END_ACCESS(access_type, read_label, write_label) \ + PDC_TIMING_END_ACCESS_GENERAL(access_type, read_label, write_label, pdc_server_timings_g, \ + pdc_server_timestamps_g) +#endif #else -int PDC_timing_report(const char *prefix); +void PDC_timing_report(const char *prefix); +#define PDC_CLIENT_TIMING_DECLARE(enum_label) +#define PDC_CLIENT_TIMING_START(enum_label) +#define PDC_CLIENT_TIMING_END(enum_label) +#define PDC_CLIENT_TIMING_START_ACCESS(access_type, read_label, write_label) +#define PDC_CLIENT_TIMING_END_ACCESS(access_type, read_label, write_label) + +#define PDC_SERVER_TIMING_DECLARE(enum_label) +#define PDC_SERVER_TIMING_START(enum_label) +#define PDC_SERVER_TIMING_END(enum_label) +#define PDC_SERVER_TIMING_START_ACCESS(access_type, read_label, write_label) +#define PDC_SERVER_TIMING_END_ACCESS(access_type, read_label, write_label) #endif extern int pdc_timing_rank_g; diff --git a/src/commons/utils/pdc_timing.c b/src/commons/utils/pdc_timing.c index d6f51a569..77e7964a2 100644 --- a/src/commons/utils/pdc_timing.c +++ b/src/commons/utils/pdc_timing.c @@ -7,523 +7,161 @@ #ifdef PDC_TIMING static double pdc_base_time; -static int +void +pdc_timestamp_register(pdc_timestamp **_timestamp, double start, double end) +{ + double *temp; + + if (*_timestamp == NULL) + *_timestamp = (pdc_timestamp *)PDC_calloc(1, sizeof(pdc_timestamp)); + pdc_timestamp *timestamp = *_timestamp; + if (timestamp->timestamp_max_size == 0) { + timestamp->timestamp_max_size = 256; + timestamp->start = (double *)PDC_malloc(sizeof(double) * timestamp->timestamp_max_size * 2); + timestamp->end = timestamp->start + timestamp->timestamp_max_size; + timestamp->timestamp_cur_size = 0; + } + else if (timestamp->timestamp_cur_size == timestamp->timestamp_max_size) { + temp = (double *)PDC_malloc(sizeof(double) * timestamp->timestamp_max_size * 4); + memcpy(temp, timestamp->start, sizeof(double) * timestamp->timestamp_max_size); + memcpy(temp + timestamp->timestamp_max_size * 2, timestamp->end, + sizeof(double) * timestamp->timestamp_max_size); + PDC_free(timestamp->start); + timestamp->start = temp; + timestamp->end = temp + timestamp->timestamp_max_size * 2; + timestamp->timestamp_max_size *= 2; + } + timestamp->start[timestamp->timestamp_cur_size] = start; + timestamp->end[timestamp->timestamp_cur_size] = end; + timestamp->timestamp_cur_size++; +} + +static void pdc_timestamp_clean(pdc_timestamp *timestamp) { - if (timestamp->timestamp_size) { - timestamp->start = (double *)PDC_free(timestamp->start); + if (timestamp != NULL && timestamp->start != NULL) { + PDC_free(timestamp->start); + timestamp->start = NULL; + timestamp->end = NULL; + timestamp->timestamp_cur_size = 0; + timestamp->timestamp_max_size = 0; } - return 0; } -static int -timestamp_log(FILE *stream, const char *header, pdc_timestamp *timestamp) +static void +timestamp_log(pdc_timestamp *timestamp) { size_t i; double total = 0.0; - fprintf(stream, "%s", header); - for (i = 0; i < timestamp->timestamp_size; ++i) { - fprintf(stream, ",%4f-%4f", timestamp->start[i], timestamp->end[i]); + + if (timestamp == NULL) + return; + + for (i = 0; i < timestamp->timestamp_cur_size; ++i) { + if (i == 0) + LOG_JUST_PRINT("%0.6f-%0.6f", timestamp->start[i], timestamp->end[i]); + else + LOG_JUST_PRINT(",%0.6f-%0.6f", timestamp->start[i], timestamp->end[i]); total += timestamp->end[i] - timestamp->start[i]; } - fprintf(stream, "\n"); + LOG_JUST_PRINT("\n"); if (i > 0) - fprintf(stream, "%s_total, %f\n", header, total); - - return 0; + LOG_JUST_PRINT("total, %f\n", total); } -int -PDC_timing_init() +void +pdc_timing_init(double *timings, pdc_timestamp **timestamps, int size) { - char hostname[HOST_NAME_MAX]; - int rank; - pdc_timestamp *ptr; - - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - gethostname(hostname, HOST_NAME_MAX); - if (!(rank % 31)) { - LOG_INFO("client process rank %d, hostname = %s\n", rank, hostname); - } - MPI_Barrier(MPI_COMM_WORLD); - - memset(&pdc_timings, 0, sizeof(pdc_timing)); - - pdc_client_buf_obj_map_timestamps = PDC_calloc(16, sizeof(pdc_timestamp)); - ptr = pdc_client_buf_obj_map_timestamps + 1; - pdc_client_buf_obj_unmap_timestamps = ptr; - ptr++; - pdc_client_obtain_lock_write_timestamps = ptr; - ptr++; - pdc_client_obtain_lock_read_timestamps = ptr; - ptr++; - pdc_client_release_lock_write_timestamps = ptr; - ptr++; - pdc_client_release_lock_read_timestamps = ptr; - ptr++; - - pdc_client_transfer_request_start_write_timestamps = ptr; - ptr++; - pdc_client_transfer_request_start_read_timestamps = ptr; - ptr++; - pdc_client_transfer_request_wait_write_timestamps = ptr; - ptr++; - pdc_client_transfer_request_wait_read_timestamps = ptr; - ptr++; - - pdc_client_transfer_request_start_all_write_timestamps = ptr; - ptr++; - pdc_client_transfer_request_start_all_read_timestamps = ptr; - ptr++; - pdc_client_transfer_request_wait_all_timestamps = ptr; - ptr++; - - pdc_client_create_cont_timestamps = ptr; - ptr++; - pdc_client_create_obj_timestamps = ptr; - - ptr++; - pdc_client_transfer_request_metadata_query_timestamps = ptr; - - return 0; + memset(timings, 0, sizeof(double) * size); + for (int i = 0; i < size; i++) + pdc_timestamp_clean(timestamps[i]); } -int -PDC_timing_finalize() +void +pdc_timing_finalize(double *timings, pdc_timestamp **timestamps, int size) { - pdc_timestamp_clean(pdc_client_buf_obj_map_timestamps); - pdc_timestamp_clean(pdc_client_buf_obj_unmap_timestamps); - - pdc_timestamp_clean(pdc_client_obtain_lock_write_timestamps); - pdc_timestamp_clean(pdc_client_obtain_lock_read_timestamps); - pdc_timestamp_clean(pdc_client_release_lock_write_timestamps); - pdc_timestamp_clean(pdc_client_release_lock_read_timestamps); - - pdc_timestamp_clean(pdc_client_transfer_request_start_write_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_start_read_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_wait_write_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_wait_read_timestamps); - pdc_timestamp_clean(pdc_client_create_cont_timestamps); - pdc_timestamp_clean(pdc_client_create_obj_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_start_all_write_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_start_all_read_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_wait_all_timestamps); - pdc_timestamp_clean(pdc_client_transfer_request_metadata_query_timestamps); - - pdc_client_buf_obj_map_timestamps = (pdc_timestamp *)PDC_free(pdc_client_buf_obj_map_timestamps); - return 0; + memset(timings, 0, sizeof(double) * size); + for (int i = 0; i < size; i++) { + pdc_timestamp_clean(timestamps[i]); + timestamps[i] = NULL; + } } -int -PDC_timing_report(const char *prefix) +void +pdc_timing_report(double *timings, pdc_timestamp **timestamps, int size, const char **timestamp_strs, + const char *prefix) { - pdc_timing max_timings; - int rank; - char filename[256], header[256]; - FILE * stream; - char hostname[HOST_NAME_MAX]; - time_t now; + double max_timings[size]; + int rank; + char hostname[HOST_NAME_MAX]; - time(&now); - MPI_Comm_rank(MPI_COMM_WORLD, &rank); gethostname(hostname, HOST_NAME_MAX); - if (!(rank % 32)) { - LOG_INFO("client process rank %d, hostname = %s\n", rank, hostname); - } - MPI_Reduce(&pdc_timings, &max_timings, sizeof(pdc_timing) / sizeof(double), MPI_DOUBLE, MPI_MAX, 0, - MPI_COMM_WORLD); - if (rank == 0) { - LOG_INFO("PDCbuf_obj_map_rpc = %lf, wait = %lf\n", max_timings.PDCbuf_obj_map_rpc, - max_timings.PDCbuf_obj_map_rpc_wait); - LOG_INFO("PDCreg_obtain_lock_write_rpc = %lf, wait = %lf\n", max_timings.PDCreg_obtain_lock_write_rpc, - max_timings.PDCreg_obtain_lock_write_rpc_wait); - LOG_INFO("PDCreg_obtain_lock_read_rpc = %lf, wait = %lf\n", max_timings.PDCreg_obtain_lock_read_rpc, - max_timings.PDCreg_obtain_lock_read_rpc_wait); - - LOG_INFO("PDCreg_release_lock_write_rpc = %lf, wait = %lf\n", - max_timings.PDCreg_release_lock_write_rpc, max_timings.PDCreg_release_lock_write_rpc_wait); - LOG_INFO("PDCreg_release_lock_read_rpc = %lf, wait = %lf\n", max_timings.PDCreg_release_lock_read_rpc, - max_timings.PDCreg_release_lock_read_rpc_wait); - LOG_INFO("PDCbuf_obj_unmap_rpc = %lf, wait = %lf\n", max_timings.PDCbuf_obj_unmap_rpc, - max_timings.PDCbuf_obj_unmap_rpc_wait); - - LOG_INFO("PDCtransfer_request_start_write = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_start_write_rpc, - max_timings.PDCtransfer_request_start_write_rpc_wait); - LOG_INFO("PDCtransfer_request_start_read = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_start_read_rpc, - max_timings.PDCtransfer_request_start_read_rpc_wait); - LOG_INFO("PDCtransfer_request_wait_write = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_wait_write_rpc, - max_timings.PDCtransfer_request_wait_write_rpc_wait); - LOG_INFO("PDCtransfer_request_wait_read = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_wait_read_rpc, - max_timings.PDCtransfer_request_wait_read_rpc_wait); - LOG_INFO("PDCtransfer_request_start_all_write = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_start_all_write_rpc, - max_timings.PDCtransfer_request_start_all_write_rpc_wait); - LOG_INFO("PDCtransfer_request_start_all_read = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_start_all_read_rpc, - max_timings.PDCtransfer_request_start_all_read_rpc_wait); - LOG_INFO("PDCtransfer_request_wait_write = %lf, wait = %lf\n", - max_timings.PDCtransfer_request_wait_all_rpc, - max_timings.PDCtransfer_request_wait_all_rpc_wait); - } + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Reduce(timings, max_timings, size, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); - sprintf(filename, "pdc_client_log_rank_%d.csv", rank); - stream = fopen(filename, "r"); - if (stream) { - fclose(stream); - stream = fopen(filename, "a"); - } - else { - stream = fopen(filename, "w"); + if (rank == 0) { + LOG_JUST_PRINT("Total Times:\n"); + for (int i = 0; i < size; i++) + LOG_JUST_PRINT("[%s, %s] %s = %f\n", hostname, prefix, timestamp_strs[i], max_timings[i]); + + LOG_JUST_PRINT("Timestamps:\n"); + for (int i = 0; i < size; i++) { + if (timestamps[i] != NULL && timestamps[i]->timestamp_cur_size > 0) { + LOG_JUST_PRINT("[%s, %s] %s:\n", hostname, prefix, timestamp_strs[i]); + timestamp_log(timestamps[i]); + } + } } + MPI_Barrier(MPI_COMM_WORLD); +} - fprintf(stream, "%s", ctime(&now)); - - sprintf(header, "buf_obj_map_%s", prefix); - timestamp_log(stream, header, pdc_client_buf_obj_map_timestamps); - sprintf(header, "buf_obj_unmap_%s", prefix); - timestamp_log(stream, header, pdc_client_buf_obj_unmap_timestamps); - - sprintf(header, "obtain_lock_write_%s", prefix); - timestamp_log(stream, header, pdc_client_obtain_lock_write_timestamps); - sprintf(header, "obtain_lock_read_%s", prefix); - timestamp_log(stream, header, pdc_client_obtain_lock_read_timestamps); - - sprintf(header, "release_lock_write_%s", prefix); - timestamp_log(stream, header, pdc_client_release_lock_write_timestamps); - sprintf(header, "release_lock_read_%s", prefix); - timestamp_log(stream, header, pdc_client_release_lock_read_timestamps); - - sprintf(header, "transfer_request_start_write_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_start_write_timestamps); - - sprintf(header, "transfer_request_start_read_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_start_read_timestamps); - - sprintf(header, "transfer_request_wait_write_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_wait_write_timestamps); - - sprintf(header, "transfer_request_wait_read_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_wait_read_timestamps); - - sprintf(header, "transfer_request_start_all_write_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_start_all_write_timestamps); - - sprintf(header, "transfer_request_start_all_read_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_start_all_read_timestamps); - - sprintf(header, "transfer_request_wait_all_%s", prefix); - timestamp_log(stream, header, pdc_client_transfer_request_wait_all_timestamps); - - sprintf(header, "create_cont"); - timestamp_log(stream, header, pdc_client_create_cont_timestamps); - - sprintf(header, "create_obj"); - timestamp_log(stream, header, pdc_client_create_obj_timestamps); - - fprintf(stream, "\n"); - fclose(stream); - - pdc_client_buf_obj_map_timestamps->timestamp_size = 0; - pdc_client_buf_obj_unmap_timestamps->timestamp_size = 0; - - pdc_client_obtain_lock_write_timestamps->timestamp_size = 0; - pdc_client_obtain_lock_read_timestamps->timestamp_size = 0; - pdc_client_release_lock_write_timestamps->timestamp_size = 0; - pdc_client_release_lock_read_timestamps->timestamp_size = 0; - - pdc_client_transfer_request_start_write_timestamps->timestamp_size = 0; - pdc_client_transfer_request_start_read_timestamps->timestamp_size = 0; - pdc_client_transfer_request_wait_write_timestamps->timestamp_size = 0; - pdc_client_transfer_request_wait_read_timestamps->timestamp_size = 0; - - pdc_client_transfer_request_start_all_write_timestamps->timestamp_size = 0; - pdc_client_transfer_request_start_all_read_timestamps->timestamp_size = 0; - pdc_client_transfer_request_wait_all_timestamps->timestamp_size = 0; - - pdc_client_create_cont_timestamps->timestamp_size = 0; - pdc_client_create_obj_timestamps->timestamp_size = 0; - - pdc_client_transfer_request_metadata_query_timestamps->timestamp_size = 0; - - memset(&pdc_timings, 0, sizeof(pdc_timings)); +#ifndef IS_PDC_SERVER +double pdc_client_timings_g[PDC_CLIENT_TIMES_SIZE]; +pdc_timestamp *pdc_client_timestamps_g[PDC_CLIENT_TIMES_SIZE]; - return 0; +void +PDC_client_timing_init() +{ + pdc_timing_init(pdc_client_timings_g, pdc_client_timestamps_g, PDC_CLIENT_TIMES_SIZE); } -int -PDC_server_timing_init() +void +PDC_client_timing_finalize() { - char hostname[HOST_NAME_MAX]; - int rank; - - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - gethostname(hostname, HOST_NAME_MAX); - - LOG_INFO("server process rank %d, hostname = %s\n", rank, hostname); - MPI_Barrier(MPI_COMM_WORLD); - - pdc_server_timings = PDC_calloc(1, sizeof(pdc_server_timing)); - pdc_timestamp *ptr = PDC_calloc(25, sizeof(pdc_timestamp)); - pdc_buf_obj_map_timestamps = ptr; - ptr++; - pdc_buf_obj_unmap_timestamps = ptr; - ptr++; - pdc_obtain_lock_write_timestamps = ptr; - ptr++; - pdc_obtain_lock_read_timestamps = ptr; - ptr++; - pdc_release_lock_write_timestamps = ptr; - ptr++; - pdc_release_lock_read_timestamps = ptr; - ptr++; - pdc_release_lock_bulk_transfer_write_timestamps = ptr; - ptr++; - pdc_release_lock_bulk_transfer_read_timestamps = ptr; - ptr++; - pdc_release_lock_bulk_transfer_inner_write_timestamps = ptr; - ptr++; - pdc_release_lock_bulk_transfer_inner_read_timestamps = ptr; - ptr++; - - pdc_transfer_request_start_write_timestamps = ptr; - ptr++; - pdc_transfer_request_start_read_timestamps = ptr; - ptr++; - pdc_transfer_request_wait_write_timestamps = ptr; - ptr++; - pdc_transfer_request_wait_read_timestamps = ptr; - ptr++; - pdc_transfer_request_start_write_bulk_timestamps = ptr; - ptr++; - pdc_transfer_request_start_read_bulk_timestamps = ptr; - ptr++; - pdc_transfer_request_inner_write_bulk_timestamps = ptr; - ptr++; - pdc_transfer_request_inner_read_bulk_timestamps = ptr; - ptr++; + pdc_timing_finalize(pdc_client_timings_g, pdc_client_timestamps_g, PDC_CLIENT_TIMES_SIZE); +} - pdc_transfer_request_start_all_write_timestamps = ptr; - ptr++; - pdc_transfer_request_start_all_read_timestamps = ptr; - ptr++; - pdc_transfer_request_wait_all_timestamps = ptr; - ptr++; - pdc_transfer_request_start_all_write_bulk_timestamps = ptr; - ptr++; - pdc_transfer_request_start_all_read_bulk_timestamps = ptr; - ptr++; - pdc_transfer_request_inner_write_all_bulk_timestamps = ptr; - ptr++; - pdc_transfer_request_inner_read_all_bulk_timestamps = ptr; - ptr++; +void +PDC_client_timing_report(const char *prefix) +{ + pdc_timing_report(pdc_client_timings_g, pdc_client_timestamps_g, PDC_CLIENT_TIMES_SIZE, + pdc_client_timestamps_str, prefix); +} - // 25 timestamps +#else // IS_PDC_SERVER +double pdc_server_timings_g[PDC_SERVER_TIMES_SIZE]; +pdc_timestamp *pdc_server_timestamps_g[PDC_SERVER_TIMES_SIZE]; - pdc_base_time = MPI_Wtime(); - return 0; +void +PDC_server_timing_init() +{ + pdc_timing_init(pdc_server_timings_g, pdc_server_timestamps_g, PDC_SERVER_TIMES_SIZE); } -int -pdc_timestamp_register(pdc_timestamp *timestamp, double start, double end) +void +PDC_server_timing_finalize() { - double *temp; - - if (timestamp->timestamp_max_size == 0) { - timestamp->timestamp_max_size = 256; - timestamp->start = (double *)PDC_malloc(sizeof(double) * timestamp->timestamp_max_size * 2); - timestamp->end = timestamp->start + timestamp->timestamp_max_size; - timestamp->timestamp_size = 0; - } - else if (timestamp->timestamp_size == timestamp->timestamp_max_size) { - temp = (double *)PDC_malloc(sizeof(double) * timestamp->timestamp_max_size * 4); - memcpy(temp, timestamp->start, sizeof(double) * timestamp->timestamp_max_size); - memcpy(temp + timestamp->timestamp_max_size * 2, timestamp->end, - sizeof(double) * timestamp->timestamp_max_size); - timestamp->start = temp; - timestamp->end = temp + timestamp->timestamp_max_size * 2; - timestamp->timestamp_max_size *= 2; - } - timestamp->start[timestamp->timestamp_size] = start; - timestamp->end[timestamp->timestamp_size] = end; - timestamp->timestamp_size++; - return 0; + pdc_timing_finalize(pdc_server_timings_g, pdc_server_timestamps_g, PDC_SERVER_TIMES_SIZE); } -int -PDC_server_timing_report() +void +PDC_server_timing_report(const char *prefix) { - pdc_server_timing max_timings; - int rank; - char filename[256]; - FILE * stream; - - // char hostname[HOST_NAME_MAX]; - time_t now; - - time(&now); - - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - MPI_Reduce(pdc_server_timings, &max_timings, sizeof(pdc_server_timing) / sizeof(double), MPI_DOUBLE, - MPI_MAX, 0, MPI_COMM_WORLD); - sprintf(filename, "pdc_server_log_rank_%d.csv", rank); - - stream = fopen(filename, "w"); - - fprintf(stream, "%s", ctime(&now)); - timestamp_log(stream, "buf_obj_map", pdc_buf_obj_map_timestamps); - timestamp_log(stream, "buf_obj_unmap", pdc_buf_obj_unmap_timestamps); - - timestamp_log(stream, "obtain_lock_write", pdc_obtain_lock_write_timestamps); - timestamp_log(stream, "obtain_lock_read", pdc_obtain_lock_read_timestamps); - timestamp_log(stream, "release_lock_write", pdc_release_lock_write_timestamps); - timestamp_log(stream, "release_lock_read", pdc_release_lock_read_timestamps); - timestamp_log(stream, "release_lock_bulk_transfer_write", - pdc_release_lock_bulk_transfer_write_timestamps); - timestamp_log(stream, "release_lock_bulk_transfer_read", pdc_release_lock_bulk_transfer_read_timestamps); - timestamp_log(stream, "release_lock_bulk_transfer_inner_write", - pdc_release_lock_bulk_transfer_inner_write_timestamps); - timestamp_log(stream, "release_lock_bulk_transfer_inner_read", - pdc_release_lock_bulk_transfer_inner_read_timestamps); - - timestamp_log(stream, "transfer_request_start_write", pdc_transfer_request_start_write_timestamps); - timestamp_log(stream, "transfer_request_wait_write", pdc_transfer_request_wait_write_timestamps); - timestamp_log(stream, "transfer_request_start_write_bulk", - pdc_transfer_request_start_write_bulk_timestamps); - timestamp_log(stream, "transfer_request_inner_write_bulk", - pdc_transfer_request_inner_write_bulk_timestamps); - timestamp_log(stream, "transfer_request_start_read", pdc_transfer_request_start_read_timestamps); - timestamp_log(stream, "transfer_request_wait_read", pdc_transfer_request_wait_read_timestamps); - timestamp_log(stream, "transfer_request_start_read_bulk", - pdc_transfer_request_start_read_bulk_timestamps); - timestamp_log(stream, "transfer_request_inner_read_bulk", - pdc_transfer_request_inner_read_bulk_timestamps); - - timestamp_log(stream, "transfer_request_start_all_write", - pdc_transfer_request_start_all_write_timestamps); - timestamp_log(stream, "transfer_request_start_all_write_bulk", - pdc_transfer_request_start_all_write_bulk_timestamps); - timestamp_log(stream, "transfer_request_start_all_read", pdc_transfer_request_start_all_read_timestamps); - timestamp_log(stream, "transfer_request_start_all_read_bulk", - pdc_transfer_request_start_all_read_bulk_timestamps); - timestamp_log(stream, "transfer_request_inner_write_all_bulk", - pdc_transfer_request_inner_write_all_bulk_timestamps); - timestamp_log(stream, "transfer_request_inner_read_all_bulk", - pdc_transfer_request_inner_read_all_bulk_timestamps); - timestamp_log(stream, "transfer_request_wait_all", pdc_transfer_request_wait_all_timestamps); - - /* timestamp_log(stream, "create_obj", create_obj_timestamps); */ - /* timestamp_log(stream, "create_cont", create_cont_timestamps); */ - fclose(stream); - - sprintf(filename, "pdc_server_timings_%d.csv", rank); - stream = fopen(filename, "w"); - fprintf(stream, "%s", ctime(&now)); - fprintf(stream, "PDCbuf_obj_map_rpc, %lf\n", pdc_server_timings->PDCbuf_obj_map_rpc); - fprintf(stream, "PDCreg_obtain_lock_write_rpc, %lf\n", pdc_server_timings->PDCreg_obtain_lock_write_rpc); - fprintf(stream, "PDCreg_obtain_lock_read_rpc, %lf\n", pdc_server_timings->PDCreg_obtain_lock_read_rpc); - fprintf(stream, "PDCreg_release_lock_write_rpc, %lf\n", - pdc_server_timings->PDCreg_release_lock_write_rpc); - fprintf(stream, "PDCreg_release_lock_read_rpc, %lf\n", pdc_server_timings->PDCreg_release_lock_read_rpc); - fprintf(stream, "PDCbuf_obj_unmap_rpc, %lf\n", pdc_server_timings->PDCbuf_obj_unmap_rpc); - fprintf(stream, "PDCreg_release_lock_bulk_transfer_write_rpc, %lf\n", - pdc_server_timings->PDCreg_release_lock_bulk_transfer_write_rpc); - fprintf(stream, "PDCreg_release_lock_bulk_transfer_read_rpc, %lf\n", - pdc_server_timings->PDCreg_release_lock_bulk_transfer_read_rpc); - fprintf(stream, "PDCreg_release_lock_bulk_transfer_inner_write_rpc, %lf\n", - pdc_server_timings->PDCreg_release_lock_bulk_transfer_inner_write_rpc); - fprintf(stream, "PDCreg_release_lock_bulk_transfer_inner_read_rpc, %lf\n", - pdc_server_timings->PDCreg_release_lock_bulk_transfer_inner_read_rpc); - fprintf(stream, "PDCregion_transfer_start_write_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_start_write_rpc); - fprintf(stream, "PDCregion_transfer_wait_write_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_wait_write_rpc); - fprintf(stream, "PDCregion_transfer_start_write_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_start_write_bulk_rpc); - fprintf(stream, "PDCregion_transfer_request_inner_write_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_inner_write_bulk_rpc); - fprintf(stream, "PDCregion_transfer_start_read_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_start_read_rpc); - fprintf(stream, "PDCregion_transfer_wait_read_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_wait_read_rpc); - fprintf(stream, "PDCregion_transfer_start_read_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_start_read_bulk_rpc); - fprintf(stream, "PDCregion_transfer_request_inner_read_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_inner_read_bulk_rpc); - - fprintf(stream, "PDCregion_transfer_start_write_all_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_start_all_write_rpc); - fprintf(stream, "PDCregion_transfer_request_inner_write_all_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_inner_write_all_bulk_rpc); - fprintf(stream, "PDCregion_transfer_start_all_read_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_start_all_read_rpc); - fprintf(stream, "PDCregion_transfer_request_inner_read_all_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_inner_read_all_bulk_rpc); - fprintf(stream, "PDCregion_transfer_wait_all_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_wait_all_rpc); - fprintf(stream, "PDCregion_transfer_wait_all_bulk_rpc, %lf\n", - pdc_server_timings->PDCreg_transfer_request_wait_all_bulk_rpc); - - fprintf(stream, "PDCserver_obj_create_rpc, %lf\n", pdc_server_timings->PDCserver_obj_create_rpc); - fprintf(stream, "PDCserver_cont_create_rpc, %lf\n", pdc_server_timings->PDCserver_cont_create_rpc); - - fprintf(stream, "PDCdata_server_write_out, %lf\n", pdc_server_timings->PDCdata_server_write_out); - fprintf(stream, "PDCdata_server_read_from, %lf\n", pdc_server_timings->PDCdata_server_read_from); - fprintf(stream, "PDCcache_write, %lf\n", pdc_server_timings->PDCcache_write); - fprintf(stream, "PDCcache_read, %lf\n", pdc_server_timings->PDCcache_read); - fprintf(stream, "PDCcache_flush, %lf\n", pdc_server_timings->PDCcache_flush); - fprintf(stream, "PDCcache_clean, %lf\n", pdc_server_timings->PDCcache_clean); - fprintf(stream, "PDCdata_server_write_posix, %lf\n", pdc_server_timings->PDCdata_server_write_posix); - fprintf(stream, "PDCdata_server_read_posix, %lf\n", pdc_server_timings->PDCdata_server_read_posix); - - fprintf(stream, "PDCserver_restart, %lf\n", pdc_server_timings->PDCserver_restart); - fprintf(stream, "PDCserver_checkpoint, %lf\n", pdc_server_timings->PDCserver_checkpoint); - fprintf(stream, "PDCstart_server_total, %lf\n", pdc_server_timings->PDCserver_start_total); - - fclose(stream); - - pdc_server_timings = (pdc_server_timing *)PDC_free(pdc_server_timings); - pdc_timestamp_clean(pdc_buf_obj_map_timestamps); - pdc_timestamp_clean(pdc_buf_obj_unmap_timestamps); - - pdc_timestamp_clean(pdc_obtain_lock_write_timestamps); - pdc_timestamp_clean(pdc_obtain_lock_read_timestamps); - pdc_timestamp_clean(pdc_release_lock_write_timestamps); - pdc_timestamp_clean(pdc_release_lock_read_timestamps); - pdc_timestamp_clean(pdc_release_lock_bulk_transfer_write_timestamps); - pdc_timestamp_clean(pdc_release_lock_bulk_transfer_read_timestamps); - pdc_timestamp_clean(pdc_release_lock_bulk_transfer_inner_write_timestamps); - pdc_timestamp_clean(pdc_release_lock_bulk_transfer_inner_read_timestamps); - - pdc_timestamp_clean(pdc_transfer_request_start_write_timestamps); - pdc_timestamp_clean(pdc_transfer_request_start_read_timestamps); - pdc_timestamp_clean(pdc_transfer_request_wait_write_timestamps); - pdc_timestamp_clean(pdc_transfer_request_wait_read_timestamps); - pdc_timestamp_clean(pdc_transfer_request_start_write_bulk_timestamps); - pdc_timestamp_clean(pdc_transfer_request_start_read_bulk_timestamps); - pdc_timestamp_clean(pdc_transfer_request_inner_write_bulk_timestamps); - pdc_timestamp_clean(pdc_transfer_request_inner_read_bulk_timestamps); - - pdc_timestamp_clean(pdc_transfer_request_start_all_write_timestamps); - pdc_timestamp_clean(pdc_transfer_request_start_all_read_timestamps); - pdc_timestamp_clean(pdc_transfer_request_start_all_write_bulk_timestamps); - pdc_timestamp_clean(pdc_transfer_request_start_all_read_bulk_timestamps); - pdc_timestamp_clean(pdc_transfer_request_wait_all_timestamps); - pdc_timestamp_clean(pdc_transfer_request_inner_write_all_bulk_timestamps); - pdc_timestamp_clean(pdc_transfer_request_inner_read_all_bulk_timestamps); - - /* pdc_timestamp_clean(pdc_create_obj_timestamps); */ - /* pdc_timestamp_clean(pdc_create_cont_timestamps); */ - - pdc_buf_obj_map_timestamps = (pdc_timestamp *)PDC_free(pdc_buf_obj_map_timestamps); - return 0; + pdc_timing_report(pdc_server_timings_g, pdc_server_timestamps_g, PDC_SERVER_TIMES_SIZE, + pdc_server_timestamps_str, prefix); } - -#else +#endif // IS_PDC_SERVER int PDC_timing_report(const char *prefix __attribute__((unused))) { diff --git a/src/server/pdc_client_server_common.c b/src/server/pdc_client_server_common.c index 509c36687..a48267e90 100644 --- a/src/server/pdc_client_server_common.c +++ b/src/server/pdc_client_server_common.c @@ -1571,7 +1571,7 @@ HG_TEST_RPC_CB(metadata_query, handle) hg_return_t ret_value = HG_SUCCESS; metadata_query_in_t in; metadata_query_out_t out; - pdc_metadata_t * query_result = NULL; + pdc_metadata_t *query_result = NULL; FUNC_ENTER(NULL); @@ -1612,7 +1612,7 @@ HG_TEST_RPC_CB(obj_reset_dims, handle) hg_return_t ret_value = HG_SUCCESS; obj_reset_dims_in_t in; obj_reset_dims_out_t out; - pdc_metadata_t * query_result = NULL; + pdc_metadata_t *query_result = NULL; FUNC_ENTER(NULL); @@ -2000,7 +2000,7 @@ pdc_region_write_out_progress(void *arg) { HG_THREAD_RETURN_TYPE ret_value = (HG_THREAD_RETURN_TYPE)0; struct buf_map_release_bulk_args *bulk_args = (struct buf_map_release_bulk_args *)arg; - struct pdc_region_info * remote_reg_info = NULL; + struct pdc_region_info *remote_reg_info = NULL; region_lock_out_t out; FUNC_ENTER(NULL); @@ -2100,7 +2100,7 @@ pdc_region_read_from_progress(void *arg) { HG_THREAD_RETURN_TYPE ret_value = (HG_THREAD_RETURN_TYPE)0; struct buf_map_release_bulk_args *bulk_args = (struct buf_map_release_bulk_args *)arg; - const struct hg_info * hg_info = NULL; + const struct hg_info *hg_info = NULL; hg_return_t hg_ret; size_t size; int error = 0; @@ -2153,21 +2153,21 @@ transform_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_inf hg_return_t ret_value = HG_SUCCESS; region_lock_out_t out; struct buf_map_transform_and_release_bulk_args *bulk_args = NULL; - void * data_buf; - char * buf; + void *data_buf; + char *buf; int ndim; int transform_id; int type_extent = 0; int use_transform_size = 0; size_t unit = 1; int64_t transform_size, expected_size; - uint64_t * dims = NULL; + uint64_t *dims = NULL; pdc_var_type_t destType; - struct _pdc_region_transform_ftn_info ** registry = NULL; + struct _pdc_region_transform_ftn_info **registry = NULL; int registered_count; #ifdef ENABLE_MULTITHREAD data_server_region_t *target_reg = NULL; - region_buf_map_t * elt; + region_buf_map_t *elt; #else struct pdc_region_info *remote_reg_info = NULL; #endif @@ -2338,12 +2338,12 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info hg_return_t ret_value = HG_SUCCESS; region_lock_out_t out; struct buf_map_analysis_and_release_bulk_args *bulk_args = NULL; - void * data_buf; + void *data_buf; int ndim; uint64_t type_extent; - uint64_t * dims = NULL; - struct pdc_region_info * remote_reg_info = NULL; - struct pdc_region_info * local_reg_info = NULL; + uint64_t *dims = NULL; + struct pdc_region_info *remote_reg_info = NULL; + struct pdc_region_info *local_reg_info = NULL; double start_t, end_t, analysis_t, io_t; double averages[4]; @@ -2396,7 +2396,7 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info int registered_count = PDC_get_analysis_registry(®istry); if ((registered_count >= analysis_meta_index) && (registry != NULL)) { - int (*analysis_ftn)(pdcid_t iterIn, pdcid_t iterOut, struct _pdc_iterator_cbs_t * _cbs) = + int (*analysis_ftn)(pdcid_t iterIn, pdcid_t iterOut, struct _pdc_iterator_cbs_t *_cbs) = registry[analysis_meta_index]->ftnPtr; int result = analysis_ftn(bulk_args->in.input_iter, bulk_args->in.output_iter, &iter_cbs); LOG_INFO("==PDC_SERVER: Analysis returned %d\n", result); @@ -2495,7 +2495,7 @@ buf_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) struct buf_map_release_bulk_args *bulk_args = NULL; #ifdef ENABLE_MULTITHREAD data_server_region_t *target_reg = NULL; - region_buf_map_t * elt; + region_buf_map_t *elt; #else struct pdc_region_info *remote_reg_info = NULL; #endif @@ -2507,7 +2507,7 @@ buf_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) end = MPI_Wtime(); pdc_server_timings->PDCreg_release_lock_bulk_transfer_write_rpc += end - bulk_args->start_time; - pdc_timestamp_register(pdc_release_lock_bulk_transfer_write_timestamps, bulk_args->start_time, end); + pdc_timestamp_register(&pdc_release_lock_bulk_transfer_write_timestamps, bulk_args->start_time, end); start = MPI_Wtime(); #endif @@ -2569,7 +2569,7 @@ buf_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) #ifdef PDC_TIMING end = MPI_Wtime(); pdc_server_timings->PDCreg_release_lock_bulk_transfer_inner_write_rpc += end - start; - pdc_timestamp_register(pdc_release_lock_bulk_transfer_inner_write_timestamps, start, end); + pdc_timestamp_register(&pdc_release_lock_bulk_transfer_inner_write_timestamps, start, end); #endif done: @@ -2606,7 +2606,7 @@ obj_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) end = MPI_Wtime(); pdc_server_timings->PDCreg_release_lock_bulk_transfer_read_rpc += end - bulk_args->start_time; - pdc_timestamp_register(pdc_release_lock_bulk_transfer_read_timestamps, bulk_args->start_time, end); + pdc_timestamp_register(&pdc_release_lock_bulk_transfer_read_timestamps, bulk_args->start_time, end); start = MPI_Wtime(); #endif @@ -2627,7 +2627,7 @@ obj_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) #ifdef PDC_TIMING end = MPI_Wtime(); pdc_server_timings->PDCreg_release_lock_bulk_transfer_inner_read_rpc += end - start; - pdc_timestamp_register(pdc_release_lock_bulk_transfer_inner_read_timestamps, start, end); + pdc_timestamp_register(&pdc_release_lock_bulk_transfer_inner_read_timestamps, start, end); #endif done: @@ -2681,23 +2681,23 @@ HG_TEST_RPC_CB(region_release, handle) hg_return_t hg_ret; region_lock_in_t in; region_lock_out_t out; - const struct hg_info * hg_info = NULL; - data_server_region_t * target_obj; + const struct hg_info *hg_info = NULL; + data_server_region_t *target_obj; int error = 0; int dirty_reg = 0; hg_size_t size, size2; - void * data_buf; - struct pdc_region_info * server_region; - region_list_t * elt, *request_region, *tmp, *elt_tmp; + void *data_buf; + struct pdc_region_info *server_region; + region_list_t *elt, *request_region, *tmp, *elt_tmp; struct region_lock_update_bulk_args *lock_update_bulk_args = NULL; - struct buf_map_release_bulk_args * buf_map_bulk_args = NULL, *obj_map_bulk_args = NULL; + struct buf_map_release_bulk_args *buf_map_bulk_args = NULL, *obj_map_bulk_args = NULL; hg_bulk_t lock_local_bulk_handle = HG_BULK_NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - struct pdc_region_info * remote_reg_info; - region_buf_map_t * eltt, *eltt2, *eltt_tmp; + struct pdc_region_info *remote_reg_info; + region_buf_map_t *eltt, *eltt2, *eltt_tmp; hg_uint32_t /*k, m, */ remote_count; - void ** data_ptrs_to = NULL; - size_t * data_size_to = NULL; + void **data_ptrs_to = NULL; + size_t *data_size_to = NULL; // size_t type_size = 0; // size_t dims[4] = {0, 0, 0, 0}; #ifdef PDC_TIMING @@ -3004,11 +3004,11 @@ HG_TEST_RPC_CB(region_release, handle) end = MPI_Wtime(); if (in.access_type == PDC_READ) { pdc_server_timings->PDCreg_release_lock_read_rpc += end - start; - pdc_timestamp_register(pdc_release_lock_read_timestamps, start, end); + pdc_timestamp_register(&pdc_release_lock_read_timestamps, start, end); } else { pdc_server_timings->PDCreg_release_lock_write_rpc += end - start; - pdc_timestamp_register(pdc_release_lock_write_timestamps, start, end); + pdc_timestamp_register(&pdc_release_lock_write_timestamps, start, end); } #endif @@ -3039,10 +3039,10 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha const struct hg_info *hg_info = NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; hg_uint32_t remote_count; - void * data_buf = NULL; + void *data_buf = NULL; ; - void ** data_ptrs_to = NULL; - size_t * data_size_to = NULL; + void **data_ptrs_to = NULL; + size_t *data_size_to = NULL; region_buf_map_t *eltt2; region_lock_out_t out; @@ -3051,8 +3051,8 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha int dirty_reg = 0; struct buf_map_transform_and_release_bulk_args *transform_release_bulk_args = NULL; - struct pdc_region_info * remote_reg_info = NULL; - data_server_region_t * target_obj = NULL; + struct pdc_region_info *remote_reg_info = NULL; + data_server_region_t *target_obj = NULL; region_list_t *tmp, *elt, *request_region = (region_list_t *)PDC_malloc(sizeof(region_list_t)); FUNC_ENTER(NULL); @@ -3205,19 +3205,19 @@ HG_TEST_RPC_CB(transform_region_release, handle) region_transform_and_lock_in_t in; region_lock_in_t reg_lock_in; region_lock_out_t out; - const struct hg_info * hg_info = NULL; - data_server_region_t * target_obj; + const struct hg_info *hg_info = NULL; + data_server_region_t *target_obj; int error = 0; int dirty_reg = 0; hg_size_t size; - void * data_buf; - region_list_t * elt, *request_region, *tmp; + void *data_buf; + region_list_t *elt, *request_region, *tmp; struct buf_map_transform_and_release_bulk_args *buf_map_bulk_args = NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - region_buf_map_t * eltt; + region_buf_map_t *eltt; hg_uint32_t remote_count; - void ** data_ptrs_to = NULL; - size_t * data_size_to = NULL; + void **data_ptrs_to = NULL; + size_t *data_size_to = NULL; FUNC_ENTER(NULL); @@ -3353,14 +3353,14 @@ HG_TEST_RPC_CB(region_transform_release, handle) int dirty_reg = 0; hg_size_t size, remote_size; ; - void * data_buf; - region_list_t * elt, *request_region, *tmp; + void *data_buf; + region_list_t *elt, *request_region, *tmp; struct buf_map_release_bulk_args *buf_map_bulk_args = NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - region_buf_map_t * eltt; + region_buf_map_t *eltt; hg_uint32_t k, remote_count = 0; - void ** data_ptrs_to = NULL; - size_t * data_size_to = NULL; + void **data_ptrs_to = NULL; + size_t *data_size_to = NULL; size_t type_size = 0; ; size_t dims[4] = {0, 0, 0, 0}; @@ -3512,26 +3512,26 @@ HG_TEST_RPC_CB(region_analysis_release, handle) } in; region_lock_out_t out; - const struct hg_info * hg_info = NULL; - data_server_region_t * target_obj; - data_server_region_t * lock_obj; + const struct hg_info *hg_info = NULL; + data_server_region_t *target_obj; + data_server_region_t *lock_obj; int error = 0; int dirty_reg = 0; hg_size_t size; hg_return_t hg_ret; - void * data_buf; - struct pdc_region_info * server_region; - region_list_t * elt, *request_region, *tmp; - struct region_lock_update_bulk_args * lock_update_bulk_args = NULL; + void *data_buf; + struct pdc_region_info *server_region; + region_list_t *elt, *request_region, *tmp; + struct region_lock_update_bulk_args *lock_update_bulk_args = NULL; struct buf_map_analysis_and_release_bulk_args *buf_map_bulk_args = NULL, *obj_map_bulk_args = NULL; hg_bulk_t lock_local_bulk_handle = HG_BULK_NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - struct pdc_region_info * remote_reg_info; - region_buf_map_t * eltt, *eltt2; + struct pdc_region_info *remote_reg_info; + region_buf_map_t *eltt, *eltt2; hg_uint32_t k, remote_count = 0; - void ** data_ptrs_to = NULL; - size_t * data_size_to = NULL; + void **data_ptrs_to = NULL; + size_t *data_size_to = NULL; size_t type_size = 0; size_t dims[4] = {0, 0, 0, 0}; @@ -3897,11 +3897,11 @@ HG_TEST_RPC_CB(region_lock, handle) if (in.access_type == PDC_READ) { pdc_server_timings->PDCreg_obtain_lock_read_rpc += end - start; - pdc_timestamp_register(pdc_obtain_lock_read_timestamps, start, end); + pdc_timestamp_register(&pdc_obtain_lock_read_timestamps, start, end); } else { pdc_server_timings->PDCreg_obtain_lock_write_rpc += end - start; - pdc_timestamp_register(pdc_obtain_lock_write_timestamps, start, end); + pdc_timestamp_register(&pdc_obtain_lock_write_timestamps, start, end); } #endif FUNC_LEAVE(ret_value); @@ -3916,14 +3916,12 @@ HG_TEST_RPC_CB(buf_unmap, handle) buf_unmap_in_t in; buf_unmap_out_t out; const struct hg_info *info; -#ifdef PDC_TIMING - double start, end; -#endif + PDC_TIMING_DECLARE(PDC_SERVER_BUF_OBJ_UNMAP_RPC_TIME); FUNC_ENTER(NULL); -#ifdef PDC_TIMING - start = MPI_Wtime(); -#endif + + PDC_TIMING_START(PDC_SERVER_BUF_OBJ_UNMAP_RPC_TIME); + // Decode input HG_Get_input(handle, &in); info = HG_Get_info(handle); @@ -3955,7 +3953,7 @@ HG_TEST_RPC_CB(buf_unmap, handle) #ifdef PDC_TIMING end = MPI_Wtime(); pdc_server_timings->PDCbuf_obj_unmap_rpc += end - start; - pdc_timestamp_register(pdc_buf_obj_unmap_timestamps, start, end); + pdc_timestamp_register(&pdc_buf_obj_unmap_timestamps, start, end); #endif FUNC_LEAVE(ret_value); } @@ -3967,7 +3965,7 @@ HG_TEST_RPC_CB(get_remote_metadata, handle) hg_return_t ret_value = HG_SUCCESS; get_remote_metadata_in_t in; get_remote_metadata_out_t out; - pdc_metadata_t * meta; + pdc_metadata_t *meta; FUNC_ENTER(NULL); @@ -4002,7 +4000,7 @@ HG_TEST_RPC_CB(buf_unmap_server, handle) hg_return_t ret_value = HG_SUCCESS; buf_unmap_in_t in; buf_unmap_out_t out; - pdc_metadata_t * target_obj; + pdc_metadata_t *target_obj; region_buf_map_t *tmp, *elt; FUNC_ENTER(NULL); @@ -4051,8 +4049,8 @@ HG_TEST_RPC_CB(buf_map_server, handle) hg_return_t ret_value = HG_SUCCESS; buf_map_in_t in; buf_map_out_t out; - pdc_metadata_t * target_obj; - region_list_t * elt, *request_region; + pdc_metadata_t *target_obj; + region_list_t *elt, *request_region; region_buf_map_t *buf_map_ptr; FUNC_ENTER(NULL); @@ -4116,13 +4114,11 @@ HG_TEST_RPC_CB(buf_map, handle) buf_map_in_t in; buf_map_out_t out; const struct hg_info *info; - region_list_t * request_region; - region_buf_map_t * new_buf_map_ptr = NULL; - void * data_ptr; + region_list_t *request_region; + region_buf_map_t *new_buf_map_ptr = NULL; + void *data_ptr; size_t ndim; -#ifdef PDC_TIMING - double start, end; -#endif + PDC_TIMING_DECLARE(PDC_SERVER_BUF_OBJ_MAP_RPC_TIME); FUNC_ENTER(NULL); @@ -4163,11 +4159,8 @@ HG_TEST_RPC_CB(buf_map, handle) if (ret != SUCCEED) PGOTO_ERROR(HG_OTHER_ERROR, "===PDC Data Server: PDC_Meta_Server_buf_map() failed"); } -#ifdef PDC_TIMING - end = MPI_Wtime(); - pdc_server_timings->PDCbuf_obj_map_rpc += end - start; - pdc_timestamp_register(pdc_buf_obj_map_timestamps, start, end); -#endif + + PDC_TIMING_END(PDC_SERVER_BUF_OBJ_MAP_RPC_TIME); done: fflush(stdout); FUNC_LEAVE(ret_value); @@ -4183,9 +4176,9 @@ HG_TEST_RPC_CB(query_partial, handle) hg_return_t hg_ret; hg_bulk_t bulk_handle = HG_BULK_NULL; uint32_t i; - void ** buf_ptrs; - size_t * buf_sizes; - uint32_t * n_meta_ptr, n_buf; + void **buf_ptrs; + size_t *buf_sizes; + uint32_t *n_meta_ptr, n_buf; metadata_query_transfer_in_t in; metadata_query_transfer_out_t out; @@ -4278,7 +4271,7 @@ HG_TEST_RPC_CB(query_kvtag, handle) hg_return_t ret_value; hg_return_t hg_ret; hg_bulk_t bulk_handle = HG_BULK_NULL; - uint64_t * buf_ptr; + uint64_t *buf_ptr; size_t buf_size[1]; uint32_t nmeta; pdc_kvtag_t in; @@ -4339,10 +4332,10 @@ update_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int cnt, i; - uint64_t * obj_id_ptr; + uint64_t *obj_id_ptr; pdc_int_ret_t out_struct; - void ** buf; - void * buf_1d; + void **buf; + void *buf_1d; FUNC_ENTER(NULL); @@ -4396,7 +4389,7 @@ HG_TEST_RPC_CB(bulk_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t * bulk_args = NULL; + struct bulk_args_t *bulk_args = NULL; bulk_rpc_in_t in_struct; int cnt; @@ -4544,7 +4537,7 @@ HG_TEST_RPC_CB(data_server_read_check, handle) // Decode input data_server_read_check_in_t in; data_server_read_check_out_t out; - server_read_check_out_t * read_out = PDC_calloc(1, sizeof(server_read_check_out_t)); + server_read_check_out_t *read_out = PDC_calloc(1, sizeof(server_read_check_out_t)); FUNC_ENTER(NULL); @@ -4646,7 +4639,7 @@ HG_TEST_RPC_CB(get_metadata_by_id, handle) hg_return_t ret_value = HG_SUCCESS; get_metadata_by_id_in_t in; get_metadata_by_id_out_t out; - pdc_metadata_t * target = NULL; + pdc_metadata_t *target = NULL; FUNC_ENTER(NULL); @@ -4752,8 +4745,8 @@ char * PDC_find_in_path(char *workingDir, char *application) { struct stat fileStat; - char * ret_value = NULL; - char * pathVar = getenv("PATH"); + char *ret_value = NULL; + char *pathVar = getenv("PATH"); char colon = ':'; char checkPath[PATH_MAX]; @@ -4808,11 +4801,11 @@ cont_add_del_objs_bulk_cb(const struct hg_cb_info *hg_cb_info) { hg_return_t ret_value = HG_SUCCESS; // Server executes after received request from client - struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int cnt, op; cont_add_del_objs_rpc_out_t out_struct; - uint64_t * obj_ids, cont_id; + uint64_t *obj_ids, cont_id; FUNC_ENTER(NULL); @@ -4863,8 +4856,8 @@ cont_add_del_objs_bulk_cb(const struct hg_cb_info *hg_cb_info) HG_TEST_RPC_CB(cont_add_del_objs_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; - const struct hg_info * hg_info = NULL; - struct bulk_args_t * bulk_args = NULL; + const struct hg_info *hg_info = NULL; + struct bulk_args_t *bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; cont_add_del_objs_rpc_in_t in_struct; @@ -4944,13 +4937,13 @@ query_read_obj_name_bulk_cb(const struct hg_cb_info *hg_cb_info) hg_return_t ret_value = HG_SUCCESS; hg_return_t ret = HG_SUCCESS; // Server executes after received request from client - struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int iter; size_t i; - char * tmp_buf; + char *tmp_buf; query_read_obj_name_out_t out_struct; - query_read_names_args_t * query_read_names_args; + query_read_names_args_t *query_read_names_args; FUNC_ENTER(NULL); @@ -5006,8 +4999,8 @@ HG_TEST_RPC_CB(query_read_obj_name_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; hg_return_t ret = HG_SUCCESS; - const struct hg_info * hg_info = NULL; - struct bulk_args_t * bulk_args = NULL; + const struct hg_info *hg_info = NULL; + struct bulk_args_t *bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; query_read_obj_name_in_t in_struct; @@ -5115,13 +5108,13 @@ get_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int i, task_id, n_regions; - int * int_ptr; - char * char_ptr, *file_path; - uint64_t * uint64_ptr, offset; + int *int_ptr; + char *char_ptr, *file_path; + uint64_t *uint64_ptr, offset; - void * buf; + void *buf; region_info_transfer_t *region_info_ptr; - region_list_t * region_list, *region_list_head = NULL; + region_list_t *region_list, *region_list_head = NULL; pdc_int_ret_t out_struct; FUNC_ENTER(NULL); @@ -5191,7 +5184,7 @@ HG_TEST_RPC_CB(get_storage_meta_name_query_bulk_result_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; const struct hg_info *hg_info = NULL; - struct bulk_args_t * bulk_args = NULL; + struct bulk_args_t *bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; bulk_rpc_in_t in_struct; @@ -5244,8 +5237,8 @@ notify_client_multi_io_complete_bulk_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int n_shm; - void * buf; - char * buf_cp; + void *buf; + char *buf_cp; pdc_int_ret_t out_struct; FUNC_ENTER(NULL); @@ -5288,7 +5281,7 @@ HG_TEST_RPC_CB(notify_client_multi_io_complete_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; const struct hg_info *hg_info = NULL; - struct bulk_args_t * bulk_args = NULL; + struct bulk_args_t *bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; bulk_rpc_in_t in_struct; @@ -5331,7 +5324,7 @@ PDC_add_task_to_list(pdc_task_list_t **target_list, perr_t (*cb)(), void *cb_arg #ifdef ENABLE_MULTITHREAD void *_mutex) #else - void *_mutex ATTRIBUTE(unused)) + void *_mutex ATTRIBUTE(unused)) #endif { int ret_value = 0; @@ -5375,7 +5368,7 @@ PDC_del_task_from_list(pdc_task_list_t **target_list, pdc_task_list_t *del, #ifdef ENABLE_MULTITHREAD void *_mutex) #else - void *_mutex ATTRIBUTE(unused)) + void *_mutex ATTRIBUTE(unused)) #endif { perr_t ret_value = SUCCEED; @@ -5559,13 +5552,13 @@ query_read_obj_name_client_bulk_cb(const struct hg_cb_info *hg_cb_info) { hg_return_t ret_value = HG_SUCCESS; // Server executes after received request from client - struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int iter; size_t i; - char * tmp_buf; + char *tmp_buf; query_read_obj_name_out_t out_struct; - query_read_names_args_t * query_read_names_args; + query_read_names_args_t *query_read_names_args; FUNC_ENTER(NULL); @@ -5621,8 +5614,8 @@ query_read_obj_name_client_bulk_cb(const struct hg_cb_info *hg_cb_info) HG_TEST_RPC_CB(query_read_obj_name_client_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; - const struct hg_info * hg_info = NULL; - struct bulk_args_t * bulk_args = NULL; + const struct hg_info *hg_info = NULL; + struct bulk_args_t *bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; query_read_obj_name_in_t in_struct; @@ -5672,9 +5665,9 @@ static hg_return_t send_client_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) { hg_return_t ret_value = HG_SUCCESS; - struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; - void * buf = NULL, *buf_cp = NULL; + void *buf = NULL, *buf_cp = NULL; process_bulk_storage_meta_args_t *process_args = NULL; FUNC_ENTER(NULL); @@ -5719,7 +5712,7 @@ HG_TEST_RPC_CB(send_client_storage_meta_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t * bulk_args = NULL; + struct bulk_args_t *bulk_args = NULL; bulk_rpc_in_t in_struct; pdc_int_ret_t out_struct; int cnt; @@ -5779,7 +5772,7 @@ server_recv_shm_bulk_cb(const struct hg_cb_info *hg_cb_info) hg_return_t ret_value = HG_SUCCESS; struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; - void * buf = NULL, *buf_cp = NULL; + void *buf = NULL, *buf_cp = NULL; FUNC_ENTER(NULL); @@ -5816,7 +5809,7 @@ HG_TEST_RPC_CB(send_shm_bulk_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t * bulk_args = NULL; + struct bulk_args_t *bulk_args = NULL; bulk_rpc_in_t in_struct; pdc_int_ret_t out_struct; int cnt; @@ -5984,7 +5977,7 @@ HG_TEST_RPC_CB(send_bulk_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t * bulk_arg = NULL; + struct bulk_args_t *bulk_arg = NULL; bulk_rpc_in_t in_struct; hg_return_t (*func_ptr)(const struct hg_cb_info *hg_cb_info); struct hg_cb_info callback_info; @@ -6083,10 +6076,10 @@ HG_TEST_RPC_CB(dart_perform_one_server, handle) dart_perform_one_server_out_t out; hg_bulk_t bulk_handle = HG_BULK_NULL; - uint64_t * n_obj_ids_ptr; + uint64_t *n_obj_ids_ptr; uint64_t n_buf; uint64_t **buf_ptrs; - size_t * buf_sizes; + size_t *buf_sizes; uint32_t i; FUNC_ENTER(NULL); diff --git a/src/server/pdc_server.c b/src/server/pdc_server.c index 710bc514d..34c145007 100644 --- a/src/server/pdc_server.c +++ b/src/server/pdc_server.c @@ -83,7 +83,7 @@ sqlite3 *sqlite3_db_g; int is_debug_g = 0; int pdc_client_num_g = 0; -hg_class_t * hg_class_g = NULL; +hg_class_t *hg_class_g = NULL; hg_context_t *hg_context_g = NULL; // Below three are guarded by pdc_server_task_mutex_g for multi-thread @@ -91,10 +91,10 @@ pdc_task_list_t *pdc_server_agg_task_head_g = NULL; pdc_task_list_t *pdc_server_s2s_task_head_g = NULL; int pdc_server_task_id_g = PDC_SERVER_TASK_INIT_VALUE; -pdc_client_info_t * pdc_client_info_g = NULL; +pdc_client_info_t *pdc_client_info_g = NULL; pdc_remote_server_info_t *pdc_remote_server_info_g = NULL; -char * all_addr_strings_1d_g = NULL; -char ** all_addr_strings_g = NULL; +char *all_addr_strings_1d_g = NULL; +char **all_addr_strings_g = NULL; int is_hash_table_init_g = 0; int lustre_stripe_size_mb_g = 16; int lustre_total_ost_g = 0; @@ -147,7 +147,7 @@ int gen_fastbit_idx_g = 0; int use_fastbit_idx_g = 0; int use_rocksdb_g = 0; int use_sqlite3_g = 0; -char * gBinningOption = NULL; +char *gBinningOption = NULL; double server_write_time_g = 0.0; double server_read_time_g = 0.0; @@ -165,9 +165,9 @@ volatile int dbg_sleep_g = 1; double total_mem_usage_g = 0.0; // Data server related -pdc_data_server_io_list_t * pdc_data_server_read_list_head_g = NULL; -pdc_data_server_io_list_t * pdc_data_server_write_list_head_g = NULL; -update_storage_meta_list_t * pdc_update_storage_meta_list_head_g = NULL; +pdc_data_server_io_list_t *pdc_data_server_read_list_head_g = NULL; +pdc_data_server_io_list_t *pdc_data_server_write_list_head_g = NULL; +update_storage_meta_list_t *pdc_update_storage_meta_list_head_g = NULL; extern data_server_region_t *dataserver_region_g; /* @@ -379,7 +379,7 @@ static int remove_directory(const char *dir) { int ret = 0; - FTS * ftsp = NULL; + FTS *ftsp = NULL; FTSENT *curr; // Cast needed (in C) because fts_open() takes a "char * const *", instead @@ -543,7 +543,7 @@ PDC_Server_lookup_server_id(int remote_server_id) lookup_args->server_id = remote_server_id; hg_ret = HG_Addr_lookup(hg_context_g, lookup_remote_server_cb, lookup_args, - pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); + pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { LOG_ERROR("==PDC_SERVER: Connection to remote server FAILED!\n"); ret_value = FAIL; @@ -663,7 +663,7 @@ PDC_Server_lookup_client(uint32_t client_id) // Lookup and fill the client info server_lookup_args_t lookup_args; - char * target_addr_string; + char *target_addr_string; lookup_args.server_id = pdc_server_rank_g; lookup_args.client_id = client_id; @@ -720,13 +720,13 @@ PDC_Server_set_close(void) #endif #ifdef PDC_ENABLE_CHECKPOINT -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start = MPI_Wtime(); #endif if (pdc_disable_checkpoint_g == 0) PDC_Server_checkpoint(); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCserver_checkpoint += MPI_Wtime() - start; #endif #endif @@ -784,7 +784,7 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) int i = 0; char self_addr_string[ADDR_MAX]; char na_info_string[NA_STRING_INFO_LEN]; - char * hostname; + char *hostname; pbool_t free_hostname = false; struct hg_init_info init_info = {0}; @@ -800,7 +800,7 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) uint32_t credential = 0, cookie; drc_info_handle_t credential_info; char pdc_auth_key[256] = {'\0'}; - char * auth_key; + char *auth_key; int rc; #endif @@ -1059,7 +1059,7 @@ perr_t PDC_Server_finalize() { pdc_data_server_io_list_t *io_elt = NULL; - region_list_t * region_elt = NULL, *region_tmp = NULL; + region_list_t *region_elt = NULL, *region_tmp = NULL; perr_t ret_value = SUCCEED; hg_return_t hg_ret; @@ -1225,21 +1225,21 @@ perr_t PDC_Server_checkpoint() { perr_t ret_value = SUCCEED; - pdc_metadata_t * elt; - region_list_t * region_elt; - pdc_kvtag_list_t * kvlist_elt; - pdc_hash_table_entry_head * head; + pdc_metadata_t *elt; + region_list_t *region_elt; + pdc_kvtag_list_t *kvlist_elt; + pdc_hash_table_entry_head *head; pdc_cont_hash_table_entry_t *cont_head; int n_entry, metadata_size = 0, region_count = 0, n_region, n_objs, n_write_region = 0, n_kvtag, key_len; uint32_t hash_key; HashTablePair pair; char checkpoint_file[ADDR_MAX], checkpoint_file_local[ADDR_MAX], cmd[4096]; HashTableIterator hash_table_iter; - char * checkpoint; - char * env_char; + char *checkpoint; + char *env_char; uint64_t checkpoint_size; bool use_tmpfs = false; - FILE * file; + FILE *file; FUNC_ENTER(NULL); @@ -1360,7 +1360,7 @@ PDC_Server_checkpoint() metadata_size++; region_count += n_region; } // End for metadata entry linked list - } // End for hash table metadata entry + } // End for hash table metadata entry // Note data server region are managed by data server instead of metadata server data_server_region_t *region = NULL; @@ -1454,15 +1454,15 @@ PDC_Server_restart(char *filename) int n_entry, count, i, j, nobj = 0, all_nobj = 0, all_n_region, n_region, n_objs, total_region = 0, n_kvtag, key_len; int n_cont, all_cont; - pdc_metadata_t * metadata, *elt; - region_list_t * region_list; - pdc_hash_table_entry_head * entry; + pdc_metadata_t *metadata, *elt; + region_list_t *region_list; + pdc_hash_table_entry_head *entry; pdc_cont_hash_table_entry_t *cont_entry; - uint32_t * hash_key; + uint32_t *hash_key; unsigned idx; uint64_t checkpoint_size; - char * checkpoint_buf; -#ifdef PDC_TIMING + char *checkpoint_buf; +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double start = MPI_Wtime(); #endif @@ -1742,8 +1742,8 @@ PDC_Server_restart(char *filename) MPI_Reduce(&nobj, &all_nobj, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Reduce(&total_region, &all_n_region, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); #else - all_nobj = nobj; - all_n_region = total_region; + all_nobj = nobj; + all_n_region = total_region; #endif if (pdc_server_rank_g == 0) { @@ -1753,7 +1753,7 @@ PDC_Server_restart(char *filename) } done: -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCserver_restart += MPI_Wtime() - start; #endif @@ -1771,7 +1771,7 @@ PDC_Server_restart(char *filename) static HG_THREAD_RETURN_TYPE hg_progress_thread(void *arg) { - hg_context_t * context = (hg_context_t *)arg; + hg_context_t *context = (hg_context_t *)arg; HG_THREAD_RETURN_TYPE tret = (HG_THREAD_RETURN_TYPE)0; hg_return_t ret = HG_SUCCESS; @@ -2256,7 +2256,7 @@ server_run(int argc, char *argv[]) rocksdb_options_set_create_if_missing(options, 1); rocksdb_block_based_table_options_t *table_options = rocksdb_block_based_options_create(); - rocksdb_filterpolicy_t * filter_policy = rocksdb_filterpolicy_create_bloom(10); + rocksdb_filterpolicy_t *filter_policy = rocksdb_filterpolicy_create_bloom(10); rocksdb_block_based_options_set_filter_policy(table_options, filter_policy); rocksdb_options_set_block_based_table_factory(options, table_options); diff --git a/src/server/pdc_server_region/pdc_server_data.c b/src/server/pdc_server_region/pdc_server_data.c index d00ce2a15..87c6a0ed1 100644 --- a/src/server/pdc_server_region/pdc_server_data.c +++ b/src/server/pdc_server_region/pdc_server_data.c @@ -62,7 +62,7 @@ #include "pdc_logger.h" // Global object region info list in local data server -data_server_region_t * dataserver_region_g = NULL; +data_server_region_t *dataserver_region_g = NULL; data_server_region_unmap_t *dataserver_region_unmap = NULL; int pdc_buffered_bulk_update_total_g = 0; @@ -79,10 +79,10 @@ uint64_t max_mem_cache_size_mb_g = 0; int cache_percentage_g = 0; int current_read_from_cache_cnt_g = 0; int total_read_from_cache_cnt_g = 0; -FILE * pdc_cache_file_ptr_g = NULL; +FILE *pdc_cache_file_ptr_g = NULL; char pdc_cache_file_path_g[ADDR_MAX]; -query_task_t * query_task_list_head_g = NULL; +query_task_t *query_task_list_head_g = NULL; cache_storage_region_t *cache_storage_region_head_g = NULL; static int @@ -263,7 +263,7 @@ PDC_Server_local_region_lock_status(PDC_mapping_info_t *mapped_region, int *lock { perr_t ret_value = SUCCEED; pdc_metadata_t *res_meta; - region_list_t * elt, *request_region; + region_list_t *elt, *request_region; FUNC_ENTER(NULL); @@ -364,7 +364,7 @@ PDC_Server_clear_obj_region() { perr_t ret_value = SUCCEED; data_server_region_t *elt, *tmp; - region_list_t * elt2, *tmp2; + region_list_t *elt2, *tmp2; FUNC_ENTER(NULL); if (dataserver_region_g != NULL) { @@ -472,10 +472,10 @@ PDC_Data_Server_region_lock(region_lock_in_t *in, region_lock_out_t *out, hg_han { perr_t ret_value = SUCCEED; int ndim; - region_list_t * request_region; + region_list_t *request_region; data_server_region_t *new_obj_reg; - region_list_t * elt1, *tmp; - region_buf_map_t * eltt; + region_list_t *elt1, *tmp; + region_buf_map_t *eltt; int error = 0; int found_lock = 0; // time_t t; @@ -576,8 +576,8 @@ perr_t PDC_Server_release_lock_request(uint64_t obj_id, struct pdc_region_info *region) { perr_t ret_value = SUCCEED; - region_list_t * request_region; - region_list_t * elt, *tmp; + region_list_t *request_region; + region_list_t *elt, *tmp; data_server_region_t *new_obj_reg; region_lock_out_t out; @@ -619,7 +619,7 @@ PDC_Data_Server_region_release(region_lock_in_t *in, region_lock_out_t *out) { perr_t ret_value = SUCCEED; int ndim; - region_list_t * tmp1, *tmp2; + region_list_t *tmp1, *tmp2; region_list_t request_region; int found = 0; data_server_region_t *obj_reg = NULL; @@ -758,7 +758,7 @@ PDC_Data_Server_buf_unmap(const struct hg_info *info, buf_unmap_in_t *in) { perr_t ret_value = SUCCEED; int ret = HG_UTIL_SUCCESS; - region_buf_map_t * tmp, *elt; + region_buf_map_t *tmp, *elt; data_server_region_t *target_obj; FUNC_ENTER(NULL); @@ -852,9 +852,9 @@ PDC_Data_Server_check_unmap() perr_t ret_value = SUCCEED; int ret = HG_UTIL_SUCCESS; pdcid_t remote_obj_id; - region_buf_map_t * tmp, *elt; + region_buf_map_t *tmp, *elt; data_server_region_unmap_t *tmp1, *elt1; - data_server_region_t * target_obj; + data_server_region_t *target_obj; int completed = 0; FUNC_ENTER(NULL); @@ -953,7 +953,7 @@ buf_unmap_lookup_remote_server_cb(const struct hg_cb_info *callback_info) struct buf_unmap_server_lookup_args_t *lookup_args; hg_handle_t server_send_buf_unmap_handle; hg_handle_t handle; - struct transfer_buf_unmap * tranx_args; + struct transfer_buf_unmap *tranx_args; int error = 0; FUNC_ENTER(NULL); @@ -1017,7 +1017,7 @@ PDC_Server_buf_unmap_lookup_server_id(int remote_server_id, struct transfer_buf_ lookup_args->server_id = remote_server_id; lookup_args->buf_unmap_args = transfer_args; hg_ret = HG_Addr_lookup(hg_context_g, buf_unmap_lookup_remote_server_cb, lookup_args, - pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); + pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; PGOTO_ERROR( @@ -1077,9 +1077,9 @@ PDC_Meta_Server_buf_unmap(buf_unmap_in_t *in, hg_handle_t *handle) hg_return_t hg_ret = HG_SUCCESS; hg_handle_t server_send_buf_unmap_handle; struct transfer_buf_unmap_args *buf_unmap_args; - struct transfer_buf_unmap * addr_args; - pdc_metadata_t * target_meta = NULL; - region_buf_map_t * tmp, *elt; + struct transfer_buf_unmap *addr_args; + pdc_metadata_t *target_meta = NULL; + region_buf_map_t *tmp, *elt; int error = 0; FUNC_ENTER(NULL); @@ -1154,14 +1154,14 @@ region_buf_map_t * PDC_Data_Server_buf_map(const struct hg_info *info, buf_map_in_t *in, region_list_t *request_region, void *data_ptr) { - region_buf_map_t * ret_value = NULL; + region_buf_map_t *ret_value = NULL; data_server_region_t *new_obj_reg = NULL; - region_list_t * elt_reg; - region_buf_map_t * buf_map_ptr = NULL; - region_buf_map_t * tmp; + region_list_t *elt_reg; + region_buf_map_t *buf_map_ptr = NULL; + region_buf_map_t *tmp; int dup = 0; - char * data_path = NULL; - char * user_specified_data_path = NULL; + char *data_path = NULL; + char *user_specified_data_path = NULL; char storage_location[ADDR_MAX]; #ifdef ENABLE_LUSTRE int stripe_count, stripe_size; @@ -1277,9 +1277,9 @@ PDC_Data_Server_buf_map(const struct hg_info *info, buf_map_in_t *in, region_lis void * PDC_Server_maybe_allocate_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region, size_t type_size) { - void * ret_value = NULL; + void *ret_value = NULL; data_server_region_t *target_obj = NULL, *elt = NULL; - region_buf_map_t * tmp; + region_buf_map_t *tmp; FUNC_ENTER(NULL); @@ -1331,9 +1331,9 @@ PDC_Server_maybe_allocate_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t void * PDC_Server_get_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region) { - void * ret_value = NULL; + void *ret_value = NULL; data_server_region_t *target_obj = NULL, *elt = NULL; - region_buf_map_t * tmp; + region_buf_map_t *tmp; FUNC_ENTER(NULL); @@ -1399,7 +1399,7 @@ buf_map_lookup_remote_server_cb(const struct hg_cb_info *callback_info) struct buf_map_server_lookup_args_t *lookup_args; hg_handle_t server_send_buf_map_handle; hg_handle_t handle; - struct transfer_buf_map * tranx_args; + struct transfer_buf_map *tranx_args; int error = 0; FUNC_ENTER(NULL); @@ -1464,7 +1464,7 @@ PDC_Server_buf_map_lookup_server_id(int remote_server_id, struct transfer_buf_ma lookup_args->server_id = remote_server_id; lookup_args->buf_map_args = transfer_args; hg_ret = HG_Addr_lookup(hg_context_g, buf_map_lookup_remote_server_cb, lookup_args, - pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); + pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; PGOTO_ERROR( @@ -1520,9 +1520,9 @@ PDC_Meta_Server_buf_map(buf_map_in_t *in, region_buf_map_t *new_buf_map_ptr, hg_ hg_return_t hg_ret = HG_SUCCESS; hg_handle_t server_send_buf_map_handle; struct transfer_buf_map_args *tranx_args = NULL; - struct transfer_buf_map * addr_args; - pdc_metadata_t * target_meta = NULL; - region_buf_map_t * buf_map_ptr; + struct transfer_buf_map *addr_args; + pdc_metadata_t *target_meta = NULL; + region_buf_map_t *buf_map_ptr; int error = 0; FUNC_ENTER(NULL); @@ -1794,11 +1794,11 @@ PDC_Server_notify_client_multi_io_complete(uint32_t client_id, int client_seq_id hg_return_t hg_ret = HG_SUCCESS; hg_handle_t rpc_handle; hg_bulk_t bulk_handle; - void ** buf_ptrs; - hg_size_t * buf_sizes; + void **buf_ptrs; + hg_size_t *buf_sizes; bulk_rpc_in_t bulk_rpc_in; int i; - region_list_t * region_elt; + region_list_t *region_elt; notify_multi_io_args_t *bulk_args; FUNC_ENTER(NULL); @@ -2004,7 +2004,7 @@ PDC_Server_read_check(data_server_read_check_in_t *in, server_read_check_out_t * { perr_t ret_value = SUCCEED; pdc_data_server_io_list_t *io_elt = NULL, *io_target = NULL; - region_list_t * region_elt = NULL; + region_list_t *region_elt = NULL; region_list_t r_target; /* uint32_t i; */ @@ -2090,7 +2090,7 @@ PDC_Server_write_check(data_server_write_check_in_t *in, data_server_write_check { perr_t ret_value = FAIL; pdc_data_server_io_list_t *io_elt = NULL, *io_target = NULL; - region_list_t * region_elt = NULL, *region_tmp = NULL; + region_list_t *region_elt = NULL, *region_tmp = NULL; int found_region = 0; FUNC_ENTER(NULL); @@ -2198,7 +2198,7 @@ PDC_Server_get_local_storage_location_of_region(uint64_t obj_id, region_list_t * { perr_t ret_value = SUCCEED; pdc_metadata_t *target_meta = NULL; - region_list_t * region_elt = NULL; + region_list_t *region_elt = NULL; FUNC_ENTER(NULL); @@ -2328,7 +2328,7 @@ PDC_Server_count_write_check_update_storage_meta_cb(const struct hg_cb_info *cal } } // end of if - } // end of if (write_ret->ret == 1) + } // end of if (write_ret->ret == 1) done: @@ -2360,17 +2360,17 @@ PDC_Server_get_storage_location_of_region_mpi(region_list_t *regions_head) perr_t ret_value = SUCCEED; uint32_t server_id = 0; uint32_t i, j; - pdc_metadata_t * region_meta = NULL, *region_meta_prev = NULL; - region_list_t * region_elt, req_region, **overlap_regions_2d = NULL; + pdc_metadata_t *region_meta = NULL, *region_meta_prev = NULL; + region_list_t *region_elt, req_region, **overlap_regions_2d = NULL; region_info_transfer_t local_region_transfer[PDC_SERVER_MAX_PROC_PER_NODE]; - region_info_transfer_t * all_requests = NULL; + region_info_transfer_t *all_requests = NULL; update_region_storage_meta_bulk_t *send_buf = NULL; update_region_storage_meta_bulk_t *result_storage_meta = NULL; uint32_t total_request_cnt; int data_size = sizeof(region_info_transfer_t); - int * send_bytes = NULL; - int * displs = NULL; - int * request_overlap_cnt = NULL; + int *send_bytes = NULL; + int *displs = NULL; + int *request_overlap_cnt = NULL; int nrequest_per_server = 0; FUNC_ENTER(NULL); @@ -2700,7 +2700,7 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) perr_t ret_value = SUCCEED; pdc_data_server_io_list_t *io_list_elt, *io_list = NULL, *io_list_target = NULL; - region_list_t * region_elt = NULL, *region_tmp; + region_list_t *region_elt = NULL, *region_tmp; int real_bb_cnt = 0, real_lustre_cnt = 0; int write_to_bb_cnt = 0; int count; @@ -3102,7 +3102,7 @@ PDC_Server_update_region_storagelocation_offset(region_list_t *region, int type) hg_return_t hg_ret; perr_t ret_value = SUCCEED; uint32_t server_id = 0; - pdc_metadata_t * region_meta = NULL; + pdc_metadata_t *region_meta = NULL; hg_handle_t update_region_loc_handle; update_region_loc_in_t in; server_lookup_args_t lookup_args; @@ -3204,7 +3204,7 @@ PDC_Server_add_region_storage_meta_to_bulk_buf(region_list_t *region, bulk_xfer_ int i; uint64_t obj_id = 0; update_region_storage_meta_bulk_t *curr_buf_ptr; - uint64_t * obj_id_ptr; + uint64_t *obj_id_ptr; FUNC_ENTER(NULL); @@ -3294,8 +3294,8 @@ PDC_Server_update_region_storage_meta_bulk_local(update_region_storage_meta_bulk { perr_t ret_value = SUCCEED; int i; - pdc_metadata_t * target_meta = NULL; - region_list_t * region_elt = NULL, *new_region = NULL; + pdc_metadata_t *target_meta = NULL; + region_list_t *region_elt = NULL, *new_region = NULL; update_region_storage_meta_bulk_t *bulk_ptr; int update_success = 0, express_insert = 0; uint64_t obj_id; @@ -3418,7 +3418,7 @@ PDC_Server_update_region_storage_meta_bulk_mpi(bulk_xfer_data_t *bulk_data) int i; uint32_t server_id = 0; update_region_storage_meta_bulk_t *recv_buf = NULL; - void ** all_meta = NULL; + void **all_meta = NULL; #endif FUNC_ENTER(NULL); @@ -3471,9 +3471,9 @@ PDC_Server_update_region_storage_meta_bulk_mpi(bulk_xfer_data_t *bulk_data) } perr_t -PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t * bulk_data, perr_t (*cb)(), +PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t *bulk_data, perr_t (*cb)(), update_storage_meta_list_t *meta_list_target, - int * n_updated) + int *n_updated) { hg_return_t hg_ret; perr_t ret_value = SUCCEED; @@ -3714,7 +3714,7 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re } *total_read_bytes += read_bytes; } // for each row - } // ndim=2 + } // ndim=2 else if (ndim == 3) { uint64_t buf_serialize_offset; /* fseek (fp, storage_offset, SEEK_SET); */ @@ -3797,8 +3797,8 @@ PDC_Server_read_one_region(region_list_t *read_region) size_t total_read_bytes = 0; uint32_t n_storage_regions = 0; region_list_t *region_elt; - FILE * fp_read = NULL; - char * prev_path = NULL; + FILE *fp_read = NULL; + char *prev_path = NULL; int is_shm_created = 0, is_read_succeed = 0; #ifdef ENABLE_TIMING double fopen_time; @@ -3941,8 +3941,8 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) uint64_t offset = 0; uint32_t i = 0; region_list_t *region_elt = NULL, *previous_region = NULL; - FILE * fp_read = NULL, *fp_write = NULL; - char * prev_path = NULL; + FILE *fp_read = NULL, *fp_write = NULL; + char *prev_path = NULL; #ifdef ENABLE_LUSTRE int stripe_count, stripe_size; #endif @@ -4402,17 +4402,17 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, { perr_t ret_value = SUCCEED; data_server_region_t *region = NULL; - region_list_t * overlap_region = NULL; + region_list_t *overlap_region = NULL; int is_contained = 0; uint64_t i, j, pos; - uint64_t * overlap_offset, *overlap_size; - char * tmp_buf; + uint64_t *overlap_offset, *overlap_size; + char *tmp_buf; #if 0 size_t total_write_size = 0, local_write_size; int is_overlap; #endif FUNC_ENTER(NULL); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double start = MPI_Wtime(), start_posix; #endif @@ -4476,13 +4476,13 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, } lseek(region->fd, overlap_region->offset + pos, SEEK_SET); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write(region->fd, buf + (overlap_offset[0] - region_info->offset[0]) * unit, overlap_size[0] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif if (ret_value != SUCCEED) { @@ -4497,14 +4497,14 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, if (data_sieving_g) { // Create a buffer for loading the entire region. tmp_buf = (char *)PDC_malloc(overlap_region->data_size); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif if (pread(region->fd, tmp_buf, overlap_region->data_size, overlap_region->offset) != (ssize_t)overlap_region->data_size) { LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", pdc_server_rank_g); } -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; #endif // Copy overlapping parts of buf from the temporary buffer. @@ -4512,13 +4512,13 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, region_info->size, tmp_buf, overlap_region->start, overlap_region->count, overlap_offset, overlap_size); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif // Read the whole region back lseek(region->fd, overlap_region->offset, SEEK_SET); ret_value = PDC_Server_posix_write(region->fd, tmp_buf, overlap_region->data_size); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif if (ret_value != SUCCEED) { @@ -4540,7 +4540,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, overlap_size[1] == region_info->size[1]) { // Overlap region is exactly the same as input region, so no need to copy // temporary buffer. -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write( @@ -4548,7 +4548,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, buf + (overlap_offset[0] - region_info->offset[0]) * region_info->size[1] * unit, overlap_size[0] * overlap_size[1] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif } @@ -4557,12 +4557,12 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, memcpy_overlap_subregion(region_info->ndim, unit, buf, region_info->offset, region_info->size, tmp_buf, overlap_offset, overlap_size, overlap_offset, overlap_size); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write(region->fd, tmp_buf, overlap_size[0] * overlap_size[1] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif tmp_buf = (char *)PDC_free(tmp_buf); @@ -4583,7 +4583,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, overlap_offset[1] - overlap_region->start[1]) * unit, SEEK_SET); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write( @@ -4593,7 +4593,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, overlap_offset[1] - region_info->offset[1]) * unit, overlap_size[1] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif if (ret_value != SUCCEED) { @@ -4619,7 +4619,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, overlap_size[2] == region_info->size[2] && overlap_offset[1] == region_info->offset[1] && overlap_size[1] == region_info->size[1]) { -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write( @@ -4627,7 +4627,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, buf + (overlap_offset[0] - region_info->offset[0]) * region_info->size[1] * region_info->size[2] * unit, overlap_size[0] * overlap_size[1] * overlap_size[2] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif } @@ -4637,13 +4637,13 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, memcpy_overlap_subregion(region_info->ndim, unit, buf, region_info->offset, region_info->size, tmp_buf, overlap_offset, overlap_size, overlap_offset, overlap_size); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write(region->fd, tmp_buf, overlap_size[0] * overlap_size[1] * overlap_size[2] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif tmp_buf = (char *)PDC_free(tmp_buf); @@ -4661,7 +4661,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, overlap_offset[2] - overlap_region->start[2]) * unit, SEEK_SET); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write( @@ -4673,7 +4673,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, overlap_offset[2] - region_info->offset[2]) * unit, overlap_size[2] * unit); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif @@ -4689,11 +4689,11 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, if (is_contained == 0) { request_region->offset = lseek(region->fd, 0, SEEK_END); #ifdef ENABLE_ZFP - zfp_field * field; + zfp_field *field; zfp_stream *zfp; size_t bufsize; - void * buffer; - bitstream * stream; + void *buffer; + bitstream *stream; field = _setup_zfp(region_info, &zfp); if (field == NULL) @@ -4722,11 +4722,11 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, stream_close(stream); #endif -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) start_posix = MPI_Wtime(); #endif ret_value = PDC_Server_posix_write(region->fd, buf, write_size); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif if (ret_value != SUCCEED) { @@ -4753,7 +4753,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, fflush(stdout); #endif -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) pdc_server_timings->PDCdata_server_write_out += MPI_Wtime() - start; #endif done: @@ -4767,10 +4767,10 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, perr_t ret_value = SUCCEED; ssize_t request_bytes = unit; data_server_region_t *region = NULL; - region_list_t * elt; + region_list_t *elt; uint64_t i, j, pos; - uint64_t * overlap_offset, *overlap_size; - char * tmp_buf; + uint64_t *overlap_offset, *overlap_size; + char *tmp_buf; FUNC_ENTER(NULL); #ifdef PDC_TIMING @@ -4868,10 +4868,10 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef ENABLE_ZFP // Uncompress the data - zfp_field * field; + zfp_field *field; zfp_stream *zfp; size_t bufsize, decompress_size; - bitstream * stream; + bitstream *stream; field = _setup_zfp(region_info, &zfp); if (field == NULL) @@ -5132,7 +5132,7 @@ PDC_Server_get_local_storage_meta_with_one_name(storage_meta_query_one_name_args { perr_t ret_value = SUCCEED; pdc_metadata_t *meta = NULL; - region_list_t * region_elt = NULL, *region_head = NULL, *res_region_list = NULL; + region_list_t *region_elt = NULL, *region_head = NULL, *res_region_list = NULL; int region_count = 0, i = 0; FUNC_ENTER(NULL); @@ -5264,7 +5264,7 @@ PDC_Server_accumulate_storage_meta_then_read(storage_meta_query_one_name_args_t { perr_t ret_value = SUCCEED; accumulate_storage_meta_t *accu_meta; - region_list_t * req_region = NULL, *region_elt = NULL, *read_list_head = NULL; + region_list_t *req_region = NULL, *region_elt = NULL, *read_list_head = NULL; int i, is_sort_read; size_t j; @@ -5432,16 +5432,16 @@ PDC_Server_storage_meta_name_query_bulk_respond(const struct hg_cb_info *callbac { hg_return_t hg_ret = HG_SUCCESS; perr_t ret_value; - storage_meta_name_query_in_t * args; + storage_meta_name_query_in_t *args; storage_meta_query_one_name_args_t *query_args; hg_handle_t rpc_handle; hg_bulk_t bulk_handle; bulk_rpc_in_t bulk_rpc_in; - void ** buf_ptrs; - hg_size_t * buf_sizes; + void **buf_ptrs; + hg_size_t *buf_sizes; uint32_t server_id; - region_info_transfer_t ** region_infos; - region_list_t * region_elt; + region_info_transfer_t **region_infos; + region_list_t *region_elt; int i, j; FUNC_ENTER(NULL); @@ -5585,9 +5585,9 @@ PDC_Server_add_client_shm_to_cache(int cnt, void *buf_cp) { perr_t ret_value = SUCCEED; int i, j; - region_storage_meta_t * storage_metas = (region_storage_meta_t *)buf_cp; + region_storage_meta_t *storage_metas = (region_storage_meta_t *)buf_cp; pdc_data_server_io_list_t *io_list_elt, *io_list_target; - region_list_t * new_region; + region_list_t *new_region; FUNC_ENTER(NULL); @@ -5699,7 +5699,7 @@ PDC_Server_data_read_to_buf_1_region(region_list_t *region) { perr_t ret_value = SUCCEED; uint64_t offset, read_bytes; - FILE * fp_read = NULL; + FILE *fp_read = NULL; if (region->is_data_ready == 1) return SUCCEED; @@ -5748,9 +5748,9 @@ PDC_Server_data_read_to_buf(region_list_t *region_list_head) { perr_t ret_value = SUCCEED; region_list_t *region_elt; - char * prev_path = NULL; + char *prev_path = NULL; uint64_t offset, read_bytes; - FILE * fp_read = NULL; + FILE *fp_read = NULL; int read_count = 0; @@ -5889,8 +5889,8 @@ static perr_t PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_combine_op_t combine_op) { perr_t ret_value = SUCCEED; - region_list_t * req_region = NULL, *region_tmp = NULL; - region_list_t * storage_region_list_head = NULL; + region_list_t *req_region = NULL, *region_tmp = NULL; + region_list_t *storage_region_list_head = NULL; pdc_data_server_io_list_t *io_list_elt, *io_list_target = NULL; uint64_t obj_id; int iter, count, is_same_region, i, can_skip; @@ -6161,7 +6161,7 @@ compare_coords_3d(const void *a, const void *b) ({ \ uint64_t idx, iii, jjj, ttt, cur_count = 0, istart, has_dup; \ int is_good, _ndim; \ - TYPE * edata = (TYPE *)(_data); \ + TYPE *edata = (TYPE *)(_data); \ _ndim = (_region)->ndim; \ istart = (_sel)->nhits * _ndim; \ if (_ndim > 3) { \ @@ -6306,7 +6306,7 @@ compare_coords_3d(const void *a, const void *b) ({ \ uint64_t idx, iii, jjj, ttt, cur_count = 0, istart, has_dup; \ int is_good, _ndim; \ - TYPE * edata = (TYPE *)(_data); \ + TYPE *edata = (TYPE *)(_data); \ _ndim = (_region)->ndim; \ istart = (_sel)->nhits * _ndim; \ if (_ndim > 3) { \ @@ -6467,11 +6467,11 @@ generate_write_fastbit_idx(uint64_t obj_id, void *data, uint64_t dataCount, Fast char keyName[128]; char offName[128]; char out_name[256]; - double * keys = NULL; - int64_t * offsets = NULL; + double *keys = NULL; + int64_t *offsets = NULL; uint32_t *bms = NULL; uint64_t nk = 0, no = 0, nb = 0; - FILE * fp; + FILE *fp; FUNC_ENTER(NULL); @@ -6569,7 +6569,7 @@ int queryData(const char *name) { uint64_t nhits, i; - uint64_t * buf; + uint64_t *buf; double val1 = 0.0, val2 = 10.0; FastBitSelectionHandle sel1 = fastbit_selection_osr(name, FastBitCompareGreater, val1); FastBitSelectionHandle sel2 = fastbit_selection_osr(name, FastBitCompareLess, val2); @@ -6604,7 +6604,7 @@ PDC_load_fastbit_index(char *idx_name, uint64_t obj_id, FastBitDataType dtype, i char offName[128]; char out_name[256]; uint64_t nk = 0, no = 0, nb = 0, size; - FILE * fp; + FILE *fp; PDC_gen_fastbit_idx_name(bmsName, "bms", obj_id, timestep, ndim, start, count); PDC_gen_fastbit_idx_name(keyName, "key", obj_id, timestep, ndim, start, count); @@ -6680,9 +6680,9 @@ PDC_query_fastbit_idx(region_list_t *region, pdc_query_constraint_t *constraint, perr_t ret_value = SUCCEED; FastBitDataType ft = 0; uint64_t type_size; - uint32_t * bms = NULL; - double * keys = NULL; - int64_t * offsets = NULL; + uint32_t *bms = NULL; + double *keys = NULL; + int64_t *offsets = NULL; int timestep; double v1, v2; size_t i; @@ -6857,7 +6857,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ pdc_query_combine_op_t combine_op) { perr_t ret_value = SUCCEED; - region_list_t * region_elt, *region_list_head, *cache_region, tmp_region, *region_constraint = NULL; + region_list_t *region_elt, *region_list_head, *cache_region, tmp_region, *region_constraint = NULL; pdc_selection_t *sel = query->sel; uint64_t nelem; size_t i, j, unit_size; @@ -6871,7 +6871,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ uint32_t ulo = 0, uhi = 0; int64_t i64lo = 0, i64hi = 0; uint64_t ui64lo = 0, ui64hi = 0; - void * value = NULL, *buf = NULL; + void *value = NULL, *buf = NULL; int n_eval_region = 0, can_skip, region_iter = 0; LOG_INFO("==PDC_SERVER[%d]: start query evaluation!\n", pdc_server_rank_g); @@ -7212,7 +7212,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ n_eval_region++; } // End DL_FOREACH - } // End not use fastbit + } // End not use fastbit if (n_eval_region == 0 && combine_op == PDC_QUERY_AND) { if (sel->nhits > 0) { @@ -7540,7 +7540,7 @@ PDC_Server_send_coords_to_client(query_task_t *task) hg_bulk_t bulk_handle; bulk_rpc_in_t in; hg_size_t buf_sizes; - void * buf; + void *buf; int client_id; FUNC_ENTER(NULL); @@ -7622,7 +7622,7 @@ PDC_Server_send_coords_to_server(query_task_t *task) hg_bulk_t bulk_handle = NULL; bulk_rpc_in_t in; hg_size_t buf_sizes; - void * buf; + void *buf; int server_id; FUNC_ENTER(NULL); @@ -7829,9 +7829,9 @@ hg_return_t PDC_Server_read_coords(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; - query_task_t * task = (query_task_t *)callback_info->arg; + query_task_t *task = (query_task_t *)callback_info->arg; pdc_query_constraint_t *constraint; - region_list_t * storage_region_head, *region_elt, *cache_region; + region_list_t *storage_region_head, *region_elt, *cache_region; size_t ndim, unit_size; uint64_t i, *coord, data_off, buf_off, my_size; @@ -7897,11 +7897,11 @@ PDC_recv_read_coords(const struct hg_cb_info *callback_info) hg_return_t ret = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; - query_task_t * task_elt = NULL; + query_task_t *task_elt = NULL; uint64_t nhits, obj_id; uint32_t ndim; int query_id, origin; - void * buf; + void *buf; pdc_int_ret_t out; out.ret = 1; @@ -7980,7 +7980,7 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) hg_return_t ret = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; - query_task_t * task_elt; + query_task_t *task_elt; uint64_t nhits = 0, total_hits; size_t ndim, unit_size; int i, query_id, origin, found_task; @@ -8198,7 +8198,7 @@ perr_t add_storage_region_to_buf(void **in_buf, uint64_t *buf_alloc, uint64_t *buf_off, const region_list_t *region) { perr_t ret_value = SUCCEED; - void * buf = *in_buf; + void *buf = *in_buf; uint64_t my_size, tmp_size; if (in_buf == NULL || *in_buf == NULL || region == NULL || buf_alloc == NULL || buf_off == NULL || @@ -8394,8 +8394,8 @@ PDC_Server_distribute_query_storage_info(query_task_t *task, uint64_t obj_id, in { pdc_metadata_t *meta = NULL; int i, server_id, count, avg_count, nsent, nsent_server; - region_list_t * elt, *new_region = NULL; - void * region_bulk_buf; + region_list_t *elt, *new_region = NULL; + void *region_bulk_buf; uint64_t buf_alloc = 0, buf_off = 0; bulk_rpc_in_t header; @@ -8535,16 +8535,16 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; - struct bulk_args_t * bulk_args = (struct bulk_args_t *)callback_info->arg; - void * buf; - region_list_t * regions = NULL; + struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; + void *buf; + region_list_t *regions = NULL; int i, nregion, *loc_len_ptr, *has_hist_ptr, found_task; uint64_t buf_off, *offset_ptr = NULL, *size_ptr = NULL; - char * loc_ptr = NULL; + char *loc_ptr = NULL; region_info_transfer_t *region_info_ptr = NULL; - pdc_histogram_t * hist_ptr = NULL; - query_task_t * task_elt = NULL; - pdc_query_t * query = NULL; + pdc_histogram_t *hist_ptr = NULL; + query_task_t *task_elt = NULL; + pdc_query_t *query = NULL; pdc_int_ret_t out; out.ret = 1; @@ -8713,10 +8713,10 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) hg_return_t ret = HG_SUCCESS; pdc_query_xfer_t *query_xfer = (pdc_query_xfer_t *)callback_info->arg; int obj_idx = 0; - uint64_t * obj_ids; - query_task_t * new_task = NULL, *task_elt; + uint64_t *obj_ids; + query_task_t *new_task = NULL, *task_elt; int query_id_exist = 0; - pdc_query_t * query; + pdc_query_t *query; query = PDC_deserialize_query(query_xfer); if (NULL == query) { @@ -8822,7 +8822,7 @@ PDC_Server_send_read_coords_to_server(int server_id, uint64_t *coord, uint64_t n hg_bulk_t bulk_handle = NULL; bulk_rpc_in_t in; hg_size_t buf_sizes; - void * buf; + void *buf; FUNC_ENTER(NULL); @@ -8933,12 +8933,12 @@ hg_return_t PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; - get_sel_data_rpc_in_t * in = (get_sel_data_rpc_in_t *)callback_info->arg; - query_task_t * task_elt, *task = NULL; + get_sel_data_rpc_in_t *in = (get_sel_data_rpc_in_t *)callback_info->arg; + query_task_t *task_elt, *task = NULL; uint64_t nhits, *coord, *coords = NULL, obj_id, buf_off, my_size, data_off, i; size_t ndim, unit_size; cache_storage_region_t *cache_region_elt; - region_list_t * storage_region_head = NULL, *cache_region, *region_elt; + region_list_t *storage_region_head = NULL, *cache_region, *region_elt; pdc_var_type_t data_type; // find task @@ -9026,8 +9026,8 @@ PDC_Server_recv_get_sel_data(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; get_sel_data_rpc_in_t *in = (get_sel_data_rpc_in_t *)callback_info->arg; - query_task_t * task_elt, *task = NULL; - pdc_metadata_t * meta; + query_task_t *task_elt, *task = NULL; + pdc_metadata_t *meta; struct hg_cb_info fake_callback_info = {0}; DL_FOREACH(query_task_list_head_g, task_elt) diff --git a/src/server/pdc_server_region/pdc_server_region_request_handler.h b/src/server/pdc_server_region/pdc_server_region_request_handler.h index 35a716153..36b28f0dd 100644 --- a/src/server/pdc_server_region/pdc_server_region_request_handler.h +++ b/src/server/pdc_server_region/pdc_server_region_request_handler.h @@ -23,12 +23,12 @@ transfer_request_all_bulk_transfer_read_cb2(const struct hg_cb_info *info) HG_Destroy(local_bulk_args2->handle); local_bulk_args2 = (struct transfer_request_all_local_bulk_args2 *)PDC_free(local_bulk_args2); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) // transfer_request_inner_read_all_bulk is purely for transferring read data from server to client. end = MPI_Wtime(); start = local_bulk_args2->start_time; pdc_server_timings->PDCreg_transfer_request_inner_read_all_bulk_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_inner_read_all_bulk_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_inner_read_all_bulk_timestamps, start, end); #endif FUNC_LEAVE(ret); @@ -38,14 +38,14 @@ hg_return_t transfer_request_all_bulk_transfer_read_cb(const struct hg_cb_info *info) { struct transfer_request_all_local_bulk_args2 *local_bulk_args2; - struct transfer_request_all_local_bulk_args * local_bulk_args = info->arg; - const struct hg_info * handle_info; + struct transfer_request_all_local_bulk_args *local_bulk_args = info->arg; + const struct hg_info *handle_info; transfer_request_all_data request_data; hg_return_t ret = HG_SUCCESS; - struct pdc_region_info * remote_reg_info; + struct pdc_region_info *remote_reg_info; int i, j; uint64_t total_mem_size, mem_size; - char * ptr; + char *ptr; FUNC_ENTER(NULL); @@ -116,12 +116,12 @@ transfer_request_all_bulk_transfer_read_cb(const struct hg_cb_info *info) temp_ptrs = (data_server_region_t **)PDC_free(temp_ptrs); #endif -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) // PDCreg_transfer_request_wait_all_read_bulk includes the timing for transfering metadata and read I/O // time. end = MPI_Wtime(); pdc_server_timings->PDCreg_transfer_request_start_all_read_bulk_rpc += end - local_bulk_args->start_time; - pdc_timestamp_register(pdc_transfer_request_start_all_read_bulk_timestamps, local_bulk_args->start_time, + pdc_timestamp_register(&pdc_transfer_request_start_all_read_bulk_timestamps, local_bulk_args->start_time, end); local_bulk_args2->start_time = end; @@ -164,7 +164,7 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) struct transfer_request_all_local_bulk_args *local_bulk_args = info->arg; transfer_request_all_data request_data; hg_return_t ret = HG_SUCCESS; - struct pdc_region_info * remote_reg_info; + struct pdc_region_info *remote_reg_info; int i; char cur_time[64]; @@ -177,10 +177,10 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) gettimeofday(&last_cache_activity_timeval_g, NULL); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double end = MPI_Wtime(), start; pdc_server_timings->PDCreg_transfer_request_start_all_write_bulk_rpc += end - local_bulk_args->start_time; - pdc_timestamp_register(pdc_transfer_request_start_all_write_bulk_timestamps, local_bulk_args->start_time, + pdc_timestamp_register(&pdc_transfer_request_start_all_write_bulk_timestamps, local_bulk_args->start_time, end); start = MPI_Wtime(); #endif @@ -255,10 +255,10 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) local_bulk_args = (struct transfer_request_all_local_bulk_args *)PDC_free(local_bulk_args); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) end = MPI_Wtime(); pdc_server_timings->PDCreg_transfer_request_inner_write_all_bulk_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_inner_write_all_bulk_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_inner_write_all_bulk_timestamps, start, end); #endif #ifdef TANG_DEBUG @@ -278,8 +278,8 @@ transfer_request_wait_all_bulk_transfer_cb(const struct hg_cb_info *info) pdcid_t transfer_request_id; hg_return_t ret = HG_SUCCESS; int i, fast_return; - char * ptr; - int * handle_ref; + char *ptr; + int *handle_ref; pdc_transfer_status_t status; FUNC_ENTER(NULL); @@ -318,11 +318,11 @@ transfer_request_wait_all_bulk_transfer_cb(const struct hg_cb_info *info) local_bulk_args = (struct transfer_request_wait_all_local_bulk_args *)PDC_free(local_bulk_args); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double end = MPI_Wtime(); pdc_server_timings->PDCreg_transfer_request_wait_all_rpc += end - local_bulk_args->start_time; - pdc_timestamp_register(pdc_transfer_request_wait_all_timestamps, local_bulk_args->start_time, end); + pdc_timestamp_register(&pdc_transfer_request_wait_all_timestamps, local_bulk_args->start_time, end); #endif FUNC_LEAVE(ret); @@ -333,7 +333,7 @@ transfer_request_bulk_transfer_write_cb(const struct hg_cb_info *info) { struct transfer_request_local_bulk_args *local_bulk_args = info->arg; hg_return_t ret = HG_SUCCESS; - struct pdc_region_info * remote_reg_info; + struct pdc_region_info *remote_reg_info; uint64_t obj_dims[3]; FUNC_ENTER(NULL); @@ -346,10 +346,10 @@ transfer_request_bulk_transfer_write_cb(const struct hg_cb_info *info) gettimeofday(&last_cache_activity_timeval_g, NULL); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double end = MPI_Wtime(), start; pdc_server_timings->PDCreg_transfer_request_start_write_bulk_rpc += end - local_bulk_args->start_time; - pdc_timestamp_register(pdc_transfer_request_start_write_bulk_timestamps, local_bulk_args->start_time, + pdc_timestamp_register(&pdc_transfer_request_start_write_bulk_timestamps, local_bulk_args->start_time, end); start = MPI_Wtime(); #endif @@ -387,10 +387,10 @@ transfer_request_bulk_transfer_write_cb(const struct hg_cb_info *info) HG_Bulk_free(local_bulk_args->bulk_handle); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) end = MPI_Wtime(); pdc_server_timings->PDCreg_transfer_request_inner_write_bulk_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_inner_write_bulk_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_inner_write_bulk_timestamps, start, end); #endif FUNC_LEAVE(ret); @@ -403,10 +403,11 @@ transfer_request_bulk_transfer_read_cb(const struct hg_cb_info *info) hg_return_t ret; FUNC_ENTER(NULL); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double end = MPI_Wtime(), start; pdc_server_timings->PDCreg_transfer_request_start_read_bulk_rpc += end - local_bulk_args->start_time; - pdc_timestamp_register(pdc_transfer_request_start_read_bulk_timestamps, local_bulk_args->start_time, end); + pdc_timestamp_register(&pdc_transfer_request_start_read_bulk_timestamps, local_bulk_args->start_time, + end); start = MPI_Wtime(); #endif @@ -420,10 +421,10 @@ transfer_request_bulk_transfer_read_cb(const struct hg_cb_info *info) HG_Bulk_free(local_bulk_args->bulk_handle); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) end = MPI_Wtime(); pdc_server_timings->PDCreg_transfer_request_inner_read_bulk_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_inner_read_bulk_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_inner_read_bulk_timestamps, start, end); #endif FUNC_LEAVE(ret); } @@ -460,10 +461,10 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) transfer_request_wait_out_t out; pdc_transfer_status_t status; int fast_return = 0; - int * handle_ref; + int *handle_ref; FUNC_ENTER(NULL); -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double start = MPI_Wtime(), end; #endif @@ -488,15 +489,15 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) HG_Free_input(handle, &in); } -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) end = MPI_Wtime(); if (in.access_type == PDC_READ) { pdc_server_timings->PDCreg_transfer_request_wait_read_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_wait_read_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_wait_read_timestamps, start, end); } else { pdc_server_timings->PDCreg_transfer_request_wait_write_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_wait_write_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_wait_write_timestamps, start, end); } #endif @@ -509,7 +510,7 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) HG_TEST_RPC_CB(transfer_request_wait_all, handle) { struct transfer_request_wait_all_local_bulk_args *local_bulk_args; - const struct hg_info * info; + const struct hg_info *info; transfer_request_wait_all_in_t in; hg_return_t ret_value = HG_SUCCESS; FUNC_ENTER(NULL); @@ -546,7 +547,7 @@ HG_TEST_RPC_CB(transfer_request_wait_all, handle) HG_TEST_RPC_CB(transfer_request_all, handle) { struct transfer_request_all_local_bulk_args *local_bulk_args; - const struct hg_info * info; + const struct hg_info *info; transfer_request_all_in_t in; transfer_request_all_out_t out; hg_return_t ret_value = HG_SUCCESS; @@ -637,11 +638,11 @@ HG_TEST_RPC_CB(transfer_request_all, handle) end = MPI_Wtime(); if (in.access_type == PDC_READ) { pdc_server_timings->PDCreg_transfer_request_start_all_read_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_start_all_read_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_start_all_read_timestamps, start, end); } else { pdc_server_timings->PDCreg_transfer_request_start_all_write_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_start_all_write_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_start_all_write_timestamps, start, end); } #endif @@ -679,7 +680,7 @@ transfer_request_metadata_query_bulk_transfer_cb(const struct hg_cb_info *info) HG_TEST_RPC_CB(transfer_request_metadata_query, handle) { struct transfer_request_metadata_query_local_bulk_args *local_bulk_args; - const struct hg_info * info; + const struct hg_info *info; transfer_request_metadata_query_in_t in; hg_return_t ret_value = HG_SUCCESS; @@ -734,7 +735,7 @@ transfer_request_metadata_query2_bulk_transfer_cb(const struct hg_cb_info *info) HG_TEST_RPC_CB(transfer_request_metadata_query2, handle) { struct transfer_request_metadata_query2_local_bulk_args *local_bulk_args; - const struct hg_info * info; + const struct hg_info *info; transfer_request_metadata_query2_in_t in; hg_return_t ret_value = HG_SUCCESS; @@ -778,8 +779,8 @@ HG_TEST_RPC_CB(transfer_request, handle) transfer_request_out_t out; struct transfer_request_local_bulk_args *local_bulk_args; size_t total_mem_size; - const struct hg_info * info; - struct pdc_region_info * remote_reg_info; + const struct hg_info *info; + struct pdc_region_info *remote_reg_info; uint64_t obj_dims[3]; FUNC_ENTER(NULL); @@ -876,11 +877,11 @@ HG_TEST_RPC_CB(transfer_request, handle) end = MPI_Wtime(); if (in.access_type == PDC_READ) { pdc_server_timings->PDCreg_transfer_request_start_read_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_start_read_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_start_read_timestamps, start, end); } else { pdc_server_timings->PDCreg_transfer_request_start_write_rpc += end - start; - pdc_timestamp_register(pdc_transfer_request_start_write_timestamps, start, end); + pdc_timestamp_register(&pdc_transfer_request_start_write_timestamps, start, end); } #endif diff --git a/src/tools/pdc_export.c b/src/tools/pdc_export.c index 473bf2e1f..a12f23a67 100644 --- a/src/tools/pdc_export.c +++ b/src/tools/pdc_export.c @@ -9,8 +9,6 @@ #include "hdf5.h" #include "pdc_generic.h" -// #define ENABLE_MPI 1 - #ifdef ENABLE_MPI #include "mpi.h" #endif @@ -28,8 +26,8 @@ int rank = 0, size = 1; pdcid_t pdc_id_g = 0; typedef struct pdc_region_metadata_pkg { - uint64_t * reg_offset; - uint64_t * reg_size; + uint64_t *reg_offset; + uint64_t *reg_size; uint32_t data_server_id; struct pdc_region_metadata_pkg *next; } pdc_region_metadata_pkg; @@ -37,8 +35,8 @@ typedef struct pdc_region_metadata_pkg { typedef struct pdc_obj_metadata_pkg { int ndim; uint64_t obj_id; - pdc_region_metadata_pkg * regions; - pdc_region_metadata_pkg * regions_end; + pdc_region_metadata_pkg *regions; + pdc_region_metadata_pkg *regions_end; struct pdc_obj_metadata_pkg *next; } pdc_obj_metadata_pkg; @@ -51,24 +49,24 @@ typedef struct pdc_obj_region_metadata { typedef struct pdc_metadata_query_buf { uint64_t id; - char * buf; + char *buf; struct pdc_metadata_query_buf *next; } pdc_metadata_query_buf; typedef struct RegionNode { - region_list_t * region_list; + region_list_t *region_list; struct RegionNode *next; } RegionNode; typedef struct MetadataNode { - pdc_metadata_t * metadata_ptr; - struct MetadataNode * next; - RegionNode * region_list_head; + pdc_metadata_t *metadata_ptr; + struct MetadataNode *next; + RegionNode *region_list_head; pdc_obj_metadata_pkg *obj_metadata_pkg; } MetadataNode; typedef struct FileNameNode { - char * file_name; + char *file_name; struct FileNameNode *next; } FileNameNode; @@ -81,7 +79,7 @@ typedef struct ArrayList { ArrayList * newList(void) { - char ** items = malloc(4 * sizeof(char *)); + char **items = malloc(4 * sizeof(char *)); ArrayList *list = malloc(sizeof(ArrayList)); list->length = 0; list->capacity = 4; @@ -161,9 +159,9 @@ main(int argc, char *argv[]) return 1; } else { - FileNameNode * head = NULL; - FileNameNode * cur_node = NULL; - DIR * d; + FileNameNode *head = NULL; + FileNameNode *cur_node = NULL; + DIR *d; struct dirent *dir; d = opendir(argv[1]); if (d) { @@ -206,7 +204,7 @@ main(int argc, char *argv[]) FILE *file = fopen(argv[1], "r"); if (file != NULL) { FileNameNode *new_node = (FileNameNode *)malloc(sizeof(FileNameNode)); - char * full_path = (char *)malloc(sizeof(char) * (strlen(argv[1]) + 1)); + char *full_path = (char *)malloc(sizeof(char) * (strlen(argv[1]) + 1)); strcpy(full_path, argv[1]); new_node->file_name = full_path; new_node->next = NULL; @@ -275,12 +273,12 @@ do_transfer_request_metadata(int pdc_server_size_input, char *checkpoint) int n_objs, reg_count; int i, j; - pdc_obj_metadata_pkg * metadata_server_objs = NULL; - pdc_obj_metadata_pkg * metadata_server_objs_end = NULL; + pdc_obj_metadata_pkg *metadata_server_objs = NULL; + pdc_obj_metadata_pkg *metadata_server_objs_end = NULL; pdc_metadata_query_buf *metadata_query_buf_head = NULL; pdc_metadata_query_buf *metadata_query_buf_end = NULL; int pdc_server_size = pdc_server_size_input; - uint64_t * data_server_bytes = (uint64_t *)calloc(pdc_server_size, sizeof(uint64_t)); + uint64_t *data_server_bytes = (uint64_t *)calloc(pdc_server_size, sizeof(uint64_t)); uint64_t query_id_g = 100000; ptr = checkpoint; @@ -359,9 +357,9 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) arg_index++; } - char * filename; + char *filename; MetadataNode *metadata_head = NULL; - RegionNode * cur_region_node = NULL; + RegionNode *cur_region_node = NULL; FileNameNode *cur_file_node = file_name_node; int all_cont_total = 0; @@ -381,12 +379,12 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) int n_entry, count, i, j, nobj = 0, all_nobj = 0, all_n_region, n_region, n_objs, total_region = 0, n_kvtag, key_len; int n_cont, all_cont; - pdc_metadata_t * metadata, *elt; - region_list_t * region_list; - uint32_t * hash_key; + pdc_metadata_t *metadata, *elt; + region_list_t *region_list; + uint32_t *hash_key; unsigned idx; pdc_cont_hash_table_entry_t *cont_entry; - pdc_hash_table_entry_head * entry; + pdc_hash_table_entry_head *entry; FILE *file = fopen(filename, "r"); if (file == NULL) { @@ -600,7 +598,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) } uint64_t checkpoint_size; - char * checkpoint_buf; + char *checkpoint_buf; if (fread(&checkpoint_size, sizeof(uint64_t), 1, file) != 1) { LOG_ERROR("Read failed for checkpoint size\n"); @@ -644,7 +642,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) } int prev_cont_id = -1; - MetadataNode * cur_metadata_node = metadata_head; + MetadataNode *cur_metadata_node = metadata_head; pdc_metadata_t *cur_metadata; hid_t file_id; fflush(stdout); @@ -679,7 +677,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) char *full_path = (char *)malloc(sizeof(char) * strlen(cur_metadata->obj_name) + 1); strcpy(full_path, cur_metadata->obj_name); - char * last_slash = strrchr(full_path, '/'); + char *last_slash = strrchr(full_path, '/'); size_t length = last_slash - full_path + 1; char temp[length + 1]; memcpy(temp, full_path, length); @@ -693,7 +691,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) char *cur_path = (char *)malloc(sizeof(char) * strlen(cur_metadata->obj_name) + strlen(buf) + 1); strcpy(cur_path, buf); const char delim[2] = "/"; - char * token; + char *token; token = strtok(temp, delim); hid_t cur_group_id = group_id; while (token != NULL) { @@ -720,7 +718,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) buf_size *= (cur_metadata->dims)[i]; } hsize_t dtype_size = H5Tget_size(data_type); - void * data_buf = malloc(buf_size * dtype_size); // if data side is large, need to write in batches + void *data_buf = malloc(buf_size * dtype_size); // if data side is large, need to write in batches uint64_t region_offset[10], region_size[10]; for (int i = 0; i < cur_metadata->ndim; i++) { diff --git a/src/tools/pdc_import.c b/src/tools/pdc_import.c index 0fb670df6..96c8e3627 100644 --- a/src/tools/pdc_import.c +++ b/src/tools/pdc_import.c @@ -4,8 +4,6 @@ #include #include -// #define ENABLE_MPI 1 - #ifdef ENABLE_MPI #include "mpi.h" #endif @@ -30,7 +28,7 @@ typedef struct ArrayList { ArrayList * newList(void) { - char ** items = malloc(4 * sizeof(char *)); + char **items = malloc(4 * sizeof(char *)); ArrayList *list = malloc(sizeof(ArrayList)); list->length = 0; list->capacity = 4; @@ -76,7 +74,7 @@ print_usage() int rank = 0, size = 1; char tags_g[MAX_TAG_SIZE]; -char * tags_ptr_g; +char *tags_ptr_g; char dset_name_g[TAG_LEN_MAX]; hsize_t tag_size_g; int ndset_g = 0; @@ -379,11 +377,11 @@ do_dset(hid_t did, char *name, char *app_name) hsize_t dtype_size, dset_size; char ds_name[MAX_NAME]; char grp_name[MAX_NAME]; - char * obj_name; + char *obj_name; int name_len, i; hsize_t ndim, dims[10]; uint64_t region_offset[10], region_size[10]; - void * buf; + void *buf; struct pdc_region_info obj_region; tag_size_g = 0; @@ -523,8 +521,8 @@ do_dtype(hid_t tid, hid_t oid, int is_compound) herr_t status; int compound_nmember, i; hsize_t dims[8], ndim; - char * mem_name; - char * attr_string[100], new_string[TAG_LEN_MAX], tmp_str[TAG_LEN_MAX]; + char *mem_name; + char *attr_string[100], new_string[TAG_LEN_MAX], tmp_str[TAG_LEN_MAX]; hsize_t attr_size, attr_len; hid_t mem_type; hid_t atype, aspace, naive_type; @@ -627,8 +625,8 @@ do_attr(hid_t aid, pdcid_t obj_id) char buf[MAX_NAME] = {0}; char read_buf[TAG_LEN_MAX] = {0}; // pdc_kvtag_t kvtag1; - char * tag_name; - void * tag_value; + char *tag_name; + void *tag_value; pdc_var_type_t value_type; size_t tag_size; From 0016ba73f2e36ce60658688a1fd890dc7d39b6fe Mon Sep 17 00:00:00 2001 From: github-actions Date: Sat, 7 Jun 2025 21:06:49 +0000 Subject: [PATCH 2/2] Committing clang-format changes --- src/api/pdc_client_connect.c | 212 +++++++-------- src/commons/utils/include/pdc_timing.h | 6 +- src/server/pdc_client_server_common.c | 210 +++++++-------- src/server/pdc_server.c | 62 ++--- .../pdc_server_region/pdc_server_data.c | 248 +++++++++--------- .../pdc_server_region_request_handler.h | 30 +-- src/tools/pdc_export.c | 58 ++-- src/tools/pdc_import.c | 16 +- 8 files changed, 421 insertions(+), 421 deletions(-) diff --git a/src/api/pdc_client_connect.c b/src/api/pdc_client_connect.c index 72a454f6f..7f1498c06 100644 --- a/src/api/pdc_client_connect.c +++ b/src/api/pdc_client_connect.c @@ -95,7 +95,7 @@ int pdc_nclient_per_server_g = 0; char pdc_client_tmp_dir_g[ADDR_MAX]; struct _pdc_server_info *pdc_server_info_g = NULL; -static int *debug_server_id_count = NULL; +static int * debug_server_id_count = NULL; int pdc_io_request_seq_id = PDC_SEQ_ID_INIT_VALUE; struct pdc_request *pdc_io_request_list_g = NULL; @@ -111,7 +111,7 @@ int nread_bb_g = 0; double read_bb_size_g = 0.0; static int mercury_has_init_g = 0; -static hg_class_t *send_class_g = NULL; +static hg_class_t * send_class_g = NULL; static hg_context_t *send_context_g = NULL; int query_id_g = 0; @@ -126,7 +126,7 @@ static hg_atomic_int32_t response_done_g; hg_atomic_int32_t bulk_transfer_done_g; // global variables for DART -static DART *dart_g; +static DART * dart_g; static dart_hash_algo_t dart_hash_algo_g = DART_HASH; static dart_object_ref_type_t dart_obj_ref_type_g = REF_PRIMARY_ID; @@ -390,8 +390,8 @@ PDC_Client_read_server_addr_from_file() perr_t ret_value = SUCCEED; int max_tries = 9, sleeptime = 1; int i = 0, is_server_ready = 0; - char *p; - FILE *na_config = NULL; + char * p; + FILE * na_config = NULL; char config_fname[PATH_MAX]; char n_server_string[PATH_MAX]; @@ -474,7 +474,7 @@ client_send_flush_obj_all_rpc_cb(const struct hg_cb_info *callback_info) hg_return_t ret_value = HG_SUCCESS; hg_handle_t handle; flush_obj_all_out_t output; - int *rpc_return; + int * rpc_return; FUNC_ENTER(NULL); @@ -530,7 +530,7 @@ client_send_flush_obj_rpc_cb(const struct hg_cb_info *callback_info) hg_return_t ret_value = HG_SUCCESS; hg_handle_t handle; flush_obj_out_t output; - int *rpc_return; + int * rpc_return; FUNC_ENTER(NULL); @@ -558,7 +558,7 @@ client_send_close_all_server_rpc_cb(const struct hg_cb_info *callback_info) hg_return_t ret_value = HG_SUCCESS; hg_handle_t handle; close_server_out_t output; - int *rpc_return; + int * rpc_return; FUNC_ENTER(NULL); @@ -942,7 +942,7 @@ PDC_Client_lookup_server(int server_id, int is_init) hg_return_t hg_ret; struct _pdc_client_lookup_args lookup_args; char self_addr[ADDR_MAX]; - char *target_addr_string; + char * target_addr_string; FUNC_ENTER(NULL); @@ -1217,14 +1217,14 @@ hg_test_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args; hg_bulk_t local_bulk_handle; uint32_t i; - void *buf = NULL; - void **ids_buf; + void * buf = NULL; + void ** ids_buf; uint32_t n_meta; uint64_t buf_sizes[2] = {0, 0}; - uint64_t *ids_buf_sizes; + uint64_t * ids_buf_sizes; uint32_t actual_cnt; - pdc_metadata_t *meta_ptr; - uint64_t *u64_arr_ptr; + pdc_metadata_t * meta_ptr; + uint64_t * u64_arr_ptr; uint32_t bulk_sgnum; FUNC_ENTER(NULL); @@ -1326,7 +1326,7 @@ PDC_Client_check_bulk(hg_context_t *hg_context) static const char * drc_strerror(int errnum) { - char *ret_value = NULL; + char * ret_value = NULL; const char *errstring = "UNDEFINED"; FUNC_ENTER(NULL); @@ -1355,7 +1355,7 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po { perr_t ret_value = SUCCEED; char na_info_string[NA_STRING_INFO_LEN]; - char *hostname; + char * hostname; pbool_t free_hostname = false; int local_server_id; /* Set the default mercury transport @@ -1365,13 +1365,13 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po * "cci+tcp" */ struct hg_init_info init_info = {0}; - char *default_hg_transport = "ofi+tcp"; - char *hg_transport; + char * default_hg_transport = "ofi+tcp"; + char * hg_transport; #ifdef PDC_HAS_CRAY_DRC uint32_t credential, cookie; drc_info_handle_t credential_info; char pdc_auth_key[256] = {'\0'}; - char *auth_key; + char * auth_key; int rc; #endif @@ -1571,7 +1571,7 @@ PDC_Client_init() { perr_t ret_value = SUCCEED; pdc_server_info_g = NULL; - char *tmp_dir; + char * tmp_dir; uint32_t port; int is_mpi_init = 0; @@ -1768,16 +1768,16 @@ static hg_return_t metadata_query_bulk_cb(const struct hg_cb_info *callback_info) { hg_return_t ret_value; - struct bulk_args_t *client_lookup_args; + struct bulk_args_t * client_lookup_args; hg_handle_t handle; metadata_query_transfer_out_t output; uint32_t n_meta; hg_op_id_t hg_bulk_op_id; hg_bulk_t local_bulk_handle = HG_BULK_NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; - const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args; - void *recv_meta; + const struct hg_info * hg_info = NULL; + struct bulk_args_t * bulk_args; + void * recv_meta; FUNC_ENTER(NULL); @@ -2187,7 +2187,7 @@ PDC_Client_add_tag(pdcid_t obj_id, const char *tag) hg_handle_t metadata_add_tag_handle; uint64_t meta_id; uint32_t server_id; - struct _pdc_obj_info *obj_prop; + struct _pdc_obj_info * obj_prop; struct _pdc_client_lookup_args lookup_args; metadata_add_tag_in_t in; @@ -2408,7 +2408,7 @@ PDC_Client_delete_metadata(char *delete_name, pdcid_t obj_delete_prop) { perr_t ret_value = SUCCEED; hg_return_t hg_ret = 0; - struct _pdc_obj_prop *delete_prop; + struct _pdc_obj_prop * delete_prop; metadata_delete_in_t in; int hash_name_value; uint32_t server_id; @@ -2468,7 +2468,7 @@ PDC_Client_query_metadata_name_only(const char *obj_name, pdc_metadata_t **out) struct _pdc_metadata_query_args **lookup_args; uint32_t server_id; uint32_t i, count = 0; - hg_handle_t *metadata_query_handle; + hg_handle_t * metadata_query_handle; FUNC_ENTER(NULL); @@ -2769,7 +2769,7 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj perr_t ret_value = SUCCEED; hg_return_t hg_ret; uint32_t server_id = 0; - struct _pdc_obj_prop *create_prop = NULL; + struct _pdc_obj_prop * create_prop = NULL; gen_obj_id_in_t in; uint32_t hash_name_value; struct _pdc_client_lookup_args lookup_args; @@ -2924,7 +2924,7 @@ PDC_Client_close_all_server() if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "PDC_Client_close_all_server(): Could not destroy handle"); } // End pdc_client_mpi_rank_g < pdc_server_num_g - } // End pdc_client_mpi_size_g >= pdc_server_num_g + } // End pdc_client_mpi_size_g >= pdc_server_num_g else { if (pdc_client_mpi_rank_g == 0) { for (i = 0; i < (uint32_t)pdc_server_num_g; i++) { @@ -2953,7 +2953,7 @@ PDC_Client_close_all_server() PGOTO_ERROR(FAIL, "PDC_Client_close_all_server(): Could not destroy handle"); } } // End of mpi_rank == 0 - } // End pdc_client_mpi_size_g < pdc_server_num_g + } // End pdc_client_mpi_size_g < pdc_server_num_g #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -3135,7 +3135,7 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_all_in_t in; - hg_class_t *hg_class; + hg_class_t * hg_class; int i; hg_handle_t client_send_transfer_request_all_handle; struct _pdc_transfer_request_all_args transfer_args; @@ -3237,7 +3237,7 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_metadata_query2_in_t in; - hg_class_t *hg_class; + hg_class_t * hg_class; hg_handle_t client_send_transfer_request_metadata_query2_handle; struct _pdc_transfer_request_metadata_query2_args transfer_args; PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); @@ -3296,7 +3296,7 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_metadata_query_in_t in; - hg_class_t *hg_class; + hg_class_t * hg_class; hg_handle_t client_send_transfer_request_metadata_query_handle; struct _pdc_transfer_request_metadata_query_args transfer_args; PDC_TIMING_DECLARE(PDC_CLIENT_TRANSFER_REQUEST_METADATA_QUERY_RPC_TIME); @@ -3357,7 +3357,7 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_wait_all_in_t in; - hg_class_t *hg_class; + hg_class_t * hg_class; hg_handle_t client_send_transfer_request_wait_all_handle; struct _pdc_transfer_request_wait_all_args transfer_args; char cur_time[64]; @@ -3427,7 +3427,7 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, perr_t ret_value = SUCCEED; hg_return_t hg_ret = HG_SUCCESS; transfer_request_in_t in; - hg_class_t *hg_class; + hg_class_t * hg_class; uint32_t meta_server_id; hg_size_t total_data_size; int i; @@ -3640,12 +3640,12 @@ PDC_Client_buf_map(pdcid_t local_region_id, pdcid_t remote_obj_id, size_t ndim, hg_return_t hg_ret = HG_SUCCESS; buf_map_in_t in; uint32_t data_server_id, meta_server_id; - hg_class_t *hg_class; + hg_class_t * hg_class; hg_uint32_t i, j; hg_uint32_t local_count; - void **data_ptrs = NULL; - size_t *data_size = NULL; + void ** data_ptrs = NULL; + size_t * data_size = NULL; size_t unit, unit_to; struct _pdc_buf_map_args map_args; hg_handle_t client_send_buf_map_handle; @@ -4006,11 +4006,11 @@ PDC_Client_get_data_from_server_shm_cb(const struct hg_cb_info *callback_info) int shm_fd = -1; // file descriptor, from shm_open() uint32_t i = 0; - char *shm_base = NULL; // base address, from mmap() - char *shm_addr = NULL; + char * shm_base = NULL; // base address, from mmap() + char * shm_addr = NULL; uint64_t data_size = 1; - client_read_info_t *read_info = NULL; - struct pdc_request *elt = NULL; + client_read_info_t * read_info = NULL; + struct pdc_request * elt = NULL; struct pdc_region_info *target_region = NULL; #ifdef ENABLE_TIMING struct timeval pdc_timer_start; @@ -4101,8 +4101,8 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat uint64_t read_size = 1; hg_handle_t data_server_read_check_handle; int shm_fd; // file descriptor, from shm_open() - char *shm_base; // base address, from mmap() - char *shm_addr; + char * shm_base; // base address, from mmap() + char * shm_addr; #ifdef ENABLE_TIMING struct timeval pdc_timer_start; struct timeval pdc_timer_end; @@ -4237,8 +4237,8 @@ PDC_Client_data_server_read(struct pdc_request *request) data_server_read_in_t in; hg_handle_t data_server_read_handle; int server_id, n_client, n_update; - pdc_metadata_t *meta; - struct pdc_region_info *region; + pdc_metadata_t * meta; + struct pdc_region_info * region; FUNC_ENTER(NULL); @@ -4370,8 +4370,8 @@ PDC_Client_data_server_write_check(struct pdc_request *request, int *status) data_server_write_check_in_t in; hg_handle_t data_server_write_check_handle; int server_id; - pdc_metadata_t *meta; - struct pdc_region_info *region; + pdc_metadata_t * meta; + struct pdc_region_info * region; uint64_t write_size = 1; uint32_t i; @@ -4472,9 +4472,9 @@ PDC_Client_data_server_write(struct pdc_request *request) int server_ret; hg_handle_t data_server_write_handle; int server_id, n_client, n_update; - pdc_metadata_t *meta; - struct pdc_region_info *region; - void *buf; + pdc_metadata_t * meta; + struct pdc_region_info * region; + void * buf; int rnd; #ifdef ENABLE_TIMING @@ -4530,7 +4530,7 @@ PDC_Client_data_server_write(struct pdc_request *request) request->shm_base = mmap(0, region_size, PROT_READ | PROT_WRITE, MAP_SHARED, request->shm_fd, 0); if (request->shm_base == MAP_FAILED) PGOTO_ERROR(FAIL, "==PDC_CLIENT: Shared memory mmap failed, region size = %" PRIu64 "", region_size); - // close and shm_unlink? + // close and shm_unlink? #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_start, 0); @@ -4742,7 +4742,7 @@ PDC_Client_write_id(pdcid_t local_obj_id, struct pdc_region_info *region, void * struct _pdc_id_info *info; struct _pdc_obj_info *object; - pdc_metadata_t *meta; + pdc_metadata_t * meta; perr_t ret_value = SUCCEED; FUNC_ENTER(NULL); @@ -4973,7 +4973,7 @@ PDC_Client_add_objects_to_container(int nobj, pdcid_t *local_obj_ids, pdcid_t lo { perr_t ret_value = SUCCEED; int i; - uint64_t *obj_ids; + uint64_t * obj_ids; uint64_t cont_meta_id; struct _pdc_id_info *id_info = NULL; @@ -4999,7 +4999,7 @@ PDC_Client_del_objects_to_container(int nobj, pdcid_t *local_obj_ids, pdcid_t lo { perr_t ret_value = SUCCEED; int i; - uint64_t *obj_ids; + uint64_t * obj_ids; uint64_t cont_meta_id; struct _pdc_id_info *id_info = NULL; @@ -5027,7 +5027,7 @@ PDC_Client_add_tags_to_container(pdcid_t cont_id, char *tags) hg_return_t hg_ret = HG_SUCCESS; hg_handle_t rpc_handle; uint32_t server_id; - struct _pdc_id_info *info; + struct _pdc_id_info * info; struct _pdc_cont_info *object; uint64_t cont_meta_id; cont_add_tags_rpc_in_t add_tag_rpc_in; @@ -5282,12 +5282,12 @@ PDC_Client_query_name_read_entire_obj(int nobj, char **obj_names, void ***out_bu hg_handle_t rpc_handle; hg_bulk_t bulk_handle; uint32_t server_id; - uint64_t *buf_sizes, total_size; + uint64_t * buf_sizes, total_size; int i; query_read_obj_name_in_t bulk_rpc_in; // Reuse the existing args structure update_region_storage_meta_bulk_args_t cb_args; - struct pdc_request *request; + struct pdc_request * request; FUNC_ENTER(NULL); @@ -5574,7 +5574,7 @@ static region_list_t * PDC_get_storage_meta_from_io_list(pdc_data_server_io_list_t **list, region_storage_meta_t *storage_meta) { pdc_data_server_io_list_t *io_list_elt, *io_list_target = NULL; - region_list_t *ret_value = NULL; + region_list_t * ret_value = NULL; FUNC_ENTER(NULL); @@ -5600,7 +5600,7 @@ PDC_add_storage_meta_to_io_list(pdc_data_server_io_list_t **list, region_storage { pdc_data_server_io_list_t *io_list_elt, *io_list_target = NULL; - region_list_t *new_region; + region_list_t * new_region; int j; perr_t ret_value = SUCCEED; @@ -5667,7 +5667,7 @@ PDC_send_region_storage_meta_shm(uint32_t server_id, int n, region_storage_meta_ buf_sizes = n * sizeof(region_storage_meta_t); hg_ret = HG_Bulk_create(send_class_g, 1, (void **)&storage_meta, (const hg_size_t *)&buf_sizes, - HG_BULK_READ_ONLY, &bulk_handle); + HG_BULK_READ_ONLY, &bulk_handle); if (hg_ret != HG_SUCCESS) PGOTO_ERROR(FAIL, "Could not create bulk data handle"); @@ -5700,7 +5700,7 @@ PDC_Client_cp_data_to_local_server(int nobj, region_storage_meta_t **all_storage perr_t ret_value = SUCCEED; uint32_t ndim, server_id; uint64_t total_size = 0, cp_loc = 0; - void *buf = NULL; + void * buf = NULL; char shm_addr[ADDR_MAX]; int i, *total_obj = NULL, ntotal_obj = nobj, *recvcounts = NULL, *displs = NULL; region_storage_meta_t *all_region_storage_meta_1d = NULL, *my_region_storage_meta_1d = NULL; @@ -5812,8 +5812,8 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ { perr_t ret_value = SUCCEED; int i; - char *fname, *prev_fname; - FILE *fp_read = NULL; + char * fname, *prev_fname; + FILE * fp_read = NULL; uint32_t ndim; uint64_t req_start, req_count, storage_start, storage_count, file_offset, buf_size; size_t read_bytes; @@ -5914,15 +5914,15 @@ PDC_Client_query_multi_storage_info(int nobj, char **obj_names, region_storage_m hg_bulk_t bulk_handle; uint32_t server_id; - uint64_t *buf_sizes = NULL, total_size; + uint64_t * buf_sizes = NULL, total_size; int i, j, loc, iter, *n_obj_name_by_server = NULL; - int **obj_names_server_seq_mapping = NULL, *obj_names_server_seq_mapping_1d; + int ** obj_names_server_seq_mapping = NULL, *obj_names_server_seq_mapping_1d; int send_n_request = 0; - char ***obj_names_by_server = NULL; - char **obj_names_by_server_2d = NULL; + char *** obj_names_by_server = NULL; + char ** obj_names_by_server_2d = NULL; query_read_obj_name_in_t bulk_rpc_in; update_region_storage_meta_bulk_args_t cb_args; - struct pdc_request **requests, *request; + struct pdc_request ** requests, *request; FUNC_ENTER(NULL); @@ -6145,12 +6145,12 @@ PDC_Client_query_name_read_entire_obj_client_agg(int my_nobj, char **my_obj_name size_t *out_buf_sizes) { perr_t ret_value = SUCCEED; - char **all_names = my_obj_names; - char *local_names_1d, *all_names_1d = NULL; - int *total_obj = NULL, i, ntotal_obj = my_nobj, *recvcounts = NULL, *displs = NULL; + char ** all_names = my_obj_names; + char * local_names_1d, *all_names_1d = NULL; + int * total_obj = NULL, i, ntotal_obj = my_nobj, *recvcounts = NULL, *displs = NULL; size_t max_name_len = 64; region_storage_meta_t **all_storage_meta = NULL, **my_storage_meta = NULL; - region_storage_meta_t *my_storage_meta_1d = NULL, *res_storage_meta_1d = NULL; + region_storage_meta_t * my_storage_meta_1d = NULL, *res_storage_meta_1d = NULL; #ifdef ENABLE_TIMING struct timeval pdc_timer1; @@ -6441,7 +6441,7 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re *total_read_bytes += read_bytes; } // for each row - } // ndim=2 + } // ndim=2 else if (ndim == 3) { if (is_client_debug_g == 1) { @@ -6512,8 +6512,8 @@ PDC_add_kvtag(pdcid_t obj_id, pdc_kvtag_t *kvtag, int is_cont) uint32_t server_id; hg_handle_t metadata_add_kvtag_handle; metadata_add_kvtag_in_t in; - struct _pdc_obj_info *obj_prop; - struct _pdc_cont_info *cont_prop; + struct _pdc_obj_info * obj_prop; + struct _pdc_cont_info * cont_prop; struct _pdc_client_lookup_args lookup_args; FUNC_ENTER(NULL); @@ -6620,8 +6620,8 @@ PDC_get_kvtag(pdcid_t obj_id, char *tag_name, pdc_kvtag_t **kvtag, int is_cont) hg_handle_t metadata_get_kvtag_handle; metadata_get_kvtag_in_t in; struct _pdc_get_kvtag_args lookup_args; - struct _pdc_obj_info *obj_prop; - struct _pdc_cont_info *cont_prop; + struct _pdc_obj_info * obj_prop; + struct _pdc_cont_info * cont_prop; FUNC_ENTER(NULL); @@ -6681,12 +6681,12 @@ kvtag_query_bulk_cb(const struct hg_cb_info *hg_cb_info) hg_bulk_t origin_bulk_handle = hg_cb_info->info.bulk.origin_handle; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; uint32_t n_meta, actual_cnt; - void *buf = NULL; + void * buf = NULL; uint64_t buf_sizes[1]; uint32_t bulk_sgnum; - uint64_t *ids_buf_sizes; - void **ids_buf; - uint64_t *u64_arr_ptr; + uint64_t * ids_buf_sizes; + void ** ids_buf; + uint64_t * u64_arr_ptr; FUNC_ENTER(NULL); @@ -6739,14 +6739,14 @@ static hg_return_t kvtag_query_forward_cb(const struct hg_cb_info *callback_info) { hg_return_t ret_value; - struct bulk_args_t *bulk_arg; + struct bulk_args_t * bulk_arg; hg_handle_t handle; metadata_query_transfer_out_t output; uint32_t n_meta; hg_op_id_t hg_bulk_op_id; hg_bulk_t local_bulk_handle = HG_BULK_NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; - const struct hg_info *hg_info = NULL; + const struct hg_info * hg_info = NULL; FUNC_ENTER(NULL); @@ -6924,8 +6924,8 @@ PDCtag_delete(pdcid_t obj_id, char *tag_name, int is_cont) uint32_t server_id; hg_handle_t metadata_del_kvtag_handle; metadata_get_kvtag_in_t in; - struct _pdc_obj_info *obj_prop; - struct _pdc_cont_info *cont_prop; + struct _pdc_obj_info * obj_prop; + struct _pdc_cont_info * cont_prop; struct _pdc_client_lookup_args lookup_args; FUNC_ENTER(NULL); @@ -7167,7 +7167,7 @@ PDCobj_put_data(const char *obj_name, void *data, uint64_t size, pdcid_t cont_id perr_t ret; // pdc_metadata_t *meta; struct _pdc_cont_info *info = NULL; - struct _pdc_id_info *id_info = NULL; + struct _pdc_id_info * id_info = NULL; pdcid_t transfer_request; FUNC_ENTER(NULL); @@ -7273,7 +7273,7 @@ PDC_Client_del_metadata(pdcid_t obj_id, int is_cont) { perr_t ret_value = SUCCEED; uint64_t meta_id; - struct _pdc_obj_info *obj_prop; + struct _pdc_obj_info * obj_prop; struct _pdc_cont_info *cont_prop; FUNC_ENTER(NULL); @@ -7406,7 +7406,7 @@ hg_return_t PDC_recv_nhits(const struct hg_cb_info *callback_info) { hg_return_t ret_value = HG_SUCCESS; - send_nhits_t *in = (send_nhits_t *)callback_info->arg; + send_nhits_t * in = (send_nhits_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; FUNC_ENTER(NULL); @@ -7434,10 +7434,10 @@ PDC_send_data_query(pdc_query_t *query, pdc_query_get_op_t get_op, uint64_t *nhi { perr_t ret_value = SUCCEED; hg_return_t hg_ret = 0; - uint32_t *target_servers = NULL; + uint32_t * target_servers = NULL; int i, server_id, next_server = 0, prev_server = 0, ntarget = 0; hg_handle_t handle; - pdc_query_xfer_t *query_xfer; + pdc_query_xfer_t * query_xfer; struct _pdc_client_lookup_args lookup_args; struct _pdc_query_result_list *result; @@ -7525,12 +7525,12 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) { hg_return_t ret_value = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; - struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; uint64_t nhits = 0; uint32_t ndim; int query_id, origin; - void *buf; + void * buf; pdc_int_ret_t out; FUNC_ENTER(NULL); @@ -7611,7 +7611,7 @@ PDC_Client_get_sel_data(pdcid_t obj_id, pdc_selection_t *sel, void *data) uint64_t meta_id, off; get_sel_data_rpc_in_t in; struct _pdc_client_lookup_args lookup_args; - struct _pdc_obj_info *obj_prop; + struct _pdc_obj_info * obj_prop; struct _pdc_query_result_list *result_elt; FUNC_ENTER(NULL); @@ -7683,11 +7683,11 @@ PDC_recv_read_coords_data(const struct hg_cb_info *callback_info) { hg_return_t ret_value = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; - struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; uint64_t nhits = 0; int query_id, seq_id; - void *buf; + void * buf; pdc_int_ret_t out; FUNC_ENTER(NULL); @@ -7759,9 +7759,9 @@ report_avg_server_profiling_rst() { for (int i = 0; i < pdc_server_num_g; i++) { - double avg_srv_time = server_call_count_g[i] > 0 - ? (double)(server_time_total_g[i]) / (double)(server_call_count_g[i]) - : 0.0; + double avg_srv_time = server_call_count_g[i] > 0 + ? (double)(server_time_total_g[i]) / (double)(server_call_count_g[i]) + : 0.0; double srv_mem_usage = server_mem_usage_g[i] / 1024.0 / 1024.0; LOG_INFO("==PDC_CLIENT[%d]: server %d, avg profiling time: %.4f ms, memory usage: %.4f MB\n", pdc_client_mpi_rank_g, i, avg_srv_time / 1000.0, srv_mem_usage); @@ -7901,7 +7901,7 @@ static hg_return_t dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) { hg_return_t ret_value; - struct bulk_args_t *client_lookup_args; + struct bulk_args_t * client_lookup_args; hg_handle_t handle; dart_perform_one_server_out_t output; uint32_t n_meta; @@ -7910,8 +7910,8 @@ dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) hg_bulk_t local_bulk_handle = HG_BULK_NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args; - void *recv_meta; + struct bulk_args_t * bulk_args; + void * recv_meta; FUNC_ENTER(NULL); @@ -8080,7 +8080,7 @@ dart_perform_on_servers(index_hash_result_t **hash_result, int num_servers, struct bulk_args_t *lookup_args = (struct bulk_args_t *)PDC_calloc(num_servers, sizeof(struct bulk_args_t)); uint64_t ret_value = 0; - hg_handle_t *dart_request_handles = (hg_handle_t *)PDC_calloc(num_servers, sizeof(hg_handle_t)); + hg_handle_t * dart_request_handles = (hg_handle_t *)PDC_calloc(num_servers, sizeof(hg_handle_t)); int num_requests = 0; uint32_t total_n_meta = 0; dart_op_type_t op_type = dart_in->op_type; @@ -8144,9 +8144,9 @@ PDC_Client_search_obj_ref_through_dart(dart_hash_algo_t hash_algo, char *query_s stopwatch_t timer; timer_start(&timer); - char *k_query = get_key(query_string, '='); - char *v_query = get_value(query_string, '='); - char *tok = NULL; + char * k_query = get_key(query_string, '='); + char * v_query = get_value(query_string, '='); + char * tok = NULL; dart_op_type_t dart_op; dart_determine_query_token_by_key_query(k_query, &tok, &dart_op); diff --git a/src/commons/utils/include/pdc_timing.h b/src/commons/utils/include/pdc_timing.h index adabc68cf..96fea2608 100644 --- a/src/commons/utils/include/pdc_timing.h +++ b/src/commons/utils/include/pdc_timing.h @@ -192,9 +192,9 @@ void PDC_client_timing_init(); void PDC_client_timing_finalize(); void PDC_client_timing_report(const char *prefix); #else -void PDC_server_timing_init(); -void PDC_server_timing_finalize(); -void PDC_server_timing_report(const char *prefix); +void PDC_server_timing_init(); +void PDC_server_timing_finalize(); +void PDC_server_timing_report(const char *prefix); #endif /** diff --git a/src/server/pdc_client_server_common.c b/src/server/pdc_client_server_common.c index a48267e90..a649c4706 100644 --- a/src/server/pdc_client_server_common.c +++ b/src/server/pdc_client_server_common.c @@ -1571,7 +1571,7 @@ HG_TEST_RPC_CB(metadata_query, handle) hg_return_t ret_value = HG_SUCCESS; metadata_query_in_t in; metadata_query_out_t out; - pdc_metadata_t *query_result = NULL; + pdc_metadata_t * query_result = NULL; FUNC_ENTER(NULL); @@ -1612,7 +1612,7 @@ HG_TEST_RPC_CB(obj_reset_dims, handle) hg_return_t ret_value = HG_SUCCESS; obj_reset_dims_in_t in; obj_reset_dims_out_t out; - pdc_metadata_t *query_result = NULL; + pdc_metadata_t * query_result = NULL; FUNC_ENTER(NULL); @@ -2000,7 +2000,7 @@ pdc_region_write_out_progress(void *arg) { HG_THREAD_RETURN_TYPE ret_value = (HG_THREAD_RETURN_TYPE)0; struct buf_map_release_bulk_args *bulk_args = (struct buf_map_release_bulk_args *)arg; - struct pdc_region_info *remote_reg_info = NULL; + struct pdc_region_info * remote_reg_info = NULL; region_lock_out_t out; FUNC_ENTER(NULL); @@ -2100,7 +2100,7 @@ pdc_region_read_from_progress(void *arg) { HG_THREAD_RETURN_TYPE ret_value = (HG_THREAD_RETURN_TYPE)0; struct buf_map_release_bulk_args *bulk_args = (struct buf_map_release_bulk_args *)arg; - const struct hg_info *hg_info = NULL; + const struct hg_info * hg_info = NULL; hg_return_t hg_ret; size_t size; int error = 0; @@ -2153,21 +2153,21 @@ transform_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_inf hg_return_t ret_value = HG_SUCCESS; region_lock_out_t out; struct buf_map_transform_and_release_bulk_args *bulk_args = NULL; - void *data_buf; - char *buf; + void * data_buf; + char * buf; int ndim; int transform_id; int type_extent = 0; int use_transform_size = 0; size_t unit = 1; int64_t transform_size, expected_size; - uint64_t *dims = NULL; + uint64_t * dims = NULL; pdc_var_type_t destType; - struct _pdc_region_transform_ftn_info **registry = NULL; + struct _pdc_region_transform_ftn_info ** registry = NULL; int registered_count; #ifdef ENABLE_MULTITHREAD data_server_region_t *target_reg = NULL; - region_buf_map_t *elt; + region_buf_map_t * elt; #else struct pdc_region_info *remote_reg_info = NULL; #endif @@ -2338,12 +2338,12 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info hg_return_t ret_value = HG_SUCCESS; region_lock_out_t out; struct buf_map_analysis_and_release_bulk_args *bulk_args = NULL; - void *data_buf; + void * data_buf; int ndim; uint64_t type_extent; - uint64_t *dims = NULL; - struct pdc_region_info *remote_reg_info = NULL; - struct pdc_region_info *local_reg_info = NULL; + uint64_t * dims = NULL; + struct pdc_region_info * remote_reg_info = NULL; + struct pdc_region_info * local_reg_info = NULL; double start_t, end_t, analysis_t, io_t; double averages[4]; @@ -2396,7 +2396,7 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info int registered_count = PDC_get_analysis_registry(®istry); if ((registered_count >= analysis_meta_index) && (registry != NULL)) { - int (*analysis_ftn)(pdcid_t iterIn, pdcid_t iterOut, struct _pdc_iterator_cbs_t *_cbs) = + int (*analysis_ftn)(pdcid_t iterIn, pdcid_t iterOut, struct _pdc_iterator_cbs_t * _cbs) = registry[analysis_meta_index]->ftnPtr; int result = analysis_ftn(bulk_args->in.input_iter, bulk_args->in.output_iter, &iter_cbs); LOG_INFO("==PDC_SERVER: Analysis returned %d\n", result); @@ -2495,7 +2495,7 @@ buf_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) struct buf_map_release_bulk_args *bulk_args = NULL; #ifdef ENABLE_MULTITHREAD data_server_region_t *target_reg = NULL; - region_buf_map_t *elt; + region_buf_map_t * elt; #else struct pdc_region_info *remote_reg_info = NULL; #endif @@ -2681,23 +2681,23 @@ HG_TEST_RPC_CB(region_release, handle) hg_return_t hg_ret; region_lock_in_t in; region_lock_out_t out; - const struct hg_info *hg_info = NULL; - data_server_region_t *target_obj; + const struct hg_info * hg_info = NULL; + data_server_region_t * target_obj; int error = 0; int dirty_reg = 0; hg_size_t size, size2; - void *data_buf; - struct pdc_region_info *server_region; - region_list_t *elt, *request_region, *tmp, *elt_tmp; + void * data_buf; + struct pdc_region_info * server_region; + region_list_t * elt, *request_region, *tmp, *elt_tmp; struct region_lock_update_bulk_args *lock_update_bulk_args = NULL; - struct buf_map_release_bulk_args *buf_map_bulk_args = NULL, *obj_map_bulk_args = NULL; + struct buf_map_release_bulk_args * buf_map_bulk_args = NULL, *obj_map_bulk_args = NULL; hg_bulk_t lock_local_bulk_handle = HG_BULK_NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - struct pdc_region_info *remote_reg_info; - region_buf_map_t *eltt, *eltt2, *eltt_tmp; + struct pdc_region_info * remote_reg_info; + region_buf_map_t * eltt, *eltt2, *eltt_tmp; hg_uint32_t /*k, m, */ remote_count; - void **data_ptrs_to = NULL; - size_t *data_size_to = NULL; + void ** data_ptrs_to = NULL; + size_t * data_size_to = NULL; // size_t type_size = 0; // size_t dims[4] = {0, 0, 0, 0}; #ifdef PDC_TIMING @@ -3039,10 +3039,10 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha const struct hg_info *hg_info = NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; hg_uint32_t remote_count; - void *data_buf = NULL; + void * data_buf = NULL; ; - void **data_ptrs_to = NULL; - size_t *data_size_to = NULL; + void ** data_ptrs_to = NULL; + size_t * data_size_to = NULL; region_buf_map_t *eltt2; region_lock_out_t out; @@ -3051,8 +3051,8 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha int dirty_reg = 0; struct buf_map_transform_and_release_bulk_args *transform_release_bulk_args = NULL; - struct pdc_region_info *remote_reg_info = NULL; - data_server_region_t *target_obj = NULL; + struct pdc_region_info * remote_reg_info = NULL; + data_server_region_t * target_obj = NULL; region_list_t *tmp, *elt, *request_region = (region_list_t *)PDC_malloc(sizeof(region_list_t)); FUNC_ENTER(NULL); @@ -3205,19 +3205,19 @@ HG_TEST_RPC_CB(transform_region_release, handle) region_transform_and_lock_in_t in; region_lock_in_t reg_lock_in; region_lock_out_t out; - const struct hg_info *hg_info = NULL; - data_server_region_t *target_obj; + const struct hg_info * hg_info = NULL; + data_server_region_t * target_obj; int error = 0; int dirty_reg = 0; hg_size_t size; - void *data_buf; - region_list_t *elt, *request_region, *tmp; + void * data_buf; + region_list_t * elt, *request_region, *tmp; struct buf_map_transform_and_release_bulk_args *buf_map_bulk_args = NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - region_buf_map_t *eltt; + region_buf_map_t * eltt; hg_uint32_t remote_count; - void **data_ptrs_to = NULL; - size_t *data_size_to = NULL; + void ** data_ptrs_to = NULL; + size_t * data_size_to = NULL; FUNC_ENTER(NULL); @@ -3353,14 +3353,14 @@ HG_TEST_RPC_CB(region_transform_release, handle) int dirty_reg = 0; hg_size_t size, remote_size; ; - void *data_buf; - region_list_t *elt, *request_region, *tmp; + void * data_buf; + region_list_t * elt, *request_region, *tmp; struct buf_map_release_bulk_args *buf_map_bulk_args = NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - region_buf_map_t *eltt; + region_buf_map_t * eltt; hg_uint32_t k, remote_count = 0; - void **data_ptrs_to = NULL; - size_t *data_size_to = NULL; + void ** data_ptrs_to = NULL; + size_t * data_size_to = NULL; size_t type_size = 0; ; size_t dims[4] = {0, 0, 0, 0}; @@ -3512,26 +3512,26 @@ HG_TEST_RPC_CB(region_analysis_release, handle) } in; region_lock_out_t out; - const struct hg_info *hg_info = NULL; - data_server_region_t *target_obj; - data_server_region_t *lock_obj; + const struct hg_info * hg_info = NULL; + data_server_region_t * target_obj; + data_server_region_t * lock_obj; int error = 0; int dirty_reg = 0; hg_size_t size; hg_return_t hg_ret; - void *data_buf; - struct pdc_region_info *server_region; - region_list_t *elt, *request_region, *tmp; - struct region_lock_update_bulk_args *lock_update_bulk_args = NULL; + void * data_buf; + struct pdc_region_info * server_region; + region_list_t * elt, *request_region, *tmp; + struct region_lock_update_bulk_args * lock_update_bulk_args = NULL; struct buf_map_analysis_and_release_bulk_args *buf_map_bulk_args = NULL, *obj_map_bulk_args = NULL; hg_bulk_t lock_local_bulk_handle = HG_BULK_NULL; hg_bulk_t remote_bulk_handle = HG_BULK_NULL; - struct pdc_region_info *remote_reg_info; - region_buf_map_t *eltt, *eltt2; + struct pdc_region_info * remote_reg_info; + region_buf_map_t * eltt, *eltt2; hg_uint32_t k, remote_count = 0; - void **data_ptrs_to = NULL; - size_t *data_size_to = NULL; + void ** data_ptrs_to = NULL; + size_t * data_size_to = NULL; size_t type_size = 0; size_t dims[4] = {0, 0, 0, 0}; @@ -3965,7 +3965,7 @@ HG_TEST_RPC_CB(get_remote_metadata, handle) hg_return_t ret_value = HG_SUCCESS; get_remote_metadata_in_t in; get_remote_metadata_out_t out; - pdc_metadata_t *meta; + pdc_metadata_t * meta; FUNC_ENTER(NULL); @@ -4000,7 +4000,7 @@ HG_TEST_RPC_CB(buf_unmap_server, handle) hg_return_t ret_value = HG_SUCCESS; buf_unmap_in_t in; buf_unmap_out_t out; - pdc_metadata_t *target_obj; + pdc_metadata_t * target_obj; region_buf_map_t *tmp, *elt; FUNC_ENTER(NULL); @@ -4049,8 +4049,8 @@ HG_TEST_RPC_CB(buf_map_server, handle) hg_return_t ret_value = HG_SUCCESS; buf_map_in_t in; buf_map_out_t out; - pdc_metadata_t *target_obj; - region_list_t *elt, *request_region; + pdc_metadata_t * target_obj; + region_list_t * elt, *request_region; region_buf_map_t *buf_map_ptr; FUNC_ENTER(NULL); @@ -4114,9 +4114,9 @@ HG_TEST_RPC_CB(buf_map, handle) buf_map_in_t in; buf_map_out_t out; const struct hg_info *info; - region_list_t *request_region; - region_buf_map_t *new_buf_map_ptr = NULL; - void *data_ptr; + region_list_t * request_region; + region_buf_map_t * new_buf_map_ptr = NULL; + void * data_ptr; size_t ndim; PDC_TIMING_DECLARE(PDC_SERVER_BUF_OBJ_MAP_RPC_TIME); @@ -4176,9 +4176,9 @@ HG_TEST_RPC_CB(query_partial, handle) hg_return_t hg_ret; hg_bulk_t bulk_handle = HG_BULK_NULL; uint32_t i; - void **buf_ptrs; - size_t *buf_sizes; - uint32_t *n_meta_ptr, n_buf; + void ** buf_ptrs; + size_t * buf_sizes; + uint32_t * n_meta_ptr, n_buf; metadata_query_transfer_in_t in; metadata_query_transfer_out_t out; @@ -4271,7 +4271,7 @@ HG_TEST_RPC_CB(query_kvtag, handle) hg_return_t ret_value; hg_return_t hg_ret; hg_bulk_t bulk_handle = HG_BULK_NULL; - uint64_t *buf_ptr; + uint64_t * buf_ptr; size_t buf_size[1]; uint32_t nmeta; pdc_kvtag_t in; @@ -4332,10 +4332,10 @@ update_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int cnt, i; - uint64_t *obj_id_ptr; + uint64_t * obj_id_ptr; pdc_int_ret_t out_struct; - void **buf; - void *buf_1d; + void ** buf; + void * buf_1d; FUNC_ENTER(NULL); @@ -4389,7 +4389,7 @@ HG_TEST_RPC_CB(bulk_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t *bulk_args = NULL; + struct bulk_args_t * bulk_args = NULL; bulk_rpc_in_t in_struct; int cnt; @@ -4537,7 +4537,7 @@ HG_TEST_RPC_CB(data_server_read_check, handle) // Decode input data_server_read_check_in_t in; data_server_read_check_out_t out; - server_read_check_out_t *read_out = PDC_calloc(1, sizeof(server_read_check_out_t)); + server_read_check_out_t * read_out = PDC_calloc(1, sizeof(server_read_check_out_t)); FUNC_ENTER(NULL); @@ -4639,7 +4639,7 @@ HG_TEST_RPC_CB(get_metadata_by_id, handle) hg_return_t ret_value = HG_SUCCESS; get_metadata_by_id_in_t in; get_metadata_by_id_out_t out; - pdc_metadata_t *target = NULL; + pdc_metadata_t * target = NULL; FUNC_ENTER(NULL); @@ -4745,8 +4745,8 @@ char * PDC_find_in_path(char *workingDir, char *application) { struct stat fileStat; - char *ret_value = NULL; - char *pathVar = getenv("PATH"); + char * ret_value = NULL; + char * pathVar = getenv("PATH"); char colon = ':'; char checkPath[PATH_MAX]; @@ -4801,11 +4801,11 @@ cont_add_del_objs_bulk_cb(const struct hg_cb_info *hg_cb_info) { hg_return_t ret_value = HG_SUCCESS; // Server executes after received request from client - struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int cnt, op; cont_add_del_objs_rpc_out_t out_struct; - uint64_t *obj_ids, cont_id; + uint64_t * obj_ids, cont_id; FUNC_ENTER(NULL); @@ -4856,8 +4856,8 @@ cont_add_del_objs_bulk_cb(const struct hg_cb_info *hg_cb_info) HG_TEST_RPC_CB(cont_add_del_objs_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; - const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args = NULL; + const struct hg_info * hg_info = NULL; + struct bulk_args_t * bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; cont_add_del_objs_rpc_in_t in_struct; @@ -4937,13 +4937,13 @@ query_read_obj_name_bulk_cb(const struct hg_cb_info *hg_cb_info) hg_return_t ret_value = HG_SUCCESS; hg_return_t ret = HG_SUCCESS; // Server executes after received request from client - struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int iter; size_t i; - char *tmp_buf; + char * tmp_buf; query_read_obj_name_out_t out_struct; - query_read_names_args_t *query_read_names_args; + query_read_names_args_t * query_read_names_args; FUNC_ENTER(NULL); @@ -4999,8 +4999,8 @@ HG_TEST_RPC_CB(query_read_obj_name_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; hg_return_t ret = HG_SUCCESS; - const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args = NULL; + const struct hg_info * hg_info = NULL; + struct bulk_args_t * bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; query_read_obj_name_in_t in_struct; @@ -5108,13 +5108,13 @@ get_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int i, task_id, n_regions; - int *int_ptr; - char *char_ptr, *file_path; - uint64_t *uint64_ptr, offset; + int * int_ptr; + char * char_ptr, *file_path; + uint64_t * uint64_ptr, offset; - void *buf; + void * buf; region_info_transfer_t *region_info_ptr; - region_list_t *region_list, *region_list_head = NULL; + region_list_t * region_list, *region_list_head = NULL; pdc_int_ret_t out_struct; FUNC_ENTER(NULL); @@ -5184,7 +5184,7 @@ HG_TEST_RPC_CB(get_storage_meta_name_query_bulk_result_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args = NULL; + struct bulk_args_t * bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; bulk_rpc_in_t in_struct; @@ -5237,8 +5237,8 @@ notify_client_multi_io_complete_bulk_cb(const struct hg_cb_info *hg_cb_info) struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int n_shm; - void *buf; - char *buf_cp; + void * buf; + char * buf_cp; pdc_int_ret_t out_struct; FUNC_ENTER(NULL); @@ -5281,7 +5281,7 @@ HG_TEST_RPC_CB(notify_client_multi_io_complete_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args = NULL; + struct bulk_args_t * bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; bulk_rpc_in_t in_struct; @@ -5324,7 +5324,7 @@ PDC_add_task_to_list(pdc_task_list_t **target_list, perr_t (*cb)(), void *cb_arg #ifdef ENABLE_MULTITHREAD void *_mutex) #else - void *_mutex ATTRIBUTE(unused)) + void *_mutex ATTRIBUTE(unused)) #endif { int ret_value = 0; @@ -5368,7 +5368,7 @@ PDC_del_task_from_list(pdc_task_list_t **target_list, pdc_task_list_t *del, #ifdef ENABLE_MULTITHREAD void *_mutex) #else - void *_mutex ATTRIBUTE(unused)) + void *_mutex ATTRIBUTE(unused)) #endif { perr_t ret_value = SUCCEED; @@ -5552,13 +5552,13 @@ query_read_obj_name_client_bulk_cb(const struct hg_cb_info *hg_cb_info) { hg_return_t ret_value = HG_SUCCESS; // Server executes after received request from client - struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; int iter; size_t i; - char *tmp_buf; + char * tmp_buf; query_read_obj_name_out_t out_struct; - query_read_names_args_t *query_read_names_args; + query_read_names_args_t * query_read_names_args; FUNC_ENTER(NULL); @@ -5614,8 +5614,8 @@ query_read_obj_name_client_bulk_cb(const struct hg_cb_info *hg_cb_info) HG_TEST_RPC_CB(query_read_obj_name_client_rpc, handle) { hg_return_t ret_value = HG_SUCCESS; - const struct hg_info *hg_info = NULL; - struct bulk_args_t *bulk_args = NULL; + const struct hg_info * hg_info = NULL; + struct bulk_args_t * bulk_args = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; query_read_obj_name_in_t in_struct; @@ -5665,9 +5665,9 @@ static hg_return_t send_client_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) { hg_return_t ret_value = HG_SUCCESS; - struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; - void *buf = NULL, *buf_cp = NULL; + void * buf = NULL, *buf_cp = NULL; process_bulk_storage_meta_args_t *process_args = NULL; FUNC_ENTER(NULL); @@ -5712,7 +5712,7 @@ HG_TEST_RPC_CB(send_client_storage_meta_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t *bulk_args = NULL; + struct bulk_args_t * bulk_args = NULL; bulk_rpc_in_t in_struct; pdc_int_ret_t out_struct; int cnt; @@ -5772,7 +5772,7 @@ server_recv_shm_bulk_cb(const struct hg_cb_info *hg_cb_info) hg_return_t ret_value = HG_SUCCESS; struct bulk_args_t *bulk_args = (struct bulk_args_t *)hg_cb_info->arg; hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle; - void *buf = NULL, *buf_cp = NULL; + void * buf = NULL, *buf_cp = NULL; FUNC_ENTER(NULL); @@ -5809,7 +5809,7 @@ HG_TEST_RPC_CB(send_shm_bulk_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t *bulk_args = NULL; + struct bulk_args_t * bulk_args = NULL; bulk_rpc_in_t in_struct; pdc_int_ret_t out_struct; int cnt; @@ -5977,7 +5977,7 @@ HG_TEST_RPC_CB(send_bulk_rpc, handle) const struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; - struct bulk_args_t *bulk_arg = NULL; + struct bulk_args_t * bulk_arg = NULL; bulk_rpc_in_t in_struct; hg_return_t (*func_ptr)(const struct hg_cb_info *hg_cb_info); struct hg_cb_info callback_info; @@ -6076,10 +6076,10 @@ HG_TEST_RPC_CB(dart_perform_one_server, handle) dart_perform_one_server_out_t out; hg_bulk_t bulk_handle = HG_BULK_NULL; - uint64_t *n_obj_ids_ptr; + uint64_t * n_obj_ids_ptr; uint64_t n_buf; uint64_t **buf_ptrs; - size_t *buf_sizes; + size_t * buf_sizes; uint32_t i; FUNC_ENTER(NULL); diff --git a/src/server/pdc_server.c b/src/server/pdc_server.c index 34c145007..7175072ab 100644 --- a/src/server/pdc_server.c +++ b/src/server/pdc_server.c @@ -83,7 +83,7 @@ sqlite3 *sqlite3_db_g; int is_debug_g = 0; int pdc_client_num_g = 0; -hg_class_t *hg_class_g = NULL; +hg_class_t * hg_class_g = NULL; hg_context_t *hg_context_g = NULL; // Below three are guarded by pdc_server_task_mutex_g for multi-thread @@ -91,10 +91,10 @@ pdc_task_list_t *pdc_server_agg_task_head_g = NULL; pdc_task_list_t *pdc_server_s2s_task_head_g = NULL; int pdc_server_task_id_g = PDC_SERVER_TASK_INIT_VALUE; -pdc_client_info_t *pdc_client_info_g = NULL; +pdc_client_info_t * pdc_client_info_g = NULL; pdc_remote_server_info_t *pdc_remote_server_info_g = NULL; -char *all_addr_strings_1d_g = NULL; -char **all_addr_strings_g = NULL; +char * all_addr_strings_1d_g = NULL; +char ** all_addr_strings_g = NULL; int is_hash_table_init_g = 0; int lustre_stripe_size_mb_g = 16; int lustre_total_ost_g = 0; @@ -147,7 +147,7 @@ int gen_fastbit_idx_g = 0; int use_fastbit_idx_g = 0; int use_rocksdb_g = 0; int use_sqlite3_g = 0; -char *gBinningOption = NULL; +char * gBinningOption = NULL; double server_write_time_g = 0.0; double server_read_time_g = 0.0; @@ -165,9 +165,9 @@ volatile int dbg_sleep_g = 1; double total_mem_usage_g = 0.0; // Data server related -pdc_data_server_io_list_t *pdc_data_server_read_list_head_g = NULL; -pdc_data_server_io_list_t *pdc_data_server_write_list_head_g = NULL; -update_storage_meta_list_t *pdc_update_storage_meta_list_head_g = NULL; +pdc_data_server_io_list_t * pdc_data_server_read_list_head_g = NULL; +pdc_data_server_io_list_t * pdc_data_server_write_list_head_g = NULL; +update_storage_meta_list_t * pdc_update_storage_meta_list_head_g = NULL; extern data_server_region_t *dataserver_region_g; /* @@ -379,7 +379,7 @@ static int remove_directory(const char *dir) { int ret = 0; - FTS *ftsp = NULL; + FTS * ftsp = NULL; FTSENT *curr; // Cast needed (in C) because fts_open() takes a "char * const *", instead @@ -543,7 +543,7 @@ PDC_Server_lookup_server_id(int remote_server_id) lookup_args->server_id = remote_server_id; hg_ret = HG_Addr_lookup(hg_context_g, lookup_remote_server_cb, lookup_args, - pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); + pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { LOG_ERROR("==PDC_SERVER: Connection to remote server FAILED!\n"); ret_value = FAIL; @@ -663,7 +663,7 @@ PDC_Server_lookup_client(uint32_t client_id) // Lookup and fill the client info server_lookup_args_t lookup_args; - char *target_addr_string; + char * target_addr_string; lookup_args.server_id = pdc_server_rank_g; lookup_args.client_id = client_id; @@ -784,7 +784,7 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) int i = 0; char self_addr_string[ADDR_MAX]; char na_info_string[NA_STRING_INFO_LEN]; - char *hostname; + char * hostname; pbool_t free_hostname = false; struct hg_init_info init_info = {0}; @@ -800,7 +800,7 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) uint32_t credential = 0, cookie; drc_info_handle_t credential_info; char pdc_auth_key[256] = {'\0'}; - char *auth_key; + char * auth_key; int rc; #endif @@ -1059,7 +1059,7 @@ perr_t PDC_Server_finalize() { pdc_data_server_io_list_t *io_elt = NULL; - region_list_t *region_elt = NULL, *region_tmp = NULL; + region_list_t * region_elt = NULL, *region_tmp = NULL; perr_t ret_value = SUCCEED; hg_return_t hg_ret; @@ -1225,21 +1225,21 @@ perr_t PDC_Server_checkpoint() { perr_t ret_value = SUCCEED; - pdc_metadata_t *elt; - region_list_t *region_elt; - pdc_kvtag_list_t *kvlist_elt; - pdc_hash_table_entry_head *head; + pdc_metadata_t * elt; + region_list_t * region_elt; + pdc_kvtag_list_t * kvlist_elt; + pdc_hash_table_entry_head * head; pdc_cont_hash_table_entry_t *cont_head; int n_entry, metadata_size = 0, region_count = 0, n_region, n_objs, n_write_region = 0, n_kvtag, key_len; uint32_t hash_key; HashTablePair pair; char checkpoint_file[ADDR_MAX], checkpoint_file_local[ADDR_MAX], cmd[4096]; HashTableIterator hash_table_iter; - char *checkpoint; - char *env_char; + char * checkpoint; + char * env_char; uint64_t checkpoint_size; bool use_tmpfs = false; - FILE *file; + FILE * file; FUNC_ENTER(NULL); @@ -1360,7 +1360,7 @@ PDC_Server_checkpoint() metadata_size++; region_count += n_region; } // End for metadata entry linked list - } // End for hash table metadata entry + } // End for hash table metadata entry // Note data server region are managed by data server instead of metadata server data_server_region_t *region = NULL; @@ -1454,14 +1454,14 @@ PDC_Server_restart(char *filename) int n_entry, count, i, j, nobj = 0, all_nobj = 0, all_n_region, n_region, n_objs, total_region = 0, n_kvtag, key_len; int n_cont, all_cont; - pdc_metadata_t *metadata, *elt; - region_list_t *region_list; - pdc_hash_table_entry_head *entry; + pdc_metadata_t * metadata, *elt; + region_list_t * region_list; + pdc_hash_table_entry_head * entry; pdc_cont_hash_table_entry_t *cont_entry; - uint32_t *hash_key; + uint32_t * hash_key; unsigned idx; uint64_t checkpoint_size; - char *checkpoint_buf; + char * checkpoint_buf; #if defined(PDC_TIMING) && defined(ENABLE_MPI) double start = MPI_Wtime(); #endif @@ -1742,8 +1742,8 @@ PDC_Server_restart(char *filename) MPI_Reduce(&nobj, &all_nobj, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Reduce(&total_region, &all_n_region, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); #else - all_nobj = nobj; - all_n_region = total_region; + all_nobj = nobj; + all_n_region = total_region; #endif if (pdc_server_rank_g == 0) { @@ -1771,7 +1771,7 @@ PDC_Server_restart(char *filename) static HG_THREAD_RETURN_TYPE hg_progress_thread(void *arg) { - hg_context_t *context = (hg_context_t *)arg; + hg_context_t * context = (hg_context_t *)arg; HG_THREAD_RETURN_TYPE tret = (HG_THREAD_RETURN_TYPE)0; hg_return_t ret = HG_SUCCESS; @@ -2256,7 +2256,7 @@ server_run(int argc, char *argv[]) rocksdb_options_set_create_if_missing(options, 1); rocksdb_block_based_table_options_t *table_options = rocksdb_block_based_options_create(); - rocksdb_filterpolicy_t *filter_policy = rocksdb_filterpolicy_create_bloom(10); + rocksdb_filterpolicy_t * filter_policy = rocksdb_filterpolicy_create_bloom(10); rocksdb_block_based_options_set_filter_policy(table_options, filter_policy); rocksdb_options_set_block_based_table_factory(options, table_options); diff --git a/src/server/pdc_server_region/pdc_server_data.c b/src/server/pdc_server_region/pdc_server_data.c index 87c6a0ed1..93dbf6c0d 100644 --- a/src/server/pdc_server_region/pdc_server_data.c +++ b/src/server/pdc_server_region/pdc_server_data.c @@ -62,7 +62,7 @@ #include "pdc_logger.h" // Global object region info list in local data server -data_server_region_t *dataserver_region_g = NULL; +data_server_region_t * dataserver_region_g = NULL; data_server_region_unmap_t *dataserver_region_unmap = NULL; int pdc_buffered_bulk_update_total_g = 0; @@ -79,10 +79,10 @@ uint64_t max_mem_cache_size_mb_g = 0; int cache_percentage_g = 0; int current_read_from_cache_cnt_g = 0; int total_read_from_cache_cnt_g = 0; -FILE *pdc_cache_file_ptr_g = NULL; +FILE * pdc_cache_file_ptr_g = NULL; char pdc_cache_file_path_g[ADDR_MAX]; -query_task_t *query_task_list_head_g = NULL; +query_task_t * query_task_list_head_g = NULL; cache_storage_region_t *cache_storage_region_head_g = NULL; static int @@ -263,7 +263,7 @@ PDC_Server_local_region_lock_status(PDC_mapping_info_t *mapped_region, int *lock { perr_t ret_value = SUCCEED; pdc_metadata_t *res_meta; - region_list_t *elt, *request_region; + region_list_t * elt, *request_region; FUNC_ENTER(NULL); @@ -364,7 +364,7 @@ PDC_Server_clear_obj_region() { perr_t ret_value = SUCCEED; data_server_region_t *elt, *tmp; - region_list_t *elt2, *tmp2; + region_list_t * elt2, *tmp2; FUNC_ENTER(NULL); if (dataserver_region_g != NULL) { @@ -472,10 +472,10 @@ PDC_Data_Server_region_lock(region_lock_in_t *in, region_lock_out_t *out, hg_han { perr_t ret_value = SUCCEED; int ndim; - region_list_t *request_region; + region_list_t * request_region; data_server_region_t *new_obj_reg; - region_list_t *elt1, *tmp; - region_buf_map_t *eltt; + region_list_t * elt1, *tmp; + region_buf_map_t * eltt; int error = 0; int found_lock = 0; // time_t t; @@ -576,8 +576,8 @@ perr_t PDC_Server_release_lock_request(uint64_t obj_id, struct pdc_region_info *region) { perr_t ret_value = SUCCEED; - region_list_t *request_region; - region_list_t *elt, *tmp; + region_list_t * request_region; + region_list_t * elt, *tmp; data_server_region_t *new_obj_reg; region_lock_out_t out; @@ -619,7 +619,7 @@ PDC_Data_Server_region_release(region_lock_in_t *in, region_lock_out_t *out) { perr_t ret_value = SUCCEED; int ndim; - region_list_t *tmp1, *tmp2; + region_list_t * tmp1, *tmp2; region_list_t request_region; int found = 0; data_server_region_t *obj_reg = NULL; @@ -758,7 +758,7 @@ PDC_Data_Server_buf_unmap(const struct hg_info *info, buf_unmap_in_t *in) { perr_t ret_value = SUCCEED; int ret = HG_UTIL_SUCCESS; - region_buf_map_t *tmp, *elt; + region_buf_map_t * tmp, *elt; data_server_region_t *target_obj; FUNC_ENTER(NULL); @@ -852,9 +852,9 @@ PDC_Data_Server_check_unmap() perr_t ret_value = SUCCEED; int ret = HG_UTIL_SUCCESS; pdcid_t remote_obj_id; - region_buf_map_t *tmp, *elt; + region_buf_map_t * tmp, *elt; data_server_region_unmap_t *tmp1, *elt1; - data_server_region_t *target_obj; + data_server_region_t * target_obj; int completed = 0; FUNC_ENTER(NULL); @@ -953,7 +953,7 @@ buf_unmap_lookup_remote_server_cb(const struct hg_cb_info *callback_info) struct buf_unmap_server_lookup_args_t *lookup_args; hg_handle_t server_send_buf_unmap_handle; hg_handle_t handle; - struct transfer_buf_unmap *tranx_args; + struct transfer_buf_unmap * tranx_args; int error = 0; FUNC_ENTER(NULL); @@ -1017,7 +1017,7 @@ PDC_Server_buf_unmap_lookup_server_id(int remote_server_id, struct transfer_buf_ lookup_args->server_id = remote_server_id; lookup_args->buf_unmap_args = transfer_args; hg_ret = HG_Addr_lookup(hg_context_g, buf_unmap_lookup_remote_server_cb, lookup_args, - pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); + pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; PGOTO_ERROR( @@ -1077,9 +1077,9 @@ PDC_Meta_Server_buf_unmap(buf_unmap_in_t *in, hg_handle_t *handle) hg_return_t hg_ret = HG_SUCCESS; hg_handle_t server_send_buf_unmap_handle; struct transfer_buf_unmap_args *buf_unmap_args; - struct transfer_buf_unmap *addr_args; - pdc_metadata_t *target_meta = NULL; - region_buf_map_t *tmp, *elt; + struct transfer_buf_unmap * addr_args; + pdc_metadata_t * target_meta = NULL; + region_buf_map_t * tmp, *elt; int error = 0; FUNC_ENTER(NULL); @@ -1154,14 +1154,14 @@ region_buf_map_t * PDC_Data_Server_buf_map(const struct hg_info *info, buf_map_in_t *in, region_list_t *request_region, void *data_ptr) { - region_buf_map_t *ret_value = NULL; + region_buf_map_t * ret_value = NULL; data_server_region_t *new_obj_reg = NULL; - region_list_t *elt_reg; - region_buf_map_t *buf_map_ptr = NULL; - region_buf_map_t *tmp; + region_list_t * elt_reg; + region_buf_map_t * buf_map_ptr = NULL; + region_buf_map_t * tmp; int dup = 0; - char *data_path = NULL; - char *user_specified_data_path = NULL; + char * data_path = NULL; + char * user_specified_data_path = NULL; char storage_location[ADDR_MAX]; #ifdef ENABLE_LUSTRE int stripe_count, stripe_size; @@ -1277,9 +1277,9 @@ PDC_Data_Server_buf_map(const struct hg_info *info, buf_map_in_t *in, region_lis void * PDC_Server_maybe_allocate_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region, size_t type_size) { - void *ret_value = NULL; + void * ret_value = NULL; data_server_region_t *target_obj = NULL, *elt = NULL; - region_buf_map_t *tmp; + region_buf_map_t * tmp; FUNC_ENTER(NULL); @@ -1331,9 +1331,9 @@ PDC_Server_maybe_allocate_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t void * PDC_Server_get_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region) { - void *ret_value = NULL; + void * ret_value = NULL; data_server_region_t *target_obj = NULL, *elt = NULL; - region_buf_map_t *tmp; + region_buf_map_t * tmp; FUNC_ENTER(NULL); @@ -1399,7 +1399,7 @@ buf_map_lookup_remote_server_cb(const struct hg_cb_info *callback_info) struct buf_map_server_lookup_args_t *lookup_args; hg_handle_t server_send_buf_map_handle; hg_handle_t handle; - struct transfer_buf_map *tranx_args; + struct transfer_buf_map * tranx_args; int error = 0; FUNC_ENTER(NULL); @@ -1464,7 +1464,7 @@ PDC_Server_buf_map_lookup_server_id(int remote_server_id, struct transfer_buf_ma lookup_args->server_id = remote_server_id; lookup_args->buf_map_args = transfer_args; hg_ret = HG_Addr_lookup(hg_context_g, buf_map_lookup_remote_server_cb, lookup_args, - pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); + pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; PGOTO_ERROR( @@ -1520,9 +1520,9 @@ PDC_Meta_Server_buf_map(buf_map_in_t *in, region_buf_map_t *new_buf_map_ptr, hg_ hg_return_t hg_ret = HG_SUCCESS; hg_handle_t server_send_buf_map_handle; struct transfer_buf_map_args *tranx_args = NULL; - struct transfer_buf_map *addr_args; - pdc_metadata_t *target_meta = NULL; - region_buf_map_t *buf_map_ptr; + struct transfer_buf_map * addr_args; + pdc_metadata_t * target_meta = NULL; + region_buf_map_t * buf_map_ptr; int error = 0; FUNC_ENTER(NULL); @@ -1794,11 +1794,11 @@ PDC_Server_notify_client_multi_io_complete(uint32_t client_id, int client_seq_id hg_return_t hg_ret = HG_SUCCESS; hg_handle_t rpc_handle; hg_bulk_t bulk_handle; - void **buf_ptrs; - hg_size_t *buf_sizes; + void ** buf_ptrs; + hg_size_t * buf_sizes; bulk_rpc_in_t bulk_rpc_in; int i; - region_list_t *region_elt; + region_list_t * region_elt; notify_multi_io_args_t *bulk_args; FUNC_ENTER(NULL); @@ -2004,7 +2004,7 @@ PDC_Server_read_check(data_server_read_check_in_t *in, server_read_check_out_t * { perr_t ret_value = SUCCEED; pdc_data_server_io_list_t *io_elt = NULL, *io_target = NULL; - region_list_t *region_elt = NULL; + region_list_t * region_elt = NULL; region_list_t r_target; /* uint32_t i; */ @@ -2090,7 +2090,7 @@ PDC_Server_write_check(data_server_write_check_in_t *in, data_server_write_check { perr_t ret_value = FAIL; pdc_data_server_io_list_t *io_elt = NULL, *io_target = NULL; - region_list_t *region_elt = NULL, *region_tmp = NULL; + region_list_t * region_elt = NULL, *region_tmp = NULL; int found_region = 0; FUNC_ENTER(NULL); @@ -2198,7 +2198,7 @@ PDC_Server_get_local_storage_location_of_region(uint64_t obj_id, region_list_t * { perr_t ret_value = SUCCEED; pdc_metadata_t *target_meta = NULL; - region_list_t *region_elt = NULL; + region_list_t * region_elt = NULL; FUNC_ENTER(NULL); @@ -2328,7 +2328,7 @@ PDC_Server_count_write_check_update_storage_meta_cb(const struct hg_cb_info *cal } } // end of if - } // end of if (write_ret->ret == 1) + } // end of if (write_ret->ret == 1) done: @@ -2360,17 +2360,17 @@ PDC_Server_get_storage_location_of_region_mpi(region_list_t *regions_head) perr_t ret_value = SUCCEED; uint32_t server_id = 0; uint32_t i, j; - pdc_metadata_t *region_meta = NULL, *region_meta_prev = NULL; - region_list_t *region_elt, req_region, **overlap_regions_2d = NULL; + pdc_metadata_t * region_meta = NULL, *region_meta_prev = NULL; + region_list_t * region_elt, req_region, **overlap_regions_2d = NULL; region_info_transfer_t local_region_transfer[PDC_SERVER_MAX_PROC_PER_NODE]; - region_info_transfer_t *all_requests = NULL; + region_info_transfer_t * all_requests = NULL; update_region_storage_meta_bulk_t *send_buf = NULL; update_region_storage_meta_bulk_t *result_storage_meta = NULL; uint32_t total_request_cnt; int data_size = sizeof(region_info_transfer_t); - int *send_bytes = NULL; - int *displs = NULL; - int *request_overlap_cnt = NULL; + int * send_bytes = NULL; + int * displs = NULL; + int * request_overlap_cnt = NULL; int nrequest_per_server = 0; FUNC_ENTER(NULL); @@ -2700,7 +2700,7 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) perr_t ret_value = SUCCEED; pdc_data_server_io_list_t *io_list_elt, *io_list = NULL, *io_list_target = NULL; - region_list_t *region_elt = NULL, *region_tmp; + region_list_t * region_elt = NULL, *region_tmp; int real_bb_cnt = 0, real_lustre_cnt = 0; int write_to_bb_cnt = 0; int count; @@ -3102,7 +3102,7 @@ PDC_Server_update_region_storagelocation_offset(region_list_t *region, int type) hg_return_t hg_ret; perr_t ret_value = SUCCEED; uint32_t server_id = 0; - pdc_metadata_t *region_meta = NULL; + pdc_metadata_t * region_meta = NULL; hg_handle_t update_region_loc_handle; update_region_loc_in_t in; server_lookup_args_t lookup_args; @@ -3204,7 +3204,7 @@ PDC_Server_add_region_storage_meta_to_bulk_buf(region_list_t *region, bulk_xfer_ int i; uint64_t obj_id = 0; update_region_storage_meta_bulk_t *curr_buf_ptr; - uint64_t *obj_id_ptr; + uint64_t * obj_id_ptr; FUNC_ENTER(NULL); @@ -3294,8 +3294,8 @@ PDC_Server_update_region_storage_meta_bulk_local(update_region_storage_meta_bulk { perr_t ret_value = SUCCEED; int i; - pdc_metadata_t *target_meta = NULL; - region_list_t *region_elt = NULL, *new_region = NULL; + pdc_metadata_t * target_meta = NULL; + region_list_t * region_elt = NULL, *new_region = NULL; update_region_storage_meta_bulk_t *bulk_ptr; int update_success = 0, express_insert = 0; uint64_t obj_id; @@ -3418,7 +3418,7 @@ PDC_Server_update_region_storage_meta_bulk_mpi(bulk_xfer_data_t *bulk_data) int i; uint32_t server_id = 0; update_region_storage_meta_bulk_t *recv_buf = NULL; - void **all_meta = NULL; + void ** all_meta = NULL; #endif FUNC_ENTER(NULL); @@ -3471,9 +3471,9 @@ PDC_Server_update_region_storage_meta_bulk_mpi(bulk_xfer_data_t *bulk_data) } perr_t -PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t *bulk_data, perr_t (*cb)(), +PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t * bulk_data, perr_t (*cb)(), update_storage_meta_list_t *meta_list_target, - int *n_updated) + int * n_updated) { hg_return_t hg_ret; perr_t ret_value = SUCCEED; @@ -3714,7 +3714,7 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re } *total_read_bytes += read_bytes; } // for each row - } // ndim=2 + } // ndim=2 else if (ndim == 3) { uint64_t buf_serialize_offset; /* fseek (fp, storage_offset, SEEK_SET); */ @@ -3797,8 +3797,8 @@ PDC_Server_read_one_region(region_list_t *read_region) size_t total_read_bytes = 0; uint32_t n_storage_regions = 0; region_list_t *region_elt; - FILE *fp_read = NULL; - char *prev_path = NULL; + FILE * fp_read = NULL; + char * prev_path = NULL; int is_shm_created = 0, is_read_succeed = 0; #ifdef ENABLE_TIMING double fopen_time; @@ -3941,8 +3941,8 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) uint64_t offset = 0; uint32_t i = 0; region_list_t *region_elt = NULL, *previous_region = NULL; - FILE *fp_read = NULL, *fp_write = NULL; - char *prev_path = NULL; + FILE * fp_read = NULL, *fp_write = NULL; + char * prev_path = NULL; #ifdef ENABLE_LUSTRE int stripe_count, stripe_size; #endif @@ -4402,11 +4402,11 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, { perr_t ret_value = SUCCEED; data_server_region_t *region = NULL; - region_list_t *overlap_region = NULL; + region_list_t * overlap_region = NULL; int is_contained = 0; uint64_t i, j, pos; - uint64_t *overlap_offset, *overlap_size; - char *tmp_buf; + uint64_t * overlap_offset, *overlap_size; + char * tmp_buf; #if 0 size_t total_write_size = 0, local_write_size; int is_overlap; @@ -4689,11 +4689,11 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, if (is_contained == 0) { request_region->offset = lseek(region->fd, 0, SEEK_END); #ifdef ENABLE_ZFP - zfp_field *field; + zfp_field * field; zfp_stream *zfp; size_t bufsize; - void *buffer; - bitstream *stream; + void * buffer; + bitstream * stream; field = _setup_zfp(region_info, &zfp); if (field == NULL) @@ -4767,10 +4767,10 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, perr_t ret_value = SUCCEED; ssize_t request_bytes = unit; data_server_region_t *region = NULL; - region_list_t *elt; + region_list_t * elt; uint64_t i, j, pos; - uint64_t *overlap_offset, *overlap_size; - char *tmp_buf; + uint64_t * overlap_offset, *overlap_size; + char * tmp_buf; FUNC_ENTER(NULL); #ifdef PDC_TIMING @@ -4868,10 +4868,10 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef ENABLE_ZFP // Uncompress the data - zfp_field *field; + zfp_field * field; zfp_stream *zfp; size_t bufsize, decompress_size; - bitstream *stream; + bitstream * stream; field = _setup_zfp(region_info, &zfp); if (field == NULL) @@ -5132,7 +5132,7 @@ PDC_Server_get_local_storage_meta_with_one_name(storage_meta_query_one_name_args { perr_t ret_value = SUCCEED; pdc_metadata_t *meta = NULL; - region_list_t *region_elt = NULL, *region_head = NULL, *res_region_list = NULL; + region_list_t * region_elt = NULL, *region_head = NULL, *res_region_list = NULL; int region_count = 0, i = 0; FUNC_ENTER(NULL); @@ -5264,7 +5264,7 @@ PDC_Server_accumulate_storage_meta_then_read(storage_meta_query_one_name_args_t { perr_t ret_value = SUCCEED; accumulate_storage_meta_t *accu_meta; - region_list_t *req_region = NULL, *region_elt = NULL, *read_list_head = NULL; + region_list_t * req_region = NULL, *region_elt = NULL, *read_list_head = NULL; int i, is_sort_read; size_t j; @@ -5432,16 +5432,16 @@ PDC_Server_storage_meta_name_query_bulk_respond(const struct hg_cb_info *callbac { hg_return_t hg_ret = HG_SUCCESS; perr_t ret_value; - storage_meta_name_query_in_t *args; + storage_meta_name_query_in_t * args; storage_meta_query_one_name_args_t *query_args; hg_handle_t rpc_handle; hg_bulk_t bulk_handle; bulk_rpc_in_t bulk_rpc_in; - void **buf_ptrs; - hg_size_t *buf_sizes; + void ** buf_ptrs; + hg_size_t * buf_sizes; uint32_t server_id; - region_info_transfer_t **region_infos; - region_list_t *region_elt; + region_info_transfer_t ** region_infos; + region_list_t * region_elt; int i, j; FUNC_ENTER(NULL); @@ -5585,9 +5585,9 @@ PDC_Server_add_client_shm_to_cache(int cnt, void *buf_cp) { perr_t ret_value = SUCCEED; int i, j; - region_storage_meta_t *storage_metas = (region_storage_meta_t *)buf_cp; + region_storage_meta_t * storage_metas = (region_storage_meta_t *)buf_cp; pdc_data_server_io_list_t *io_list_elt, *io_list_target; - region_list_t *new_region; + region_list_t * new_region; FUNC_ENTER(NULL); @@ -5699,7 +5699,7 @@ PDC_Server_data_read_to_buf_1_region(region_list_t *region) { perr_t ret_value = SUCCEED; uint64_t offset, read_bytes; - FILE *fp_read = NULL; + FILE * fp_read = NULL; if (region->is_data_ready == 1) return SUCCEED; @@ -5748,9 +5748,9 @@ PDC_Server_data_read_to_buf(region_list_t *region_list_head) { perr_t ret_value = SUCCEED; region_list_t *region_elt; - char *prev_path = NULL; + char * prev_path = NULL; uint64_t offset, read_bytes; - FILE *fp_read = NULL; + FILE * fp_read = NULL; int read_count = 0; @@ -5889,8 +5889,8 @@ static perr_t PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_combine_op_t combine_op) { perr_t ret_value = SUCCEED; - region_list_t *req_region = NULL, *region_tmp = NULL; - region_list_t *storage_region_list_head = NULL; + region_list_t * req_region = NULL, *region_tmp = NULL; + region_list_t * storage_region_list_head = NULL; pdc_data_server_io_list_t *io_list_elt, *io_list_target = NULL; uint64_t obj_id; int iter, count, is_same_region, i, can_skip; @@ -6161,7 +6161,7 @@ compare_coords_3d(const void *a, const void *b) ({ \ uint64_t idx, iii, jjj, ttt, cur_count = 0, istart, has_dup; \ int is_good, _ndim; \ - TYPE *edata = (TYPE *)(_data); \ + TYPE * edata = (TYPE *)(_data); \ _ndim = (_region)->ndim; \ istart = (_sel)->nhits * _ndim; \ if (_ndim > 3) { \ @@ -6306,7 +6306,7 @@ compare_coords_3d(const void *a, const void *b) ({ \ uint64_t idx, iii, jjj, ttt, cur_count = 0, istart, has_dup; \ int is_good, _ndim; \ - TYPE *edata = (TYPE *)(_data); \ + TYPE * edata = (TYPE *)(_data); \ _ndim = (_region)->ndim; \ istart = (_sel)->nhits * _ndim; \ if (_ndim > 3) { \ @@ -6467,11 +6467,11 @@ generate_write_fastbit_idx(uint64_t obj_id, void *data, uint64_t dataCount, Fast char keyName[128]; char offName[128]; char out_name[256]; - double *keys = NULL; - int64_t *offsets = NULL; + double * keys = NULL; + int64_t * offsets = NULL; uint32_t *bms = NULL; uint64_t nk = 0, no = 0, nb = 0; - FILE *fp; + FILE * fp; FUNC_ENTER(NULL); @@ -6569,7 +6569,7 @@ int queryData(const char *name) { uint64_t nhits, i; - uint64_t *buf; + uint64_t * buf; double val1 = 0.0, val2 = 10.0; FastBitSelectionHandle sel1 = fastbit_selection_osr(name, FastBitCompareGreater, val1); FastBitSelectionHandle sel2 = fastbit_selection_osr(name, FastBitCompareLess, val2); @@ -6604,7 +6604,7 @@ PDC_load_fastbit_index(char *idx_name, uint64_t obj_id, FastBitDataType dtype, i char offName[128]; char out_name[256]; uint64_t nk = 0, no = 0, nb = 0, size; - FILE *fp; + FILE * fp; PDC_gen_fastbit_idx_name(bmsName, "bms", obj_id, timestep, ndim, start, count); PDC_gen_fastbit_idx_name(keyName, "key", obj_id, timestep, ndim, start, count); @@ -6680,9 +6680,9 @@ PDC_query_fastbit_idx(region_list_t *region, pdc_query_constraint_t *constraint, perr_t ret_value = SUCCEED; FastBitDataType ft = 0; uint64_t type_size; - uint32_t *bms = NULL; - double *keys = NULL; - int64_t *offsets = NULL; + uint32_t * bms = NULL; + double * keys = NULL; + int64_t * offsets = NULL; int timestep; double v1, v2; size_t i; @@ -6857,7 +6857,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ pdc_query_combine_op_t combine_op) { perr_t ret_value = SUCCEED; - region_list_t *region_elt, *region_list_head, *cache_region, tmp_region, *region_constraint = NULL; + region_list_t * region_elt, *region_list_head, *cache_region, tmp_region, *region_constraint = NULL; pdc_selection_t *sel = query->sel; uint64_t nelem; size_t i, j, unit_size; @@ -6871,7 +6871,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ uint32_t ulo = 0, uhi = 0; int64_t i64lo = 0, i64hi = 0; uint64_t ui64lo = 0, ui64hi = 0; - void *value = NULL, *buf = NULL; + void * value = NULL, *buf = NULL; int n_eval_region = 0, can_skip, region_iter = 0; LOG_INFO("==PDC_SERVER[%d]: start query evaluation!\n", pdc_server_rank_g); @@ -7212,7 +7212,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ n_eval_region++; } // End DL_FOREACH - } // End not use fastbit + } // End not use fastbit if (n_eval_region == 0 && combine_op == PDC_QUERY_AND) { if (sel->nhits > 0) { @@ -7540,7 +7540,7 @@ PDC_Server_send_coords_to_client(query_task_t *task) hg_bulk_t bulk_handle; bulk_rpc_in_t in; hg_size_t buf_sizes; - void *buf; + void * buf; int client_id; FUNC_ENTER(NULL); @@ -7622,7 +7622,7 @@ PDC_Server_send_coords_to_server(query_task_t *task) hg_bulk_t bulk_handle = NULL; bulk_rpc_in_t in; hg_size_t buf_sizes; - void *buf; + void * buf; int server_id; FUNC_ENTER(NULL); @@ -7829,9 +7829,9 @@ hg_return_t PDC_Server_read_coords(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; - query_task_t *task = (query_task_t *)callback_info->arg; + query_task_t * task = (query_task_t *)callback_info->arg; pdc_query_constraint_t *constraint; - region_list_t *storage_region_head, *region_elt, *cache_region; + region_list_t * storage_region_head, *region_elt, *cache_region; size_t ndim, unit_size; uint64_t i, *coord, data_off, buf_off, my_size; @@ -7897,11 +7897,11 @@ PDC_recv_read_coords(const struct hg_cb_info *callback_info) hg_return_t ret = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; - query_task_t *task_elt = NULL; + query_task_t * task_elt = NULL; uint64_t nhits, obj_id; uint32_t ndim; int query_id, origin; - void *buf; + void * buf; pdc_int_ret_t out; out.ret = 1; @@ -7980,7 +7980,7 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) hg_return_t ret = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; - query_task_t *task_elt; + query_task_t * task_elt; uint64_t nhits = 0, total_hits; size_t ndim, unit_size; int i, query_id, origin, found_task; @@ -8198,7 +8198,7 @@ perr_t add_storage_region_to_buf(void **in_buf, uint64_t *buf_alloc, uint64_t *buf_off, const region_list_t *region) { perr_t ret_value = SUCCEED; - void *buf = *in_buf; + void * buf = *in_buf; uint64_t my_size, tmp_size; if (in_buf == NULL || *in_buf == NULL || region == NULL || buf_alloc == NULL || buf_off == NULL || @@ -8394,8 +8394,8 @@ PDC_Server_distribute_query_storage_info(query_task_t *task, uint64_t obj_id, in { pdc_metadata_t *meta = NULL; int i, server_id, count, avg_count, nsent, nsent_server; - region_list_t *elt, *new_region = NULL; - void *region_bulk_buf; + region_list_t * elt, *new_region = NULL; + void * region_bulk_buf; uint64_t buf_alloc = 0, buf_off = 0; bulk_rpc_in_t header; @@ -8535,16 +8535,16 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; hg_bulk_t local_bulk_handle = callback_info->info.bulk.local_handle; - struct bulk_args_t *bulk_args = (struct bulk_args_t *)callback_info->arg; - void *buf; - region_list_t *regions = NULL; + struct bulk_args_t * bulk_args = (struct bulk_args_t *)callback_info->arg; + void * buf; + region_list_t * regions = NULL; int i, nregion, *loc_len_ptr, *has_hist_ptr, found_task; uint64_t buf_off, *offset_ptr = NULL, *size_ptr = NULL; - char *loc_ptr = NULL; + char * loc_ptr = NULL; region_info_transfer_t *region_info_ptr = NULL; - pdc_histogram_t *hist_ptr = NULL; - query_task_t *task_elt = NULL; - pdc_query_t *query = NULL; + pdc_histogram_t * hist_ptr = NULL; + query_task_t * task_elt = NULL; + pdc_query_t * query = NULL; pdc_int_ret_t out; out.ret = 1; @@ -8713,10 +8713,10 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) hg_return_t ret = HG_SUCCESS; pdc_query_xfer_t *query_xfer = (pdc_query_xfer_t *)callback_info->arg; int obj_idx = 0; - uint64_t *obj_ids; - query_task_t *new_task = NULL, *task_elt; + uint64_t * obj_ids; + query_task_t * new_task = NULL, *task_elt; int query_id_exist = 0; - pdc_query_t *query; + pdc_query_t * query; query = PDC_deserialize_query(query_xfer); if (NULL == query) { @@ -8822,7 +8822,7 @@ PDC_Server_send_read_coords_to_server(int server_id, uint64_t *coord, uint64_t n hg_bulk_t bulk_handle = NULL; bulk_rpc_in_t in; hg_size_t buf_sizes; - void *buf; + void * buf; FUNC_ENTER(NULL); @@ -8933,12 +8933,12 @@ hg_return_t PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; - get_sel_data_rpc_in_t *in = (get_sel_data_rpc_in_t *)callback_info->arg; - query_task_t *task_elt, *task = NULL; + get_sel_data_rpc_in_t * in = (get_sel_data_rpc_in_t *)callback_info->arg; + query_task_t * task_elt, *task = NULL; uint64_t nhits, *coord, *coords = NULL, obj_id, buf_off, my_size, data_off, i; size_t ndim, unit_size; cache_storage_region_t *cache_region_elt; - region_list_t *storage_region_head = NULL, *cache_region, *region_elt; + region_list_t * storage_region_head = NULL, *cache_region, *region_elt; pdc_var_type_t data_type; // find task @@ -9026,8 +9026,8 @@ PDC_Server_recv_get_sel_data(const struct hg_cb_info *callback_info) { hg_return_t ret = HG_SUCCESS; get_sel_data_rpc_in_t *in = (get_sel_data_rpc_in_t *)callback_info->arg; - query_task_t *task_elt, *task = NULL; - pdc_metadata_t *meta; + query_task_t * task_elt, *task = NULL; + pdc_metadata_t * meta; struct hg_cb_info fake_callback_info = {0}; DL_FOREACH(query_task_list_head_g, task_elt) diff --git a/src/server/pdc_server_region/pdc_server_region_request_handler.h b/src/server/pdc_server_region/pdc_server_region_request_handler.h index 36b28f0dd..861fb44d9 100644 --- a/src/server/pdc_server_region/pdc_server_region_request_handler.h +++ b/src/server/pdc_server_region/pdc_server_region_request_handler.h @@ -38,14 +38,14 @@ hg_return_t transfer_request_all_bulk_transfer_read_cb(const struct hg_cb_info *info) { struct transfer_request_all_local_bulk_args2 *local_bulk_args2; - struct transfer_request_all_local_bulk_args *local_bulk_args = info->arg; - const struct hg_info *handle_info; + struct transfer_request_all_local_bulk_args * local_bulk_args = info->arg; + const struct hg_info * handle_info; transfer_request_all_data request_data; hg_return_t ret = HG_SUCCESS; - struct pdc_region_info *remote_reg_info; + struct pdc_region_info * remote_reg_info; int i, j; uint64_t total_mem_size, mem_size; - char *ptr; + char * ptr; FUNC_ENTER(NULL); @@ -164,7 +164,7 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) struct transfer_request_all_local_bulk_args *local_bulk_args = info->arg; transfer_request_all_data request_data; hg_return_t ret = HG_SUCCESS; - struct pdc_region_info *remote_reg_info; + struct pdc_region_info * remote_reg_info; int i; char cur_time[64]; @@ -278,8 +278,8 @@ transfer_request_wait_all_bulk_transfer_cb(const struct hg_cb_info *info) pdcid_t transfer_request_id; hg_return_t ret = HG_SUCCESS; int i, fast_return; - char *ptr; - int *handle_ref; + char * ptr; + int * handle_ref; pdc_transfer_status_t status; FUNC_ENTER(NULL); @@ -333,7 +333,7 @@ transfer_request_bulk_transfer_write_cb(const struct hg_cb_info *info) { struct transfer_request_local_bulk_args *local_bulk_args = info->arg; hg_return_t ret = HG_SUCCESS; - struct pdc_region_info *remote_reg_info; + struct pdc_region_info * remote_reg_info; uint64_t obj_dims[3]; FUNC_ENTER(NULL); @@ -461,7 +461,7 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) transfer_request_wait_out_t out; pdc_transfer_status_t status; int fast_return = 0; - int *handle_ref; + int * handle_ref; FUNC_ENTER(NULL); #if defined(PDC_TIMING) && defined(ENABLE_MPI) @@ -510,7 +510,7 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) HG_TEST_RPC_CB(transfer_request_wait_all, handle) { struct transfer_request_wait_all_local_bulk_args *local_bulk_args; - const struct hg_info *info; + const struct hg_info * info; transfer_request_wait_all_in_t in; hg_return_t ret_value = HG_SUCCESS; FUNC_ENTER(NULL); @@ -547,7 +547,7 @@ HG_TEST_RPC_CB(transfer_request_wait_all, handle) HG_TEST_RPC_CB(transfer_request_all, handle) { struct transfer_request_all_local_bulk_args *local_bulk_args; - const struct hg_info *info; + const struct hg_info * info; transfer_request_all_in_t in; transfer_request_all_out_t out; hg_return_t ret_value = HG_SUCCESS; @@ -680,7 +680,7 @@ transfer_request_metadata_query_bulk_transfer_cb(const struct hg_cb_info *info) HG_TEST_RPC_CB(transfer_request_metadata_query, handle) { struct transfer_request_metadata_query_local_bulk_args *local_bulk_args; - const struct hg_info *info; + const struct hg_info * info; transfer_request_metadata_query_in_t in; hg_return_t ret_value = HG_SUCCESS; @@ -735,7 +735,7 @@ transfer_request_metadata_query2_bulk_transfer_cb(const struct hg_cb_info *info) HG_TEST_RPC_CB(transfer_request_metadata_query2, handle) { struct transfer_request_metadata_query2_local_bulk_args *local_bulk_args; - const struct hg_info *info; + const struct hg_info * info; transfer_request_metadata_query2_in_t in; hg_return_t ret_value = HG_SUCCESS; @@ -779,8 +779,8 @@ HG_TEST_RPC_CB(transfer_request, handle) transfer_request_out_t out; struct transfer_request_local_bulk_args *local_bulk_args; size_t total_mem_size; - const struct hg_info *info; - struct pdc_region_info *remote_reg_info; + const struct hg_info * info; + struct pdc_region_info * remote_reg_info; uint64_t obj_dims[3]; FUNC_ENTER(NULL); diff --git a/src/tools/pdc_export.c b/src/tools/pdc_export.c index a12f23a67..5c9b2aafd 100644 --- a/src/tools/pdc_export.c +++ b/src/tools/pdc_export.c @@ -26,8 +26,8 @@ int rank = 0, size = 1; pdcid_t pdc_id_g = 0; typedef struct pdc_region_metadata_pkg { - uint64_t *reg_offset; - uint64_t *reg_size; + uint64_t * reg_offset; + uint64_t * reg_size; uint32_t data_server_id; struct pdc_region_metadata_pkg *next; } pdc_region_metadata_pkg; @@ -35,8 +35,8 @@ typedef struct pdc_region_metadata_pkg { typedef struct pdc_obj_metadata_pkg { int ndim; uint64_t obj_id; - pdc_region_metadata_pkg *regions; - pdc_region_metadata_pkg *regions_end; + pdc_region_metadata_pkg * regions; + pdc_region_metadata_pkg * regions_end; struct pdc_obj_metadata_pkg *next; } pdc_obj_metadata_pkg; @@ -49,24 +49,24 @@ typedef struct pdc_obj_region_metadata { typedef struct pdc_metadata_query_buf { uint64_t id; - char *buf; + char * buf; struct pdc_metadata_query_buf *next; } pdc_metadata_query_buf; typedef struct RegionNode { - region_list_t *region_list; + region_list_t * region_list; struct RegionNode *next; } RegionNode; typedef struct MetadataNode { - pdc_metadata_t *metadata_ptr; - struct MetadataNode *next; - RegionNode *region_list_head; + pdc_metadata_t * metadata_ptr; + struct MetadataNode * next; + RegionNode * region_list_head; pdc_obj_metadata_pkg *obj_metadata_pkg; } MetadataNode; typedef struct FileNameNode { - char *file_name; + char * file_name; struct FileNameNode *next; } FileNameNode; @@ -79,7 +79,7 @@ typedef struct ArrayList { ArrayList * newList(void) { - char **items = malloc(4 * sizeof(char *)); + char ** items = malloc(4 * sizeof(char *)); ArrayList *list = malloc(sizeof(ArrayList)); list->length = 0; list->capacity = 4; @@ -159,9 +159,9 @@ main(int argc, char *argv[]) return 1; } else { - FileNameNode *head = NULL; - FileNameNode *cur_node = NULL; - DIR *d; + FileNameNode * head = NULL; + FileNameNode * cur_node = NULL; + DIR * d; struct dirent *dir; d = opendir(argv[1]); if (d) { @@ -204,7 +204,7 @@ main(int argc, char *argv[]) FILE *file = fopen(argv[1], "r"); if (file != NULL) { FileNameNode *new_node = (FileNameNode *)malloc(sizeof(FileNameNode)); - char *full_path = (char *)malloc(sizeof(char) * (strlen(argv[1]) + 1)); + char * full_path = (char *)malloc(sizeof(char) * (strlen(argv[1]) + 1)); strcpy(full_path, argv[1]); new_node->file_name = full_path; new_node->next = NULL; @@ -273,12 +273,12 @@ do_transfer_request_metadata(int pdc_server_size_input, char *checkpoint) int n_objs, reg_count; int i, j; - pdc_obj_metadata_pkg *metadata_server_objs = NULL; - pdc_obj_metadata_pkg *metadata_server_objs_end = NULL; + pdc_obj_metadata_pkg * metadata_server_objs = NULL; + pdc_obj_metadata_pkg * metadata_server_objs_end = NULL; pdc_metadata_query_buf *metadata_query_buf_head = NULL; pdc_metadata_query_buf *metadata_query_buf_end = NULL; int pdc_server_size = pdc_server_size_input; - uint64_t *data_server_bytes = (uint64_t *)calloc(pdc_server_size, sizeof(uint64_t)); + uint64_t * data_server_bytes = (uint64_t *)calloc(pdc_server_size, sizeof(uint64_t)); uint64_t query_id_g = 100000; ptr = checkpoint; @@ -357,9 +357,9 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) arg_index++; } - char *filename; + char * filename; MetadataNode *metadata_head = NULL; - RegionNode *cur_region_node = NULL; + RegionNode * cur_region_node = NULL; FileNameNode *cur_file_node = file_name_node; int all_cont_total = 0; @@ -379,12 +379,12 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) int n_entry, count, i, j, nobj = 0, all_nobj = 0, all_n_region, n_region, n_objs, total_region = 0, n_kvtag, key_len; int n_cont, all_cont; - pdc_metadata_t *metadata, *elt; - region_list_t *region_list; - uint32_t *hash_key; + pdc_metadata_t * metadata, *elt; + region_list_t * region_list; + uint32_t * hash_key; unsigned idx; pdc_cont_hash_table_entry_t *cont_entry; - pdc_hash_table_entry_head *entry; + pdc_hash_table_entry_head * entry; FILE *file = fopen(filename, "r"); if (file == NULL) { @@ -598,7 +598,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) } uint64_t checkpoint_size; - char *checkpoint_buf; + char * checkpoint_buf; if (fread(&checkpoint_size, sizeof(uint64_t), 1, file) != 1) { LOG_ERROR("Read failed for checkpoint size\n"); @@ -642,7 +642,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) } int prev_cont_id = -1; - MetadataNode *cur_metadata_node = metadata_head; + MetadataNode * cur_metadata_node = metadata_head; pdc_metadata_t *cur_metadata; hid_t file_id; fflush(stdout); @@ -677,7 +677,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) char *full_path = (char *)malloc(sizeof(char) * strlen(cur_metadata->obj_name) + 1); strcpy(full_path, cur_metadata->obj_name); - char *last_slash = strrchr(full_path, '/'); + char * last_slash = strrchr(full_path, '/'); size_t length = last_slash - full_path + 1; char temp[length + 1]; memcpy(temp, full_path, length); @@ -691,7 +691,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) char *cur_path = (char *)malloc(sizeof(char) * strlen(cur_metadata->obj_name) + strlen(buf) + 1); strcpy(cur_path, buf); const char delim[2] = "/"; - char *token; + char * token; token = strtok(temp, delim); hid_t cur_group_id = group_id; while (token != NULL) { @@ -718,7 +718,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) buf_size *= (cur_metadata->dims)[i]; } hsize_t dtype_size = H5Tget_size(data_type); - void *data_buf = malloc(buf_size * dtype_size); // if data side is large, need to write in batches + void * data_buf = malloc(buf_size * dtype_size); // if data side is large, need to write in batches uint64_t region_offset[10], region_size[10]; for (int i = 0; i < cur_metadata->ndim; i++) { diff --git a/src/tools/pdc_import.c b/src/tools/pdc_import.c index 96c8e3627..cccc20cfa 100644 --- a/src/tools/pdc_import.c +++ b/src/tools/pdc_import.c @@ -28,7 +28,7 @@ typedef struct ArrayList { ArrayList * newList(void) { - char **items = malloc(4 * sizeof(char *)); + char ** items = malloc(4 * sizeof(char *)); ArrayList *list = malloc(sizeof(ArrayList)); list->length = 0; list->capacity = 4; @@ -74,7 +74,7 @@ print_usage() int rank = 0, size = 1; char tags_g[MAX_TAG_SIZE]; -char *tags_ptr_g; +char * tags_ptr_g; char dset_name_g[TAG_LEN_MAX]; hsize_t tag_size_g; int ndset_g = 0; @@ -377,11 +377,11 @@ do_dset(hid_t did, char *name, char *app_name) hsize_t dtype_size, dset_size; char ds_name[MAX_NAME]; char grp_name[MAX_NAME]; - char *obj_name; + char * obj_name; int name_len, i; hsize_t ndim, dims[10]; uint64_t region_offset[10], region_size[10]; - void *buf; + void * buf; struct pdc_region_info obj_region; tag_size_g = 0; @@ -521,8 +521,8 @@ do_dtype(hid_t tid, hid_t oid, int is_compound) herr_t status; int compound_nmember, i; hsize_t dims[8], ndim; - char *mem_name; - char *attr_string[100], new_string[TAG_LEN_MAX], tmp_str[TAG_LEN_MAX]; + char * mem_name; + char * attr_string[100], new_string[TAG_LEN_MAX], tmp_str[TAG_LEN_MAX]; hsize_t attr_size, attr_len; hid_t mem_type; hid_t atype, aspace, naive_type; @@ -625,8 +625,8 @@ do_attr(hid_t aid, pdcid_t obj_id) char buf[MAX_NAME] = {0}; char read_buf[TAG_LEN_MAX] = {0}; // pdc_kvtag_t kvtag1; - char *tag_name; - void *tag_value; + char * tag_name; + void * tag_value; pdc_var_type_t value_type; size_t tag_size;