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..7f1498c06 100644 --- a/src/api/pdc_client_connect.c +++ b/src/api/pdc_client_connect.c @@ -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); @@ -2780,13 +2774,11 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj 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); @@ -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..."); @@ -3153,23 +3140,22 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d 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); @@ -3277,12 +3240,11 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, 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); @@ -3341,12 +3299,12 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i 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); @@ -3407,6 +3361,8 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u 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); @@ -3486,18 +3434,22 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, 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..."); @@ -3724,12 +3649,12 @@ PDC_Client_buf_map(pdcid_t local_region_id, pdcid_t remote_obj_id, size_t ndim, 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; @@ -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..96fea2608 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..a649c4706 100644 --- a/src/server/pdc_client_server_common.c +++ b/src/server/pdc_client_server_common.c @@ -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: @@ -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 @@ -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); } @@ -4120,9 +4118,7 @@ HG_TEST_RPC_CB(buf_map, handle) 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); diff --git a/src/server/pdc_server.c b/src/server/pdc_server.c index 710bc514d..7175072ab 100644 --- a/src/server/pdc_server.c +++ b/src/server/pdc_server.c @@ -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 @@ -1462,7 +1462,7 @@ PDC_Server_restart(char *filename) unsigned idx; uint64_t checkpoint_size; char * checkpoint_buf; -#ifdef PDC_TIMING +#if defined(PDC_TIMING) && defined(ENABLE_MPI) double start = MPI_Wtime(); #endif @@ -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 diff --git a/src/server/pdc_server_region/pdc_server_data.c b/src/server/pdc_server_region/pdc_server_data.c index d00ce2a15..93dbf6c0d 100644 --- a/src/server/pdc_server_region/pdc_server_data.c +++ b/src/server/pdc_server_region/pdc_server_data.c @@ -4412,7 +4412,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, 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 @@ -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: 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..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 @@ -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); @@ -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; @@ -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 @@ -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); @@ -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); } @@ -463,7 +464,7 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) 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 @@ -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 @@ -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..5c9b2aafd 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 diff --git a/src/tools/pdc_import.c b/src/tools/pdc_import.c index 0fb670df6..cccc20cfa 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