diff --git a/examples/C_plus_plus_example/multidataset_plugin.cc b/examples/C_plus_plus_example/multidataset_plugin.cc index 3c1d71848..e5782a2e9 100644 --- a/examples/C_plus_plus_example/multidataset_plugin.cc +++ b/examples/C_plus_plus_example/multidataset_plugin.cc @@ -8,38 +8,43 @@ static pdcid_t cont; static std::map dp2event; -static std::vector cached_objs; -static std::vector cached_requests; -static std::vector cached_bufs; +static std::vector cached_objs; +static std::vector cached_requests; +static std::vector cached_bufs; static std::set existing_objs; static int hdf5_method_g = -1; #endif -static std::map multi_datasets; +static std::map multi_datasets; -int init_multidataset() { +int +init_multidataset() +{ char *p = getenv("HEP_IO_TYPE"); - if ( p != NULL ) { + if (p != NULL) { set_hdf5_method(atoi(p)); - } else { + } + else { set_hdf5_method(1); } #ifdef PDC_PATCH pdcid_t cont_prop; - pdc = PDCinit("pdc"); + pdc = PDCinit("pdc"); cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - cont = PDCcont_create("C", cont_prop); + cont = PDCcont_create("C", cont_prop); PDCprop_close(cont_prop); #endif return 0; } -int finalize_multidataset() { - unsigned i; - std::map::iterator it; - std::vector::iterator it2; - double start_time; +int +finalize_multidataset() +{ + unsigned i; + std::map::iterator it; + std::vector::iterator it2; + double start_time; #ifdef PDC_PATCH flush_multidatasets(); @@ -47,25 +52,25 @@ int finalize_multidataset() { #ifdef H5_TIMING_ENABLE register_timer_start(&start_time); #endif - //PDCregion_transfer_wait_all(&cached_requests[0], cached_requests.size()); + // PDCregion_transfer_wait_all(&cached_requests[0], cached_requests.size()); #ifdef H5_TIMING_ENABLE register_PDCwait_timer_end(start_time); #endif - for ( i = 0; i < cached_requests.size(); ++i ) { + for (i = 0; i < cached_requests.size(); ++i) { PDCregion_transfer_close(cached_requests[i]); } - for ( i = 0; i < cached_bufs.size(); ++i ) { + for (i = 0; i < cached_bufs.size(); ++i) { free(cached_bufs[i]); } - for ( i = 0; i < cached_objs.size(); ++i ) { + for (i = 0; i < cached_objs.size(); ++i) { PDCobj_close(cached_objs[i]); } } PDCcont_close(cont); PDCclose(pdc); #else - for ( it = multi_datasets.begin(); it != multi_datasets.end(); ++it ) { - for ( it2 = it->second->temp_mem->begin(); it2 != it->second->temp_mem->end(); ++it2 ) { + for (it = multi_datasets.begin(); it != multi_datasets.end(); ++it) { + for (it2 = it->second->temp_mem->begin(); it2 != it->second->temp_mem->end(); ++it2) { free(*it2); } if (it->second->did != -1) { @@ -77,39 +82,46 @@ int finalize_multidataset() { register_H5Dclose_timer_end(start_time); #endif } - delete it->second->start; - delete it->second->end; - delete it->second->temp_mem; + delete it->second->start; + delete it->second->end; + delete it->second->temp_mem; free(it->second); } #endif return 0; } -int set_hdf5_method(int hdf5_method) { +int +set_hdf5_method(int hdf5_method) +{ hdf5_method_g = hdf5_method; return 0; } -int get_hdf5_method() { +int +get_hdf5_method() +{ return hdf5_method_g; } -static int wrap_hdf5_spaces(int total_requests, hsize_t *start, hsize_t *end, hid_t did, hid_t* dsid_ptr, hid_t *msid_ptr) { +static int +wrap_hdf5_spaces(int total_requests, hsize_t *start, hsize_t *end, hid_t did, hid_t *dsid_ptr, + hid_t *msid_ptr) +{ const hsize_t ndims = 1; - hsize_t old_dims[ndims]; //our datasets are 1D - hsize_t new_dims[ndims]; - hsize_t max_dims[ndims]; //= {H5S_UNLIMITED}; - hsize_t max_offset, data_size, total_data_size; - hid_t dsid, msid; - int i; + hsize_t old_dims[ndims]; // our datasets are 1D + hsize_t new_dims[ndims]; + hsize_t max_dims[ndims]; //= {H5S_UNLIMITED}; + hsize_t max_offset, data_size, total_data_size; + hid_t dsid, msid; + int i; dsid = H5Dget_space(did); H5Sget_simple_extent_dims(dsid, old_dims, max_dims); - + max_offset = end[0]; - for ( i = 1; i < total_requests; ++i ) { - if ( max_offset < end[i] ) { + for (i = 1; i < total_requests; ++i) { + if (max_offset < end[i]) { max_offset = end[i]; } } @@ -123,49 +135,54 @@ static int wrap_hdf5_spaces(int total_requests, hsize_t *start, hsize_t *end, hi data_size = end[0] - start[0]; H5Sselect_hyperslab(dsid, H5S_SELECT_SET, start, NULL, &data_size, NULL); total_data_size = data_size; - for ( i = 1; i < total_requests; ++i ) { + for (i = 1; i < total_requests; ++i) { data_size = end[i] - start[i]; total_data_size += data_size; H5Sselect_hyperslab(dsid, H5S_SELECT_OR, start + i, NULL, &data_size, NULL); } max_dims[0] = H5S_UNLIMITED; - msid = H5Screate_simple(ndims, &total_data_size, max_dims); + msid = H5Screate_simple(ndims, &total_data_size, max_dims); *dsid_ptr = dsid; *msid_ptr = msid; return 0; } #ifdef PDC_PATCH -int register_multidataset_request(const char *name, void *buf, hsize_t start, hsize_t end, hid_t mtype) { +int +register_multidataset_request(const char *name, void *buf, hsize_t start, hsize_t end, hid_t mtype) +{ #else -int register_multidataset_request(const char *name, hid_t gid, void *buf, hsize_t start, hsize_t end, hid_t mtype) { +int +register_multidataset_request(const char *name, hid_t gid, void *buf, hsize_t start, hsize_t end, hid_t mtype) +{ #endif - std::string s(name); - std::map::iterator it; - char *temp_mem; - size_t esize = H5Tget_size (mtype) * (end - start); - int flag = 0; + std::string s(name); + std::map::iterator it; + char *temp_mem; + size_t esize = H5Tget_size(mtype) * (end - start); + int flag = 0; it = multi_datasets.find(s); - if ( it == multi_datasets.end()) { - multidataset_array *multi_dataset = (multidataset_array *) malloc(sizeof(multidataset_array)); - multi_dataset->start = new std::vector; - multi_dataset->end =new std::vector; - multi_dataset->temp_mem = new std::vector; - multi_datasets[s] = multi_dataset; - it = multi_datasets.find(s); - flag = 1; + if (it == multi_datasets.end()) { + multidataset_array *multi_dataset = (multidataset_array *)malloc(sizeof(multidataset_array)); + multi_dataset->start = new std::vector; + multi_dataset->end = new std::vector; + multi_dataset->temp_mem = new std::vector; + multi_datasets[s] = multi_dataset; + it = multi_datasets.find(s); + flag = 1; } #ifdef PDC_PATCH - int ndim = 1; + int ndim = 1; uint64_t dims; if (flag) { if (existing_objs.find(s) == existing_objs.end()) { pdcid_t obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); - if (mtype == H5T_NATIVE_ULLONG){ + if (mtype == H5T_NATIVE_ULLONG) { PDCprop_set_obj_type(obj_prop, PDC_UINT64); - } else { + } + else { PDCprop_set_obj_type(obj_prop, PDC_CHAR); } dims = end - start; @@ -174,7 +191,8 @@ int register_multidataset_request(const char *name, hid_t gid, void *buf, hsize_ it->second->did = PDCobj_create(cont, name, obj_prop); PDCprop_close(obj_prop); existing_objs.insert(s); - } else { + } + else { it->second->did = PDCobj_open(name, pdc); } } @@ -185,28 +203,31 @@ int register_multidataset_request(const char *name, hid_t gid, void *buf, hsize_ #endif it->second->start->push_back(start); it->second->end->push_back(end); - temp_mem = (char*) malloc(esize); + temp_mem = (char *)malloc(esize); it->second->temp_mem->push_back(temp_mem); memcpy(temp_mem, buf, esize); it->second->last_end = end; - it->second->mtype = mtype; + it->second->mtype = mtype; return 0; } -int register_multidataset_request_append(const char *name, hid_t gid, void *buf, hsize_t data_size, hid_t mtype) { +int +register_multidataset_request_append(const char *name, hid_t gid, void *buf, hsize_t data_size, hid_t mtype) +{ std::string s(name); - hsize_t start, end; + hsize_t start, end; - std::map::iterator it; + std::map::iterator it; it = multi_datasets.find(s); - if ( it != multi_datasets.end() ){ + if (it != multi_datasets.end()) { start = it->second->last_end; - end = it->second->last_end + data_size; - } else { + end = it->second->last_end + data_size; + } + else { start = 0; - end = data_size; + end = data_size; } #ifdef PDC_PATCH @@ -217,38 +238,42 @@ int register_multidataset_request_append(const char *name, hid_t gid, void *buf, return 0; } -static int merge_requests(std::vector *start, std::vector *end, int request_size, std::vector *buf, hsize_t **new_start, hsize_t **new_end, char** new_buf, hid_t mtype, int *request_size_ptr) { - int i, index; - int merged_requests = request_size; - char* ptr; - size_t esize = H5Tget_size (mtype); +static int +merge_requests(std::vector *start, std::vector *end, int request_size, + std::vector *buf, hsize_t **new_start, hsize_t **new_end, char **new_buf, hid_t mtype, + int *request_size_ptr) +{ + int i, index; + int merged_requests = request_size; + char *ptr; + size_t esize = H5Tget_size(mtype); size_t total_data_size = end[0][0] - start[0][0]; - for ( i = 1; i < request_size; ++i ) { + for (i = 1; i < request_size; ++i) { total_data_size += end[0][i] - start[0][i]; - if ( end[0][i-1] == start[0][i] ) { + if (end[0][i - 1] == start[0][i]) { merged_requests--; } } - *new_start = (hsize_t*) malloc(sizeof(hsize_t) * merged_requests * 2); - *new_end = new_start[0] + merged_requests; + *new_start = (hsize_t *)malloc(sizeof(hsize_t) * merged_requests * 2); + *new_end = new_start[0] + merged_requests; - index = 0; + index = 0; new_start[0][0] = start[0][0]; - new_end[0][0] = end[0][0]; + new_end[0][0] = end[0][0]; - *new_buf = (char*) malloc(esize * total_data_size); - ptr = *new_buf; + *new_buf = (char *)malloc(esize * total_data_size); + ptr = *new_buf; memcpy(ptr, buf[0][0], (end[0][0] - start[0][0]) * esize); ptr += (end[0][0] - start[0][0]) * esize; free(buf[0][0]); - for ( i = 1; i < request_size; ++i ) { + for (i = 1; i < request_size; ++i) { memcpy(ptr, buf[0][i], (end[0][i] - start[0][i]) * esize); ptr += (end[0][i] - start[0][i]) * esize; free(buf[0][i]); - if ( end[0][i-1] < start[0][i] ) { + if (end[0][i - 1] < start[0][i]) { index++; new_start[0][index] = start[0][i]; } @@ -258,85 +283,89 @@ static int merge_requests(std::vector *start, std::vector *end return 0; } -int flush_multidatasets() { +int +flush_multidatasets() +{ unsigned i; - int j; + int j; #ifndef PDC_PATCH - size_t esize; - hsize_t dims[H5S_MAX_RANK], mdims[H5S_MAX_RANK]; + size_t esize; + hsize_t dims[H5S_MAX_RANK], mdims[H5S_MAX_RANK]; H5D_rw_multi_t *multi_datasets_temp; - hid_t msid, dsid; + hid_t msid, dsid; #endif - hsize_t *new_start, *new_end; - int new_request_size; - std::map::iterator it; - int dataset_size = multi_datasets.size(); - char **temp_buf = (char**) malloc(sizeof(char*) * dataset_size); + hsize_t *new_start, *new_end; + int new_request_size; + std::map::iterator it; + int dataset_size = multi_datasets.size(); + char **temp_buf = (char **)malloc(sizeof(char *) * dataset_size); #ifdef H5_TIMING_ENABLE double start_time; #endif i = 0; - LOG_DEBUG("Rank %d number of datasets to be written %d\n", rank, dataset_size); -#if ENABLE_MULTIDATASET==1 - #ifdef H5_TIMING_ENABLE + LOG_DEBUG("Number of datasets to be written %d\n", rank, dataset_size); +#if ENABLE_MULTIDATASET == 1 +#ifdef H5_TIMING_ENABLE increment_H5Dwrite(); - #endif - multi_datasets_temp = (H5D_rw_multi_t*) malloc(sizeof(H5D_rw_multi_t) * dataset_size); - for ( it = multi_datasets.begin(); it != multi_datasets.end(); ++it ) { +#endif + multi_datasets_temp = (H5D_rw_multi_t *)malloc(sizeof(H5D_rw_multi_t) * dataset_size); + for (it = multi_datasets.begin(); it != multi_datasets.end(); ++it) { if (it->second->did == -1) { - i++; + i++; continue; } - //MPI_Barrier(MPI_COMM_WORLD); - #ifdef H5_TIMING_ENABLE +// MPI_Barrier(MPI_COMM_WORLD); +#ifdef H5_TIMING_ENABLE increment_H5Dwrite(); - #endif +#endif - merge_requests(it->second->start, it->second->end, it->second->start->size(), it->second->temp_mem, &new_start, &new_end, &(temp_buf[i]), it->second->mtype, &new_request_size); - multi_datasets_temp[i].dset_id = it->second->did; + merge_requests(it->second->start, it->second->end, it->second->start->size(), it->second->temp_mem, + &new_start, &new_end, &(temp_buf[i]), it->second->mtype, &new_request_size); + multi_datasets_temp[i].dset_id = it->second->did; multi_datasets_temp[i].mem_type_id = it->second->mtype; - multi_datasets_temp[i].u.wbuf = temp_buf[i]; + multi_datasets_temp[i].u.wbuf = temp_buf[i]; - wrap_hdf5_spaces(new_request_size, new_start, new_end, it->second->did, &(multi_datasets_temp[i].dset_space_id), &(multi_datasets_temp[i].mem_space_id)); - i++; + wrap_hdf5_spaces(new_request_size, new_start, new_end, it->second->did, + &(multi_datasets_temp[i].dset_space_id), &(multi_datasets_temp[i].mem_space_id)); + i++; } H5Dwrite_multi(H5P_DEFAULT, dataset_size, multi_datasets_temp); - for ( it = multi_datasets.begin(); it != multi_datasets.end(); ++it ) { + for (it = multi_datasets.begin(); it != multi_datasets.end(); ++it) { if (it->second->did == -1) { continue; } H5Sclose(multi_datasets_temp[i].dset_space_id); H5Sclose(multi_datasets_temp[i].mem_space_id); H5Dclose(multi_datasets_temp[i].dset_id); - delete it->second->start; - delete it->second->end; - delete it->second->temp_mem; + delete it->second->start; + delete it->second->end; + delete it->second->temp_mem; free(temp_buf[i]); } free(multi_datasets_temp); #else - LOG_DEBUG("rank %d has dataset_size %lld\n", rank, (long long int) dataset_size); + LOG_DEBUG("Dataset_size %lld\n", rank, (long long int)dataset_size); #ifdef PDC_PATCH if (cached_objs.size()) { #ifdef H5_TIMING_ENABLE register_timer_start(&start_time); #endif - //PDCregion_transfer_wait_all(&cached_requests[0], cached_requests.size()); + // PDCregion_transfer_wait_all(&cached_requests[0], cached_requests.size()); #ifdef H5_TIMING_ENABLE register_PDCwait_timer_end(start_time); #endif - for ( i = 0; i < cached_requests.size(); ++i ) { + for (i = 0; i < cached_requests.size(); ++i) { PDCregion_transfer_close(cached_requests[i]); } - for ( i = 0; i < cached_bufs.size(); ++i ) { + for (i = 0; i < cached_bufs.size(); ++i) { free(cached_bufs[i]); } - for ( i = 0; i < cached_objs.size(); ++i ) { + for (i = 0; i < cached_objs.size(); ++i) { PDCobj_close(cached_objs[i]); } cached_objs.clear(); @@ -344,32 +373,36 @@ int flush_multidatasets() { cached_bufs.clear(); } i = 0; - for ( it = multi_datasets.begin(); it != multi_datasets.end(); ++it ) { + for (it = multi_datasets.begin(); it != multi_datasets.end(); ++it) { #ifdef H5_TIMING_ENABLE register_timer_start(&start_time); #endif - merge_requests(it->second->start, it->second->end, it->second->start->size(), it->second->temp_mem, &new_start, &new_end, temp_buf + i, it->second->mtype, &new_request_size); + merge_requests(it->second->start, it->second->end, it->second->start->size(), it->second->temp_mem, + &new_start, &new_end, temp_buf + i, it->second->mtype, &new_request_size); #ifdef H5_TIMING_ENABLE register_merge_requests_timer_end(start_time); #endif uint64_t max_dim = new_end[new_request_size - 1]; PDCobj_set_dims(it->second->did, 1, &max_dim); - char* ptr = temp_buf[i]; - for ( j = 0; j < new_request_size; ++j ) { + char *ptr = temp_buf[i]; + for (j = 0; j < new_request_size; ++j) { uint64_t offset, offset_length; - offset = new_start[j]; + offset = new_start[j]; offset_length = new_end[j] - new_start[j]; - pdcid_t reg = PDCregion_create(1, &offset, &offset_length); - pdcid_t transfer_request_id = PDCregion_transfer_create(ptr, PDC_WRITE, it->second->did, reg, reg); - LOG_DEBUG("did = %lu, starting request offset = %lu, size = %lu, j = %d\n", it->second->did, offset, offset_length, j); + pdcid_t reg = PDCregion_create(1, &offset, &offset_length); + pdcid_t transfer_request_id = + PDCregion_transfer_create(ptr, PDC_WRITE, it->second->did, reg, reg); + LOG_DEBUG("did = %lu, starting request offset = %lu, size = %lu, j = %d\n", it->second->did, + offset, offset_length, j); PDCregion_transfer_start(transfer_request_id); PDCregion_transfer_wait(transfer_request_id); cached_requests.push_back(transfer_request_id); if (it->second->mtype == H5T_NATIVE_CHAR) { ptr += new_end[j] - new_start[j]; - } else { + } + else { ptr += (new_end[j] - new_start[j]) * sizeof(uint64_t); } } @@ -379,33 +412,34 @@ int flush_multidatasets() { delete it->second->start; delete it->second->end; delete it->second->temp_mem; - #ifdef H5_TIMING_ENABLE +#ifdef H5_TIMING_ENABLE increment_PDCwrite(); - #endif +#endif i++; } #ifdef H5_TIMING_ENABLE register_timer_start(&start_time); #endif - //PDCregion_transfer_start_all(&cached_requests[0], cached_requests.size()); + // PDCregion_transfer_start_all(&cached_requests[0], cached_requests.size()); #ifdef H5_TIMING_ENABLE register_PDCstart_timer_end(start_time); #endif #else - for ( it = multi_datasets.begin(); it != multi_datasets.end(); ++it ) { + for (it = multi_datasets.begin(); it != multi_datasets.end(); ++it) { if (it->second->did == -1) { - i++; + i++; continue; } - #ifdef H5_TIMING_ENABLE +#ifdef H5_TIMING_ENABLE increment_H5Dwrite(); - #endif +#endif #ifdef H5_TIMING_ENABLE register_timer_start(&start_time); #endif - merge_requests(it->second->start, it->second->end, it->second->start->size(), it->second->temp_mem, &new_start, &new_end, temp_buf + i, it->second->mtype, &new_request_size); + merge_requests(it->second->start, it->second->end, it->second->start->size(), it->second->temp_mem, + &new_start, &new_end, temp_buf + i, it->second->mtype, &new_request_size); #ifdef H5_TIMING_ENABLE register_merge_requests_timer_end(start_time); @@ -421,7 +455,7 @@ int flush_multidatasets() { #ifdef H5_TIMING_ENABLE register_timer_start(&start_time); #endif - H5Dwrite (it->second->did, it->second->mtype, msid, dsid, H5P_DEFAULT, temp_buf[i]); + H5Dwrite(it->second->did, it->second->mtype, msid, dsid, H5P_DEFAULT, temp_buf[i]); #ifdef H5_TIMING_ENABLE register_H5Dwrite_timer_end(start_time); #endif @@ -435,11 +469,11 @@ int flush_multidatasets() { #ifdef H5_TIMING_ENABLE register_H5Dclose_timer_end(start_time); #endif - delete it->second->start; - delete it->second->end; - delete it->second->temp_mem; + delete it->second->start; + delete it->second->end; + delete it->second->temp_mem; free(temp_buf[i]); - i++; + i++; } #endif free(temp_buf); diff --git a/examples/C_plus_plus_example/region_transfer_1D_append.cc b/examples/C_plus_plus_example/region_transfer_1D_append.cc index cce884945..52ce6ae53 100644 --- a/examples/C_plus_plus_example/region_transfer_1D_append.cc +++ b/examples/C_plus_plus_example/region_transfer_1D_append.cc @@ -27,17 +27,17 @@ #include #include "multidataset_plugin.h" -#define DATA_SIZE 128 +#define DATA_SIZE 128 #define ARRAY_SIZE 10 int main(int argc, char **argv) { - int rank = 0, size = 1; - int ret_value = 0; - int *data; - int i; - char data_name[1024]; + int rank = 0, size = 1; + int ret_value = 0; + int *data; + int i; + char data_name[1024]; // create a pdc #ifdef ENABLE_MPI @@ -52,21 +52,21 @@ main(int argc, char **argv) init_multidataset(); - data = (int*) malloc(sizeof(int) * DATA_SIZE); - for ( i = 0; i < DATA_SIZE; ++i ) { + data = (int *)malloc(sizeof(int) * DATA_SIZE); + for (i = 0; i < DATA_SIZE; ++i) { data[i] = i; } sprintf(data_name, "data0_%d", rank); - LOG_INFO("rank %d C++ example for writing %d lists of arrays with size %d\n", rank, ARRAY_SIZE, DATA_SIZE); - for ( i = 0; i < ARRAY_SIZE; ++i ) { + LOG_INFO("C++ example for writing %d lists of arrays with size %d\n", rank, ARRAY_SIZE, DATA_SIZE); + for (i = 0; i < ARRAY_SIZE; ++i) { register_multidataset_request_append(data_name, 0, data, sizeof(int) * DATA_SIZE, H5T_NATIVE_CHAR); } sprintf(data_name, "data1_%d", rank); - LOG_INFO("rank %d C++ example for writing %d lists of arrays with size %d\n", rank, ARRAY_SIZE, DATA_SIZE); - for ( i = 0; i < ARRAY_SIZE; ++i ) { + LOG_INFO("C++ example for writing %d lists of arrays with size %d\n", rank, ARRAY_SIZE, DATA_SIZE); + for (i = 0; i < ARRAY_SIZE; ++i) { register_multidataset_request_append(data_name, 0, data, sizeof(int) * DATA_SIZE, H5T_NATIVE_CHAR); } flush_multidatasets(); diff --git a/examples/obj_get_data.c b/examples/obj_get_data.c index c0f23d660..2c6396e8e 100644 --- a/examples/obj_get_data.c +++ b/examples/obj_get_data.c @@ -63,7 +63,7 @@ main(int argc, char **argv) sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Rank %d Create a container %s\n", rank, cont_name); + LOG_INFO("Created a container %s\n", cont_name); } else { LOG_ERROR("Failed to create container"); @@ -74,7 +74,7 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_put_data(obj_name1, (void *)data, 16 * sizeof(double), cont); if (obj1 > 0) { - LOG_INFO("Rank %d Put data to %s\n", rank, obj_name1); + LOG_INFO("Put data to %s\n", obj_name1); } else { LOG_ERROR("Failed to put data into object"); @@ -85,7 +85,7 @@ main(int argc, char **argv) sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_put_data(obj_name2, (void *)data, 128 * sizeof(double), cont); if (obj2 > 0) { - LOG_INFO("Rank %d Put data to %s\n", rank, obj_name2); + LOG_INFO("Put data to %s\n", rank, obj_name2); } else { LOG_ERROR("Failed to put data into object"); diff --git a/examples/region_transfer_2D.c b/examples/region_transfer_2D.c index 6aad007c5..37328c3bd 100644 --- a/examples/region_transfer_2D.c +++ b/examples/region_transfer_2D.c @@ -68,7 +68,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -78,7 +78,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -87,13 +87,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, 2, dims); @@ -109,7 +109,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object @@ -119,7 +119,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -143,19 +143,19 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -183,65 +183,65 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/examples/region_transfer_3D.c b/examples/region_transfer_3D.c index 6aefd40d5..7336e5d58 100644 --- a/examples/region_transfer_3D.c +++ b/examples/region_transfer_3D.c @@ -66,29 +66,29 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } @@ -107,20 +107,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -146,19 +146,19 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -188,65 +188,65 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/api/include/pdc.h b/src/api/include/pdc.h index 714120dab..ae790d42b 100644 --- a/src/api/include/pdc.h +++ b/src/api/include/pdc.h @@ -30,6 +30,7 @@ #include "pdc_prop.h" #include "pdc_cont.h" #include "pdc_logger.h" +#include "pdc_client_connect.h" #ifdef ENABLE_MPI #include "pdc_mpi.h" diff --git a/src/api/pdc.c b/src/api/pdc.c index 2fcbd81c0..6f3a462fb 100644 --- a/src/api/pdc.c +++ b/src/api/pdc.c @@ -51,10 +51,9 @@ PDC_class_init() /* Initialize the atom group for the container property IDs */ if (PDC_register_type(PDC_CLASS, (PDC_free_t)PDC_class__close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize pdc class interface"); + PGOTO_ERROR(FAIL, "Unable to initialize pdc class interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -69,7 +68,7 @@ PDC_class_create(const char *pdc_name) p = (struct _pdc_class *)PDC_malloc(sizeof(struct _pdc_class)); if (!p) - PGOTO_ERROR(FAIL, "PDC class property memory allocation failed\n"); + PGOTO_ERROR(FAIL, "PDC class property memory allocation failed"); p->name = strdup(pdc_name); pdcid = PDC_id_register(PDC_CLASS, p); @@ -77,7 +76,6 @@ PDC_class_create(const char *pdc_name) ret_value = pdcid; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -116,7 +114,6 @@ PDCinit(const char *pdc_name) ret_value = pdcid; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -149,7 +146,6 @@ PDC_class_close(pdcid_t pdc) PGOTO_ERROR(FAIL, "PDC: problem of freeing id"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -161,10 +157,9 @@ PDC_class_end() perr_t ret_value = SUCCEED; if (PDC_destroy_type(PDC_CLASS) < 0) - PGOTO_ERROR(FAIL, "unable to destroy pdc class interface"); + PGOTO_ERROR(FAIL, "Unable to destroy pdc class interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -222,6 +217,5 @@ PDCclose(pdcid_t pdcid) PDC_Client_finalize(); done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_analysis/include/pdc_analysis_and_transforms_common.h b/src/api/pdc_analysis/include/pdc_analysis_and_transforms_common.h index 52e22998f..d812c65c7 100644 --- a/src/api/pdc_analysis/include/pdc_analysis_and_transforms_common.h +++ b/src/api/pdc_analysis/include/pdc_analysis_and_transforms_common.h @@ -209,27 +209,22 @@ hg_proc_analysis_ftn_in_t(hg_proc_t proc, void *data) analysis_ftn_in_t *struct_data = (analysis_ftn_in_t *)data; ret = hg_proc_hg_const_string_t(proc, &struct_data->ftn_name); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_hg_const_string_t(proc, &struct_data->loadpath); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->local_obj_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->iter_in); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->iter_out); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } @@ -245,112 +240,90 @@ hg_proc_obj_data_iterator_in_t(hg_proc_t proc, void *data) obj_data_iterator_in_t *struct_data = (obj_data_iterator_in_t *)data; ret = hg_proc_uint64_t(proc, &struct_data->client_iter_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->object_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->reg_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->sliceCount); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->sliceNext); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->sliceResetCount); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->elementsPerSlice); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->slicePerBlock); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->elementsPerPlane); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->elementsPerBlock); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->skipCount); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->element_size); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->srcBlockCount); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->contigBlockSize); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->totalElements); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->ndim); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->dims_0); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->dims_1); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->dims_2); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->dims_3); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->storageinfo); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->server_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } @@ -367,7 +340,6 @@ hg_proc_analysis_ftn_out_t(hg_proc_t proc, void *data) ret = hg_proc_uint64_t(proc, &struct_data->remote_ftn_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } @@ -384,22 +356,18 @@ hg_proc_obj_data_iterator_out_t(hg_proc_t proc, void *data) ret = hg_proc_uint64_t(proc, &struct_data->server_iter_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->client_iter_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->server_region_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->ret); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } diff --git a/src/api/pdc_analysis/pdc_analysis.c b/src/api/pdc_analysis/pdc_analysis.c index 7c82cd570..872c9a403 100644 --- a/src/api/pdc_analysis/pdc_analysis.c +++ b/src/api/pdc_analysis/pdc_analysis.c @@ -123,7 +123,7 @@ iterator_init(pdcid_t objectId, pdcid_t reg_id, int blocks, struct _pdc_iterator iter->contigBlockSize = obj_elementsPerSlice * element_size; } else - PGOTO_ERROR(-1, "Error: object (%" PRIu64 ") has not been initalized correctly!", objectId); + PGOTO_ERROR(FAIL, "Error: Object (%" PRIu64 ") has not been initalized correctly", objectId); iter->element_size = element_size; iter->objectId = objectId; @@ -249,7 +249,6 @@ iterator_init(pdcid_t objectId, pdcid_t reg_id, int blocks, struct _pdc_iterator ret_value = 0; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -273,7 +272,6 @@ PDCobj_data_block_iterator_create(pdcid_t obj_id, pdcid_t reg_id, int contig_blo PGOTO_ERROR(0, "Unable to register a new iterator"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -338,7 +336,7 @@ PDC_get_argv0_() shellcmd = fopen(procpath, "r"); if (shellcmd == NULL) { procpath = (char *)PDC_free(procpath); - PGOTO_ERROR(NULL, "fopen failed!"); + PGOTO_ERROR(NULL, "fopen failed"); } else { cmdLength = fread(fullPath, 1, sizeof(fullPath), shellcmd); @@ -373,12 +371,11 @@ PDC_get_argv0_() } } if (_argv0 == NULL) - PGOTO_ERROR(NULL, "ERROR: Unable to resolve user application name!"); + PGOTO_ERROR(NULL, "Unable to resolve user application name"); ret_value = _argv0; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -408,7 +405,6 @@ PDC_get_realpath(char *fname, char *app_path) ret_value = strdup(fullPath); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -449,7 +445,7 @@ PDCobj_analysis_register(char *func, pdcid_t iterIn, pdcid_t iterOut) // loadpath = PDC_get_realpath(analyislibrary, applicationDir); if (PDC_get_ftnPtr_((const char *)userdefinedftn, (const char *)loadpath, &ftnHandle) < 0) - PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error!"); + PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error"); if ((ftnPtr = ftnHandle) == NULL) PGOTO_ERROR(FAIL, "Analysis function lookup failed"); @@ -494,7 +490,7 @@ PDCobj_analysis_register(char *func, pdcid_t iterIn, pdcid_t iterOut) // Add to our own list of analysis functions if (PDC_add_analysis_ptr_to_registry_(thisFtn) < 0) - PGOTO_ERROR(FAIL, "PDC unable to register analysis function!"); + PGOTO_ERROR(FAIL, "PDC unable to register analysis function"); done: if (applicationDir) @@ -504,7 +500,6 @@ PDCobj_analysis_register(char *func, pdcid_t iterIn, pdcid_t iterOut) if (loadpath) loadpath = (char *)PDC_free(loadpath); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -528,7 +523,6 @@ PDCobj_data_getSliceCount(pdcid_t iter) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -559,7 +553,7 @@ PDCobj_data_getNextBlock(pdcid_t iter, void **nextBlock, size_t *dims) if ((thisIter->srcNext = PDC_Server_get_region_data_ptr(thisIter->objectId)) == NULL) thisIter->srcNext = PDC_malloc(thisIter->totalElements * thisIter->element_size); if ((thisIter->srcStart = thisIter->srcNext) == NULL) - PGOTO_ERROR(0, "==PDC_ANALYSIS_SERVER: Unable to allocate iterator storage"); + PGOTO_ERROR(0, "Unable to allocate iterator storage"); thisIter->srcNext += thisIter->startOffset + thisIter->skipCount; } @@ -628,7 +622,6 @@ PDCobj_data_getNextBlock(pdcid_t iter, void **nextBlock, size_t *dims) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_analysis/pdc_analysis_and_transforms_connect.c b/src/api/pdc_analysis/pdc_analysis_and_transforms_connect.c index 413123ddf..8346f8502 100644 --- a/src/api/pdc_analysis/pdc_analysis_and_transforms_connect.c +++ b/src/api/pdc_analysis/pdc_analysis_and_transforms_connect.c @@ -104,7 +104,7 @@ PDC_Client_send_iter_recv_id(pdcid_t iter_id, pdcid_t *meta_id) if (n_retry > 0) break; if (PDC_Client_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_lookup_server"); n_retry++; } @@ -127,7 +127,6 @@ PDC_Client_send_iter_recv_id(pdcid_t iter_id, pdcid_t *meta_id) *meta_id = my_rpc_state_p->value; done: - fflush(stdout); HG_Destroy(my_rpc_state_p->handle); my_rpc_state_p = (struct _pdc_my_rpc_state *)PDC_free(my_rpc_state_p); @@ -148,14 +147,12 @@ client_register_iterator_rpc_cb(const struct hg_cb_info *info) if (info->ret == HG_SUCCESS) { ret_value = HG_Get_output(info->info.forward.handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(FAIL, - "PDC_CLIENT: register_iterator_rpc_cb(): Unable to read the server return values"); + PGOTO_ERROR(FAIL, "Unable to read the server return values"); my_rpc_state_p->value = output.server_iter_id; } done: - fflush(stdout); hg_atomic_decr32(atomic_work_todo_g); HG_Free_output(info->info.forward.handle, &output); @@ -219,7 +216,7 @@ PDC_Client_register_obj_analysis(struct _pdc_region_analysis_ftn_info *thisFtn, if (n_retry > 0) break; if (PDC_Client_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_lookup_server"); n_retry++; } @@ -248,7 +245,6 @@ PDC_Client_register_obj_analysis(struct _pdc_region_analysis_ftn_info *thisFtn, thisFtn->meta_index = my_rpc_state_p->value; done: - fflush(stdout); HG_Destroy(my_rpc_state_p->handle); my_rpc_state_p = (struct _pdc_my_rpc_state *)PDC_free(my_rpc_state_p); @@ -269,14 +265,12 @@ client_register_analysis_rpc_cb(const struct hg_cb_info *info) if (info->ret == HG_SUCCESS) { ret_value = HG_Get_output(info->info.forward.handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, - "PDC_CLIENT: register_analysis_rpc_cb(): Unable to read the server return values"); + PGOTO_ERROR(ret_value, "Unable to read the server return values"); my_rpc_state_p->value = output.remote_ftn_id; } done: - fflush(stdout); hg_atomic_decr32(atomic_work_todo_g); HG_Free_output(info->info.forward.handle, &output); @@ -342,7 +336,6 @@ PDC_Client_register_region_transform(const char *func, const char *loadpath, // Here, we should update the local registry with the returned valued from my_rpc_state_p; done: - fflush(stdout); if (object_info) PDC_free_obj_info(object_info); HG_Destroy(my_rpc_state_p->handle); @@ -364,13 +357,12 @@ client_register_transform_rpc_cb(const struct hg_cb_info *info) if (info->ret == HG_SUCCESS) { ret_value = HG_Get_output(info->info.forward.handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "PDC_CLIENT: Unable to read the server return values"); + PGOTO_ERROR(ret_value, "Unable to read the server return values"); PDC_update_transform_server_meta_index(output.client_index, output.ret); } done: - fflush(stdout); hg_atomic_decr32(atomic_work_todo_g); HG_Free_output(info->info.forward.handle, &output); diff --git a/src/api/pdc_analysis/pdc_analysis_common.c b/src/api/pdc_analysis/pdc_analysis_common.c index 82d438d59..c04b3f7d5 100644 --- a/src/api/pdc_analysis/pdc_analysis_common.c +++ b/src/api/pdc_analysis/pdc_analysis_common.c @@ -116,7 +116,6 @@ pdc_analysis_registry_init_(size_t newSize) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -152,7 +151,6 @@ pdc_transform_registry_init_(size_t newSize) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -199,7 +197,6 @@ check_analysis(pdc_obj_transform_t op_type ATTRIBUTE(unused), struct pdc_region_ } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -215,7 +212,7 @@ PDC_add_analysis_ptr_to_registry_(struct _pdc_region_analysis_ftn_info *ftn_info if (analysis_registry_size == 0) { if (pdc_analysis_registry_init_(initial_registry_size) == 0) { - perror("Unable to initialize analysis registry!"); + perror("Unable to initialize analysis registry"); PGOTO_DONE(-1); } } @@ -241,7 +238,6 @@ PDC_add_analysis_ptr_to_registry_(struct _pdc_region_analysis_ftn_info *ftn_info ret_value = registry_index; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -260,7 +256,7 @@ PDCiter_get_nextId(void) PDC_Block_iterator_cache = (struct _pdc_iterator_info *)PDC_calloc(iterator_cache_entries, sizeof(struct _pdc_iterator_info)); if (PDC_Block_iterator_cache == NULL) - PGOTO_ERROR(-1, "calloc failed"); + PGOTO_ERROR(FAIL, "calloc failed"); i_cache_freed = (int *)PDC_calloc(iterator_cache_entries, sizeof(int)); /* Index 0 is NOT-USED other than to indicate an empty iterator */ @@ -295,7 +291,6 @@ PDCiter_get_nextId(void) ret_value = nextId; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -322,7 +317,6 @@ PDC_check_transform(pdc_obj_transform_t op_type, struct pdc_region_info *dest_re } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -339,7 +333,6 @@ PDC_get_transforms(struct _pdc_region_transform_ftn_info ***registry) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -355,12 +348,12 @@ PDC_add_transform_ptr_to_registry_(struct _pdc_region_transform_ftn_info *ftn_in if (transform_registry_size == 0) { if (pdc_transform_registry_init_(initial_registry_size) == 0) - PGOTO_ERROR(-1, "Unable to initialize transform registry!"); + PGOTO_ERROR(FAIL, "Unable to initialize transform registry"); } currentCount = (size_t)hg_atomic_get32(®istered_transform_ftn_count_g); if (currentCount == transform_registry_size) { if (pdc_transform_registry_init_(transform_registry_size * 2) == 0) - PGOTO_ERROR(-1, "memory allocation failed"); + PGOTO_ERROR(FAIL, "Memory allocation failed"); } /* If the new function is already registered * simply return the OLD index. @@ -379,7 +372,6 @@ PDC_add_transform_ptr_to_registry_(struct _pdc_region_transform_ftn_info *ftn_in ret_value = registry_index; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -396,10 +388,9 @@ PDC_update_transform_server_meta_index(int client_index, int meta_index) ftnPtr->meta_index = meta_index; } else - PGOTO_ERROR(-1, "Bad client index(%d)", client_index); + PGOTO_ERROR(FAIL, "Bad client index(%d)", client_index); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -437,19 +428,18 @@ PDC_get_ftnPtr_(const char *ftn, const char *loadpath, void **ftnPtr) if (appHandle == NULL) { if ((appHandle = dlopen(loadpath, RTLD_NOW)) == NULL) { this_error = dlerror(); - PGOTO_ERROR(-1, "dlopen failed: %s", this_error); + PGOTO_ERROR(FAIL, "dlopen failed: %s", this_error); } } ftnHandle = dlsym(appHandle, ftn); if (ftnHandle == NULL) - PGOTO_ERROR(-1, "dlsym failed: %s", dlerror()); + PGOTO_ERROR(FAIL, "dlsym failed: %s", dlerror()); *ftnPtr = ftnHandle; ret_value = 0; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -476,7 +466,7 @@ HG_TEST_RPC_CB(analysis_ftn, handle) HG_Get_input(handle, &in); if (PDC_get_ftnPtr_(in.ftn_name, in.loadpath, &ftnHandle) < 0) - PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error!"); + PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error"); if ((ftnPtr = ftnHandle) == NULL) PGOTO_ERROR(FAIL, "Transforms function lookup failed"); @@ -541,7 +531,6 @@ HG_TEST_RPC_CB(analysis_ftn, handle) } done: - fflush(stdout); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -560,7 +549,7 @@ HG_TEST_RPC_CB(obj_data_iterator, handle) memset(&in, 0, sizeof(in)); // Decode input HG_Get_input(handle, &in); - // LOG_INFO("obj_data_iterator_cb entered!\n"); + // LOG_INFO("obj_data_iterator_cb entered\n"); ret_value = PDC_Server_instantiate_data_iterator(&in, &out); HG_Respond(handle, NULL, NULL, &out); diff --git a/src/api/pdc_analysis/pdc_hist_pkg.c b/src/api/pdc_analysis/pdc_hist_pkg.c index 879ecea26..72117fd96 100644 --- a/src/api/pdc_analysis/pdc_hist_pkg.c +++ b/src/api/pdc_analysis/pdc_hist_pkg.c @@ -44,11 +44,10 @@ PDC_sample_min_max(pdc_var_type_t dtype, uint64_t n, void *data, double sample_p else if (PDC_UINT == dtype) MACRO_SAMPLE_MIN_MAX(uint32_t, n, data, sample_pct, *min, *max); else { - PGOTO_ERROR(FAIL, "== datatype %d not supported!", dtype); + PGOTO_ERROR(FAIL, "Datatype %d not supported", dtype); } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -156,7 +155,6 @@ PDC_create_hist(pdc_var_type_t dtype, int nbin, double min, double max) ret_value = hist; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -236,10 +234,9 @@ PDC_hist_incr_all(pdc_histogram_t *hist, pdc_var_type_t dtype, uint64_t n, void else if (PDC_UINT == dtype) MACRO_HIST_INCR_ALL(uint32_t, hist, n, data); else - PGOTO_ERROR(FAIL, "== datatype %d not supported!", dtype); + PGOTO_ERROR(FAIL, "Datatype %d not supported", dtype); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -268,21 +265,19 @@ PDC_gen_hist(pdc_var_type_t dtype, uint64_t n, void *data) hist = PDC_create_hist(dtype, 50, min, max); if (NULL == hist) - PGOTO_ERROR(NULL, "== error with PDC_create_hist!"); + PGOTO_ERROR(NULL, "Error with PDC_create_hist"); PDC_hist_incr_all(hist, dtype, n, data); #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); gen_hist_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - LOG_INFO("== generate histogram of %lu elements with %d bins takes %.2fs\n", n, hist->nbin, - gen_hist_time); + LOG_INFO("Generate histogram of %lu elements with %d bins takes %.2fs\n", n, hist->nbin, gen_hist_time); #endif ret_value = hist; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -299,7 +294,6 @@ PDC_free_hist(pdc_histogram_t *hist) hist = (pdc_histogram_t *)PDC_free(hist); done: - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -322,7 +316,6 @@ PDC_print_hist(pdc_histogram_t *hist) LOG_INFO("\n\n"); done: - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -352,7 +345,6 @@ PDC_dup_hist(pdc_histogram_t *hist) ret_value = res; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -375,7 +367,7 @@ PDC_merge_hist(int n, pdc_histogram_t **hists) for (i = 1; i < n; i++) { if (hists[i]->dtype != hists[i - 1]->dtype) { - PGOTO_ERROR(NULL, "== cannot merge histograms of different types!"); + PGOTO_ERROR(NULL, "Cannot merge histograms of different types"); } if (hists[i]->incr > incr_max) { incr_max = hists[i]->incr; @@ -393,7 +385,7 @@ PDC_merge_hist(int n, pdc_histogram_t **hists) // Duplicate the base hist to result res = PDC_dup_hist(hists[incr_max_idx]); if (NULL == res) - PGOTO_ERROR(NULL, "== error with PDC_dup_hist!"); + PGOTO_ERROR(NULL, "Error with PDC_dup_hist"); res->range[0] = tot_min; res->range[(res->nbin) * 2 - 1] = tot_max; @@ -422,7 +414,6 @@ PDC_merge_hist(int n, pdc_histogram_t **hists) ret_value = res; done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_client_connect.c b/src/api/pdc_client_connect.c index 8b982a9dd..ef503178e 100644 --- a/src/api/pdc_client_connect.c +++ b/src/api/pdc_client_connect.c @@ -43,6 +43,7 @@ #include "pdc_transforms_common.h" #include "pdc_client_connect.h" #include "pdc_logger.h" +#include "pdc_timing.h" #include "pdc_malloc.h" #include "mercury.h" @@ -65,9 +66,7 @@ #include #include #include -#include "pdc_timing.h" - -/* #define TANG_DEBUG 1 */ +#include int is_client_debug_g = 0; pdc_server_selection_t pdc_server_selection_g = PDC_SERVER_DEFAULT; @@ -247,16 +246,15 @@ pdc_client_check_int_ret_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==Error with HG_Get_output"); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); if (output.ret != 1) - LOG_ERROR("==() - Return value [%d] is NOT expected\n", output.ret); + LOG_ERROR("Return value [%d] is NOT expected\n", output.ret); if (lookup_args != NULL) lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -272,12 +270,6 @@ hg_progress_fn(void *foo) unsigned int actual_count; hg_context_t *hg_context = (hg_context_t *)foo; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_INFO("enter %s \n", cur_time); -#endif - while (hg_progress_flag_g != 1) { do { ret = HG_Trigger(hg_context, 0, 1, &actual_count); @@ -287,11 +279,6 @@ hg_progress_fn(void *foo) usleep(1000); } -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("leaving %s\n", cur_time); -#endif - FUNC_LEAVE(NULL); } @@ -305,11 +292,6 @@ PDC_Client_transfer_pthread_create() if (hg_progress_flag_g == -1) { pthread_create(&hg_progress_tid_g, NULL, hg_progress_fn, send_context_g); hg_progress_flag_g = 0; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s created pthread\n", cur_time); -#endif } FUNC_LEAVE(ret_value); @@ -326,11 +308,6 @@ PDC_Client_transfer_pthread_terminate() hg_progress_flag_g = 1; pthread_join(hg_progress_tid_g, NULL); hg_progress_flag_g = -1; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s terminated pthread\n", cur_time); -#endif } FUNC_LEAVE(ret_value); @@ -342,12 +319,6 @@ PDC_Client_transfer_pthread_cnt_add(int n) FUNC_ENTER(NULL); perr_t ret_value = SUCCEED; - -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s change cnt from %d to %d\n", cur_time, hg_progress_task_cnt_g, hg_progress_task_cnt_g + n); -#endif hg_progress_task_cnt_g += n; FUNC_LEAVE(ret_value); @@ -415,15 +386,14 @@ PDC_Client_read_server_addr_from_file() is_server_ready = 1; break; } - LOG_WARNING("==PDC_CLIENT[%d]: Config file from default location [%s] not available, " + LOG_WARNING("Config file from default location [%s] not available, " "waiting %d seconds\n", - pdc_client_mpi_rank_g, config_fname, sleeptime); - fflush(stdout); + config_fname, sleeptime); sleep(sleeptime); sleeptime *= 2; } if (is_server_ready != 1) - PGOTO_ERROR(FAIL, "server is not ready"); + PGOTO_ERROR(FAIL, "Server is not ready"); na_config = fopen(config_fname, "r"); if (!na_config) @@ -431,7 +401,7 @@ PDC_Client_read_server_addr_from_file() // Get the first line as $pdc_server_num_g if (fgets(n_server_string, PATH_MAX, na_config) == NULL) { - PGOTO_ERROR(FAIL, "Get first line failed\n"); + PGOTO_ERROR(FAIL, "Get first line failed"); } pdc_server_num_g = atoi(n_server_string); } @@ -441,7 +411,7 @@ PDC_Client_read_server_addr_from_file() #endif if (pdc_server_num_g == 0) { - LOG_ERROR("==PDC_CLIENT[%d]: server number error %d\n", pdc_client_mpi_rank_g, pdc_server_num_g); + LOG_ERROR("Server number error %d\n", pdc_server_num_g); FUNC_LEAVE(-1); } @@ -453,7 +423,7 @@ PDC_Client_read_server_addr_from_file() while (i < pdc_server_num_g) { if (pdc_client_mpi_rank_g == 0) { if (fgets(pdc_server_info_g[i].addr_string, ADDR_MAX, na_config) == NULL) { - PGOTO_ERROR(FAIL, "Get first line failed\n"); + PGOTO_ERROR(FAIL, "Get first line failed"); } p = strrchr(pdc_server_info_g[i].addr_string, '\n'); if (p != NULL) @@ -474,7 +444,6 @@ PDC_Client_read_server_addr_from_file() ret_value = SUCCEED; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -493,13 +462,10 @@ client_send_flush_obj_all_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); *rpc_return = output.ret; - if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: flush_obj_all_rpc_cb error with HG_Get_output\n", pdc_client_mpi_rank_g); - goto done; - } + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -521,13 +487,11 @@ obj_reset_dims_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: obj_reset_dims_rpc_cb error with HG_Get_output\n", pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "obj_reset_dims_rpc_cb error with HG_Get_output"); } region_transfer_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -549,13 +513,11 @@ client_send_flush_obj_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); *rpc_return = output.ret; - if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: flush_obj_rpc_cb error with HG_Get_output\n", pdc_client_mpi_rank_g); - goto done; - } + + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -577,14 +539,10 @@ client_send_close_all_server_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); *rpc_return = output.ret; - if (ret_value != HG_SUCCESS || output.ret != 88) { - LOG_ERROR("PDC_CLIENT[%d]: close_all_server_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); - goto done; - } + if (ret_value != HG_SUCCESS || output.ret != 88) + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -606,17 +564,13 @@ client_send_transfer_request_metadata_query_rpc_cb(const struct hg_cb_info *call ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR( - "PDC_CLIENT[%d]: client_send_transfer_request_metadata_query_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->query_id = output.query_id; region_transfer_args->total_buf_size = output.total_buf_size; region_transfer_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -639,15 +593,11 @@ client_send_transfer_request_metadata_query2_rpc_cb(const struct hg_cb_info *cal ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR( - "PDC_CLIENT[%d]: client_send_transfer_request_metadata_query2_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -664,26 +614,18 @@ client_send_transfer_request_all_rpc_cb(const struct hg_cb_info *callback_info) struct _pdc_transfer_request_all_args *region_transfer_args; transfer_request_all_out_t output; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] enter\n", cur_time, pdc_client_mpi_rank_g); -#endif - region_transfer_args = (struct _pdc_transfer_request_all_args *)callback_info->arg; handle = callback_info->info.forward.handle; ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: error with HG_Get_output\n", pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->ret = output.ret; region_transfer_args->metadata_id = output.metadata_id; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -705,14 +647,11 @@ client_send_transfer_request_wait_all_rpc_cb(const struct hg_cb_info *callback_i ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: client_send_transfer_request_wait_all_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -734,15 +673,13 @@ client_send_transfer_request_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: error with HG_Get_output\n", pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->ret = output.ret; region_transfer_args->metadata_id = output.metadata_id; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -764,17 +701,14 @@ client_send_transfer_request_status_rpc_cb(const struct hg_cb_info *callback_inf ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: client_send_transfer_request_status_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->ret = output.ret; region_transfer_args->status = output.status; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -797,16 +731,13 @@ client_send_transfer_request_wait_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: client_send_transfer_request_wait_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); region_transfer_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_transfer_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -830,17 +761,13 @@ client_send_buf_unmap_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("PDC_CLIENT[%d]: client_send_buf_unmap_rpc_cb error with HG_Get_output\n", - pdc_client_mpi_rank_g); - fflush(stdout); region_unmap_args->ret = -1; - PGOTO_DONE(ret_value); + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } region_unmap_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -865,14 +792,12 @@ client_send_buf_map_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { buf_map_args->ret = -1; - PGOTO_ERROR(ret_value, "PDC_CLIENT[%d]: client_send_buf_map_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } buf_map_args->ret = output.ret; done: - fflush(stdout); hg_atomic_set32(&atomic_work_todo_g, 0); HG_Free_output(handle, &output); @@ -894,13 +819,12 @@ client_test_connect_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(ret_value, "PDC_CLIENT[%d]: error with HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_set32(&atomic_work_todo_g, 0); HG_Free_output(handle, &output); HG_Destroy(callback_info->info.forward.handle); @@ -940,7 +864,6 @@ client_test_connect_lookup_cb(const struct hg_cb_info *callback_info) PGOTO_ERROR(ret_value, "Could not start HG_Forward"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -956,12 +879,11 @@ PDC_Client_lookup_server(int server_id, int is_init) char * target_addr_string; if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with server id input %d", pdc_client_mpi_rank_g, - server_id); + PGOTO_ERROR(FAIL, "Error with server id input %d", server_id); ret_value = PDC_get_self_addr(send_class_g, self_addr); if (ret_value != SUCCEED) - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: ERROR geting self addr", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error getting self addr"); lookup_args.client_id = pdc_client_mpi_rank_g; lookup_args.server_id = server_id; @@ -969,29 +891,22 @@ PDC_Client_lookup_server(int server_id, int is_init) lookup_args.is_init = is_init; target_addr_string = pdc_server_info_g[lookup_args.server_id].addr_string; - if (is_client_debug_g == 1) { - LOG_DEBUG("==PDC_CLIENT[%d]: - Testing connection to server %d [%s]\n", pdc_client_mpi_rank_g, - lookup_args.server_id, target_addr_string); - fflush(stdout); - } + if (is_client_debug_g == 1) + LOG_DEBUG("Testing connection to server %d [%s]\n", lookup_args.server_id, target_addr_string); hg_ret = HG_Addr_lookup(send_context_g, client_test_connect_lookup_cb, &lookup_args, target_addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: Connection to server FAILED!"); + PGOTO_ERROR(FAIL, "Connection to server failed"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); - if (is_client_debug_g == 1) { - LOG_DEBUG("==PDC_CLIENT[%5d]: - connected to server %5d\n", pdc_client_mpi_rank_g, - lookup_args.server_id); - fflush(stdout); - } + if (is_client_debug_g == 1) + LOG_DEBUG("Connected to server %5d\n", lookup_args.server_id); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1004,19 +919,18 @@ PDC_Client_try_lookup_server(int server_id, int is_init) int n_retry = 1; if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid server ID %d", pdc_client_mpi_rank_g, server_id); + PGOTO_ERROR(FAIL, "Invalid server ID %d", server_id); while (pdc_server_info_g[server_id].addr_valid != 1) { if (n_retry > PDC_MAX_TRIAL_NUM) break; ret_value = PDC_Client_lookup_server(server_id, is_init); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with PDC_Client_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_lookup_server"); n_retry++; } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1035,13 +949,11 @@ send_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: metadata_add_tag_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "metadata_add_tag_rpc_cb error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -1060,13 +972,13 @@ PDC_Client_send_rpc(int server_id) send_rpc_in_t in; if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid server ID %d", pdc_client_mpi_rank_g, server_id); + PGOTO_ERROR(FAIL, "Invalid server ID %d", server_id); // Debug statistics for counting number of messages sent to each server. debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, send_rpc_register_id_g, &handle); @@ -1074,7 +986,7 @@ PDC_Client_send_rpc(int server_id) hg_ret = HG_Forward(handle, send_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - HG_Forward Error!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "HG_Forward Error"); // No need to wait // Wait for response from server @@ -1083,7 +995,6 @@ PDC_Client_send_rpc(int server_id) PDC_Client_check_response(&send_context_g); done: - fflush(stdout); HG_Destroy(handle); FUNC_LEAVE(ret_value); @@ -1108,13 +1019,11 @@ client_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->obj_id = 0; - PGOTO_ERROR(ret_value, "PDC_CLIENT[%d]: client_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } client_lookup_args->obj_id = output.obj_id; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -1138,13 +1047,12 @@ client_region_lock_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(ret_value, "PDC_CLIENT[%d]: error with HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -1167,56 +1075,17 @@ client_region_release_rpc_cb(const struct hg_cb_info *callback_info) /* Get output from server*/ ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: client_region_release_rpc_cb - HG_Get_output error!"); + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); FUNC_LEAVE(ret_value); } -/* -static hg_return_t -client_region_release_with_transform_cb(const struct hg_cb_info *callback_info) -{ - FUNC_ENTER(NULL); - - hg_return_t ret_value = HG_SUCCESS; - hg_handle_t handle; - struct _pdc_client_transform_args *transform_args; - region_lock_out_t output; - size_t size; - size_t (*this_transform)(void *, pdc_var_type_t, int, uint64_t *, void **, pdc_var_type_t) = NULL; - void *result; - - transform_args = (struct _pdc_client_transform_args *)callback_info->arg; - result = transform_args->transform_result; - handle = callback_info->info.forward.handle; - this_transform = transform_args->this_transform->ftnPtr; - size = this_transform(transform_args->data, transform_args->this_transform->dest_type, - transform_args->region_info->ndim, transform_args->region_info->size, &result, - transform_args->this_transform->dest_type); - - transform_args->size = size; - - // Get output from server - ret_value = HG_Get_output(handle, &output); - if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_CLIENT: client_region_release_rpc_cb - HG_Get_output error!"); - - transform_args->ret = output.ret; - -done: - fflush(stdout); - hg_atomic_decr32(&atomic_work_todo_g); - HG_Free_output(handle, &output); - FUNC_LEAVE(ret_value); -} -*/ // Bulk // Callback after bulk transfer is received by client static hg_return_t @@ -1287,8 +1156,6 @@ hg_test_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) // checking the following flag will make sure the current bulk transfer is done. hg_atomic_cas32(&(bulk_args->bulk_done_flag), 0, 1); - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -1388,18 +1255,25 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po #endif if ((hg_transport = getenv("HG_TRANSPORT")) == NULL) { + LOG_INFO("Environment variable HG_TRANSPORT was NOT set\n"); hg_transport = default_hg_transport; } + else + LOG_INFO("Environment variable HG_TRANSPORT was set\n"); if ((hostname = getenv("HG_HOST")) == NULL) { + LOG_INFO("Environment variable HG_HOST was NOT set\n"); hostname = PDC_malloc(HOSTNAME_LEN); memset(hostname, 0, HOSTNAME_LEN); gethostname(hostname, HOSTNAME_LEN - 1); free_hostname = true; } + else + LOG_INFO("Environment variable HG_HOST was set\n"); + sprintf(na_info_string, "%s://%s:%d", hg_transport, hostname, port); if (pdc_client_mpi_rank_g == 0) - LOG_INFO("==PDC_CLIENT: using %s\n", na_info_string); + LOG_INFO("Connection string: %s\n", na_info_string); if (free_hostname) hostname = (char *)PDC_free(hostname); @@ -1417,18 +1291,16 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po if (rc != DRC_SUCCESS) { /* failed to access credential */ if (rc == -DRC_EINVAL) { sleep(1); - goto drc_access_again; + PGOTO_DONE(drc_access_again); } LOG_ERROR("client drc_access() failed (%d, %s)", rc, drc_strerror(-rc)); - fflush(stdout); - PGOTO_ERROR(FAIL, "client drc_access() failed"); + PGOTO_ERROR(FAIL, "Client drc_access() failed"); } cookie = drc_get_first_cookie(credential_info); if (pdc_client_mpi_rank_g == 0) { LOG_INFO("# Credential is %u\n", credential); LOG_INFO("# Cookie is %u\n", cookie); - fflush(stdout); } sprintf(pdc_auth_key, "%u", cookie); init_info.na_init_info.auth_key = strdup(pdc_auth_key); @@ -1545,34 +1417,28 @@ PDC_Client_mercury_init(hg_class_t **hg_class, hg_context_t **hg_context, int po local_server_id = PDC_get_local_server_id(pdc_client_mpi_rank_g, pdc_nclient_per_server_g, pdc_server_num_g); if (PDC_Client_try_lookup_server(local_server_id, 1) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR lookup server %d\n", pdc_client_mpi_rank_g, - local_server_id); + PGOTO_ERROR(FAIL, "Error lookup server %d", local_server_id); } else if (strcmp(client_lookup_env, "ALL") == 0) { if (pdc_client_mpi_rank_g == 0) - LOG_INFO("==PDC_CLIENT[%d]: Client lookup all servers at start time!\n", pdc_client_mpi_rank_g); + LOG_INFO("Client lookup all servers at start time\n"); for (local_server_id = 0; local_server_id < pdc_server_num_g; local_server_id++) { if (pdc_client_mpi_size_g > 1000) PDC_msleep(pdc_client_mpi_rank_g % 300); if (PDC_Client_try_lookup_server(local_server_id, 1) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR lookup server %d", pdc_client_mpi_rank_g, - local_server_id); + PGOTO_ERROR(FAIL, "Error lookup server %d", local_server_id); } } else { if (pdc_client_mpi_rank_g == 0) - LOG_INFO("==PDC_CLIENT[%d]: Client lookup server at start time disabled!\n", - pdc_client_mpi_rank_g); + LOG_INFO("Client lookup server at start time disabled\n"); } - if (is_client_debug_g == 1 && pdc_client_mpi_rank_g == 0) { - LOG_INFO("==PDC_CLIENT[%d]: Successfully established connection to %d PDC metadata server%s\n\n", - pdc_client_mpi_rank_g, pdc_server_num_g, pdc_client_mpi_size_g == 1 ? "" : "s"); - fflush(stdout); - } + if (is_client_debug_g == 1 && pdc_client_mpi_rank_g == 0) + LOG_INFO("Successfully established connection to %d PDC metadata server%s\n\n", pdc_server_num_g, + pdc_client_mpi_size_g == 1 ? "" : "s"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1613,16 +1479,16 @@ PDC_Client_init() MPI_Comm_dup(MPI_COMM_WORLD, &PDC_CLIENT_COMM_WORLD_g); MPI_Comm_rank(PDC_CLIENT_COMM_WORLD_g, &pdc_client_mpi_rank_g); MPI_Comm_size(PDC_CLIENT_COMM_WORLD_g, &pdc_client_mpi_size_g); - LOG_DEBUG("my client rank = %d, client communicator size = %d\n", pdc_client_mpi_rank_g, + LOG_DEBUG("My client rank = %d, client communicator size = %d\n", pdc_client_mpi_rank_g, pdc_client_mpi_size_g); #endif if (pdc_client_mpi_rank_g == 0) - LOG_INFO("==PDC_CLIENT: PDC_DEBUG set to %d!\n", is_client_debug_g); + LOG_INFO("PDC_DEBUG set to %d\n", is_client_debug_g); // get server address and fill in $pdc_server_info_g if (PDC_Client_read_server_addr_from_file() != SUCCEED) { - LOG_ERROR("==PDC_CLIENT[%d]: Error getting PDC Metadata servers info, exiting ...", pdc_server_num_g); + LOG_ERROR("Error getting PDC Metadata servers info, exiting..."); exit(0); } @@ -1649,8 +1515,8 @@ PDC_Client_init() PDC_set_execution_locus(CLIENT_MEMORY); if (pdc_client_mpi_rank_g == 0) { - LOG_INFO("==PDC_CLIENT[0]: Found %d PDC Metadata servers, running with %d PDC clients\n", - pdc_server_num_g, pdc_client_mpi_size_g); + LOG_INFO("Found %d PDC Metadata servers, running with %d PDC clients\n", pdc_server_num_g, + pdc_client_mpi_size_g); } // Init debug info @@ -1659,7 +1525,7 @@ PDC_Client_init() memset(debug_server_id_count, 0, sizeof(int) * pdc_server_num_g); } else - LOG_ERROR("==PDC_CLIENT: Server number not properly initialized!\n"); + LOG_ERROR("Server number not properly initialized\n"); // Cori KNL has 68 cores per node, Haswell 32 port = pdc_client_mpi_rank_g % PDC_MAX_CORE_PER_NODE + 8000; @@ -1667,7 +1533,7 @@ PDC_Client_init() // Init Mercury network connection ret_value = PDC_Client_mercury_init(&send_class_g, &send_context_g, port); if (ret_value != SUCCEED || send_class_g == NULL || send_context_g == NULL) { - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with Mercury Init, exiting...", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_mercury_init, exiting..."); } hg_atomic_init32(&atomic_work_todo_g, 0); @@ -1678,8 +1544,8 @@ PDC_Client_init() } if (pdc_client_mpi_rank_g == 0) { - LOG_INFO("==PDC_CLIENT[%d]: using [%s] as tmp dir, %d clients per server\n", pdc_client_mpi_rank_g, - pdc_client_tmp_dir_g, pdc_nclient_per_server_g); + LOG_INFO("Using [%s] as tmp dir, %d clients per server\n", pdc_client_tmp_dir_g, + pdc_nclient_per_server_g); } if (mercury_has_init_g) { @@ -1695,7 +1561,6 @@ PDC_Client_init() } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1758,19 +1623,18 @@ PDC_Client_finalize() #ifdef ENABLE_TIMING if (pdc_client_mpi_rank_g == 0) - LOG_INFO("==PDC_CLIENT[%d]: T_memcpy: %.2f\n", pdc_client_mpi_rank_g, memcpy_time_g); + LOG_INFO("T_memcpy: %.2f\n", memcpy_time_g); #endif hg_ret = HG_Context_destroy(send_context_g); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with HG_Context_destroy", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with HG_Context_destroy"); hg_ret = HG_Finalize(send_class_g); - /* if (hg_ret != HG_SUCCESS) */ - /* PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with HG_Finalize", pdc_client_mpi_rank_g); */ + if (hg_ret != HG_SUCCESS) + LOG_WARNING("Error with HG_Finalize\n"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1798,7 +1662,7 @@ metadata_query_bulk_cb(const struct hg_cb_info *callback_info) // Get output from server ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: - error HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); n_meta = output.ret; client_lookup_args->n_meta = n_meta; @@ -1840,7 +1704,6 @@ metadata_query_bulk_cb(const struct hg_cb_info *callback_info) client_lookup_args->meta_arr = bulk_args->meta_arr; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -1919,17 +1782,17 @@ PDC_partial_query(int is_list_all, int user_id, const char *app_name, const char for (server_id = my_server_start; server_id < my_server_end; server_id++) { if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, query_partial_register_id_g, &query_partial_handle); if (query_partial_handle == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: Error with query_partial_handle", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with query_partial_handle"); hg_ret = HG_Forward(query_partial_handle, metadata_query_bulk_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_client_list_all(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); hg_atomic_set32(&bulk_transfer_done_g, 0); @@ -1966,7 +1829,6 @@ PDC_partial_query(int is_list_all, int user_id, const char *app_name, const char // TODO: need to be careful when freeing the lookup_args, as it include the results returned to user done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1985,7 +1847,7 @@ PDC_Client_query_tag(const char *tags, int *n_res, pdc_metadata_t ***out) struct bulk_args_t lookup_args; if (tags == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: input tag is NULL!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "tags was NULL"); // Fill input structure metadata_query_transfer_in_t in; @@ -2003,17 +1865,17 @@ PDC_Client_query_tag(const char *tags, int *n_res, pdc_metadata_t ***out) for (server_id = 0; server_id < pdc_server_num_g; server_id++) { if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, query_partial_register_id_g, &query_partial_handle); if (query_partial_handle == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: Error with query_partial_handle", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with query_partial_handle"); hg_ret = HG_Forward(query_partial_handle, metadata_query_bulk_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_client_list_all(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward()"); hg_atomic_set32(&bulk_transfer_done_g, 0); @@ -2050,7 +1912,6 @@ PDC_Client_query_tag(const char *tags, int *n_res, pdc_metadata_t ***out) // TODO: need to be careful when freeing the lookup_args, as it include the results returned to user done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2071,8 +1932,7 @@ metadata_query_rpc_cb(const struct hg_cb_info *callback_info) /* Get output from server*/ ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: metadata_query_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "metadata_query_rpc_cb error with HG_Get_output"); if (output.ret.user_id == -1 && output.ret.obj_id == 0 && output.ret.time_step == -1) { client_lookup_args->data = NULL; @@ -2080,9 +1940,7 @@ metadata_query_rpc_cb(const struct hg_cb_info *callback_info) else { client_lookup_args->data = (pdc_metadata_t *)PDC_malloc(sizeof(pdc_metadata_t)); if (client_lookup_args->data == NULL) - PGOTO_ERROR(HG_OTHER_ERROR, - "==PDC_CLIENT[%d]: - cannnot allocate space for client_lookup_args->data", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Cannnot allocate space for client_lookup_args->data"); // Now copy the received metadata info ret_value = PDC_metadata_init(client_lookup_args->data); @@ -2090,7 +1948,6 @@ metadata_query_rpc_cb(const struct hg_cb_info *callback_info) } done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -2116,13 +1973,11 @@ metadata_delete_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: metadata_delete_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -2148,13 +2003,11 @@ metadata_delete_by_id_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: metadata_delete_by_id_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -2178,13 +2031,11 @@ metadata_add_tag_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: metadata_add_tag_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -2206,7 +2057,7 @@ PDC_Client_add_tag(pdcid_t obj_id, const char *tag) metadata_add_tag_in_t in; if (tag == NULL || tag[0] == 0) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - invalid tag content!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid tag content"); obj_prop = PDC_obj_get_info(obj_id); meta_id = obj_prop->obj_info_pub->meta_id; @@ -2216,7 +2067,7 @@ PDC_Client_add_tag(pdcid_t obj_id, const char *tag) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_add_tag_register_id_g, &metadata_add_tag_handle); @@ -2228,17 +2079,16 @@ PDC_Client_add_tag(pdcid_t obj_id, const char *tag) hg_ret = HG_Forward(metadata_add_tag_handle, metadata_add_tag_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - HG_Forward Error!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - add tag NOT successful ...", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Add tag NOT successful"); done: - fflush(stdout); HG_Destroy(metadata_add_tag_handle); FUNC_LEAVE(ret_value); @@ -2264,13 +2114,11 @@ metadata_update_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: metadata_update_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "metadata_update_rpc_cb error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -2291,7 +2139,7 @@ PDC_Client_update_metadata(pdc_metadata_t *old, pdc_metadata_t *new) hg_handle_t metadata_update_handle; if (old == NULL || new == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC_Client_update_metadata() - NULL inputs!"); + PGOTO_ERROR(FAIL, "old or new was NULL"); hash_name_value = PDC_get_hash_by_name(old->obj_name); server_id = (hash_name_value + old->time_step); @@ -2301,7 +2149,7 @@ PDC_Client_update_metadata(pdc_metadata_t *old, pdc_metadata_t *new) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_update_register_id_g, &metadata_update_handle); @@ -2351,17 +2199,16 @@ PDC_Client_update_metadata(pdc_metadata_t *old, pdc_metadata_t *new) hg_ret = HG_Forward(metadata_update_handle, metadata_update_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_update_metadata_with_name(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: update NOT successful ..."); + PGOTO_ERROR(FAIL, "Update NOT successful"); done: - fflush(stdout); HG_Destroy(metadata_update_handle); FUNC_LEAVE(ret_value); @@ -2390,26 +2237,25 @@ PDC_Client_delete_metadata_by_id(uint64_t obj_id) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_delete_by_id_register_id_g, &metadata_delete_by_id_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_Client_delete_by_id_metadata_with_name(): Could not create handle"); + PGOTO_ERROR(FAIL, "Could not create handle"); hg_ret = HG_Forward(metadata_delete_by_id_handle, metadata_delete_by_id_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_delete_by_id_metadata_with_name(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (lookup_args.ret < 0) - PGOTO_ERROR(FAIL, "PDC_CLIENT: delete_by_id NOT successful ..."); + PGOTO_ERROR(FAIL, "Failed to delete_by_id"); done: - fflush(stdout); HG_Destroy(metadata_delete_by_id_handle); FUNC_LEAVE(ret_value); @@ -2447,23 +2293,22 @@ PDC_Client_delete_metadata(char *delete_name, pdcid_t obj_delete_prop) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_delete_register_id_g, &metadata_delete_handle); hg_ret = HG_Forward(metadata_delete_handle, metadata_delete_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_delete_metadata_with_name(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - LOG_ERROR("PDC_CLIENT: delete NOT successful ... ret_value = %d\n", lookup_args.ret); + LOG_ERROR("Delete NOT successful ... ret_value = %d\n", lookup_args.ret); done: - fflush(stdout); HG_Destroy(metadata_delete_handle); FUNC_LEAVE(ret_value); @@ -2502,7 +2347,7 @@ PDC_Client_query_metadata_name_only(const char *obj_name, pdc_metadata_t **out) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_query_register_id_g, &metadata_query_handle[server_id]); @@ -2527,7 +2372,6 @@ PDC_Client_query_metadata_name_only(const char *obj_name, pdc_metadata_t **out) } done: - fflush(stdout); metadata_query_handle = (hg_handle_t *)PDC_free(metadata_query_handle); FUNC_LEAVE(ret_value); @@ -2558,7 +2402,7 @@ PDC_Client_query_metadata_name_timestep(const char *obj_name, int time_step, pdc debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_query_register_id_g, &metadata_query_handle); @@ -2570,14 +2414,11 @@ PDC_Client_query_metadata_name_timestep(const char *obj_name, int time_step, pdc lookup_args.data = (pdc_metadata_t *)PDC_malloc(sizeof(pdc_metadata_t)); if (lookup_args.data == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: ERROR - PDC_Client_query_metadata_with_name() " - "cannnot allocate space for client_lookup_args->data"); + PGOTO_ERROR(FAIL, "Cannnot allocate space for client_lookup_args->data"); hg_ret = HG_Forward(metadata_query_handle, metadata_query_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, - "==PDC_CLIENT[%d] - PDC_Client_query_metadata_with_name(): Could not start HG_Forward()", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); @@ -2586,7 +2427,6 @@ PDC_Client_query_metadata_name_timestep(const char *obj_name, int time_step, pdc LOG_DEBUG("rank = %d, PDC_Client_query_metadata_name_timestep = %u\n", pdc_client_mpi_rank_g, out[0]->data_server_id); done: - fflush(stdout); HG_Destroy(metadata_query_handle); FUNC_LEAVE(ret_value); @@ -2607,7 +2447,7 @@ PDC_Client_query_metadata_name_timestep_agg(const char *obj_name, int time_step, MPI_Bcast(&ret_value, 1, MPI_INT, 0, PDC_CLIENT_COMM_WORLD_g); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - ERROR with query [%s]", pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(FAIL, "Error with query [%s]", obj_name); if (pdc_client_mpi_rank_g != 0) *out = (pdc_metadata_t *)PDC_calloc(1, sizeof(pdc_metadata_t)); @@ -2617,11 +2457,10 @@ PDC_Client_query_metadata_name_timestep_agg(const char *obj_name, int time_step, #else ret_value = PDC_Client_query_metadata_name_timestep(obj_name, time_step, out, metadata_server_id); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - ERROR with query [%s]", pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(FAIL, "Error with query [%s]", obj_name); #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2662,14 +2501,14 @@ PDC_Client_create_cont_id(const char *cont_name, pdcid_t cont_create_prop ATTRIB debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, gen_cont_register_id_g, &rpc_handle); hg_ret = HG_Forward(rpc_handle, client_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_send_name_to_server(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); @@ -2691,7 +2530,6 @@ PDC_Client_create_cont_id(const char *cont_name, pdcid_t cont_create_prop ATTRIB #endif done: - fflush(stdout); HG_Destroy(rpc_handle); FUNC_LEAVE(ret_value); @@ -2737,7 +2575,7 @@ PDC_Client_obj_reset_dims(const char *obj_name, int time_step, int ndim, uint64_ debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, obj_reset_dims_register_id_g, &obj_reset_dims_handle); @@ -2759,9 +2597,7 @@ PDC_Client_obj_reset_dims(const char *obj_name, int time_step, int ndim, uint64_ hg_ret = HG_Forward(obj_reset_dims_handle, obj_reset_dims_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, - "==PDC_CLIENT[%d] - PDC_Client_query_metadata_with_name(): Could not start HG_Forward()", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error[%d] Could not start HG_Forward()", pdc_client_mpi_rank_g); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); @@ -2773,7 +2609,6 @@ PDC_Client_obj_reset_dims(const char *obj_name, int time_step, int ndim, uint64_ *reset = 0; } done: - fflush(stdout); HG_Destroy(obj_reset_dims_handle); FUNC_LEAVE(ret_value); @@ -2860,13 +2695,10 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj // Debug statistics for counting number of messages sent to each server. debug_server_id_count[server_id]++; - if (is_client_debug_g == 1) { - LOG_INFO("==PDC_CLIENT[%d]: obj [%s] to be created on server%u\n", pdc_client_mpi_rank_g, obj_name, - server_id); - fflush(stdout); - } + if (is_client_debug_g == 1) + LOG_INFO("obj [%s] to be created on server%u\n", obj_name, server_id); if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); // We have already filled in the pdc_server_info_g[server_id].addr in previous // client_test_connect_lookup_cb @@ -2874,7 +2706,7 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj hg_ret = HG_Forward(rpc_handle, client_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_send_name_to_server(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); @@ -2896,7 +2728,6 @@ PDC_Client_send_name_recv_id(const char *obj_name, uint64_t cont_id, pdcid_t obj #endif done: - fflush(stdout); if (create_prop) PDC_obj_prop_free(create_prop); HG_Destroy(rpc_handle); @@ -2919,17 +2750,15 @@ PDC_Client_close_all_server() if (pdc_client_mpi_size_g < pdc_server_num_g) { if (pdc_client_mpi_rank_g == 0) - LOG_INFO( - "==CLIENT[%d]: run close_server with equal ranks of servers (%d) for faster checkpoint!\n", - pdc_client_mpi_rank_g, pdc_server_num_g); + LOG_INFO("Run close_server with equal ranks of servers (%d) for faster checkpoint\n", + pdc_server_num_g); } if (pdc_client_mpi_size_g >= pdc_server_num_g) { if (pdc_client_mpi_rank_g < pdc_server_num_g) { server_id = pdc_client_mpi_rank_g; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, close_server_register_id_g, &close_server_handle); @@ -2954,8 +2783,7 @@ PDC_Client_close_all_server() for (i = 0; i < (uint32_t)pdc_server_num_g; i++) { server_id = pdc_server_num_g - 1 - i; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, close_server_register_id_g, &close_server_handle); @@ -2984,7 +2812,6 @@ PDC_Client_close_all_server() #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3022,7 +2849,7 @@ PDC_Client_buf_unmap(pdcid_t remote_obj_id, pdcid_t remote_reg_id, struct pdc_re debug_server_id_count[data_server_id]++; if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, buf_unmap_register_id_g, &client_send_buf_unmap_handle); @@ -3044,10 +2871,9 @@ PDC_Client_buf_unmap(pdcid_t remote_obj_id, pdcid_t remote_reg_id, struct pdc_re pdc_timestamp_register(pdc_client_buf_obj_unmap_timestamps, function_start, end); #endif if (unmap_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: buf unmap failed..."); + PGOTO_ERROR(FAIL, "buf unmap failed"); done: - fflush(stdout); HG_Destroy(client_send_buf_unmap_handle); FUNC_LEAVE(ret_value); @@ -3064,7 +2890,6 @@ pack_region_metadata(int ndim, uint64_t *offset, uint64_t *size, region_info_tra PDC_copy_region_desc(offset, transfer->start, ndim, ndim); PDC_copy_region_desc(size, transfer->count, ndim, ndim); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3084,7 +2909,7 @@ PDC_Client_flush_obj(uint64_t obj_id) for (i = 0; i < (uint32_t)pdc_server_num_g; i++) { server_id = pdc_server_num_g - 1 - i; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, flush_obj_register_id_g, &flush_obj_handle); @@ -3105,7 +2930,6 @@ PDC_Client_flush_obj(uint64_t obj_id) PGOTO_ERROR(FAIL, "PDC_Client_flush_obj(): Could not destroy handle"); } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3125,7 +2949,7 @@ PDC_Client_flush_obj_all() for (i = 0; i < (uint32_t)pdc_server_num_g; i++) { server_id = pdc_server_num_g - 1 - i; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, flush_obj_all_register_id_g, &flush_obj_all_handle); @@ -3134,7 +2958,7 @@ PDC_Client_flush_obj_all() in.tag = 44; hg_ret = HG_Forward(flush_obj_all_handle, client_send_flush_obj_all_rpc_cb, &rpc_return, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_flush_obj_all(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server @@ -3146,7 +2970,6 @@ PDC_Client_flush_obj_all() PGOTO_ERROR(FAIL, "PDC_Client_flush_obj_all(): Could not destroy handle"); } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3170,34 +2993,23 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d struct _pdc_transfer_request_all_args transfer_args; char cur_time[64]; -#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; - } + if (!(access_type == PDC_WRITE || access_type == PDC_READ)) + PGOTO_ERROR(FAIL, "Invalid PDC type"); in.n_objs = n_objs; in.access_type = access_type; in.total_buf_size = bulk_size; in.client_id = pdc_client_mpi_rank_g; - // Compute metadata server id - // meta_server_id = PDC_get_server_by_obj_id(obj_id[0], pdc_server_num_g); - debug_server_id_count[data_server_id]++; hg_class = HG_Context_get_class(send_context_g); if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, transfer_request_all_register_id_g, &client_send_transfer_request_all_handle); @@ -3206,18 +3018,13 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d hg_ret = HG_Bulk_create(hg_class, 1, (void **)&bulk_buf, &bulk_size, HG_BULK_READWRITE, &(in.local_bulk_handle)); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_atomic_set32(&atomic_work_todo_g, 1); hg_ret = HG_Forward(client_send_transfer_request_all_handle, client_send_transfer_request_all_rpc_cb, &transfer_args, &in); -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] forwarded to %d\n", cur_time, pdc_client_mpi_rank_g, data_server_id); -#endif - #ifdef ENABLE_MPI if (comm != 0) MPI_Barrier(comm); @@ -3236,17 +3043,10 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d #endif if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_all(): Could not start HG_Forward()\n"); - - /* PDC_Client_check_response(&send_context_g); */ + PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_all(): Could not start HG_Forward()"); 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); @@ -3267,17 +3067,11 @@ PDC_Client_transfer_request_all(int n_objs, pdc_access_t access_type, uint32_t d metadata_id[i] = transfer_args.metadata_id + i; } if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer request failed..."); + PGOTO_ERROR(FAIL, "Transfer request failed"); 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); } @@ -3307,8 +3101,7 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, hg_class = HG_Context_get_class(send_context_g); if (PDC_Client_try_lookup_server(metadata_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server @ line", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[metadata_server_id].addr, transfer_request_metadata_query2_register_id_g, &client_send_transfer_request_metadata_query2_handle); @@ -3318,19 +3111,18 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, hg_ret = HG_Bulk_create(hg_class, 1, (void **)&buf, (hg_size_t *)&(in.total_buf_size), HG_BULK_READWRITE, &(in.local_bulk_handle)); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_ret = HG_Forward(client_send_transfer_request_metadata_query2_handle, client_send_transfer_request_metadata_query2_rpc_cb, &transfer_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, - "PDC_Client_send_transfer_request_metadata_query2(): Could not start HG_Forward()\n"); + PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_metadata_query2(): Could not start HG_Forward()"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer_request_metadata_query2 failed..."); + PGOTO_ERROR(FAIL, "transfer_request_metadata_query2 failed"); HG_Destroy(client_send_transfer_request_metadata_query2_handle); @@ -3341,7 +3133,6 @@ PDC_Client_transfer_request_metadata_query2(char *buf, uint64_t total_buf_size, #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3374,7 +3165,7 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i hg_class = HG_Context_get_class(send_context_g); if (PDC_Client_try_lookup_server(metadata_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[metadata_server_id].addr, transfer_request_metadata_query_register_id_g, &client_send_transfer_request_metadata_query_handle); @@ -3384,18 +3175,17 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i hg_ret = HG_Bulk_create(hg_class, 1, (void **)&buf, (hg_size_t *)&(in.total_buf_size), HG_BULK_READWRITE, &(in.local_bulk_handle)); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_ret = HG_Forward(client_send_transfer_request_metadata_query_handle, client_send_transfer_request_metadata_query_rpc_cb, &transfer_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, - "PDC_Client_send_transfer_request_metadata_query(): Could not start HG_Forward()\n"); + PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_metadata_query(): Could not start HG_Forward()"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer_request_metadata_query failed..."); + PGOTO_ERROR(FAIL, "Transfer_request_metadata_query failed"); *output_buf_size = transfer_args.total_buf_size; *query_id = transfer_args.query_id; @@ -3409,7 +3199,6 @@ PDC_Client_transfer_request_metadata_query(char *buf, uint64_t total_buf_size, i #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3426,12 +3215,6 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u struct _pdc_transfer_request_wait_all_args transfer_args; char cur_time[64]; - /* if (hg_progress_flag_g == 0) { */ - /* hg_progress_flag_g = 1; */ - /* pthread_join(hg_progress_tid_g, NULL); */ - /* hg_progress_flag_g = -1; */ - /* } */ - #ifdef PDC_TIMING double start = MPI_Wtime(), end; double function_start = start; @@ -3446,7 +3229,7 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u hg_class = HG_Context_get_class(send_context_g); if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, transfer_request_wait_all_register_id_g, &client_send_transfer_request_wait_all_handle); @@ -3456,7 +3239,7 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u hg_ret = HG_Bulk_create(hg_class, 1, (void **)&transfer_request_id, (hg_size_t *)&(in.total_buf_size), HG_BULK_READWRITE, &(in.local_bulk_handle)); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_ret = HG_Forward(client_send_transfer_request_wait_all_handle, client_send_transfer_request_wait_all_rpc_cb, &transfer_args, &in); @@ -3466,12 +3249,12 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u start = MPI_Wtime(); #endif if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request_wait_all(): Could not start HG_Forward()\n"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer request wait all failed..."); + PGOTO_ERROR(FAIL, "Transfer request wait all failed"); HG_Destroy(client_send_transfer_request_wait_all_handle); @@ -3482,7 +3265,6 @@ PDC_Client_transfer_request_wait_all(int n_objs, pdcid_t *transfer_request_id, u #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3510,11 +3292,8 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, 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; - } + if (!(access_type == PDC_WRITE || access_type == PDC_READ)) + PGOTO_ERROR(FAIL, "Invalid PDC type"); LOG_DEBUG("rank = %d, data_server_id = %u\n", pdc_client_mpi_rank_g, data_server_id); in.access_type = access_type; @@ -3541,7 +3320,7 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, pack_region_metadata(remote_ndim, remote_offset, remote_size, &(in.remote_region)); if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, transfer_request_register_id_g, &client_send_transfer_request_handle); @@ -3551,7 +3330,7 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, &(in.local_bulk_handle)); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_atomic_set32(&atomic_work_todo_g, 1); @@ -3571,14 +3350,7 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, PDC_Client_transfer_pthread_create(); 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); */ - - /* if (hg_progress_flag_g == -1) { */ - /* pthread_create(&hg_progress_tid_g, NULL, hg_progress_fn, send_context_g); */ - /* hg_progress_flag_g = 0; */ - /* } */ + PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request(): Could not start HG_Forward()"); PDC_Client_wait_pthread_progress(); @@ -3596,11 +3368,10 @@ PDC_Client_transfer_request(void *buf, pdcid_t obj_id, uint32_t data_server_id, *metadata_id = transfer_args.metadata_id; if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer request failed..."); + PGOTO_ERROR(FAIL, "Transfer request failed"); HG_Destroy(client_send_transfer_request_handle); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3619,29 +3390,28 @@ PDC_Client_transfer_request_status(pdcid_t transfer_request_id, uint32_t data_se in.transfer_request_id = transfer_request_id; if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, transfer_request_status_register_id_g, &client_send_transfer_request_status_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_ret = HG_Forward(client_send_transfer_request_status_handle, client_send_transfer_request_status_rpc_cb, &transfer_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request(): Could not start HG_Forward() @ line %d\n"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer request failed..."); + PGOTO_ERROR(FAIL, "Transfer request failed"); HG_Destroy(client_send_transfer_request_status_handle); *completed = transfer_args.status; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3676,13 +3446,13 @@ PDC_Client_transfer_request_wait(pdcid_t transfer_request_id, uint32_t data_serv in.access_type = access_type; if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, transfer_request_wait_register_id_g, &client_send_transfer_request_wait_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "Could not create local bulk data handle\n"); + PGOTO_ERROR(FAIL, "Could not create local bulk data handle"); hg_ret = HG_Forward(client_send_transfer_request_wait_handle, client_send_transfer_request_wait_rpc_cb, &transfer_args, &in); @@ -3698,7 +3468,7 @@ PDC_Client_transfer_request_wait(pdcid_t transfer_request_id, uint32_t data_serv #endif if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request(): Could not start HG_Forward()\n"); + PGOTO_ERROR(FAIL, "PDC_Client_send_transfer_request(): Could not start HG_Forward()"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); @@ -3715,12 +3485,11 @@ PDC_Client_transfer_request_wait(pdcid_t transfer_request_id, uint32_t data_serv #endif if (transfer_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: transfer request failed..."); + PGOTO_ERROR(FAIL, "Transfer request failed"); HG_Destroy(client_send_transfer_request_wait_handle); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3844,10 +3613,10 @@ PDC_Client_buf_map(pdcid_t local_region_id, pdcid_t remote_obj_id, size_t ndim, } } else - PGOTO_ERROR(FAIL, "mapping for array of dimension greater than 4 is not supproted"); + PGOTO_ERROR(FAIL, "Mapping for array of dimension greater than 4 is not supproted"); if (PDC_Client_try_lookup_server(data_server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[data_server_id].addr, buf_map_register_id_g, &client_send_buf_map_handle); @@ -3877,10 +3646,9 @@ PDC_Client_buf_map(pdcid_t local_region_id, pdcid_t remote_obj_id, size_t ndim, pdc_timestamp_register(pdc_client_buf_obj_map_timestamps, function_start, end); #endif if (map_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: buf map failed..."); + PGOTO_ERROR(FAIL, "buf map failed"); done: - fflush(stdout); data_ptrs = (void **)PDC_free(data_ptrs); data_size = (size_t *)PDC_free(data_size); HG_Destroy(client_send_buf_map_handle); @@ -3931,7 +3699,7 @@ PDC_Client_region_lock(pdcid_t remote_obj_id, struct _pdc_obj_info *object_info, PDC_region_info_t_to_transfer_unit(region_info, &(in.region), in.data_unit); if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, region_lock_register_id_g, ®ion_lock_handle); @@ -3977,7 +3745,6 @@ PDC_Client_region_lock(pdcid_t remote_obj_id, struct _pdc_obj_info *object_info, } done: - fflush(stdout); HG_Destroy(region_lock_handle); FUNC_LEAVE(ret_value); @@ -4025,7 +3792,7 @@ PDC_Client_region_release(pdcid_t remote_obj_id, struct _pdc_obj_info *object_in in.data_unit = PDC_get_var_type_size(data_type); PDC_region_info_t_to_transfer_unit(region_info, &(in.region), in.data_unit); if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, region_release_register_id_g, ®ion_release_handle); @@ -4070,7 +3837,6 @@ PDC_Client_region_release(pdcid_t remote_obj_id, struct _pdc_obj_info *object_in } done: - fflush(stdout); if (region_release_handle != HG_HANDLE_NULL) HG_Destroy(region_release_handle); @@ -4098,7 +3864,7 @@ data_server_read_check_rpc_cb(const struct hg_cb_info *callback_info) if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; client_lookup_args->ret_string = " "; - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: error with HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; @@ -4110,7 +3876,6 @@ data_server_read_check_rpc_cb(const struct hg_cb_info *callback_info) client_lookup_args->ret_string = NULL; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -4152,9 +3917,8 @@ PDC_Client_get_data_from_server_shm_cb(const struct hg_cb_info *callback_info) } if (target_region == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: request region not found!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Request region not found"); - // Calculate data_size, TODO: this should be done in other places? data_size = 1; for (i = 0; i < target_region->ndim; i++) { data_size *= target_region->size[i]; @@ -4163,13 +3927,12 @@ PDC_Client_get_data_from_server_shm_cb(const struct hg_cb_info *callback_info) /* open the shared memory segment as if it was a file */ shm_fd = shm_open(shm_addr, O_RDONLY, 0666); if (shm_fd == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: - Shared memory open failed [%s]!", pdc_client_mpi_rank_g, - shm_addr); + PGOTO_ERROR(FAIL, "Shared memory open failed [%s]", shm_addr); /* map the shared memory segment to the address space of the process */ shm_base = mmap(0, data_size, PROT_READ, MAP_SHARED, shm_fd, 0); if (shm_base == MAP_FAILED) { - LOG_ERROR("==PDC_CLIENT: Map failed\n"); + LOG_ERROR("Map failed\n"); ret_value = FAIL; goto close; } @@ -4194,14 +3957,13 @@ PDC_Client_get_data_from_server_shm_cb(const struct hg_cb_info *callback_info) close: /* close the shared memory segment as if it was a file */ if (close(shm_fd) == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: Close failed!"); + PGOTO_ERROR(FAIL, "Close failed"); /* remove the shared memory segment from the file system */ if (shm_unlink(shm_addr) == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: Error removing %s", shm_addr); + PGOTO_ERROR(FAIL, "Error removing %s", shm_addr); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); FUNC_LEAVE(ret_value); @@ -4230,11 +3992,10 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat #endif if (meta == NULL || region == NULL || status == NULL || buf == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: NULL input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "NULL input"); if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid server id %d/%d", pdc_client_mpi_rank_g, server_id, - pdc_server_num_g); + PGOTO_ERROR(FAIL, "Invalid server id %d/%d", server_id, pdc_server_num_g); // Dummy value fill in.client_id = client_id; @@ -4246,14 +4007,14 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat } if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, data_server_read_check_register_id_g, &data_server_read_check_handle); hg_ret = HG_Forward(data_server_read_check_handle, data_server_read_check_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "== Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward()"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); @@ -4263,8 +4024,7 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat if (lookup_args.ret != 1 && lookup_args.ret != 111) { ret_value = SUCCEED; if (is_client_debug_g) - LOG_DEBUG("==PDC_CLIENT[%d]: IO request has not been fulfilled by server\n", - pdc_client_mpi_rank_g); + LOG_DEBUG("IO request has not been fulfilled by server\n"); HG_Destroy(data_server_read_check_handle); if (lookup_args.ret == -1) ret_value = FAIL; @@ -4276,15 +4036,12 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat /* open the shared memory segment as if it was a file */ shm_fd = shm_open(shm_addr, O_RDONLY, 0666); if (shm_fd == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Shared memory open failed [%s]!", pdc_client_mpi_rank_g, - shm_addr); + PGOTO_ERROR(FAIL, "Shared memory open failed [%s]", shm_addr); /* map the shared memory segment to the address space of the process */ shm_base = mmap(0, read_size, PROT_READ, MAP_SHARED, shm_fd, 0); - if (shm_base == MAP_FAILED) { - // PGOTO_ERROR(FAIL, "==PDC_CLIENT: Map failed: %s", strerror(errno)); - } - // close and unlink? + if (shm_base == MAP_FAILED) + PGOTO_ERROR(FAIL, "Map failed: %s", strerror(errno)); #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_start, 0); @@ -4299,22 +4056,18 @@ PDC_Client_data_server_read_check(int server_id, uint32_t client_id, pdc_metadat #endif /* remove the mapped shared memory segment from the address space of the process */ - if (munmap(shm_base, read_size) == -1) { - // PGOTO_ERROR(FAIL, "==PDC_CLIENT: Unmap failed: %s", strerror(errno)); - } + if (munmap(shm_base, read_size) == -1) + PGOTO_ERROR(FAIL, "Unmap failed: %s", strerror(errno)); HG_Destroy(data_server_read_check_handle); - } // end of check io + } - // close: /* close the shared memory segment as if it was a file */ if (close(shm_fd) == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: Close failed!"); + PGOTO_ERROR(FAIL, "Close failed"); - // TODO: need to make sure server has cached it to BB lookup_args.ret_string = (char *)PDC_free(lookup_args.ret_string); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4334,13 +4087,11 @@ data_server_read_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: data_server_read_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "data_server_read_rpc_cb error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -4368,11 +4119,10 @@ PDC_Client_data_server_read(struct pdc_request *request) region = request->region; if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "PDC_CLIENT[%d]: invalid server id %d/%d", pdc_client_mpi_rank_g, server_id, - pdc_server_num_g); + PGOTO_ERROR(FAIL, "Invalid server ID %d/%d", server_id, pdc_server_num_g); if (meta == NULL || region == NULL) - PGOTO_ERROR(FAIL, "PDC_CLIENT[%d]: invalid metadata or region", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid metadata or region"); // TODO TEMPWORK char *tmp_env = getenv("PDC_CACHE_PERCENTAGE"); @@ -4393,7 +4143,7 @@ PDC_Client_data_server_read(struct pdc_request *request) PDC_region_info_t_to_transfer(region, &in.region); if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, data_server_read_register_id_g, &data_server_read_handle); @@ -4407,10 +4157,9 @@ PDC_Client_data_server_read(struct pdc_request *request) PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - PGOTO_ERROR(FAIL, "PDC_CLIENT: ERROR from server"); + PGOTO_ERROR(FAIL, "Error from server"); done: - fflush(stdout); HG_Destroy(data_server_read_handle); FUNC_LEAVE(ret_value); @@ -4427,24 +4176,18 @@ PDC_Client_close_shm(struct pdc_request *req) perr_t ret_value = SUCCEED; if (req == NULL || req->shm_fd == 0 || req->shm_base == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid input"); /* remove the mapped memory segment from the address space of the process */ if (munmap(req->shm_base, req->shm_size) == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Unmap failed", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Unmap failed"); /* close the shared memory segment as if it was a file */ if (close(req->shm_fd) == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: close shm failed", pdc_client_mpi_rank_g); - - /* remove the shared memory segment from the file system */ - // TODO: fix error - /* if (shm_unlink(req->shm_addr) == -1) */ - /* PGOTO_ERROR(FAIL, "==PDC_CLIENT: Error removing %s", req->shm_addr); */ + PGOTO_ERROR(FAIL, "close shm failed"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4466,13 +4209,11 @@ data_server_write_check_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: data_server_write_check_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "data_server_write_check_rpc_cb error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -4500,8 +4241,7 @@ PDC_Client_data_server_write_check(struct pdc_request *request, int *status) region = request->region; if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "PDC_CLIENT[%d]: invalid server id %d/%d", pdc_client_mpi_rank_g, server_id, - pdc_server_num_g); + PGOTO_ERROR(FAIL, "Invalid server id %d/%d", server_id, pdc_server_num_g); in.client_id = pdc_client_mpi_rank_g; PDC_metadata_t_to_transfer_t(meta, &in.meta); @@ -4512,7 +4252,7 @@ PDC_Client_data_server_write_check(struct pdc_request *request, int *status) } if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, data_server_write_check_register_id_g, &data_server_write_check_handle); @@ -4530,7 +4270,7 @@ PDC_Client_data_server_write_check(struct pdc_request *request, int *status) ret_value = SUCCEED; if (is_client_debug_g == 1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: IO request not done by server yet", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "IO request not done by server yet"); if (lookup_args.ret == -1) PGOTO_DONE(FAIL); @@ -4541,7 +4281,6 @@ PDC_Client_data_server_write_check(struct pdc_request *request, int *status) } done: - fflush(stdout); HG_Destroy(data_server_write_check_handle); FUNC_LEAVE(ret_value); @@ -4564,14 +4303,12 @@ data_server_write_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: data_server_write_rpc_cb error with HG_Get_output", - pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "data_server_write_rpc_cb error with HG_Get_output"); } client_lookup_args->ret = output.ret; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -4611,20 +4348,19 @@ PDC_Client_data_server_write(struct pdc_request *request) buf = request->buf; if (NULL == meta || NULL == region || NULL == buf) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: input NULL", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Input NULL"); if (server_id < 0 || server_id >= pdc_server_num_g) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid server id %d/%d", pdc_client_mpi_rank_g, server_id, - pdc_server_num_g); + PGOTO_ERROR(FAIL, "Invalid server id %d/%d", server_id, pdc_server_num_g); if (region->ndim > 4) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid dim %lu", pdc_client_mpi_rank_g, region->ndim); + PGOTO_ERROR(FAIL, "Invalid dim %lu", region->ndim); // Calculate region size for (i = 0; i < region->ndim; i++) { region_size *= region->size[i]; if (region_size == 0) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: size[%d]=0", pdc_client_mpi_rank_g, i); + PGOTO_ERROR(FAIL, "size[%d]=0", i); } // Create shared memory @@ -4636,18 +4372,18 @@ PDC_Client_data_server_write(struct pdc_request *request) /* create the shared memory segment as if it was a file */ request->shm_fd = shm_open(request->shm_addr, O_CREAT | O_RDWR, 0666); if (request->shm_fd == -1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: Shared memory creation with shm_open failed"); + PGOTO_ERROR(FAIL, "Shared memory creation with shm_open failed"); /* configure the size of the shared memory segment */ if (ftruncate(request->shm_fd, region_size) != 0) { - PGOTO_ERROR(FAIL, "==PDC_CLIENT: Memory truncate failed"); + PGOTO_ERROR(FAIL, "Memory truncate failed"); } request->shm_size = region_size; /* map the shared memory segment to the address space of the process */ 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); + PGOTO_ERROR(FAIL, "Shared memory mmap failed, region size = %" PRIu64 "", region_size); // close and shm_unlink? #ifdef ENABLE_TIMING @@ -4677,17 +4413,17 @@ PDC_Client_data_server_write(struct pdc_request *request) PDC_region_info_t_to_transfer(region, &in.region); if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, data_server_write_register_id_g, &data_server_write_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==Could not HG_Create()"); + PGOTO_ERROR(FAIL, "Could not HG_Create()"); hg_ret = HG_Forward(data_server_write_handle, data_server_write_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) { HG_Destroy(data_server_write_handle); - PGOTO_ERROR(FAIL, "==Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward()"); } // Wait for response from server @@ -4699,10 +4435,9 @@ PDC_Client_data_server_write(struct pdc_request *request) server_ret = lookup_args.ret; if (server_ret != 1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR from server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error from server"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4714,25 +4449,24 @@ PDC_Client_test(struct pdc_request *request, int *completed) perr_t ret_value = SUCCEED; if (request == NULL || completed == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: request and/or completed is NULL!"); + PGOTO_ERROR(FAIL, "request and/or completed is NULL"); if (request->access_type == PDC_READ) { ret_value = PDC_Client_data_server_read_check(request->server_id, pdc_client_mpi_rank_g, request->metadata, request->region, completed, request->buf); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC Client read check ERROR!"); + PGOTO_ERROR(FAIL, "Read check error"); } else if (request->access_type == PDC_WRITE) { ret_value = PDC_Client_data_server_write_check(request, completed); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC Client write check ERROR!"); + PGOTO_ERROR(FAIL, "Write check error"); } else - PGOTO_ERROR(FAIL, "==PDC_CLIENT: error with request access type!"); + PGOTO_ERROR(FAIL, "Error with request access type"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4754,21 +4488,20 @@ PDC_Client_wait(struct pdc_request *request, unsigned long max_wait_ms, unsigned while (completed == 0 && cnt < PDC_MAX_TRIAL_NUM) { ret_value = PDC_Client_test(request, &completed); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: PDC_Client_test ERROR!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "PDC_Client_test error"); gettimeofday(&end_time, 0); elapsed_ms = ((end_time.tv_sec - start_time.tv_sec) * 1000000LL + end_time.tv_usec - start_time.tv_usec) / 1000; if (elapsed_ms > max_wait_ms) { - LOG_WARNING("==PDC_CLIENT[%d]: exceeded max IO request waiting time...\n", pdc_client_mpi_rank_g); + LOG_WARNING("Exceeded max IO request waiting time...\n"); break; } PDC_msleep(check_interval_ms); } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4841,14 +4574,13 @@ PDC_Client_write(pdc_metadata_t *meta, struct pdc_region_info *region, void *buf request.n_client = 1; ret_value = PDC_Client_iwrite(meta, region, &request, buf); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC_Client_write - PDC_Client_iwrite error"); + PGOTO_ERROR(FAIL, "PDC_Client_write - PDC_Client_iwrite error"); ret_value = PDC_Client_wait(&request, 60000, 500); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC_Client_write - PDC_Client_wait error"); + PGOTO_ERROR(FAIL, "PDC_Client_write - PDC_Client_wait error"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4867,27 +4599,25 @@ PDC_Client_write_id(pdcid_t local_obj_id, struct pdc_region_info *region, void * info = PDC_find_id(local_obj_id); if (info == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: obj_id %" PRIu64 " invalid!", pdc_client_mpi_rank_g, - local_obj_id); + PGOTO_ERROR(FAIL, "obj_id %" PRIu64 " invalid", local_obj_id); object = (struct _pdc_obj_info *)(info->obj_ptr); meta = object->metadata; if (meta == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: metadata is NULL!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "metadata is NULL"); request.n_update = 1; request.n_client = 1; ret_value = PDC_Client_iwrite(meta, region, &request, buf); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC_Client_write - PDC_Client_iwrite error"); + PGOTO_ERROR(FAIL, "PDC_Client_write - PDC_Client_iwrite error"); ret_value = PDC_Client_wait(&request, 60000, 500); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC_Client_write - PDC_Client_wait error"); + PGOTO_ERROR(FAIL, "PDC_Client_write - PDC_Client_wait error"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4910,10 +4640,9 @@ PDC_Client_iread(pdc_metadata_t *meta, struct pdc_region_info *region, struct pd ret_value = PDC_Client_data_server_read(request); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT: PDC_Client_iread- PDC_Client_data_server_read error"); + PGOTO_ERROR(FAIL, "PDC_Client_iread- PDC_Client_data_server_read error"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4928,16 +4657,15 @@ PDC_Client_read(pdc_metadata_t *meta, struct pdc_region_info *region, void *buf) request.n_update = 1; ret_value = PDC_Client_iread(meta, region, &request, buf); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: PDC_Client_iread error", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "PDC_Client_iread error"); PDC_msleep(500); ret_value = PDC_Client_wait(&request, 60000, 500); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: PDC_Client_wait error", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "PDC_Client_wait error"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4951,21 +4679,17 @@ PDC_Client_write_wait_notify(pdc_metadata_t *meta, struct pdc_region_info *regio ret_value = PDC_Client_iwrite(meta, region, request, buf); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Failed to send write request to server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Failed to send write request to server"); DL_PREPEND(pdc_io_request_list_g, request); - LOG_INFO("==PDC_CLIENT[%d]: Finished sending write request to server, waiting for notification\n", - pdc_client_mpi_rank_g); - fflush(stdout); + LOG_INFO("Finished sending write request to server, waiting for notification\n"); hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); - LOG_INFO("==PDC_CLIENT[%d]: received write finish notification\n", pdc_client_mpi_rank_g); - fflush(stdout); + LOG_INFO("Received write finish notification\n"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4979,7 +4703,7 @@ PDC_Client_read_wait_notify(pdc_metadata_t *meta, struct pdc_region_info *region ret_value = PDC_Client_iread(meta, region, request, buf); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Faile to send read request to server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Failed to send read request to server"); DL_PREPEND(pdc_io_request_list_g, request); @@ -4987,7 +4711,6 @@ PDC_Client_read_wait_notify(pdc_metadata_t *meta, struct pdc_region_info *region PDC_Client_check_response(&send_context_g); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5019,7 +4742,6 @@ PDC_Client_add_del_objects_to_container_cb(const struct hg_cb_info *callback_inf HG_Destroy(cb_args->rpc_handle); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); FUNC_LEAVE(ret_value); @@ -5047,7 +4769,7 @@ PDC_Client_add_del_objects_to_container(int nobj, uint64_t *obj_ids, uint64_t co debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); // Send the bulk handle to the target with RPC hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, cont_add_del_objs_rpc_register_id_g, @@ -5081,7 +4803,6 @@ PDC_Client_add_del_objects_to_container(int nobj, uint64_t *obj_ids, uint64_t co PDC_Client_check_response(&send_context_g); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5154,7 +4875,7 @@ PDC_Client_add_tags_to_container(pdcid_t cont_id, char *tags) info = PDC_find_id(cont_id); if (info == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: cont_id %" PRIu64 " invalid!", pdc_client_mpi_rank_g, cont_id); + PGOTO_ERROR(FAIL, "cont_id %" PRIu64 " invalid", cont_id); object = (struct _pdc_cont_info *)(info->obj_ptr); cont_meta_id = object->cont_info_pub->meta_id; @@ -5165,7 +4886,7 @@ PDC_Client_add_tags_to_container(pdcid_t cont_id, char *tags) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); // Send the bulk handle to the target with RPC hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, cont_add_tags_rpc_register_id_g, @@ -5188,7 +4909,6 @@ PDC_Client_add_tags_to_container(pdcid_t cont_id, char *tags) ret_value = SUCCEED; done: - fflush(stdout); HG_Destroy(rpc_handle); FUNC_LEAVE(ret_value); @@ -5209,12 +4929,11 @@ container_query_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: error with HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); client_lookup_args->cont_id = output.cont_id; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -5242,7 +4961,7 @@ PDC_Client_query_container_name(const char *cont_name, uint64_t *cont_meta_id) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, container_query_register_id_g, &container_query_handle); @@ -5254,10 +4973,7 @@ PDC_Client_query_container_name(const char *cont_name, uint64_t *cont_meta_id) hg_ret = HG_Forward(container_query_handle, container_query_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - - PGOTO_ERROR(FAIL, - "==PDC_CLIENT[%d] - PDC_Client_query_container_with_name(): Could not start HG_Forward()", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Could not start HG_Forward()"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); @@ -5266,7 +4982,6 @@ PDC_Client_query_container_name(const char *cont_name, uint64_t *cont_meta_id) *cont_meta_id = lookup_args.cont_id; done: - fflush(stdout); HG_Destroy(container_query_handle); FUNC_LEAVE(ret_value); @@ -5283,18 +4998,15 @@ PDC_Client_query_container_name_col(const char *cont_name, uint64_t *cont_meta_i if (pdc_client_mpi_rank_g == 0) { ret_value = PDC_Client_query_container_name(cont_name, cont_meta_id); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with PDC_Client_query_container_name", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_query_container_name"); } MPI_Bcast(cont_meta_id, 1, MPI_LONG_LONG, 0, PDC_CLIENT_COMM_WORLD_g); #else - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Calling MPI collective operation without enabling MPI!", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Calling MPI collective operation without enabling MPI"); #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5328,7 +5040,6 @@ PDC_Client_query_read_obj_name_cb(const struct hg_cb_info *callback_info) HG_Destroy(cb_args->rpc_handle); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); FUNC_LEAVE(ret_value); @@ -5342,13 +5053,12 @@ PDC_add_request_to_list(struct pdc_request **list_head, struct pdc_request *requ perr_t ret_value = SUCCEED; if (list_head == NULL || request == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid input"); request->seq_id = pdc_io_request_seq_id++; DL_PREPEND(*list_head, request); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5360,13 +5070,12 @@ PDC_del_request_from_list(struct pdc_request **list_head, struct pdc_request *re perr_t ret_value = SUCCEED; if (list_head == NULL || request == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid input"); request->seq_id = pdc_io_request_seq_id++; DL_DELETE(*list_head, request); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5379,14 +5088,13 @@ PDC_find_request_from_list_by_seq_id(struct pdc_request **list_head, int seq_id) struct pdc_request *elt; if (list_head == NULL || seq_id < PDC_SEQ_ID_INIT_VALUE || seq_id > 99999) - PGOTO_ERROR(NULL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(NULL, "Invalid input"); DL_FOREACH(*list_head, elt) if (elt->seq_id == seq_id) ret_value = elt; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5410,7 +5118,7 @@ PDC_Client_query_name_read_entire_obj(int nobj, char **obj_names, void ***out_bu if (nobj == 0 || obj_names == NULL || out_buf == NULL || out_buf_sizes == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid input"); server_id = PDC_get_local_server_id(pdc_client_mpi_rank_g, pdc_nclient_per_server_g, pdc_server_num_g); @@ -5418,7 +5126,7 @@ PDC_Client_query_name_read_entire_obj(int nobj, char **obj_names, void ***out_bu debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); // Send the bulk handle to the target with RPC hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, query_read_obj_name_register_id_g, @@ -5471,7 +5179,6 @@ PDC_Client_query_name_read_entire_obj(int nobj, char **obj_names, void ***out_bu PDC_Client_check_response(&send_context_g); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5499,15 +5206,14 @@ PDC_Client_complete_read_request(int nbuf, struct pdc_request *req) /* open the shared memory segment as if it was a file */ req->shm_fd_arr[i] = shm_open(req->shm_addr_arr[i], O_RDONLY, 0666); if (req->shm_fd_arr[i] == -1) { - LOG_ERROR("==PDC_CLIENT[%d]: Shared memory open failed [%s]!\n", pdc_client_mpi_rank_g, - req->shm_addr_arr[i]); + LOG_ERROR("Shared memory open failed [%s]\n", req->shm_addr_arr[i]); continue; } /* map the shared memory segment to the address space of the process */ req->shm_base_arr[i] = mmap(0, (req->shm_size_arr)[i], PROT_READ, MAP_SHARED, req->shm_fd_arr[i], 0); if (req->shm_base_arr[i] == MAP_FAILED) { - LOG_ERROR("==PDC_CLIENT: Map failed\n"); + LOG_ERROR("Map failed\n"); continue; } @@ -5525,25 +5231,25 @@ PDC_Client_complete_read_request(int nbuf, struct pdc_request *req) #endif /* remove the mapped shared memory segment from the address space of the process */ + errno = 0; if (munmap(req->shm_base_arr[i], (req->shm_size_arr)[i]) == -1) { + LOG_ERROR("Unmap failed: %s\n", strerror(errno)); + continue; } - // PGOTO_ERROR(FAIL, "==PDC_CLIENT: Unmap failed: %s", strerror(errno)); /* close the shared memory segment as if it was a file */ if (close(req->shm_fd_arr[i]) == -1) { - LOG_ERROR("==PDC_CLIENT: Close failed!\n"); + LOG_ERROR("Close failed\n"); continue; } /* remove the shared memory segment from the file system */ if (shm_unlink(req->shm_addr_arr[i]) == -1) { - LOG_ERROR("==PDC_CLIENT: Error removing %s\n", req->shm_addr_arr[i]); + LOG_ERROR("Error removing %s\n", req->shm_addr_arr[i]); continue; } } - // done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5558,7 +5264,7 @@ PDC_Client_query_read_complete(char *shm_addrs, int size, int n_shm, int seq_id) request = PDC_find_request_from_list_by_seq_id(&pdc_io_request_list_g, seq_id); if (request == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: cannot find previous request", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Cannot find previous request"); request->shm_addr_arr = (char **)PDC_calloc(n_shm, sizeof(char *)); cnt = 0; @@ -5579,7 +5285,6 @@ PDC_Client_query_read_complete(char *shm_addrs, int size, int n_shm, int seq_id) PDC_del_request_from_list(&pdc_io_request_list_g, request); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); FUNC_LEAVE(ret_value); @@ -5601,24 +5306,23 @@ PDC_Client_server_checkpoint(uint32_t server_id) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, server_checkpoint_rpc_register_id_g, &rpc_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Could not create handle", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Could not create handle"); in.origin = pdc_client_mpi_rank_g; hg_ret = HG_Forward(rpc_handle, pdc_client_check_int_ret_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Could not start forward to server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Could not start forward to server"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); done: - fflush(stdout); HG_Destroy(rpc_handle); FUNC_LEAVE(ret_value); @@ -5633,7 +5337,7 @@ PDC_Client_all_server_checkpoint() int i; if (pdc_server_num_g == 0) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: server number not initialized!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Server number not initialized"); // only let client rank 0 send all requests if (pdc_client_mpi_rank_g != 0) @@ -5643,7 +5347,6 @@ PDC_Client_all_server_checkpoint() ret_value = PDC_Client_server_checkpoint(i); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5662,12 +5365,12 @@ PDC_Client_send_client_shm_info(uint32_t server_id, char *shm_addr, uint64_t siz debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, send_shm_register_id_g, &rpc_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Could not create handle", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Could not create handle"); in.client_id = pdc_client_mpi_rank_g; @@ -5676,14 +5379,13 @@ PDC_Client_send_client_shm_info(uint32_t server_id, char *shm_addr, uint64_t siz hg_ret = HG_Forward(rpc_handle, pdc_client_check_int_ret_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Could not forward to server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Could not forward to server"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); done: - fflush(stdout); HG_Destroy(rpc_handle); FUNC_LEAVE(ret_value); @@ -5778,7 +5480,7 @@ PDC_send_region_storage_meta_shm(uint32_t server_id, int n, region_storage_meta_ debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, send_region_storage_meta_shm_bulk_rpc_register_id_g, &rpc_handle); @@ -5808,7 +5510,6 @@ PDC_send_region_storage_meta_shm(uint32_t server_id, int n, region_storage_meta_ PDC_Client_check_response(&send_context_g); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5839,14 +5540,12 @@ PDC_Client_cp_data_to_local_server(int nobj, region_storage_meta_t **all_storage // Copy data to the shm segment for (i = 0; i < nobj; i++) { if (NULL == all_storage_meta[i]) { - LOG_ERROR("==PDC_CLIENT[%d]: NULL storage meta for %dth object!\n", pdc_client_mpi_rank_g, i); - fflush(stdout); + LOG_ERROR("NULL storage meta for %dth object\n", i); continue; } ndim = all_storage_meta[i]->region_transfer.ndim; if (ndim != 1) { - LOG_ERROR("==PDC_CLIENT[%d]: only support for 1D data now (%u)!\n", pdc_client_mpi_rank_g, ndim); - fflush(stdout); + LOG_ERROR("PDC only supports for 1D data now (%u)\n", ndim); continue; } @@ -5949,13 +5648,13 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ prev_fname = NULL; for (i = 0; i < nobj; i++) { if (NULL == all_storage_meta[i]) { - LOG_ERROR("==PDC_CLIENT[%d]: NULL storage meta for %dth object!\n", pdc_client_mpi_rank_g, i); + LOG_ERROR("NULL storage meta for %dth object\n", i); continue; } ndim = all_storage_meta[i]->region_transfer.ndim; if (ndim != 1) { - LOG_ERROR("==PDC_CLIENT[%d]: only support for 1D data now (%u)!\n", pdc_client_mpi_rank_g, ndim); + LOG_ERROR("PDC only supports 1D data now (%u)\n", ndim); continue; } @@ -5981,8 +5680,7 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ fp_read = fopen(fname, "r"); nfopen_g++; if (fp_read == NULL) { - LOG_ERROR("==PDC_CLIENT[%d]: fopen failed [%s] objid %" PRIu64 "\n", pdc_client_mpi_rank_g, - fname, all_storage_meta[i]->obj_id); + LOG_ERROR("fopen failed [%s] objid %" PRIu64 "\n", fname, all_storage_meta[i]->obj_id); prev_fname = fname; continue; } @@ -6003,8 +5701,7 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ file_offset, (*buf_arr)[i], &read_bytes); size_arr[i] = read_bytes; if (read_bytes != buf_size) { - LOG_ERROR("==PDC_CLIENT[%d]: actual read size %zu is not expected %" PRIu64 "\n", - pdc_client_mpi_rank_g, read_bytes, buf_size); + LOG_ERROR("Actual read size %zu is not expected %" PRIu64 "\n", read_bytes, buf_size); } if (strstr(fname, "PDCcacheBB") != NULL) { @@ -6013,7 +5710,6 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ } } - fflush(stdout); if (fp_read != NULL) fclose(fp_read); FUNC_LEAVE(ret_value); @@ -6021,8 +5717,8 @@ PDC_Client_read_with_storage_meta(int nobj, region_storage_meta_t **all_storage_ // Query and retrieve all the storage regions of objects with their names // It is possible that an object has multiple storage regions, they will be stored sequintially in -// storage_meta The storage_meta is also ordered based on the order in obj_names, the mapping can be easily -// formed by checking the obj_id in region_storage_meta_t +// storage_meta The storage_meta is also ordered based on the order in obj_names, the mapping can be +// easily formed by checking the obj_id in region_storage_meta_t perr_t PDC_Client_query_multi_storage_info(int nobj, char **obj_names, region_storage_meta_t ***all_storage_meta) { @@ -6047,7 +5743,7 @@ PDC_Client_query_multi_storage_info(int nobj, char **obj_names, region_storage_m if (nobj == 0) PGOTO_DONE(SUCCEED); else if (obj_names == NULL || all_storage_meta == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid input"); // One request to each metadata server requests = (struct pdc_request **)PDC_calloc(sizeof(struct pdc_request *), pdc_server_num_g); @@ -6081,8 +5777,7 @@ PDC_Client_query_multi_storage_info(int nobj, char **obj_names, region_storage_m debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); // Send the bulk handle to the target with RPC hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, @@ -6153,8 +5848,6 @@ PDC_Client_query_multi_storage_info(int nobj, char **obj_names, region_storage_m } done: - fflush(stdout); - if (NULL != obj_names_by_server) obj_names_by_server = (char ***)PDC_free(obj_names_by_server); if (NULL != n_obj_name_by_server) @@ -6194,7 +5887,7 @@ PDC_get_io_stats_mpi(double read_time, double query_time, int nfopen) reduce_overhead = MPI_Wtime() - reduce_overhead; if (pdc_client_mpi_rank_g == 0) { - LOG_INFO("==PDC_CLIENT: IO STATS (MIN, AVG, MAX)\n" + LOG_INFO("IO STATS (MIN, AVG, MAX)\n" " #fopen (%d, %d, %d)\n" " Tquery (%6.4f, %6.4f, %6.4f)\n" " #readBB %d, size %.2f MB\n" @@ -6222,7 +5915,7 @@ PDC_Client_query_name_read_entire_obj_client(int nobj, char **obj_names, void ** #endif if (nobj == 0 || obj_names == NULL || out_buf == NULL || out_buf_sizes == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: invalid input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Invalid input"); #ifdef ENABLE_TIMING gettimeofday(&pdc_timer1, 0); @@ -6254,7 +5947,6 @@ PDC_Client_query_name_read_entire_obj_client(int nobj, char **obj_names, void ** PDC_Client_cp_data_to_local_server(nobj, all_storage_meta, out_buf, (size_t *)out_buf_sizes); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6282,8 +5974,7 @@ PDC_Client_query_name_read_entire_obj_client_agg(int my_nobj, char **my_obj_name local_names_1d = (char *)PDC_calloc(my_nobj, max_name_len); for (i = 0; i < my_nobj; i++) { if (strlen(my_obj_names[i]) > max_name_len) - LOG_ERROR("==PDC_CLIENT[%2d]: object name longer than %lu [%s]!\n", pdc_client_mpi_rank_g, - max_name_len, my_obj_names[i]); + LOG_ERROR("Object name longer than %lu [%s]\n", max_name_len, my_obj_names[i]); strncpy(local_names_1d + i * max_name_len, my_obj_names[i], max_name_len - 1); } @@ -6409,12 +6100,12 @@ PDC_Client_recv_bulk_storage_meta(process_bulk_storage_meta_args_t *process_args struct pdc_request *request; if (NULL == process_args) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: NULL input", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "NULL input"); // Now find the task and assign the storage meta to corresponding query request request = PDC_find_request_from_list_by_seq_id(&pdc_io_request_list_g, process_args->seq_id); if (NULL == request) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: cannot find previous IO request", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Cannot find previous IO request"); // Attach the received storage meta to the request request->storage_meta = process_args; @@ -6422,7 +6113,6 @@ PDC_Client_recv_bulk_storage_meta(process_bulk_storage_meta_args_t *process_args ret_value = PDC_del_request_from_list(&pdc_io_request_list_g, request); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); FUNC_LEAVE(ret_value); @@ -6462,12 +6152,12 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re *total_read_bytes = 0; if (ndim > 3 || ndim <= 0) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: dim=%" PRIu32 " unsupported yet!", pdc_client_mpi_rank_g, ndim); + PGOTO_ERROR(FAIL, "dim=%" PRIu32 " unsupported yet", ndim); // Get the actual start and count of region in storage if (PDC_get_overlap_start_count(ndim, req_start, req_count, storage_start, storage_count, overlap_start, overlap_count) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: PDC_get_overlap_start_count FAILED!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "PDC_get_overlap_start_count failed"); total_bytes = 1; for (i = 0; i < ndim; i++) { @@ -6512,8 +6202,8 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re } if (is_client_debug_g == 1) { - LOG_DEBUG("==PDC_CLIENT[%d]: read storage offset %" PRIu64 ", buf_offset %" PRIu64 "\n", - pdc_client_mpi_rank_g, storage_offset, buf_offset); + LOG_DEBUG("Read storage offset %" PRIu64 ", buf_offset %" PRIu64 "\n", storage_offset, + buf_offset); } read_bytes = fread(buf + buf_offset, 1, total_bytes, fp); @@ -6521,25 +6211,20 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end1, 0); double region_read_time1 = PDC_get_elapsed_time_double(&pdc_timer_start1, &pdc_timer_end1); - if (is_client_debug_g) { - LOG_DEBUG("==PDC_CLIENT[%d]: fseek + fread %" PRIu64 " bytes, %.2fs\n", pdc_client_mpi_rank_g, - read_bytes, region_read_time1); - fflush(stdout); - } + if (is_client_debug_g) + LOG_DEBUG("fseek + fread %" PRIu64 " bytes, %.2fs\n", read_bytes, region_read_time1); #endif n_contig_MB += read_bytes / 1048576.0; n_contig_read++; if (read_bytes != total_bytes) - PGOTO_ERROR(FAIL, - "==PDC_CLIENT[%d]: fread failed actual read bytes %" PRIu64 ", should be %" PRIu64 "", - pdc_client_mpi_rank_g, read_bytes, total_bytes); + PGOTO_ERROR(FAIL, "fread failed actual read bytes %" PRIu64 ", should be %" PRIu64 "\n", + read_bytes, total_bytes); *total_read_bytes += read_bytes; if (is_client_debug_g == 1) { - LOG_DEBUG("==PDC_CLIENT[%d]: Read entire storage region, size=%" PRIu64 "", pdc_client_mpi_rank_g, - read_bytes); + LOG_DEBUG("Read entire storage region, size=%" PRIu64 "\n", read_bytes); } } // end if else { @@ -6557,7 +6242,7 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re n_contig_MB += read_bytes / 1048576.0; n_contig_read++; if (read_bytes != overlap_count[0]) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: fread failed!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "fread failed"); *total_read_bytes += read_bytes; } // for each row @@ -6588,7 +6273,7 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re n_contig_MB += read_bytes / 1048576.0; n_contig_read++; if (read_bytes != overlap_count[0]) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: fread failed!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "fread failed"); *total_read_bytes += read_bytes; if (is_client_debug_g == 1) { @@ -6601,10 +6286,9 @@ PDC_Client_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re } // end else (ndim != 1 && !is_all_selected); if (total_bytes != *total_read_bytes) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: read size error!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Read size error"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6650,16 +6334,13 @@ PDC_add_kvtag(pdcid_t obj_id, pdc_kvtag_t *kvtag, int is_cont) in.hash_value = PDC_get_hash_by_name(cont_prop->cont_info_pub->name); } - // TODO: delete this line after debugging. - // LOG_INFO("==CLIENT[%d]: PDC_add_kvtag::in.obj_id = %llu \n ", pdc_client_mpi_rank_g, in.obj_id); - server_id = PDC_get_server_by_obj_id(meta_id, pdc_server_num_g); // Debug statistics for counting number of messages sent to each server. debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_add_kvtag_register_id_g, &metadata_add_kvtag_handle); @@ -6673,21 +6354,20 @@ PDC_add_kvtag(pdcid_t obj_id, pdc_kvtag_t *kvtag, int is_cont) in.kvtag.size = kvtag->size; } else - PGOTO_ERROR(FAIL, "==PDC_Client_add_kvtag(): invalid tag content!"); + PGOTO_ERROR(FAIL, "Invalid tag content"); hg_ret = HG_Forward(metadata_add_kvtag_handle, metadata_add_tag_rpc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "PDC_Client_add_kvtag_metadata_with_name(): Could not start HG_Forward()"); + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - LOG_INFO("PDC_CLIENT: add kvtag NOT successful ... ret_value = %d\n", lookup_args.ret); + LOG_ERROR("Add kvtag NOT successful, ret_value = %d\n", lookup_args.ret); done: - fflush(stdout); HG_Destroy(metadata_add_kvtag_handle); FUNC_LEAVE(ret_value); @@ -6706,7 +6386,7 @@ metadata_get_kvtag_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { client_lookup_args->ret = -1; - PGOTO_ERROR(ret_value, "==PDC_CLIENT[%d]: error with HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } client_lookup_args->ret = output.ret; if (output.kvtag.name) @@ -6721,7 +6401,6 @@ metadata_get_kvtag_rpc_cb(const struct hg_cb_info *callback_info) client_lookup_args->kvtag->value = NULL; done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -6760,7 +6439,7 @@ PDC_get_kvtag(pdcid_t obj_id, char *tag_name, pdc_kvtag_t **kvtag, int is_cont) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_get_kvtag_register_id_g, &metadata_get_kvtag_handle); @@ -6769,7 +6448,7 @@ PDC_get_kvtag(pdcid_t obj_id, char *tag_name, pdc_kvtag_t **kvtag, int is_cont) in.key = tag_name; } else - PGOTO_ERROR(FAIL, "PDC_get_kvtag: invalid tag content!"); + PGOTO_ERROR(FAIL, "PDC_get_kvtag: invalid tag content"); *kvtag = (pdc_kvtag_t *)PDC_malloc(sizeof(pdc_kvtag_t)); lookup_args.kvtag = *kvtag; @@ -6782,10 +6461,9 @@ PDC_get_kvtag(pdcid_t obj_id, char *tag_name, pdc_kvtag_t **kvtag, int is_cont) PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - LOG_INFO("PDC_CLIENT: get kvtag NOT successful ... ret_value = %d\n", lookup_args.ret); + LOG_INFO("Get kvtag NOT successful ... ret_value = %d\n", lookup_args.ret); done: - fflush(stdout); HG_Destroy(metadata_get_kvtag_handle); FUNC_LEAVE(ret_value); @@ -6825,15 +6503,9 @@ kvtag_query_bulk_cb(const struct hg_cb_info *hg_cb_info) bulk_args->obj_ids[i] = *u64_arr_ptr; u64_arr_ptr++; } - - // HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, &buf, buf_sizes, - // &actual_cnt); - - // bulk_args->obj_ids = (uint64_t *)PDC_calloc(sizeof(uint64_t), n_meta); - // memcpy(bulk_args->obj_ids, buf, sizeof(uint64_t) * n_meta); } else - PGOTO_ERROR(HG_PROTOCOL_ERROR, "==PDC_CLIENT[%d]: Error with bulk handle", pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_PROTOCOL_ERROR, "Error with bulk handle"); // Free local bulk handle ret_value = HG_Bulk_free(local_bulk_handle); @@ -6847,7 +6519,6 @@ kvtag_query_bulk_cb(const struct hg_cb_info *hg_cb_info) done: hg_atomic_decr32(&bulk_todo_g); hg_atomic_cas32(&bulk_transfer_done_g, 0, 1); - fflush(stdout); HG_Destroy(bulk_args->handle); FUNC_LEAVE(ret_value); @@ -6874,14 +6545,13 @@ kvtag_query_forward_cb(const struct hg_cb_info *callback_info) // Get output from server ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error HG_Get_output", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error HG_Get_output"); bulk_arg->server_time_elapsed = output.server_time_elapsed; bulk_arg->server_memory_consumption = output.server_memory_consumption; if (output.bulk_handle == HG_BULK_NULL || output.ret == 0) { hg_atomic_decr32(&bulk_todo_g); - // hg_atomic_decr32(&atomic_work_todo_g); bulk_arg->n_meta = 0; bulk_arg->obj_ids = NULL; HG_Free_output(handle, &output); @@ -6912,7 +6582,6 @@ kvtag_query_forward_cb(const struct hg_cb_info *callback_info) PGOTO_ERROR(FAIL, "Could not read bulk data"); done: - fflush(stdout); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); @@ -6931,11 +6600,11 @@ PDC_Client_query_kvtag_server(uint32_t server_id, const pdc_kvtag_t *kvtag, int struct bulk_args_t *bulk_arg; if (kvtag == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: kvtag is NULL!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "kvtag is NULL"); if (n_res == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: n_res is NULL!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "n_res is NULL"); if (out == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: out is NULL!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "out is NULL"); if (kvtag->name == NULL) in.name = " "; @@ -6957,14 +6626,14 @@ PDC_Client_query_kvtag_server(uint32_t server_id, const pdc_kvtag_t *kvtag, int *n_res = 0; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); hg_ret = HG_Create(send_context_g, pdc_server_info_g[server_id].addr, query_kvtag_register_id_g, &query_kvtag_server_handle); bulk_arg = (struct bulk_args_t *)PDC_calloc(1, sizeof(struct bulk_args_t)); if (query_kvtag_server_handle == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: Error with query_kvtag_server_handle", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with query_kvtag_server_handle"); hg_ret = HG_Forward(query_kvtag_server_handle, kvtag_query_forward_cb, bulk_arg, &in); if (hg_ret != HG_SUCCESS) @@ -6987,7 +6656,6 @@ PDC_Client_query_kvtag_server(uint32_t server_id, const pdc_kvtag_t *kvtag, int // TODO: need to be careful when freeing the lookup_args, as it include the results returned to user done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7007,14 +6675,11 @@ PDC_Client_query_kvtag(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ids) *pdc_ids = NULL; for (i = 0; i < pdc_server_num_g; i++) { - // TODO: when there are multiple clients issuing different queries concurrently, try to balance the - // server workload by having different clients sending queries with a different order - // server_id = (pdc_client_mpi_rank_g + i) % pdc_server_num_g; - // ret_value = PDC_Client_query_kvtag_server(server_id, kvtag, &nmeta, &temp_ids); + // TODO: when there are multiple clients issuing different queries concurrently, try to balance + // the server workload by having different clients sending queries with a different order ret_value = PDC_Client_query_kvtag_server((uint32_t)i, kvtag, &nmeta, &temp_ids); if (ret_value != SUCCEED) { - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with PDC_Client_query_kvtag_server to server %d", - pdc_client_mpi_rank_g, i); + PGOTO_ERROR(FAIL, "Error with PDC_Client_query_kvtag_server to server %d", i); } if (i == 0) { *pdc_ids = temp_ids; @@ -7027,8 +6692,6 @@ PDC_Client_query_kvtag(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ids) *n_res = *n_res + nmeta; } done: - // memory_debug_g = 1; - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7062,7 +6725,7 @@ PDCtag_delete(pdcid_t obj_id, char *tag_name, int is_cont) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, metadata_del_kvtag_register_id_g, &metadata_del_kvtag_handle); @@ -7086,10 +6749,9 @@ PDCtag_delete(pdcid_t obj_id, char *tag_name, int is_cont) PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - LOG_INFO("PDC_CLIENT: del kvtag NOT successful ... ret_value = %d\n", lookup_args.ret); + LOG_INFO("del kvtag NOT successful ... ret_value = %d\n", lookup_args.ret); done: - fflush(stdout); HG_Destroy(metadata_del_kvtag_handle); FUNC_LEAVE(ret_value); @@ -7116,10 +6778,9 @@ PDCcont_put(const char *cont_name, pdcid_t pdc) ret_value = PDC_Client_create_cont_id(cont_name, cont_prop, &cont_id); #endif if (ret_value != SUCCEED) - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: error with PDC_Client_create_cont_id", pdc_client_mpi_rank_g); + PGOTO_ERROR(0, "Error with PDC_Client_create_cont_id"); done: - fflush(stdout); FUNC_LEAVE(cont_id); } @@ -7157,11 +6818,9 @@ PDCcont_del(pdcid_t cont_id) perr_t ret_value = SUCCEED; ret_value = PDC_Client_del_metadata(cont_id, 1); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with PDC_Client_del_objects_to_container", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_del_objects_to_container"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7174,11 +6833,9 @@ PDCcont_put_objids(pdcid_t cont_id, int nobj, pdcid_t *obj_ids) perr_t ret_value = SUCCEED; ret_value = PDC_Client_add_objects_to_container(nobj, obj_ids, cont_id); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with PDC_Client_add_objects_to_container", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_add_objects_to_container"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7190,11 +6847,9 @@ PDCcont_del_objids(pdcid_t cont_id, int nobj, pdcid_t *obj_ids) perr_t ret_value = SUCCEED; ret_value = PDC_Client_del_objects_to_container(nobj, obj_ids, cont_id); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with PDC_Client_del_objects_to_container", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_del_objects_to_container"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7226,10 +6881,10 @@ PDCcont_put_tag(pdcid_t cont_id, char *tag_name, void *tag_value, pdc_var_type_t ret_value = PDC_add_kvtag(cont_id, &kvtag, 1); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with PDCcont_put_tag", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDCcont_put_tag"); done: - fflush(stdout); + FUNC_LEAVE(ret_value); } @@ -7244,14 +6899,13 @@ PDCcont_get_tag(pdcid_t cont_id, char *tag_name, void **tag_value, pdc_var_type_ ret_value = PDC_get_kvtag(cont_id, tag_name, &kvtag, 1); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with PDC_get_kvtag", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_get_kvtag"); *tag_value = kvtag->value; *value_type = kvtag->type; *value_size = kvtag->size; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7264,10 +6918,9 @@ PDCcont_del_tag(pdcid_t cont_id, char *tag_name) ret_value = PDCtag_delete(cont_id, tag_name, 1); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: error with PDCtag_delete", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDCtag_delete"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7296,7 +6949,7 @@ PDCobj_put_data(const char *obj_name, void *data, uint64_t size, pdcid_t cont_id obj_id = PDCobj_create(cont_id, obj_name, obj_prop); if (obj_id <= 0) - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error creating object [%s]", pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(0, "Error creating object [%s]", obj_name); uint64_t offset = 0; // size = ceil(size/sizeof(int)); @@ -7304,42 +6957,35 @@ PDCobj_put_data(const char *obj_name, void *data, uint64_t size, pdcid_t cont_id transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj_id, obj_region, obj_region); if (transfer_request == 0) { - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error with region transfer create for obj [%s]", - pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(0, "Error with region transfer create for obj [%s]", obj_name); } ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error with region transfer start for obj [%s]", - pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(0, "Error with region transfer start for obj [%s]", obj_name); } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error with region transfer wait for obj [%s]", - pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(0, "Error with region transfer wait for obj [%s]", obj_name); } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error with region transfer close for obj [%s]", - pdc_client_mpi_rank_g, obj_name); + PGOTO_ERROR(0, "Error with region transfer close for obj [%s]", obj_name); } ret = PDCregion_close(obj_region); if (ret != SUCCEED) { - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error with PDCregion_close for obj [%s]", pdc_client_mpi_rank_g, - obj_name); + PGOTO_ERROR(0, "Error with PDCregion_close for obj [%s]", obj_name); } ret = PDCprop_close(obj_prop); if (ret != SUCCEED) { - PGOTO_ERROR(0, "==PDC_CLIENT[%d]: Error with PDCprop_close for obj [%s]", pdc_client_mpi_rank_g, - obj_name); + PGOTO_ERROR(0, "Error with PDCprop_close for obj [%s]", obj_name); } ret_value = obj_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7356,29 +7002,26 @@ PDCobj_get_data(pdcid_t obj_id, void *data, uint64_t size) reg = PDCregion_create(1, &offset, &size); transfer_request = PDCregion_transfer_create(data, PDC_READ, obj_id, reg, reg); if (transfer_request == 0) { - goto done; + PGOTO_DONE(ret_value); } ret_value = PDCregion_transfer_start(transfer_request); if (ret_value != SUCCEED) { - goto done; + PGOTO_ERROR(FAIL, "Error when calling PDCregion_transfer_start"); } ret_value = PDCregion_transfer_wait(transfer_request); if (ret_value != SUCCEED) { - goto done; + PGOTO_ERROR(FAIL, "Error when calling PDCregion_transfer_wait"); } - ret_value = PDCregion_transfer_close(transfer_request); if (ret_value != SUCCEED) { - - goto done; + PGOTO_ERROR(FAIL, "Error when calling PDCregion_transfer_close"); } - ret_value = PDCregion_close(reg); if (ret_value != SUCCEED) { - goto done; + PGOTO_ERROR(FAIL, "Error when calling PDCregion_close"); } + done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7403,11 +7046,9 @@ PDC_Client_del_metadata(pdcid_t obj_id, int is_cont) ret_value = PDC_Client_delete_metadata_by_id(meta_id); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with PDC_Client_delete_metadata_by_id", - pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_delete_metadata_by_id"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7426,10 +7067,9 @@ PDCobj_put_tag(pdcid_t obj_id, char *tag_name, void *tag_value, pdc_var_type_t v ret_value = PDC_add_kvtag(obj_id, &kvtag, 0); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with PDC_add_kvtag", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_add_kvtag"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7444,14 +7084,13 @@ PDCobj_get_tag(pdcid_t obj_id, char *tag_name, void **tag_value, pdc_var_type_t ret_value = PDC_get_kvtag(obj_id, tag_name, &kvtag, 0); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with PDC_get_kvtag", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_get_kvtag"); *tag_value = kvtag->value; *value_type = kvtag->type; *value_size = kvtag->size; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7464,10 +7103,9 @@ PDCobj_del_tag(pdcid_t obj_id, char *tag_name) ret_value = PDCtag_delete(obj_id, tag_name, 0); if (ret_value != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: Error with PDC_del_kvtag", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_del_kvtag"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7524,7 +7162,7 @@ PDC_recv_nhits(const struct hg_cb_info *callback_info) send_nhits_t * in = (send_nhits_t *)callback_info->arg; struct _pdc_query_result_list *result_elt; - LOG_INFO("==PDC_CLIENT[%d]: received %" PRIu64 " hits from server\n", pdc_client_mpi_rank_g, in->nhits); + LOG_INFO("Received %" PRIu64 " hits from server\n", in->nhits); DL_FOREACH(pdcquery_result_list_head_g, result_elt) { @@ -7537,7 +7175,6 @@ PDC_recv_nhits(const struct hg_cb_info *callback_info) hg_atomic_decr32(&atomic_work_todo_g); in = (send_nhits_t *)PDC_free(in); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7558,7 +7195,7 @@ PDC_send_data_query(pdc_query_t *query, pdc_query_get_op_t get_op, uint64_t *nhi query_xfer = PDC_serialize_query(query); if (query_xfer == NULL) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_serialize_query", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_serialize_query"); // Find unique server IDs that has metadata of the queried objects target_servers = (uint32_t *)PDC_calloc(pdc_server_num_g, sizeof(uint32_t)); @@ -7592,7 +7229,7 @@ PDC_send_data_query(pdc_query_t *query, pdc_query_get_op_t get_op, uint64_t *nhi query_xfer->prev_server_id = prev_server; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, send_data_query_register_id_g, &handle); @@ -7605,8 +7242,8 @@ PDC_send_data_query(pdc_query_t *query, pdc_query_get_op_t get_op, uint64_t *nhi PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: send data query to server %u failed ... ret_value = %d", - pdc_client_mpi_rank_g, server_id, lookup_args.ret); + PGOTO_ERROR(FAIL, "Send data query to server %u failed ... ret_value = %d", server_id, + lookup_args.ret); HG_Destroy(handle); } @@ -7626,7 +7263,6 @@ PDC_send_data_query(pdc_query_t *query, pdc_query_get_op_t get_op, uint64_t *nhi } done: - fflush(stdout); if (target_servers) target_servers = (uint32_t *)PDC_free(target_servers); @@ -7660,8 +7296,7 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) query_id = bulk_args->query_id; origin = bulk_args->origin; - LOG_INFO("==PDC_CLIENT[%d]: received %" PRIu64 " coords from server %d\n", pdc_client_mpi_rank_g, - nhits, origin); + LOG_INFO("Received %" PRIu64 " coords from server %d\n", nhits, origin); if (nhits > 0) { ret_value = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, @@ -7680,7 +7315,7 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) } if (result_elt == NULL) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: Invalid task ID!", pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Invalid task ID"); } // End else done: @@ -7695,7 +7330,6 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) if (ret_value != HG_SUCCESS) PGOTO_ERROR(ret_value, "Could not respond"); - fflush(stdout); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); @@ -7730,7 +7364,7 @@ PDC_Client_get_sel_data(pdcid_t obj_id, pdc_selection_t *sel, void *data) struct _pdc_query_result_list *result_elt; if (sel == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: NULL input!", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "NULL input"); if (PDC_find_id(obj_id) != NULL) { obj_prop = PDC_obj_get_info(obj_id); @@ -7746,21 +7380,21 @@ PDC_Client_get_sel_data(pdcid_t obj_id, pdc_selection_t *sel, void *data) debug_server_id_count[server_id]++; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); HG_Create(send_context_g, pdc_server_info_g[server_id].addr, get_sel_data_register_id_g, &handle); hg_ret = HG_Forward(handle, pdc_client_check_int_ret_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: ERROR with HG_Forward", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with HG_Forward"); // Wait for response from server hg_atomic_set32(&atomic_work_todo_g, 1); PDC_Client_check_response(&send_context_g); if (lookup_args.ret != 1) { - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: send data selection to server %u failed ... ret_value = %d", - pdc_client_mpi_rank_g, server_id, lookup_args.ret); + PGOTO_ERROR(FAIL, "Send data selection to server %u failed ... ret_value = %d", server_id, + lookup_args.ret); } // Wait for server to send data @@ -7785,7 +7419,6 @@ PDC_Client_get_sel_data(pdcid_t obj_id, pdc_selection_t *sel, void *data) } done: - fflush(stdout); HG_Destroy(handle); FUNC_LEAVE(ret_value); @@ -7837,14 +7470,13 @@ PDC_recv_read_coords_data(const struct hg_cb_info *callback_info) } } if (result_elt == NULL) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: Invalid task ID!", pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Invalid task ID"); if (result_elt->recv_data_nhits == result_elt->nhits) { hg_atomic_decr32(&atomic_work_todo_g); } else if (result_elt->recv_data_nhits > result_elt->nhits) { - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_CLIENT[%d]: received more results data than expected!", - pdc_client_mpi_rank_g); + PGOTO_ERROR(HG_OTHER_ERROR, "Received more results data than expected"); hg_atomic_decr32(&atomic_work_todo_g); } } // End else @@ -7860,7 +7492,6 @@ PDC_recv_read_coords_data(const struct hg_cb_info *callback_info) if (ret_value != HG_SUCCESS) PGOTO_ERROR(ret_value, "Could not respond"); - fflush(stdout); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); @@ -7878,8 +7509,8 @@ report_avg_server_profiling_rst() ? (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); + LOG_INFO("Server %d, avg profiling time: %.4f ms, memory usage: %.4f MB\n", i, avg_srv_time / 1000.0, + srv_mem_usage); } FUNC_LEAVE_VOID(); @@ -7887,61 +7518,6 @@ report_avg_server_profiling_rst() /******************** METADATA INDEX BEGINS *******************************/ -// metadata_index_create callback -// static hg_return_t -// client_metadata_index_create_cb(const struct hg_cb_info *callback_info) -// { -// FUNC_ENTER(NULL); -// hg_return_t ret_value = HG_SUCCESS; -// hg_handle_t handle; -// struct client_lookup_args *client_lookup_args; - -// metadata_index_create_out_t output; - -// /* LOG_INFO("Entered client_rpc_cb()"); */ -// client_lookup_args = (struct client_lookup_args*) callback_info->arg; -// handle = callback_info->info.forward.handle; - -// /* Get output from server*/ -// ret_value = HG_Get_output(handle, &output); -// /* LOG_INFO("Return value=%llu\n", output.ret); */ -// client_lookup_args->obj_id = output.ret; - -// hg_atomic_decr32(&atomic_work_todo_g); - -// done: -// HG_Destroy(handle); -// FUNC_LEAVE(ret_value); -// } - -// metadata_index_delete callback -// static hg_return_t -// client_metadata_index_delete_cb(const struct hg_cb_info *callback_info) -// { -// FUNC_ENTER(NULL); - -// hg_return_t ret_value = HG_SUCCESS; -// hg_handle_t handle; -// struct client_lookup_args *client_lookup_args; - -// metadata_index_delete_out_t output; - -// /* LOG_INFO("Entered client_rpc_cb()"); */ -// client_lookup_args = (struct client_lookup_args*) callback_info->arg; -// handle = callback_info->info.forward.handle; - -// /* Get output from server*/ -// ret_value = HG_Get_output(handle, &output); -// /* LOG_INFO("Return value=%llu\n", output.ret); */ -// client_lookup_args->obj_id = output.ret; - -// hg_atomic_decr32(&atomic_work_todo_g); - -// done: -// HG_Destroy(handle); -// FUNC_LEAVE(ret_value); -// } - // get_server_info_callback static hg_return_t client_dart_get_server_info_cb(const struct hg_cb_info *callback_info) @@ -7959,8 +7535,7 @@ client_dart_get_server_info_cb(const struct hg_cb_info *callback_info) handle = callback_info->info.forward.handle; /* Get output from server*/ - ret_value = HG_Get_output(handle, &output); - /* LOG_INFO("Return value=%llu\n", output.ret); */ + ret_value = HG_Get_output(handle, &output); client_lookup_args->int64_value1 = output.indexed_word_count; client_lookup_args->int64_value2 = output.request_count; @@ -7976,10 +7551,8 @@ dart_retrieve_server_info_cb(dart_server *server_ptr) FUNC_ENTER(NULL); perr_t srv_lookup_rst = PDC_Client_try_lookup_server(server_ptr->id, 0); - if (srv_lookup_rst == FAIL) { - println("the server %d cannot be connected. ", server_ptr->id); - goto done; - } + if (srv_lookup_rst == FAIL) + PGOTO_ERROR_VOID("the server %d cannot be connected", server_ptr->id); // Mercury comm here. hg_handle_t dart_get_server_info_handle; @@ -8003,6 +7576,7 @@ dart_retrieve_server_info_cb(dart_server *server_ptr) server_ptr->indexed_word_count = lookup_args.int64_value1; server_ptr->request_count = lookup_args.int64_value2; + done: HG_Destroy(dart_get_server_info_handle); @@ -8037,39 +7611,28 @@ dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) client_lookup_args = (struct bulk_args_t *)callback_info->arg; handle = callback_info->info.forward.handle; - // Get output from server - ret_value = HG_Get_output(handle, &output); + ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_INFO("==PDC_CLIENT[%d]: dart_perform_one_server_on_receive_cb - error HG_Get_output\n", - pdc_client_mpi_rank_g); + LOG_INFO("dart_perform_one_server_on_receive_cb - error HG_Get_output\n"); client_lookup_args->n_meta = 0; - goto done; + PGOTO_DONE(ret_value); } client_lookup_args->server_time_elapsed = output.server_time_elapsed; client_lookup_args->server_memory_consumption = output.server_memory_consumption; - // LOG_INFO("lookup_args.op_type = %d and output.op_type = %d\n", client_lookup_args->op_type, - // output.op_type); if (ret_value == HG_SUCCESS && output.has_bulk == 0) { - // LOG_INFO("=== NO Bulk data should be taken care of. \n"); client_lookup_args->n_meta = 0; - goto done; + PGOTO_DONE(ret_value); } - // println("[Client_Side_Bulk] before copy n_meta. rank = %d", pdc_client_mpi_rank_g); - // LOG_INFO("==PDC_CLIENT: Received response from server with bulk handle, n_buf=%d\n", output.ret); - n_meta = output.n_items; - + n_meta = output.n_items; client_lookup_args->n_meta = n_meta; - // LOG_INFO("*(client_lookup_args->n_meta) = %ld\n", *(client_lookup_args->n_meta)); - - // println("[Client_Side_Bulk] before determining size. rank = %d", pdc_client_mpi_rank_g); if (n_meta == 0) { client_lookup_args->obj_ids = NULL; client_lookup_args->n_meta = 0; - goto done; + PGOTO_DONE(ret_value); } // Prepare to receive BULK data. @@ -8086,38 +7649,30 @@ dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) } else { // throw an error - LOG_INFO("==PDC_CLIENT[%d]: ERROR - DART queries can only retrieve object IDs. Please check " - "client_lookup_args->is_id\n", - pdc_client_mpi_rank_g); - goto done; + LOG_ERROR("DART queries can only retrieve object IDs. Please check " + "client_lookup_args->is_id\n"); + PGOTO_DONE(ret_value); } /* Create a new bulk handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, (void **)&recv_meta, (hg_size_t *)&client_lookup_args->nbytes, HG_BULK_READWRITE, &local_bulk_handle); - // println("[Client_Side_Bulk] after bulk create. rank = %d", pdc_client_mpi_rank_g); - /* Pull bulk data */ ret_value = HG_Bulk_transfer(hg_info->context, hg_test_bulk_transfer_cb, client_lookup_args, HG_BULK_PULL, hg_info->addr, origin_bulk_handle, 0, local_bulk_handle, 0, client_lookup_args->nbytes, &hg_bulk_op_id); - // println("[Client_Side_Bulk] after bulk transfer. rank = %d", pdc_client_mpi_rank_g); - if (ret_value != HG_SUCCESS) { - LOG_INFO("Could not read bulk data\n"); client_lookup_args->n_meta = 0; - goto done; + PGOTO_ERROR(FAIL, "Could not read bulk data"); } hg_atomic_init32(&(client_lookup_args->bulk_done_flag), 0); hg_atomic_incr32(&bulk_todo_g); - // hg_atomic_set32(&bulk_transfer_done_g, 0); // loop PDC_Client_check_bulk(send_context_g); - // println("[Client_Side_Bulk] after check bulk. rank = %d", pdc_client_mpi_rank_g); while (1) { if (hg_atomic_get32(&(client_lookup_args->bulk_done_flag)) == 1) { @@ -8126,7 +7681,6 @@ dart_perform_one_server_on_receive_cb(const struct hg_cb_info *callback_info) } done: - // println("[Client_Side_Bulk] finish bulk. rank = %d", pdc_client_mpi_rank_g); hg_atomic_decr32(&atomic_work_todo_g); HG_Free_output(handle, &output); // we destroy the handle here. There will be no need to clean it up in the loop from the request @@ -8145,24 +7699,22 @@ _dart_send_request_to_one_server(int server_id, dart_perform_one_server_in_t *da hg_return_t hg_ret; HG_Create(send_context_g, pdc_server_info_g[server_id].addr, dart_perform_one_server_g, handle); if (handle == NULL) { - LOG_INFO("==CLIENT[%d]: Error with _dart_send_request_to_one_server\n", pdc_client_mpi_rank_g); + LOG_INFO("Error with _dart_send_request_to_one_server\n"); FUNC_LEAVE(FAIL); } lookup_args_ptr->server_id = server_id; - // println("dart_in->attr_key: %s", dart_in->attr_key); hg_ret = HG_Forward(*handle, dart_perform_one_server_on_receive_cb, lookup_args_ptr, dart_in); hg_atomic_incr32(&atomic_work_todo_g); if (hg_ret != HG_SUCCESS) { - LOG_INFO("==CLIENT[%d]: _dart_send_request_to_one_server(): Could not start HG_Forward()\n", - pdc_client_mpi_rank_g); + LOG_INFO("_dart_send_request_to_one_server(): Could not start HG_Forward()\n"); hg_atomic_decr32(&atomic_work_todo_g); FUNC_LEAVE(FAIL); } + // waiting for response and get the results if any. // Wait for response from server - // hg_atomic_cas32(&atomic_work_todo_g, 0, num_requests); PDC_Client_check_response(&send_context_g); // This will block until all requests are done. FUNC_LEAVE(SUCCEED); @@ -8223,7 +7775,7 @@ dart_perform_on_servers(index_hash_result_t **hash_result, int num_servers, for (int i = 0; i < num_servers; i++) { int server_id = (*hash_result)[i].server_id; if (PDC_Client_try_lookup_server(server_id, 0) != SUCCEED) - PGOTO_ERROR(FAIL, "==CLIENT[%d]: ERROR with PDC_Client_try_lookup_server", pdc_client_mpi_rank_g); + PGOTO_ERROR(FAIL, "Error with PDC_Client_try_lookup_server"); lookup_args[i].is_id = 1; lookup_args[i].op_type = op_type; @@ -8282,7 +7834,7 @@ PDC_Client_search_obj_ref_through_dart(dart_hash_algo_t hash_algo, char *query_s dart_determine_query_token_by_key_query(k_query, &tok, &dart_op); if (tok == NULL) { - LOG_INFO("==PDC_CLIENT[%d]: Error with tok\n", pdc_client_mpi_rank_g); + LOG_ERROR("tok was NULL\n"); ret_value = FAIL; FUNC_LEAVE(ret_value); } @@ -8327,7 +7879,6 @@ PDC_Client_search_obj_ref_through_dart(dart_hash_algo_t hash_algo, char *query_s // Pick deduplicated result. *n_res = set_num_entries(result_set); - // println("num_ids = %d", num_ids); if (*n_res > 0) { *out = (uint64_t *)PDC_calloc(*n_res, sizeof(uint64_t)); uint64_t **set_arr = (uint64_t **)set_to_array(result_set); @@ -8400,7 +7951,6 @@ PDC_Client_insert_obj_ref_into_dart(dart_hash_algo_t hash_algo, char *attr_key, { FUNC_ENTER(NULL); - // println("input: attr_key = %s, attr_val = %s", attr_key, attr_val); perr_t ret_value = SUCCEED; dart_perform_one_server_in_t input_param; input_param.op_type = OP_INSERT; @@ -8517,11 +8067,10 @@ PDC_Client_query_kvtag_col(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ *query_sent = 0; break; } - /* LOG_INFO("==PDC_CLIENT[%d]: querying server %u\n", pdc_client_mpi_rank_g, i); */ temp_ids = NULL; ret_value = PDC_Client_query_kvtag_server((uint32_t)i, kvtag, &nmeta, &temp_ids); if (ret_value != SUCCEED) { - PGOTO_ERROR(FAIL, "==PDC_CLIENT[%d]: querying server %u", pdc_client_mpi_rank_g, i); + PGOTO_ERROR(FAIL, "Querying server %u", i); } if (i == my_server_start) { *pdc_ids = temp_ids; @@ -8536,8 +8085,6 @@ PDC_Client_query_kvtag_col(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ } done: - // memory_debug_g = 1; - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -8555,10 +8102,8 @@ _standard_all_gather_result(int query_sent, int *n_res, uint64_t **pdc_ids, MPI_ duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == 0) { - println("==PDC Client[%d]: Time for MPI_Allgather for Syncing ID count: %.4f ms", - pdc_client_mpi_rank_g, duration * 1000.0); - } + if (pdc_client_mpi_rank_g == 0) + LOG_INFO("Time for MPI_Allgather for Syncing ID count: %.4f ms\n", duration * 1000.0); disp = (int *)PDC_calloc(pdc_client_mpi_size_g, sizeof(int)); ntotal = 0; @@ -8604,8 +8149,6 @@ _customized_all_gather_result(int query_sent, int *n_res, uint64_t **pdc_ids, MP int sub_comm_rank, sub_comm_size; MPI_Comm_rank(sub_comm, &sub_comm_rank); MPI_Comm_size(sub_comm, &sub_comm_size); - // println("World rank %d is rank %d in the new communicator of size %d", pdc_client_mpi_rank_g, - // sub_comm_rank, sub_comm_size); int n_sent_ranks = sub_comm_color == 1 ? sub_comm_size : pdc_client_mpi_size_g - sub_comm_size; int sub_n_obj_len = n_sent_ranks + 1; // the last element is the first rank who sent the query. @@ -8617,7 +8160,8 @@ _customized_all_gather_result(int query_sent, int *n_res, uint64_t **pdc_ids, MP if (sub_comm_color == 1) { // the result is first gathered among the ranks who sent the requests. - MPI_Allgather(n_res, 1, MPI_INT, sub_n_obj_arr, 1, MPI_INT, sub_comm); // get the number of results + MPI_Allgather(n_res, 1, MPI_INT, sub_n_obj_arr, 1, MPI_INT, + sub_comm); // get the number of results } MPI_Barrier(world_comm); @@ -8627,10 +8171,8 @@ _customized_all_gather_result(int query_sent, int *n_res, uint64_t **pdc_ids, MP // now all ranks in the world_comm should know about the number of results from each rank who sent the // query. duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == 0) { - println("==PDC Client[%d]: Time for MPI_Allgather for Syncing ID count: %.4f ms", - pdc_client_mpi_rank_g, duration * 1000.0); - } + if (pdc_client_mpi_rank_g == 0) + LOG_INFO("Time for MPI_Allgather for Syncing ID count: %.4f ms\n", duration * 1000.0); // Okay, now each rank of the WORLD_COMM knows about the number of results from the clients who sent // queries. @@ -8646,8 +8188,8 @@ _customized_all_gather_result(int query_sent, int *n_res, uint64_t **pdc_ids, MP ntotal += all_nmeta[i]; } - // Finally, let's gather all the results. Since each client is getting a partial result which can be of - // different size, we need to use MPI_Allgatherv for gathering variable-size arrays from different + // Finally, let's gather all the results. Since each client is getting a partial result which can be + // of different size, we need to use MPI_Allgatherv for gathering variable-size arrays from different // clients. uint64_t *all_ids = (uint64_t *)PDC_malloc(ntotal * sizeof(uint64_t)); @@ -8682,19 +8224,16 @@ PDC_Client_query_kvtag_mpi(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ MPI_Barrier(world_comm); duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == 0) { - println("==PDC Client[%d]: Time for C/S communication: %.4f ms", pdc_client_mpi_rank_g, - duration * 1000.0); - } + if (pdc_client_mpi_rank_g == 0) + LOG_INFO("Time for C/S communication: %.4f ms\n", duration * 1000.0); if (*n_res <= 0) { *n_res = 0; *pdc_ids = NULL; } - if (pdc_client_mpi_size_g == 1) { - goto done; - } + if (pdc_client_mpi_size_g == 1) + PGOTO_DONE_VOID; MPI_Barrier(world_comm); stime = MPI_Wtime(); @@ -8702,10 +8241,8 @@ PDC_Client_query_kvtag_mpi(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ _standard_all_gather_result(query_sent, n_res, pdc_ids, world_comm); duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == 0) { - println("==PDC Client[%d]: Time for MPI_Allgatherv for Syncing ID array: %.4f ms", - pdc_client_mpi_rank_g, duration * 1000.0); - } + if (pdc_client_mpi_rank_g == 0) + LOG_INFO("Time for MPI_Allgatherv for Syncing ID array: %.4f ms\n", duration * 1000.0); // deducplicating result with a Set. Set *result_set = set_new(ui64_hash, ui64_equal); @@ -8718,7 +8255,6 @@ PDC_Client_query_kvtag_mpi(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ *pdc_ids = (uint64_t *)PDC_free(*pdc_ids); // Pick deduplicated result. *n_res = set_num_entries(result_set); - // println("num_ids = %d", num_ids); if (*n_res > 0) { *pdc_ids = (uint64_t *)PDC_calloc(*n_res, sizeof(uint64_t)); uint64_t **set_arr = (uint64_t **)set_to_array(result_set); @@ -8730,7 +8266,6 @@ PDC_Client_query_kvtag_mpi(const pdc_kvtag_t *kvtag, int *n_res, uint64_t **pdc_ set_free(result_set); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -8747,14 +8282,11 @@ _standard_bcast_result(int root, int *n_res, uint64_t **out, MPI_Comm world_comm duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == 0) { - println("==PDC Client[%d]: Time for MPI_Bcast for Syncing ID count: %.4f ms", pdc_client_mpi_rank_g, - duration * 1000.0); - } + if (pdc_client_mpi_rank_g == 0) + LOG_INFO("Time for MPI_Bcast for Syncing ID count: %.4f ms\n", duration * 1000.0); - if (pdc_client_mpi_rank_g != root) { + if (pdc_client_mpi_rank_g != root) *out = (uint64_t *)PDC_calloc(*n_res, sizeof(uint64_t)); - } // broadcast the result to all other ranks MPI_Bcast(*out, *n_res, MPI_UINT64_T, root, world_comm); @@ -8790,9 +8322,6 @@ _customized_bcast_result(int first_sender_global_rank, int num_groups, int sende int group_head_comm_rank, group_head_comm_size; MPI_Comm_rank(group_head_comm, &group_head_comm_rank); MPI_Comm_size(group_head_comm, &group_head_comm_size); - // println("World rank %d is rank %d in the 'group_head_comm' of size %d", pdc_client_mpi_rank_g, - // group_head_comm_rank, - // group_head_comm_size); // broadcast result size among group_head_comm if (group_head_comm_color == 1) { @@ -8811,23 +8340,18 @@ _customized_bcast_result(int first_sender_global_rank, int num_groups, int sende int group_rank, group_size; MPI_Comm_rank(group_comm, &group_rank); MPI_Comm_size(group_comm, &group_size); - // println("World rank %d is rank %d in the 'group_comm' of size %d", pdc_client_mpi_rank_g, - // group_rank, - // group_size); MPI_Bcast(n_res, 1, MPI_INT, rank_in_group, group_comm); MPI_Barrier(world_comm); duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == 0) { - println("==PDC Client[%d]: Time for MPI_Bcast for Syncing ID count: %.4f ms", pdc_client_mpi_rank_g, - duration * 1000.0); - } + if (pdc_client_mpi_rank_g == 0) + LOG_INFO("Time for MPI_Bcast for Syncing ID count: %.4f ms\n", duration * 1000.0); - // Okay, now each rank of the WORLD_COMM knows about the number of results from the sender ranks, and the - // root for WORLD_COMM. Let's perform BCAST for the array data. for those ranks that are not the root, - // allocate memory for the object IDs. + // Okay, now each rank of the WORLD_COMM knows about the number of results from the sender ranks, and + // the root for WORLD_COMM. Let's perform BCAST for the array data. for those ranks that are not the + // root, allocate memory for the object IDs. if (*out == NULL) { *out = (uint64_t *)PDC_calloc(*n_res, sizeof(uint64_t)); } @@ -8861,8 +8385,8 @@ PDC_Client_search_obj_ref_through_dart_mpi(dart_hash_algo_t hash_algo, char *que double stime = 0.0, duration = 0.0; // Let's calcualte an approprate root. - // FIXME: needs to be examined and fixed. Currently, first_sender_global_rank is different in different - // ranks. this is not correct. + // FIXME: needs to be examined and fixed. Currently, first_sender_global_rank is different in + // different ranks. this is not correct. int first_sender_global_rank, num_groups, sender_group_id, rank_in_group, sender_group_size, prefer_custom_exchange; @@ -8876,15 +8400,12 @@ PDC_Client_search_obj_ref_through_dart_mpi(dart_hash_algo_t hash_algo, char *que stime = MPI_Wtime(); // let the root send the query - if (pdc_client_mpi_rank_g == first_sender_global_rank) { + if (pdc_client_mpi_rank_g == first_sender_global_rank) PDC_Client_search_obj_ref_through_dart(hash_algo, query_string, ref_type, &n_obj, &dart_out); - } duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == first_sender_global_rank) { - println("==PDC Client[%d]: Time for C/S communication: %.4f ms", pdc_client_mpi_rank_g, - duration * 1000.0); - } + if (pdc_client_mpi_rank_g == first_sender_global_rank) + LOG_INFO("Time for C/S communication: %.4f ms\n", duration * 1000.0); MPI_Barrier(world_comm); stime = MPI_Wtime(); @@ -8894,10 +8415,8 @@ PDC_Client_search_obj_ref_through_dart_mpi(dart_hash_algo_t hash_algo, char *que duration = MPI_Wtime() - stime; - if (pdc_client_mpi_rank_g == first_sender_global_rank) { - println("==PDC Client[%d]: Time for MPI_Bcast for Syncing ID array: %.4f ms", pdc_client_mpi_rank_g, - duration * 1000.0); - } + if (pdc_client_mpi_rank_g == first_sender_global_rank) + LOG_INFO("Time for MPI_Bcast for Syncing ID array: %.4f ms\n", duration * 1000.0); *n_res = n_obj; *out = dart_out; diff --git a/src/api/pdc_obj/include/pdc_cont.h b/src/api/pdc_obj/include/pdc_cont.h index 33e924c14..9bdb22149 100644 --- a/src/api/pdc_obj/include/pdc_cont.h +++ b/src/api/pdc_obj/include/pdc_cont.h @@ -158,7 +158,7 @@ pbool_t PDCcont_iter_null(cont_handle *chandle); * \param chandle [IN] Pointer to cont_handle struct, returned by * PDCcont_iter_start(pdcid_t pdc_id) * - * \return Pointer to cont_handle struct/NULL on failure + * \return Pointer to cont_handle struct/NULL on failure or no more containers */ cont_handle *PDCcont_iter_next(cont_handle *chandle); diff --git a/src/api/pdc_obj/include/pdc_prop.h b/src/api/pdc_obj/include/pdc_prop.h index 0459e0283..fb13ff407 100644 --- a/src/api/pdc_obj/include/pdc_prop.h +++ b/src/api/pdc_obj/include/pdc_prop.h @@ -85,7 +85,7 @@ pdcid_t PDCprop_obj_dup(pdcid_t prop_id); * * \param prop_id [IN] ID of the property * - * \return Pointer to _pdc_cont_prop struct/Null on failure + * \return Pointer to _pdc_cont_prop struct/NULL on failure */ struct _pdc_cont_prop *PDCcont_prop_get_info(pdcid_t prop_id); diff --git a/src/api/pdc_obj/pdc_cont.c b/src/api/pdc_obj/pdc_cont.c index cc8e3fba6..f325da333 100644 --- a/src/api/pdc_obj/pdc_cont.c +++ b/src/api/pdc_obj/pdc_cont.c @@ -43,10 +43,9 @@ PDC_cont_init() /* Initialize the atom group for the container IDs */ if (PDC_register_type(PDC_CONT, (PDC_free_t)PDC_cont_close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize container interface"); + PGOTO_ERROR(FAIL, "Unable to initialize container interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -88,14 +87,13 @@ PDCcont_create(const char *cont_name, pdcid_t cont_prop_id) ret = PDC_Client_create_cont_id(cont_name, cont_prop_id, &(p->cont_info_pub->meta_id)); if (ret == FAIL) - PGOTO_ERROR(0, "Unable to create container on the server!"); + PGOTO_ERROR(0, "Unable to create container on the server"); p->cont_info_pub->local_id = PDC_id_register(PDC_CONT, p); ret_value = p->cont_info_pub->local_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -138,13 +136,12 @@ PDCcont_create_col(const char *cont_name, pdcid_t cont_prop_id) ret = PDC_Client_create_cont_id_mpi(cont_name, cont_prop_id, &(p->cont_info_pub->meta_id)); if (ret == FAIL) - PGOTO_ERROR(0, "Unable to create container object on server!"); + PGOTO_ERROR(0, "Unable to create container object on server"); p->cont_info_pub->local_id = PDC_id_register(PDC_CONT, p); ret_value = p->cont_info_pub->local_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -192,7 +189,6 @@ PDC_cont_create_local(pdcid_t pdc, const char *cont_name, uint64_t cont_meta_id) PDCprop_close(cont_prop_id); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -212,7 +208,6 @@ PDC_cont_list_null() } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -242,10 +237,9 @@ PDCcont_close(pdcid_t id) /* When the reference count reaches zero the resources are freed */ if (PDC_dec_ref(id) < 0) - PGOTO_ERROR(FAIL, "container: problem of freeing id"); + PGOTO_ERROR(FAIL, "Container: problem of freeing id"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -254,13 +248,12 @@ PDC_cont_end() { FUNC_ENTER(NULL); - perr_t ret_value = SUCCEED; /* Return value */ + perr_t ret_value = SUCCEED; if (PDC_destroy_type(PDC_CONT) < 0) - PGOTO_ERROR(FAIL, "unable to destroy container interface"); + PGOTO_ERROR(FAIL, "Unable to destroy container interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -276,15 +269,14 @@ PDCcont_open(const char *cont_name, pdcid_t pdc) ret = PDC_Client_query_container_name(cont_name, &cont_meta_id); if (ret == FAIL) - PGOTO_ERROR(0, "query container name failed"); + PGOTO_ERROR(0, "Query container name failed"); if (cont_meta_id == 0) - PGOTO_ERROR(0, "query container not found"); + PGOTO_ERROR(0, "Query container not found"); cont_id = PDC_cont_create_local(pdc, cont_name, cont_meta_id); ret_value = cont_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -300,12 +292,11 @@ PDCcont_open_col(const char *cont_name, pdcid_t pdc) ret = PDC_Client_query_container_name_col(cont_name, &cont_meta_id); if (ret == FAIL) - PGOTO_ERROR(0, "query container name failed"); + PGOTO_ERROR(0, "Query container name failed"); cont_id = PDC_cont_create_local(pdc, cont_name, cont_meta_id); ret_value = cont_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -320,14 +311,14 @@ PDC_cont_get_info(pdcid_t cont_id) id_info = PDC_find_id(cont_id); if (id_info == NULL) - PGOTO_ERROR(NULL, "cannot locate object"); + PGOTO_ERROR(NULL, "Cannot locate object"); info = (struct _pdc_cont_info *)(id_info->obj_ptr); ret_value = (struct _pdc_cont_info *)PDC_calloc(1, sizeof(struct _pdc_cont_info)); if (ret_value) memcpy(ret_value, info, sizeof(struct _pdc_cont_info)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value"); ret_value->cont_info_pub = (struct pdc_cont_info *)PDC_calloc(1, sizeof(struct pdc_cont_info)); if (ret_value->cont_info_pub) @@ -340,7 +331,7 @@ PDC_cont_get_info(pdcid_t cont_id) if (ret_value->cont_pt) memcpy(ret_value->cont_pt, info->cont_pt, sizeof(struct _pdc_cont_prop)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value->cont_pt"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->cont_pt"); ret_value->cont_pt->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (ret_value->cont_pt->pdc) { ret_value->cont_pt->pdc->local_id = info->cont_pt->pdc->local_id; @@ -348,10 +339,9 @@ PDC_cont_get_info(pdcid_t cont_id) ret_value->cont_pt->pdc->name = strdup(info->cont_pt->pdc->name); } else - PGOTO_ERROR(NULL, "cannot allocate ret_value->cont_pt->pdc"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->cont_pt->pdc"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -370,12 +360,11 @@ PDCcont_get_info(const char *cont_name) ret_value = (struct pdc_cont_info *)PDC_calloc(1, sizeof(struct pdc_cont_info)); if (!ret_value) - PGOTO_ERROR(NULL, "cannot allocate memory"); + PGOTO_ERROR(NULL, "Cannot allocate memory"); ret_value = tmp->cont_info_pub; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -390,12 +379,11 @@ PDCcont_iter_start() type_ptr = (pdc_id_list_g->PDC_id_type_list_g)[PDC_CONT]; if (type_ptr == NULL) - PGOTO_ERROR(NULL, "container list is empty"); + PGOTO_ERROR(NULL, "Container list is empty"); conthl = (&type_ptr->ids)->head; ret_value = conthl; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -420,12 +408,11 @@ PDCcont_iter_next(cont_handle *chandle) cont_handle *next = NULL; if (chandle == NULL) - PGOTO_ERROR(NULL, "no next container"); + PGOTO_ERROR(NULL, "No next container"); next = PDC_LIST_NEXT(chandle, entry); ret_value = next; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -443,12 +430,11 @@ PDCcont_iter_get_info(cont_handle *chandle) ret_value = (struct pdc_cont_info *)PDC_calloc(1, sizeof(struct pdc_cont_info)); if (!ret_value) - PGOTO_ERROR(NULL, "failed to allocate memory"); + PGOTO_ERROR(NULL, "Failed to allocate memory"); ret_value = info->cont_info_pub; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -462,12 +448,11 @@ PDCcont_persist(pdcid_t cont_id) info = PDC_find_id(cont_id); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate container ID"); + PGOTO_ERROR(FAIL, "Cannot locate container ID"); ((struct _pdc_cont_info *)info->obj_ptr)->cont_pt->cont_life = PDC_PERSIST; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -481,10 +466,9 @@ PDCprop_set_cont_lifetime(pdcid_t cont_prop, pdc_lifetime_t cont_lifetime) info = PDC_find_id(cont_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate container property ID"); + PGOTO_ERROR(FAIL, "Cannot locate container property ID"); ((struct _pdc_cont_prop *)(info->obj_ptr))->cont_life = cont_lifetime; done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_obj/pdc_dt_conv.c b/src/api/pdc_obj/pdc_dt_conv.c index 7375d263c..ed156f578 100644 --- a/src/api/pdc_obj/pdc_dt_conv.c +++ b/src/api/pdc_obj/pdc_dt_conv.c @@ -59,7 +59,7 @@ pdc_find_conv_func(PDC_var_type_t src_id, PDC_var_type_t des_id, size_t nelemt, if (src_id == PDC_DOUBLE && des_id == PDC_INT) ret_value = pdc__conv_db_i; else - PGOTO_ERROR(NULL, "no matching type convert function"); + PGOTO_ERROR(NULL, "No matching type convert function"); done: FUNC_LEAVE(ret_value); diff --git a/src/api/pdc_obj/pdc_mpi.c b/src/api/pdc_obj/pdc_mpi.c index ec3b214c1..dde76f6f8 100644 --- a/src/api/pdc_obj/pdc_mpi.c +++ b/src/api/pdc_obj/pdc_mpi.c @@ -76,17 +76,17 @@ PDCobj_encode(pdcid_t obj_id, pdcid_t *meta_id) MPI_Comm_size(MPI_COMM_WORLD, &client_size); if (client_size < 2) - PGOTO_ERROR(ret_value, "Requires at least two processes."); + PGOTO_ERROR(ret_value, "Requires at least two processes"); MPI_Comm_rank(MPI_COMM_WORLD, &client_rank); if (client_rank == 0) { objinfo = PDC_find_id(obj_id); if (objinfo == NULL) - PGOTO_ERROR(ret_value, "cannot locate object ID"); + PGOTO_ERROR(ret_value, "Cannot locate object ID"); obj = (struct _pdc_obj_info *)(objinfo->obj_ptr); if (obj->location == PDC_OBJ_LOCAL) - PGOTO_ERROR(FAIL, "trying to encode local object"); + PGOTO_ERROR(FAIL, "Trying to encode local object"); *meta_id = obj->obj_info_pub->meta_id; } @@ -106,18 +106,17 @@ PDCobj_decode(pdcid_t obj_id, pdcid_t meta_id) MPI_Comm_size(MPI_COMM_WORLD, &client_size); if (client_size < 2) - PGOTO_ERROR(ret_value, "Requires at least two processes."); + PGOTO_ERROR(ret_value, "Requires at least two processes"); MPI_Comm_rank(MPI_COMM_WORLD, &client_rank); if (client_rank != 0) { objinfo = PDC_find_id(obj_id); if (objinfo == NULL) - PGOTO_ERROR(ret_value, "cannot locate object ID"); + PGOTO_ERROR(ret_value, "Cannot locate object ID"); obj = (struct _pdc_obj_info *)(objinfo->obj_ptr); obj->obj_info_pub->meta_id = meta_id; } done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_obj/pdc_obj.c b/src/api/pdc_obj/pdc_obj.c index 4684b034e..e2712ed0e 100644 --- a/src/api/pdc_obj/pdc_obj.c +++ b/src/api/pdc_obj/pdc_obj.c @@ -51,10 +51,9 @@ PDC_obj_init() /* Initialize the atom group for the object IDs */ if (PDC_register_type(PDC_OBJ, (PDC_free_t)PDC_obj_close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize object interface"); + PGOTO_ERROR(FAIL, "Unable to initialize object interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -62,10 +61,7 @@ pdcid_t PDCobj_create(pdcid_t cont_id, const char *obj_name, pdcid_t obj_prop_id) { FUNC_ENTER(NULL); - - pdcid_t ret_value = 0; - ret_value = PDC_obj_create(cont_id, obj_name, obj_prop_id, PDC_OBJ_GLOBAL); - FUNC_LEAVE(ret_value); + FUNC_LEAVE(PDC_obj_create(cont_id, obj_name, obj_prop_id, PDC_OBJ_GLOBAL)); } /** @@ -191,7 +187,7 @@ PDC_obj_create(pdcid_t cont_id, const char *obj_name, pdcid_t obj_prop_id, _pdc_ p->obj_pt->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (!p->obj_pt->pdc) - PGOTO_ERROR(0, "cannot allocate ret_value->pdc"); + PGOTO_ERROR(0, "Cannot allocate ret_value->pdc"); if (obj_prop->pdc->name) p->obj_pt->pdc->name = strdup(obj_prop->pdc->name); p->obj_pt->pdc->local_id = obj_prop->pdc->local_id; @@ -199,11 +195,11 @@ PDC_obj_create(pdcid_t cont_id, const char *obj_name, pdcid_t obj_prop_id, _pdc_ /* struct pdc_obj_prop field */ p->obj_pt->obj_prop_pub = (struct pdc_obj_prop *)PDC_calloc(1, sizeof(struct pdc_obj_prop)); if (!p->obj_pt->obj_prop_pub) - PGOTO_ERROR(0, "cannot allocate ret_value->obj_pt->obj_prop_pub"); + PGOTO_ERROR(0, "Cannot allocate ret_value->obj_pt->obj_prop_pub"); p->obj_pt->obj_prop_pub->ndim = obj_prop->obj_prop_pub->ndim; p->obj_pt->obj_prop_pub->dims = PDC_malloc(obj_prop->obj_prop_pub->ndim * sizeof(uint64_t)); if (!p->obj_pt->obj_prop_pub->dims) - PGOTO_ERROR(0, "cannot allocate ret_value->dims"); + PGOTO_ERROR(0, "Cannot allocate ret_value->dims"); for (i = 0; i < obj_prop->obj_prop_pub->ndim; i++) p->obj_pt->obj_prop_pub->dims[i] = obj_prop->obj_prop_pub->dims[i]; p->obj_pt->obj_prop_pub->type = obj_prop->obj_prop_pub->type; @@ -230,7 +226,7 @@ PDC_obj_create(pdcid_t cont_id, const char *obj_name, pdcid_t obj_prop_id, _pdc_ ret = PDC_Client_send_name_recv_id(obj_name, p->cont->cont_info_pub->meta_id, obj_prop_id, &(p->obj_info_pub->meta_id), &data_server_id, &metadata_server_id); if (ret == FAIL) - PGOTO_ERROR(0, "Unable to create object on server!"); + PGOTO_ERROR(0, "Unable to create object on server"); } p->obj_info_pub->metadata_server_id = (pdcid_t)metadata_server_id; @@ -246,14 +242,13 @@ PDC_obj_create(pdcid_t cont_id, const char *obj_name, pdcid_t obj_prop_id, _pdc_ p->obj_info_pub->obj_pt->ndim = obj_prop->obj_prop_pub->ndim; p->obj_info_pub->obj_pt->dims = PDC_malloc(obj_prop->obj_prop_pub->ndim * sizeof(uint64_t)); if (!p->obj_info_pub->obj_pt->dims) - PGOTO_ERROR(0, "failed to allocate obj pub property memory"); + PGOTO_ERROR(0, "Failed to allocate obj pub property memory"); for (i = 0; i < obj_prop->obj_prop_pub->ndim; i++) p->obj_info_pub->obj_pt->dims[i] = obj_prop->obj_prop_pub->dims[i]; ret_value = p->obj_info_pub->local_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -273,7 +268,6 @@ PDC_obj_list_null() } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -339,7 +333,6 @@ PDCobj_flush_start(pdcid_t obj_id) perr_t ret_value = SUCCEED; PDC_Client_flush_obj(obj_id); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -351,7 +344,6 @@ PDCobj_flush_all_start() perr_t ret_value = SUCCEED; PDC_Client_flush_obj_all(); - fflush(stdout); FUNC_LEAVE(ret_value); } #else @@ -359,22 +351,14 @@ perr_t PDCobj_flush_start(pdcid_t obj_id __attribute__((unused))) { FUNC_ENTER(NULL); - - perr_t ret_value = SUCCEED; - - fflush(stdout); - FUNC_LEAVE(ret_value); + FUNC_LEAVE(SUCCEED); } perr_t PDCobj_flush_all_start() { FUNC_ENTER(NULL); - - perr_t ret_value = SUCCEED; - fflush(stdout); - - FUNC_LEAVE(ret_value); + FUNC_LEAVE(SUCCEED); } #endif @@ -386,10 +370,9 @@ PDCobj_close(pdcid_t obj_id) perr_t ret_value = SUCCEED; /* When the reference count reaches zero the resources are freed */ if (PDC_dec_ref(obj_id) < 0) - PGOTO_ERROR(FAIL, "object: problem of freeing id"); + PGOTO_ERROR(FAIL, "Object: problem of freeing ID"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -400,10 +383,9 @@ PDC_obj_end() perr_t ret_value = SUCCEED; if (PDC_destroy_type(PDC_OBJ) < 0) - PGOTO_ERROR(FAIL, "unable to destroy object interface"); + PGOTO_ERROR(FAIL, "Unable to destroy object interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -435,9 +417,8 @@ PDCobj_open_common(const char *obj_name, pdcid_t pdc, int is_col) } if (is_opened) { - ret_value = info->local_id; PDC_inc_ref(info->local_id); - goto done; + PGOTO_DONE(info->local_id); } p = (struct _pdc_obj_info *)PDC_malloc(sizeof(struct _pdc_obj_info)); @@ -469,7 +450,7 @@ PDCobj_open_common(const char *obj_name, pdcid_t pdc, int is_col) PGOTO_ERROR(0, "PDC object prop memory allocation failed"); p->obj_pt->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (!p->obj_pt->pdc) - PGOTO_ERROR(0, "cannot allocate ret_value->pdc"); + PGOTO_ERROR(0, "Cannot allocate ret_value->pdc"); // contact metadata server if (is_col == 0) @@ -478,7 +459,7 @@ PDCobj_open_common(const char *obj_name, pdcid_t pdc, int is_col) ret = PDC_Client_query_metadata_name_timestep_agg(obj_name, 0, &out, &metadata_server_id); if (ret == FAIL) - PGOTO_ERROR(0, "query object failed"); + PGOTO_ERROR(0, "Query object failed"); obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); PDCprop_set_obj_dims(obj_prop, out->ndim, out->dims); @@ -488,7 +469,7 @@ PDCobj_open_common(const char *obj_name, pdcid_t pdc, int is_col) p->obj_pt->obj_prop_pub->ndim = out->ndim; p->obj_pt->obj_prop_pub->dims = PDC_malloc(out->ndim * sizeof(uint64_t)); if (!p->obj_pt->obj_prop_pub->dims) - PGOTO_ERROR(0, "cannot allocate ret_value->obj_prop_pub->dims"); + PGOTO_ERROR(0, "Cannot allocate ret_value->obj_prop_pub->dims"); for (i = 0; i < out->ndim; i++) p->obj_pt->obj_prop_pub->dims[i] = out->dims[i]; @@ -526,14 +507,13 @@ PDCobj_open_common(const char *obj_name, pdcid_t pdc, int is_col) memcpy(p->obj_info_pub->obj_pt, p->obj_pt->obj_prop_pub, sizeof(struct pdc_obj_prop)); p->obj_info_pub->obj_pt->dims = PDC_malloc(p->obj_pt->obj_prop_pub->ndim * sizeof(uint64_t)); if (!p->obj_info_pub->obj_pt->dims) - PGOTO_ERROR(0, "failed to allocate obj pub property memory"); + PGOTO_ERROR(0, "Failed to allocate obj pub property memory"); for (i = 0; i < p->obj_pt->obj_prop_pub->ndim; i++) p->obj_info_pub->obj_pt->dims[i] = p->obj_pt->obj_prop_pub->dims[i]; ret_value = p->obj_info_pub->local_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -570,7 +550,7 @@ PDCobj_iter_start(pdcid_t cont_id) type_ptr = (pdc_id_list_g->PDC_id_type_list_g)[PDC_OBJ]; if (type_ptr == NULL) - PGOTO_ERROR(NULL, "object list is empty"); + PGOTO_ERROR(NULL, "Object list is empty"); objhl = (&type_ptr->ids)->head; while (objhl != NULL && @@ -581,7 +561,6 @@ PDCobj_iter_start(pdcid_t cont_id) ret_value = objhl; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -606,7 +585,7 @@ PDCobj_iter_next(obj_handle *ohandle, pdcid_t cont_id) obj_handle *next = NULL; if (ohandle == NULL) - PGOTO_ERROR(NULL, "no next object"); + PGOTO_ERROR(NULL, "No next object"); next = PDC_LIST_NEXT(ohandle, entry); while (next != NULL && @@ -617,7 +596,6 @@ PDCobj_iter_next(obj_handle *ohandle, pdcid_t cont_id) ret_value = next; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -636,21 +614,20 @@ PDCobj_iter_get_info(obj_handle *ohandle) ret_value = (struct pdc_obj_info *)PDC_calloc(1, sizeof(struct pdc_obj_info)); if (!ret_value) - PGOTO_ERROR(NULL, "failed to allocate memory"); + PGOTO_ERROR(NULL, "Failed to allocate memory"); memcpy(ret_value, info->obj_info_pub, sizeof(struct pdc_obj_info)); ret_value->obj_pt = (struct pdc_obj_prop *)PDC_calloc(1, sizeof(struct pdc_obj_prop)); if (!ret_value->obj_pt) - PGOTO_ERROR(NULL, "failed to allocate memory"); + PGOTO_ERROR(NULL, "Failed to allocate memory"); memcpy(ret_value->obj_pt, info->obj_info_pub->obj_pt, sizeof(struct pdc_obj_prop)); ret_value->obj_pt->dims = PDC_malloc(ret_value->obj_pt->ndim * sizeof(uint64_t)); if (!ret_value->obj_pt->dims) - PGOTO_ERROR(0, "failed to allocate obj pub property memory"); + PGOTO_ERROR(0, "Failed to allocate obj pub property memory"); for (i = 0; i < ret_value->obj_pt->ndim; i++) ret_value->obj_pt->dims[i] = info->obj_info_pub->obj_pt->dims[i]; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -664,11 +641,10 @@ PDCprop_set_obj_user_id(pdcid_t obj_prop, uint32_t user_id) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); ((struct _pdc_obj_prop *)(info->obj_ptr))->user_id = user_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -682,7 +658,7 @@ PDCprop_set_obj_app_name(pdcid_t obj_prop, char *app_name) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); if (((struct _pdc_obj_prop *)(info->obj_ptr))->app_name != NULL) { ((struct _pdc_obj_prop *)(info->obj_ptr))->app_name = (char *)PDC_free(((struct _pdc_obj_prop *)(info->obj_ptr))->app_name); @@ -690,7 +666,6 @@ PDCprop_set_obj_app_name(pdcid_t obj_prop, char *app_name) ((struct _pdc_obj_prop *)(info->obj_ptr))->app_name = strdup(app_name); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -704,11 +679,10 @@ PDCprop_set_obj_time_step(pdcid_t obj_prop, uint32_t time_step) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); ((struct _pdc_obj_prop *)(info->obj_ptr))->time_step = time_step; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -722,7 +696,7 @@ PDCprop_set_obj_data_loc(pdcid_t obj_prop, char *loc) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); if (((struct _pdc_obj_prop *)(info->obj_ptr))->data_loc != NULL) { ((struct _pdc_obj_prop *)(info->obj_ptr))->data_loc = (char *)PDC_free(((struct _pdc_obj_prop *)(info->obj_ptr))->data_loc); @@ -730,7 +704,6 @@ PDCprop_set_obj_data_loc(pdcid_t obj_prop, char *loc) ((struct _pdc_obj_prop *)(info->obj_ptr))->data_loc = strdup(loc); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -744,7 +717,7 @@ PDCprop_set_obj_tags(pdcid_t obj_prop, char *tags) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); if (((struct _pdc_obj_prop *)(info->obj_ptr))->tags != NULL) { ((struct _pdc_obj_prop *)(info->obj_ptr))->tags = (char *)PDC_free(((struct _pdc_obj_prop *)(info->obj_ptr))->tags); @@ -752,7 +725,6 @@ PDCprop_set_obj_tags(pdcid_t obj_prop, char *tags) ((struct _pdc_obj_prop *)(info->obj_ptr))->tags = strdup(tags); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -781,7 +753,6 @@ PDCprop_set_obj_dims(pdcid_t obj_prop, PDC_int_t ndim, uint64_t *dims) memcpy(prop->obj_prop_pub->dims, dims, ndim * sizeof(uint64_t)); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -796,12 +767,11 @@ PDCprop_set_obj_type(pdcid_t obj_prop, pdc_var_type_t type) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); prop = (struct _pdc_obj_prop *)(info->obj_ptr); prop->obj_prop_pub->type = type; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -816,12 +786,11 @@ PDCprop_set_obj_transfer_region_type(pdcid_t obj_prop, pdc_region_partition_t re info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); prop = (struct _pdc_obj_prop *)(info->obj_ptr); prop->obj_prop_pub->region_partition = region_partition; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -836,12 +805,11 @@ PDCprop_set_obj_consistency_semantics(pdcid_t obj_prop, pdc_consistency_t consis info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); prop = (struct _pdc_obj_prop *)(info->obj_ptr); prop->obj_prop_pub->consistency = consistency; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -856,12 +824,11 @@ PDCprop_set_obj_buf(pdcid_t obj_prop, void *buf) info = PDC_find_id(obj_prop); if (info == NULL) - PGOTO_ERROR(FAIL, "cannot locate object property ID"); + PGOTO_ERROR(FAIL, "Cannot locate object property ID"); prop = (struct _pdc_obj_prop *)(info->obj_ptr); prop->buf = buf; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -882,8 +849,7 @@ PDCobj_set_dims(pdcid_t obj_id, int ndim, uint64_t *dims) object = (struct _pdc_obj_info *)(info->obj_ptr); if (object->local_transfer_request_size) { // We do not allow setting obj dims while the region transfer requests are taking places. - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Attempt to set obj dims while a region transfer request was taking place"); } if (ndim != (int)((pdc_metadata_t *)(object->metadata))->ndim) { @@ -897,7 +863,7 @@ PDCobj_set_dims(pdcid_t obj_id, int ndim, uint64_t *dims) if (!reset) { // Server rejects reset object dims for some reasons, so we close this operation. - ret_value = FAIL; + PGOTO_DONE(FAIL); } done: @@ -937,13 +903,12 @@ PDCobj_buf_retrieve(pdcid_t obj_id) info = PDC_find_id(obj_id); if (info == NULL) - PGOTO_ERROR(NULL, "cannot locate object ID"); + PGOTO_ERROR(NULL, "Cannot locate object ID"); object = (struct _pdc_obj_info *)(info->obj_ptr); buffer = &(object->obj_pt->buf); ret_value = buffer; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -959,21 +924,21 @@ PDC_obj_get_info(pdcid_t obj_id) obj = PDC_find_id(obj_id); if (obj == NULL) - PGOTO_ERROR(NULL, "cannot locate object"); + PGOTO_ERROR(NULL, "Cannot locate object"); info = (struct _pdc_obj_info *)(obj->obj_ptr); ret_value = (struct _pdc_obj_info *)PDC_calloc(1, sizeof(struct _pdc_obj_info)); if (ret_value) memcpy(ret_value, info, sizeof(struct _pdc_obj_info)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value"); /* struct pdc_obj_info field */ ret_value->obj_info_pub = (struct pdc_obj_info *)PDC_calloc(1, sizeof(struct pdc_obj_info)); if (ret_value->obj_info_pub) memcpy(ret_value->obj_info_pub, info->obj_info_pub, sizeof(struct pdc_obj_info)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value"); if (info->obj_info_pub->name) ret_value->obj_info_pub->name = strdup(info->obj_info_pub->name); else @@ -981,12 +946,12 @@ PDC_obj_get_info(pdcid_t obj_id) ret_value->obj_info_pub->obj_pt = (struct pdc_obj_prop *)PDC_calloc(1, sizeof(struct pdc_obj_prop)); if (!ret_value->obj_info_pub->obj_pt) - PGOTO_ERROR(NULL, "failed to allocate memory"); + PGOTO_ERROR(NULL, "Failed to allocate memory"); memcpy(ret_value->obj_info_pub->obj_pt, info->obj_info_pub->obj_pt, sizeof(struct pdc_obj_prop)); ret_value->obj_info_pub->obj_pt->dims = PDC_malloc(ret_value->obj_info_pub->obj_pt->ndim * sizeof(uint64_t)); if (!ret_value->obj_info_pub->obj_pt->dims) - PGOTO_ERROR(0, "failed to allocate obj pub property memory"); + PGOTO_ERROR(0, "Failed to allocate obj pub property memory"); for (i = 0; i < ret_value->obj_info_pub->obj_pt->ndim; i++) ret_value->obj_info_pub->obj_pt->dims[i] = info->obj_info_pub->obj_pt->dims[i]; @@ -998,13 +963,13 @@ PDC_obj_get_info(pdcid_t obj_id) if (ret_value->cont) memcpy(ret_value->cont, info->cont, sizeof(struct _pdc_cont_info)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value->cont"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->cont"); ret_value->cont->cont_info_pub = (struct pdc_cont_info *)PDC_calloc(1, sizeof(struct pdc_cont_info)); if (ret_value->cont->cont_info_pub) memcpy(ret_value->cont->cont_info_pub, info->cont->cont_info_pub, sizeof(struct pdc_cont_info)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value->cont->cont_info_pub"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->cont->cont_info_pub"); if (info->cont->cont_info_pub->name) ret_value->cont->cont_info_pub->name = strdup(info->cont->cont_info_pub->name); else @@ -1014,7 +979,7 @@ PDC_obj_get_info(pdcid_t obj_id) if (ret_value->cont->cont_pt) memcpy(ret_value->cont->cont_pt, info->cont->cont_pt, sizeof(struct _pdc_cont_prop)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value->cont->cont_pt"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->cont->cont_pt"); ret_value->cont->cont_pt->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (ret_value->cont->cont_pt->pdc) { ret_value->cont->cont_pt->pdc->local_id = info->cont->cont_pt->pdc->local_id; @@ -1024,14 +989,14 @@ PDC_obj_get_info(pdcid_t obj_id) ret_value->cont->cont_pt->pdc->name = NULL; } else - PGOTO_ERROR(NULL, "cannot allocate ret_value->cont->cont_pt->pdc"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->cont->cont_pt->pdc"); // fill in struct _pdc_obj_prop field in ret_value->obj_pt ret_value->obj_pt = (struct _pdc_obj_prop *)PDC_calloc(1, sizeof(struct _pdc_obj_prop)); if (ret_value->obj_pt) memcpy(ret_value->obj_pt, info->obj_pt, sizeof(struct _pdc_obj_prop)); else - PGOTO_ERROR(NULL, "cannot allocate ret_value->obj_pt"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->obj_pt"); ret_value->obj_pt->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (ret_value->obj_pt->pdc) { ret_value->obj_pt->pdc->local_id = info->obj_pt->pdc->local_id; @@ -1041,7 +1006,7 @@ PDC_obj_get_info(pdcid_t obj_id) ret_value->obj_pt->pdc->name = NULL; } else - PGOTO_ERROR(NULL, "cannot allocate ret_value->obj_pt->pdc"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->obj_pt->pdc"); ret_value->obj_pt->obj_prop_pub = (struct pdc_obj_prop *)PDC_calloc(1, sizeof(struct pdc_obj_prop)); if (ret_value->obj_pt->obj_prop_pub) @@ -1057,7 +1022,7 @@ PDC_obj_get_info(pdcid_t obj_id) } } else - PGOTO_ERROR(NULL, "cannot allocate ret_value->obj_pt->dims"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->obj_pt->dims"); if (info->obj_pt->app_name) ret_value->obj_pt->app_name = strdup(info->obj_pt->app_name); else @@ -1074,7 +1039,6 @@ PDC_obj_get_info(pdcid_t obj_id) ret_value->region_list_head = NULL; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1144,12 +1108,11 @@ PDCobj_get_info(pdcid_t obj_id) tmp = PDC_obj_get_info(obj_id); if (NULL == tmp) - PGOTO_ERROR(NULL, "failed to allocate memory"); + PGOTO_ERROR(NULL, "Failed to allocate memory"); ret_value = tmp->obj_info_pub; done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_obj/pdc_prop.c b/src/api/pdc_obj/pdc_prop.c index 33c3acdf8..76db3c8b9 100644 --- a/src/api/pdc_obj/pdc_prop.c +++ b/src/api/pdc_obj/pdc_prop.c @@ -43,14 +43,13 @@ PDC_prop_init() /* Initialize the atom group for the container property IDs */ if (PDC_register_type(PDC_CONT_PROP, (PDC_free_t)pdc_prop_cont_close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize container property interface"); + PGOTO_ERROR(FAIL, "Unable to initialize container property interface"); /* Initialize the atom group for the object property IDs */ if (PDC_register_type(PDC_OBJ_PROP, (PDC_free_t)pdc_prop_obj_close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize object property interface"); + PGOTO_ERROR(FAIL, "Unable to initialize object property interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -122,7 +121,6 @@ PDCprop_create(pdc_prop_type_t type, pdcid_t pdcid) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -140,7 +138,7 @@ PDCprop_obj_dup(pdcid_t prop_id) prop = PDC_find_id(prop_id); if (prop == NULL) - PGOTO_ERROR(0, "cannot locate object property"); + PGOTO_ERROR(0, "Cannot locate object property"); info = (struct _pdc_obj_prop *)(prop->obj_ptr); q = (struct _pdc_obj_prop *)PDC_calloc(1, sizeof(struct _pdc_obj_prop)); @@ -178,7 +176,6 @@ PDCprop_obj_dup(pdcid_t prop_id) ret_value = new_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -198,7 +195,6 @@ PDC_prop_cont_list_null() } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -217,7 +213,6 @@ PDC_prop_obj_list_null() } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -266,10 +261,9 @@ PDCprop_close(pdcid_t id) /* When the reference count reaches zero the resources are freed */ if (PDC_dec_ref(id) < 0) - PGOTO_ERROR(FAIL, "property: problem of freeing id"); + PGOTO_ERROR(FAIL, "Property: problem of freeing id"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -281,13 +275,12 @@ PDC_prop_end() perr_t ret_value = SUCCEED; if (PDC_destroy_type(PDC_CONT_PROP) < 0) - PGOTO_ERROR(FAIL, "unable to destroy container property interface"); + PGOTO_ERROR(FAIL, "Unable to destroy container property interface"); if (PDC_destroy_type(PDC_OBJ_PROP) < 0) - PGOTO_ERROR(FAIL, "unable to destroy object property interface"); + PGOTO_ERROR(FAIL, "Unable to destroy object property interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -302,7 +295,7 @@ PDCcont_prop_get_info(pdcid_t cont_prop) prop = PDC_find_id(cont_prop); if (prop == NULL) - PGOTO_ERROR(NULL, "cannot allocate container property"); + PGOTO_ERROR(NULL, "Cannot allocate container property"); info = (struct _pdc_cont_prop *)(prop->obj_ptr); ret_value = (struct _pdc_cont_prop *)PDC_calloc(1, sizeof(struct _pdc_cont_prop)); @@ -313,13 +306,12 @@ PDCcont_prop_get_info(pdcid_t cont_prop) ret_value->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (!ret_value->pdc) - PGOTO_ERROR(NULL, "cannot allocate ret_value->pdc"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->pdc"); if (info->pdc->name) ret_value->pdc->name = strdup(info->pdc->name); ret_value->pdc->local_id = info->pdc->local_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -335,7 +327,7 @@ PDCobj_prop_get_info(pdcid_t obj_prop) prop = PDC_find_id(obj_prop); if (prop == NULL) - PGOTO_ERROR(NULL, "cannot locate object property"); + PGOTO_ERROR(NULL, "Cannot locate object property"); info = (struct _pdc_obj_prop *)(prop->obj_ptr); ret_value = (struct pdc_obj_prop *)PDC_calloc(1, sizeof(struct pdc_obj_prop)); @@ -345,12 +337,11 @@ PDCobj_prop_get_info(pdcid_t obj_prop) ret_value->dims = PDC_malloc(info->obj_prop_pub->ndim * sizeof(uint64_t)); if (ret_value->dims == NULL) - PGOTO_ERROR(NULL, "cannot allocate ret_value->dims"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->dims"); for (i = 0; i < info->obj_prop_pub->ndim; i++) ret_value->dims[i] = info->obj_prop_pub->dims[i]; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -366,7 +357,7 @@ PDC_obj_prop_get_info(pdcid_t obj_prop) prop = PDC_find_id(obj_prop); if (prop == NULL) - PGOTO_ERROR(NULL, "cannot locate object property"); + PGOTO_ERROR(NULL, "Cannot locate object property"); info = (struct _pdc_obj_prop *)(prop->obj_ptr); ret_value = (struct _pdc_obj_prop *)PDC_calloc(1, sizeof(struct _pdc_obj_prop)); @@ -385,7 +376,7 @@ PDC_obj_prop_get_info(pdcid_t obj_prop) /* struct _pdc_class field */ ret_value->pdc = (struct _pdc_class *)PDC_calloc(1, sizeof(struct _pdc_class)); if (ret_value->pdc == NULL) - PGOTO_ERROR(NULL, "cannot allocate ret_value->pdc"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->pdc"); if (info->pdc->name) ret_value->pdc->name = strdup(info->pdc->name); ret_value->pdc->local_id = info->pdc->local_id; @@ -397,12 +388,11 @@ PDC_obj_prop_get_info(pdcid_t obj_prop) memcpy(ret_value->obj_prop_pub, info->obj_prop_pub, sizeof(struct pdc_obj_prop)); ret_value->obj_prop_pub->dims = PDC_malloc(info->obj_prop_pub->ndim * sizeof(uint64_t)); if (ret_value->obj_prop_pub->dims == NULL) - PGOTO_ERROR(NULL, "cannot allocate ret_value->obj_prop_pub->dims"); + PGOTO_ERROR(NULL, "Cannot allocate ret_value->obj_prop_pub->dims"); for (i = 0; i < info->obj_prop_pub->ndim; i++) ret_value->obj_prop_pub->dims[i] = info->obj_prop_pub->dims[i]; done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_query/pdc_query.c b/src/api/pdc_query/pdc_query.c index f63e9adef..c71f1b2ad 100644 --- a/src/api/pdc_query/pdc_query.c +++ b/src/api/pdc_query/pdc_query.c @@ -47,14 +47,13 @@ PDCquery_create(pdcid_t obj_id, pdc_query_op_t op, pdc_var_type_t type, void *va query->constraint->type = type; type_size = PDC_get_var_type_size(type); if (type_size > 8) - PGOTO_ERROR(NULL, "Cannot handle value larger than 8 bytes!"); + PGOTO_ERROR(NULL, "Cannot handle value larger than 8 bytes"); memcpy(&query->constraint->value, value, type_size); ret_value = query; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -70,7 +69,6 @@ PDCquery_sel_region(pdc_query_t *query, struct pdc_region_info *obj_region) query->region = obj_region; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -110,49 +108,6 @@ PDCquery_and(pdc_query_t *q1, pdc_query_t *q2) (q2->constraint->op == PDC_LT || q2->constraint->op == PDC_LTE))) { break; } - /* - switch (q1->constraint->type) { - case PDC_FLOAT: - flo = *((float *)&q1->constraint->value); - fhi = *((float *)&q2->constraint->value); - if (flo <= fhi) - can_combine = 1; - break; - case PDC_DOUBLE: - dlo = *((double *)&q1->constraint->value); - dhi = *((double *)&q2->constraint->value); - if (dlo <= dhi) - can_combine = 1; - break; - case PDC_INT: - ilo = *((int *)&q1->constraint->value); - ihi = *((int *)&q2->constraint->value); - if (ilo <= ihi) - can_combine = 1; - break; - case PDC_UINT: - ulo = *((uint32_t *)&q1->constraint->value); - uhi = *((uint32_t *)&q2->constraint->value); - if (ulo <= uhi) - can_combine = 1; - break; - case PDC_INT64: - i64lo = *((int64_t *)&q1->constraint->value); - i64hi = *((int64_t *)&q2->constraint->value); - if (i64lo <= i64hi) - can_combine = 1; - break; - case PDC_UINT64: - ui64lo = *((uint64_t *)&q1->constraint->value); - ui64hi = *((uint64_t *)&q2->constraint->value); - if (ui64lo <= ui64hi) - can_combine = 1; - break; - default: - PGOTO_ERROR(NULL, "== error with operator type!"); - break; - } // End switch - */ switch (q1->constraint->type) { case PDC_FLOAT: flo = (float)q1->constraint->value; @@ -191,7 +146,7 @@ PDCquery_and(pdc_query_t *q1, pdc_query_t *q2) can_combine = 1; break; default: - PGOTO_ERROR(NULL, "== error with operator type!"); + PGOTO_ERROR(NULL, "Error with operator type"); break; } // End switch break; @@ -220,7 +175,6 @@ PDCquery_and(pdc_query_t *q1, pdc_query_t *q2) ret_value = query; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -246,7 +200,6 @@ PDCquery_or(pdc_query_t *q1, pdc_query_t *q2) ret_value = query; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -257,12 +210,11 @@ PDCquery_get_nhits(pdc_query_t *query, uint64_t *n) perr_t ret_value = SUCCEED; if (query == NULL || n == NULL) - PGOTO_ERROR(FAIL, "==PDC input NULL!"); + PGOTO_ERROR(FAIL, "Input NULL"); ret_value = PDC_send_data_query(query, PDC_QUERY_GET_NHITS, n, NULL, NULL); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -273,13 +225,12 @@ PDCquery_get_selection(pdc_query_t *query, pdc_selection_t *sel) perr_t ret_value = SUCCEED; if (query == NULL || sel == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[] input NULL!"); + PGOTO_ERROR(FAIL, "Input NULL"); memset(sel, 0, sizeof(pdc_selection_t)); ret_value = PDC_send_data_query(query, PDC_QUERY_GET_SEL, NULL, sel, NULL); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -293,7 +244,7 @@ PDCquery_get_data(pdcid_t obj_id, pdc_selection_t *sel, void *obj_data) uint64_t meta_id; if (obj_data == NULL || sel == NULL) - PGOTO_ERROR(FAIL, "==PDC_CLIENT[] input NULL!"); + PGOTO_ERROR(FAIL, "Input NULL"); if (PDC_find_id(obj_id) != NULL) { obj_prop = PDC_obj_get_info(obj_id); @@ -305,7 +256,6 @@ PDCquery_get_data(pdcid_t obj_id, pdc_selection_t *sel, void *obj_data) ret_value = PDC_Client_get_sel_data(meta_id, sel, obj_data); done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_region/include/pdc_region.h b/src/api/pdc_region/include/pdc_region.h index 5a6a97efb..1a273a9f4 100644 --- a/src/api/pdc_region/include/pdc_region.h +++ b/src/api/pdc_region/include/pdc_region.h @@ -187,7 +187,7 @@ perr_t PDCregion_transfer_status(pdcid_t transfer_request_id, pdc_transfer_statu perr_t PDCregion_transfer_wait(pdcid_t transfer_request_id); /** - * Block and wait for several region transfer request to finish + * Block and wait for several region transfer requests to finish * * \param transfer_request_id [IN] ID of the region transfer request * \param size [IN] Number of requests in transfer_request_id diff --git a/src/api/pdc_region/pdc_region.c b/src/api/pdc_region/pdc_region.c index 597488a3f..366df124c 100644 --- a/src/api/pdc_region/pdc_region.c +++ b/src/api/pdc_region/pdc_region.c @@ -52,10 +52,9 @@ PDC_region_init() perr_t ret_value = SUCCEED; /* Initialize the atom group for the region IDs */ if (PDC_register_type(PDC_REGION, (PDC_free_t)pdc_region_close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize region interface"); + PGOTO_ERROR(FAIL, "Unable to initialize region interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -67,10 +66,9 @@ PDC_transfer_request_init() perr_t ret_value = SUCCEED; /* Initialize the atom group for the region IDs */ if (PDC_register_type(PDC_TRANSFER_REQUEST, (PDC_free_t)pdc_transfer_request_close) < 0) - PGOTO_ERROR(FAIL, "unable to initialize region interface"); + PGOTO_ERROR(FAIL, "Unable to initialize region interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -90,7 +88,6 @@ PDC_region_list_null() } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -130,10 +127,9 @@ PDCregion_close(pdcid_t region_id) /* When the reference count reaches zero the resources are freed */ if (PDC_dec_ref(region_id) < 0) - PGOTO_ERROR(FAIL, "object: problem of freeing id"); + PGOTO_ERROR(FAIL, "Object: problem of freeing id"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -144,35 +140,12 @@ PDC_region_end() perr_t ret_value = SUCCEED; if (PDC_destroy_type(PDC_REGION) < 0) - PGOTO_ERROR(FAIL, "unable to destroy region interface"); + PGOTO_ERROR(FAIL, "Failed to destroy region interface"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } -/* -static pdc_transfer_status_t check_local_transfer_request(struct _pdc_obj_info *p, pdcid_t -transfer_request_id) { pdc_transfer_status_t ret_value; struct pdc_local_transfer_request *temp; - - FUNC_ENTER(NULL); - - ret_value = PDC_TRANSFER_STATUS_NOT_FOUND; - - temp = p->local_transfer_request_head; - - while ( temp != NULL ) { - if (temp->local_id == transfer_request_id) { - ret_value = PDC_TRANSFER_STATUS_PENDING; - } - temp = temp->next; - } -done: - fflush(stdout); - FUNC_LEAVE(ret_value); -} -*/ - pdcid_t PDCregion_create(psize_t ndims, uint64_t *offset, uint64_t *size) { @@ -201,7 +174,6 @@ PDCregion_create(psize_t ndims, uint64_t *offset, uint64_t *size) ret_value = new_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -227,7 +199,7 @@ PDCbuf_obj_map(void *buf, pdc_var_type_t local_type, pdcid_t local_reg, pdcid_t objinfo2 = PDC_find_id(remote_obj); if (objinfo2 == NULL) - PGOTO_ERROR(FAIL, "cannot locate remote object ID"); + PGOTO_ERROR(FAIL, "Cannot locate remote object ID"); obj2 = (struct _pdc_obj_info *)(objinfo2->obj_ptr); remote_meta_id = obj2->obj_info_pub->meta_id; remote_type = obj2->obj_pt->obj_prop_pub->type; @@ -235,10 +207,10 @@ PDCbuf_obj_map(void *buf, pdc_var_type_t local_type, pdcid_t local_reg, pdcid_t reginfo2 = PDC_find_id(remote_reg); reg2 = (struct pdc_region_info *)(reginfo2->obj_ptr); if (obj2->obj_pt->obj_prop_pub->ndim != reg2->ndim) - PGOTO_ERROR(FAIL, "remote object dimension and region dimension does not match"); + PGOTO_ERROR(FAIL, "Remote object dimension and region dimension does not match"); for (i = 0; i < reg2->ndim; i++) if ((obj2->obj_pt->obj_prop_pub->dims)[i] < (reg2->size)[i]) - PGOTO_ERROR(FAIL, "remote object region size error"); + PGOTO_ERROR(FAIL, "Remote object region size error"); ret_value = PDC_Client_buf_map(local_reg, remote_meta_id, reg1->ndim, reg1->size, reg1->offset, local_type, buf, remote_type, reg1, reg2, obj2); @@ -255,7 +227,6 @@ PDCbuf_obj_map(void *buf, pdc_var_type_t local_type, pdcid_t local_reg, pdcid_t } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -270,13 +241,12 @@ PDCregion_get_info(pdcid_t reg_id) region = PDC_find_id(reg_id); if (region == NULL) - PGOTO_ERROR(NULL, "cannot locate region"); + PGOTO_ERROR(NULL, "Cannot locate region"); info = (struct pdc_region_info *)(region->obj_ptr); ret_value = info; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -293,13 +263,13 @@ PDCbuf_obj_unmap(pdcid_t remote_obj_id, pdcid_t remote_reg_id) info1 = PDC_find_id(remote_obj_id); if (info1 == NULL) - PGOTO_ERROR(FAIL, "cannot locate object ID"); + PGOTO_ERROR(FAIL, "Cannot locate object ID"); object1 = (struct _pdc_obj_info *)(info1->obj_ptr); data_type = object1->obj_pt->obj_prop_pub->type; info1 = PDC_find_id(remote_reg_id); if (info1 == NULL) - PGOTO_ERROR(FAIL, "cannot locate region ID"); + PGOTO_ERROR(FAIL, "Cannot locate region ID"); reginfo = (struct pdc_region_info *)(info1->obj_ptr); ret_value = @@ -311,7 +281,6 @@ PDCbuf_obj_unmap(pdcid_t remote_obj_id, pdcid_t remote_reg_id) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -329,7 +298,7 @@ PDCreg_obtain_lock(pdcid_t obj_id, pdcid_t reg_id, pdc_access_t access_type, pdc info1 = PDC_find_id(obj_id); if (info1 == NULL) - PGOTO_ERROR(FAIL, "cannot locate object ID"); + PGOTO_ERROR(FAIL, "Cannot locate object ID"); object_info = (struct _pdc_obj_info *)(info1->obj_ptr); // object_info = PDC_obj_get_info(obj_id); data_type = object_info->obj_pt->obj_prop_pub->type; @@ -356,7 +325,7 @@ PDCreg_release_lock(pdcid_t obj_id, pdcid_t reg_id, pdc_access_t access_type) info1 = PDC_find_id(obj_id); if (info1 == NULL) - PGOTO_ERROR(FAIL, "cannot locate object ID"); + PGOTO_ERROR(FAIL, "Cannot locate object ID"); object_info = (struct _pdc_obj_info *)(info1->obj_ptr); // object_info = PDC_obj_get_info(obj_id); data_type = object_info->obj_pt->obj_prop_pub->type; diff --git a/src/api/pdc_region/pdc_region_transfer.c b/src/api/pdc_region/pdc_region_transfer.c index 48eea2520..2a773a299 100644 --- a/src/api/pdc_region/pdc_region_transfer.c +++ b/src/api/pdc_region/pdc_region_transfer.c @@ -46,7 +46,6 @@ #include #define PDC_MERGE_TRANSFER_MIN_COUNT 50 -/* #define TANG_DEBUG 1 */ // pdc region transfer class. Contains essential information for performing non-blocking PDC client I/O // perations. @@ -208,21 +207,21 @@ PDCregion_transfer_create(void *buf, pdc_access_t access_type, pdcid_t obj_id, p int j; if (buf == NULL) - PGOTO_ERROR(FAIL, "client buffer was NULL"); + PGOTO_ERROR(FAIL, "Client buffer was NULL"); reginfo1 = PDC_find_id(local_reg); if (reginfo1 == NULL) - PGOTO_ERROR(FAIL, "cannot locate local region ID"); + PGOTO_ERROR(FAIL, "Cannot locate local region ID"); reg1 = (struct pdc_region_info *)(reginfo1->obj_ptr); reginfo2 = PDC_find_id(remote_reg); if (reginfo2 == NULL) - PGOTO_ERROR(FAIL, "cannot locate remote region ID"); + PGOTO_ERROR(FAIL, "Cannot locate remote region ID"); reg2 = (struct pdc_region_info *)(reginfo2->obj_ptr); objinfo2 = PDC_find_id(obj_id); if (objinfo2 == NULL) - PGOTO_ERROR(FAIL, "cannot locate remote object ID"); + PGOTO_ERROR(FAIL, "Cannot locate remote object ID"); obj2 = (struct _pdc_obj_info *)(objinfo2->obj_ptr); // remote_meta_id = obj2->obj_info_pub->meta_id; @@ -280,7 +279,6 @@ PDCregion_transfer_create(void *buf, pdc_access_t access_type, pdcid_t obj_id, p ret_value = PDC_id_register(PDC_TRANSFER_REQUEST, p); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -294,9 +292,9 @@ PDCregion_transfer_close(pdcid_t transfer_request_id) perr_t ret_value = SUCCEED; transferinfo = PDC_find_id(transfer_request_id); - if (transferinfo == NULL) { - goto done; - } + if (transferinfo == NULL) + PGOTO_DONE(ret_value); + transfer_request = (pdc_transfer_request *)(transferinfo->obj_ptr); if (transfer_request->local_region_offset) transfer_request->local_region_offset = (uint64_t *)PDC_free(transfer_request->local_region_offset); @@ -313,7 +311,6 @@ PDCregion_transfer_close(pdcid_t transfer_request_id) PDC_Client_transfer_pthread_cnt_add(-1); PDC_Client_transfer_pthread_terminate(); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -344,7 +341,7 @@ attach_local_transfer_request(struct _pdc_obj_info *p, pdcid_t transfer_request_ } p->local_transfer_request_end->local_id = transfer_request_id; p->local_transfer_request_size++; - fflush(stdout); + FUNC_LEAVE(ret_value); } @@ -382,7 +379,6 @@ remove_local_transfer_request(struct _pdc_obj_info *p, pdcid_t transfer_request_ temp = temp->next; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -514,7 +510,6 @@ static_region_partition(char *buf, int ndim, uint64_t unit, pdc_access_t access_ } } - fflush(stdout); FUNC_LEAVE(ret_value); } /* @@ -565,7 +560,6 @@ pack_region_buffer(char *buf, uint64_t *obj_dims, size_t total_data_size, int lo ret_value = FAIL; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -586,7 +580,7 @@ set_obj_server_bufs(pdc_transfer_request *transfer_request) transfer_request->read_bulk_buf = (char **)PDC_malloc(sizeof(char *) * transfer_request->n_obj_servers); } - fflush(stdout); + FUNC_LEAVE(ret_value); } @@ -633,7 +627,7 @@ pack_region_metadata_query(pdc_transfer_request_start_all_pkg **transfer_request } *total_buf_size_ptr = total_buf_size; - fflush(stdout); + FUNC_LEAVE(ret_value); } @@ -733,7 +727,6 @@ unpack_region_metadata_query(char *buf, pdc_transfer_request_start_all_pkg **tra *transfer_request_end_ptr = transfer_request_end; *size_ptr += size; - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -859,7 +852,6 @@ register_metadata(pdc_transfer_request_start_all_pkg **transfer_request_input, i transfer_requests = (pdc_transfer_request_start_all_pkg **)PDC_free(transfer_requests); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -900,7 +892,7 @@ prepare_start_all_requests(pdcid_t *transfer_request_id, int size, continue; transfer_request = (pdc_transfer_request *)(transferinfo->obj_ptr); if (transfer_request->metadata_id != NULL) { - LOG_ERROR("==PDC_CLIENT[%d]: cannot start transfer request\n", pdc_client_mpi_rank_g); + LOG_ERROR("Cannot start transfer request\n"); FUNC_LEAVE(FAIL); } if (transfer_request->consistency == PDC_CONSISTENCY_POSIX) { @@ -927,8 +919,7 @@ prepare_start_all_requests(pdcid_t *transfer_request_id, int size, &(transfer_request->sub_offsets), &(transfer_request->output_offsets), &(transfer_request->output_sizes), &(transfer_request->output_buf)); if (transfer_request->n_obj_servers == 0) { - LOG_ERROR("PDC_Client %d error with static region partition, no server is selected!\n", - pdc_client_mpi_rank_g); + LOG_ERROR("Error with static region partition, no server is selected"); FUNC_LEAVE(FAIL); } for (j = 0; j < transfer_request->n_obj_servers; ++j) { @@ -1184,7 +1175,7 @@ PDC_Client_pack_all_requests(int n_objs, pdc_transfer_request_start_all_pkg **tr } } *total_buf_size_ptr = total_buf_size; - fflush(stdout); + FUNC_LEAVE(ret_value); } @@ -1202,14 +1193,8 @@ PDC_Client_start_all_requests(pdc_transfer_request_start_all_pkg **transfer_requ size_t bulk_buf_size; int * bulk_buf_ref; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] enter\n", cur_time, pdc_client_mpi_rank_g); -#endif - if (size == 0) - goto done; + PGOTO_DONE(ret_value); metadata_id = (uint64_t *)PDC_malloc(sizeof(uint64_t) * size); read_bulk_buf = (char **)PDC_malloc(sizeof(char *) * size); @@ -1271,7 +1256,6 @@ PDC_Client_start_all_requests(pdc_transfer_request_start_all_pkg **transfer_requ metadata_id = (uint64_t *)PDC_free(metadata_id); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1297,12 +1281,12 @@ merge_transfer_request_ids(pdcid_t *transfer_request_id, int size, pdcid_t *merg for (i = 0; i < size; ++i) { transferinfo = PDC_find_id(transfer_request_id[i]); if (NULL == transferinfo) { - LOG_ERROR("==PDC_CLIENT[%d]: cannot find transfer request info\n", pdc_client_mpi_rank_g); + LOG_ERROR("Cannot find transfer request info\n"); FUNC_LEAVE(FAIL); } all_transfer_request[i] = (pdc_transfer_request *)(transferinfo->obj_ptr); if (NULL == all_transfer_request[i]) { - LOG_ERROR("==PDC_CLIENT[%d]: transfer request is NULL\n", pdc_client_mpi_rank_g); + LOG_ERROR("Transfer request is NULL\n"); FUNC_LEAVE(FAIL); } @@ -1394,12 +1378,6 @@ PDCregion_transfer_start_all_common(pdcid_t *transfer_request_id, int size, int pdc_transfer_request_start_all_pkg **write_transfer_requests = NULL, **read_transfer_requests = NULL; pdcid_t * posix_transfer_request_id, *merged_request_id; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s PDC_CLIENT[%d] enter\n", cur_time, pdc_client_mpi_rank_g); -#endif - // Merge the transfer_request_ids when they are operating on the same obj and have contiguous off, len if (size > PDC_MERGE_TRANSFER_MIN_COUNT) { merged_request_id = PDC_malloc(sizeof(pdcid_t)); @@ -1431,7 +1409,7 @@ PDCregion_transfer_start_all_common(pdcid_t *transfer_request_id, int size, int // For POSIX consistency, we block here until the data is received by the server if (posix_size > 0) { - LOG_ERROR("==PDC_CLIENT[%d]: wait for posix requests\n", pdc_client_mpi_rank_g); + LOG_ERROR("Wait for posix requests\n"); PDCregion_transfer_wait_all(posix_transfer_request_id, posix_size); posix_transfer_request_id = (pdcid_t *)PDC_free(posix_transfer_request_id); } @@ -1488,15 +1466,13 @@ PDCregion_transfer_start_common(pdcid_t transfer_request_id, transferinfo = PDC_find_id(transfer_request_id); if (NULL == transferinfo) - goto done; + PGOTO_DONE(ret_value); transfer_request = (pdc_transfer_request *)(transferinfo->obj_ptr); - if (transfer_request->metadata_id != NULL) { - LOG_ERROR("PDC_Client %s attempt to start existing transfer request\n"); - ret_value = FAIL; - goto done; - } + if (transfer_request->metadata_id != NULL) + PGOTO_ERROR(FAIL, "PDC_Client attempted to start existing transfer request"); + // Dynamic case is implemented within the the aggregated version. The main reason is that the target data // server may not be unique, so we may end up sending multiple requests to the same data server. // Aggregated method will take care of this type of operation. @@ -1507,7 +1483,7 @@ PDCregion_transfer_start_common(pdcid_t transfer_request_id, #else PDCregion_transfer_start_all(&transfer_request_id, 1); #endif - goto done; + PGOTO_DONE(ret_value); } PDC_Client_transfer_pthread_cnt_add(1); @@ -1533,8 +1509,7 @@ PDCregion_transfer_start_common(pdcid_t transfer_request_id, &(transfer_request->output_offsets), &(transfer_request->output_sizes), &(transfer_request->output_buf)); if (transfer_request->n_obj_servers == 0) { - LOG_ERROR("PDC_Client %d: error with static region partition, no server is selected!\n", - pdc_client_mpi_rank_g); + LOG_ERROR("Error with static region partition, no server is selected\n"); return FAIL; } // The following memories will be freed in the wait function. @@ -1580,7 +1555,6 @@ PDCregion_transfer_start_common(pdcid_t transfer_request_id, } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1649,7 +1623,6 @@ release_region_buffer(char *buf, uint64_t *obj_dims, int local_ndim, uint64_t *l if (read_bulk_buf) read_bulk_buf = (char **)PDC_free(read_bulk_buf); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1667,7 +1640,7 @@ PDCregion_transfer_status(pdcid_t transfer_request_id, pdc_transfer_status_t *co transferinfo = PDC_find_id(transfer_request_id); if (NULL == transferinfo) { *completed = PDC_TRANSFER_STATUS_COMPLETE; - goto done; + PGOTO_DONE(ret_value); } transfer_request = (pdc_transfer_request *)(transferinfo->obj_ptr); @@ -1680,9 +1653,8 @@ PDCregion_transfer_status(pdcid_t transfer_request_id, pdc_transfer_status_t *co for (i = 0; i < transfer_request->n_obj_servers; ++i) { ret_value = PDC_Client_transfer_request_status(transfer_request->metadata_id[i], transfer_request->obj_servers[i], completed); - if (*completed != PDC_TRANSFER_STATUS_COMPLETE) { - goto done; - } + if (*completed != PDC_TRANSFER_STATUS_COMPLETE) + PGOTO_DONE(ret_value); } // If we reach here, then all transfers are finished. for (i = 0; i < transfer_request->n_obj_servers; ++i) { @@ -1715,9 +1687,8 @@ PDCregion_transfer_status(pdcid_t transfer_request_id, pdc_transfer_status_t *co else if (transfer_request->region_partition == PDC_OBJ_STATIC) { ret_value = PDC_Client_transfer_request_status(transfer_request->metadata_id[0], transfer_request->data_server_id, completed); - if (*completed != PDC_TRANSFER_STATUS_COMPLETE) { - goto done; - } + if (*completed != PDC_TRANSFER_STATUS_COMPLETE) + PGOTO_DONE(ret_value); if (transfer_request->access_type == PDC_READ) { memcpy(transfer_request->new_buf, transfer_request->read_bulk_buf[0], transfer_request->total_data_size); @@ -1737,7 +1708,6 @@ PDCregion_transfer_status(pdcid_t transfer_request_id, pdc_transfer_status_t *co *completed = PDC_TRANSFER_STATUS_NOT_FOUND; } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1760,9 +1730,8 @@ PDCregion_transfer_wait_all(pdcid_t *transfer_request_id, int size) double t0, t1; - if (!size) { - goto done; - } + if (!size) + PGOTO_DONE(ret_value); transferinfo = (struct _pdc_id_info **)PDC_malloc(size * sizeof(struct _pdc_id_info *)); @@ -1791,9 +1760,9 @@ PDCregion_transfer_wait_all(pdcid_t *transfer_request_id, int size) if (1 == transfer_request->is_done) continue; if (!transfer_request->metadata_id) { - LOG_ERROR("PDCregion_transfer_wait_all [rank %d]: Attempt to wait for a transfer request " + LOG_ERROR("Attempt to wait for a transfer request " "that has not been started. %d/%d\n", - pdc_client_mpi_rank_g, i, size); + i, size); continue; } total_requests += transfer_request->n_obj_servers; @@ -1980,7 +1949,6 @@ PDCregion_transfer_wait_all(pdcid_t *transfer_request_id, int size) metadata_ids = (uint64_t *)PDC_free(metadata_ids); transferinfo = (struct _pdc_id_info **)PDC_free(transferinfo); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1997,7 +1965,7 @@ PDCregion_transfer_wait(pdcid_t transfer_request_id) transferinfo = PDC_find_id(transfer_request_id); if (NULL == transferinfo) - goto done; + PGOTO_DONE(ret_value); transfer_request = (pdc_transfer_request *)(transferinfo->obj_ptr); if (transfer_request->metadata_id != NULL) { @@ -2005,7 +1973,7 @@ PDCregion_transfer_wait(pdcid_t transfer_request_id) if (transfer_request->region_partition == PDC_REGION_DYNAMIC || transfer_request->region_partition == PDC_REGION_LOCAL) { PDCregion_transfer_wait_all(&transfer_request_id, 1); - goto done; + PGOTO_DONE(ret_value); } unit = transfer_request->unit; @@ -2068,6 +2036,5 @@ PDCregion_transfer_wait(pdcid_t transfer_request_id) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/api/pdc_transform/include/pdc_transforms_common.h b/src/api/pdc_transform/include/pdc_transforms_common.h index 1d936ade5..5cc1c4ca6 100644 --- a/src/api/pdc_transform/include/pdc_transforms_common.h +++ b/src/api/pdc_transform/include/pdc_transforms_common.h @@ -72,52 +72,42 @@ hg_proc_transform_ftn_in_t(hg_proc_t proc, void *data) transform_ftn_in_t *struct_data = (transform_ftn_in_t *)data; ret = hg_proc_hg_const_string_t(proc, &struct_data->ftn_name); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_hg_const_string_t(proc, &struct_data->loadpath); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->object_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->region_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->client_index); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->operation_type); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->start_state); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->next_state); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int8_t(proc, &struct_data->op_type); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int8_t(proc, &struct_data->when); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } @@ -134,22 +124,18 @@ hg_proc_transform_ftn_out_t(hg_proc_t proc, void *data) transform_ftn_out_t *struct_data = (transform_ftn_out_t *)data; ret = hg_proc_uint64_t(proc, &struct_data->object_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_uint64_t(proc, &struct_data->region_id); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->client_index); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } ret = hg_proc_int32_t(proc, &struct_data->ret); if (ret != HG_SUCCESS) { - // HG_LOG_ERROR("Proc error"); FUNC_LEAVE(ret); } diff --git a/src/api/pdc_transform/pdc_transform.c b/src/api/pdc_transform/pdc_transform.c index b6395427c..111893380 100644 --- a/src/api/pdc_transform/pdc_transform.c +++ b/src/api/pdc_transform/pdc_transform.c @@ -89,7 +89,7 @@ PDCobj_transform_register(char *func, pdcid_t obj_id, int current_state, int nex loadpath = PDC_get_realpath(transformslibrary, applicationDir); if (PDC_get_ftnPtr_(userdefinedftn, loadpath, &ftnHandle) < 0) - PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error!\n"); + PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error"); if ((ftnPtr = ftnHandle) == NULL) PGOTO_ERROR(FAIL, "Transforms function lookup failed"); @@ -109,13 +109,13 @@ PDCobj_transform_register(char *func, pdcid_t obj_id, int current_state, int nex // Add to our own list of transform functions if ((local_regIndex = PDC_add_transform_ptr_to_registry_(thisFtn)) < 0) - PGOTO_ERROR(FAIL, "PDC unable to register transform function!"); + PGOTO_ERROR(FAIL, "PDC unable to register transform function"); // Flag the transform as being active on mapping operations if (op_type == PDC_DATA_MAP) { objinfo1 = PDC_find_id(obj_id); if (objinfo1 == NULL) - PGOTO_ERROR(FAIL, "cannot locate local object ID"); + PGOTO_ERROR(FAIL, "Cannot locate local object ID"); obj1 = (struct _pdc_obj_info *)(objinfo1->obj_ptr); /* See if any mapping operations are defined */ if (obj1 && (obj1->region_list_head != NULL)) { @@ -154,7 +154,6 @@ PDCobj_transform_register(char *func, pdcid_t obj_id, int current_state, int nex } done: - fflush(stdout); if (applicationDir) applicationDir = (char *)PDC_free(applicationDir); if (userdefinedftn) @@ -203,10 +202,10 @@ PDCbuf_map_transform_register(char *func, void *buf, pdcid_t src_region_id, pdci loadpath = PDC_get_realpath(transformslibrary, applicationDir); if (PDC_get_ftnPtr_(userdefinedftn, loadpath, &ftnHandle) < 0) - PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error!"); + PGOTO_ERROR(FAIL, "PDC_get_ftnPtr_ returned an error"); if ((ftnPtr = ftnHandle) == NULL) - PGOTO_ERROR(FAIL, "Transforms function lookup failed\n"); + PGOTO_ERROR(FAIL, "Transforms function lookup failed"); if ((thisFtn = (struct _pdc_region_transform_ftn_info *)PDC_malloc( sizeof(struct _pdc_region_transform_ftn_info))) == NULL) @@ -256,14 +255,13 @@ PDCbuf_map_transform_register(char *func, void *buf, pdcid_t src_region_id, pdci // Add to our own list of transforms functions if ((local_regIndex = PDC_add_transform_ptr_to_registry_(thisFtn)) < 0) - PGOTO_ERROR(FAIL, "PDC unable to register transform function!"); + PGOTO_ERROR(FAIL, "PDC unable to register transform function"); PDC_Client_register_region_transform(userdefinedftn, loadpath, src_region_id, dest_region_id, dest_object_id, current_state, thisFtn->nextState, (int)PDC_DATA_MAP, (int)when, local_regIndex); done: - fflush(stdout); if (applicationDir) applicationDir = (char *)PDC_free(applicationDir); if (userdefinedftn) @@ -281,10 +279,9 @@ PDCbuf_io_transform_register(char *func ATTRIBUTE(unused), void *buf ATTRIBUTE(u { FUNC_ENTER(NULL); - perr_t ret_value = FAIL; /* Return value (not implemented) */ LOG_ERROR("IO transforms are not currently supported!\n"); - FUNC_LEAVE(ret_value); + FUNC_LEAVE(FAIL); } perr_t diff --git a/src/api/pdc_transform/pdc_transforms_common.c b/src/api/pdc_transform/pdc_transforms_common.c index cd5f5f0fd..c4bbbcc7c 100644 --- a/src/api/pdc_transform/pdc_transforms_common.c +++ b/src/api/pdc_transform/pdc_transforms_common.c @@ -86,7 +86,6 @@ HG_TEST_RPC_CB(transform_ftn, handle) } done: - fflush(stdout); HG_Respond(handle, NULL, NULL, &out); HG_Free_input(handle, &in); HG_Destroy(handle); diff --git a/src/commons/collections/pdc_deque.c b/src/commons/collections/pdc_deque.c index 6e2a5558e..7fe0afc79 100644 --- a/src/commons/collections/pdc_deque.c +++ b/src/commons/collections/pdc_deque.c @@ -27,7 +27,7 @@ resize_deque(PDC_deque_t *deque, size_t new_capacity) void **new_data = PDC_malloc(sizeof(void *) * new_capacity); if (new_data == NULL) { - LOG_ERROR("Failed to allocate memory for deque!\n"); + LOG_ERROR("Failed to allocate memory for deque\n"); exit(1); } diff --git a/src/commons/collections/pdc_stack.c b/src/commons/collections/pdc_stack.c index 21e81e79d..22df1d45e 100644 --- a/src/commons/collections/pdc_stack.c +++ b/src/commons/collections/pdc_stack.c @@ -29,7 +29,7 @@ stack_push(PDC_stack_t *stack, void *value) size_t new_capacity = stack->capacity * 2; void **new_data = PDC_realloc(stack->data, sizeof(void *) * new_capacity); if (new_data == NULL) { - LOG_ERROR("Failed to reallocate memory for stack!\n"); + LOG_ERROR("Failed to reallocate memory for stack\n"); exit(1); } stack->data = new_data; @@ -46,7 +46,7 @@ stack_pop(PDC_stack_t *stack) FUNC_ENTER(NULL); if (stack->size == 0) { - LOG_ERROR("Stack underflow!\n"); + LOG_ERROR("Stack underflow\n"); exit(1); } FUNC_LEAVE(stack->data[--stack->size]); diff --git a/src/commons/index/dart/dart_core_test.c b/src/commons/index/dart/dart_core_test.c index 864def3c5..05718237a 100644 --- a/src/commons/index/dart/dart_core_test.c +++ b/src/commons/index/dart/dart_core_test.c @@ -43,10 +43,10 @@ main(int argc, char *argv[]) __dart_space_init(&dart, num_server, alphabet_size, extra_tree_height, replication_factor, 1024); - println( - "num_server: %d, num_client: %d, alphabet_size: %d, extra_tree_height: %d, replication_factor: %d", + LOG_INFO( + "num_server: %d, num_client: %d, alphabet_size: %d, extra_tree_height: %d, replication_factor: %d\n", num_server, num_client, alphabet_size, extra_tree_height, replication_factor); - println("DART: num_vnode: %lu", dart.num_vnode); + LOG_INFO("DART: num_vnode: %lu\n", dart.num_vnode); index_hash_result_t *out; int array_len = DART_hash(&dart, query_str, OP_INSERT, NULL, &out); diff --git a/src/commons/index/dart/index/idioms/idioms_local_index.c b/src/commons/index/dart/index/idioms/idioms_local_index.c index 17194f6ac..89c4a82a2 100644 --- a/src/commons/index/dart/index/idioms/idioms_local_index.c +++ b/src/commons/index/dart/index/idioms/idioms_local_index.c @@ -543,7 +543,7 @@ collect_obj_ids(value_index_leaf_content_t *value_index_leaf, IDIOMS_md_idx_reco idx_record->num_obj_ids += num_obj_ids; } else { - LOG_ERROR("ERROR: offset %zu != num_obj_ids %d\n", offset, num_obj_ids); + LOG_ERROR("Error offset %zu != num_obj_ids %d\n", offset, num_obj_ids); } FUNC_LEAVE(0); @@ -649,7 +649,7 @@ value_number_query(char *secondary_query, key_index_leaf_content_t *leafcnt, // the string is not ended or started with '~', and if it contains '~', it is a in-between query. split_string(secondary_query, "~", &tokens, &num_tokens); if (num_tokens != 2) { - LOG_ERROR("ERROR: invalid range query: %s\n", secondary_query); + LOG_ERROR("Error invalid range query: %s\n", secondary_query); FUNC_LEAVE(-1); } char *lo_tok = tokens[0]; @@ -666,7 +666,6 @@ value_number_query(char *secondary_query, key_index_leaf_content_t *leafcnt, int num_visited_node = rbt_range_walk(leafcnt->primary_rbt, val1, klen1, val2, klen2, value_rbt_callback, idx_record, beginInclusive, endInclusive); - // println("[value_number_query] num_visited_node: %d\n", num_visited_node); } else { // exact query by default @@ -813,7 +812,7 @@ idioms_local_index_search(IDIOMS_t *idioms, IDIOMS_md_idx_record_t *idx_record) uint64_t result_count = 0; stopwatch_t index_timer; if (idioms == NULL) { - println("[Server_Side_Query_%d] idioms is NULL.", idioms->server_id_g); + LOG_INFO("[Server_Side_Query_%d] idioms is NULL\n", idioms->server_id_g); FUNC_LEAVE(result_count); } if (idx_record == NULL) { @@ -825,7 +824,7 @@ idioms_local_index_search(IDIOMS_t *idioms, IDIOMS_md_idx_record_t *idx_record) if (NULL == kdelim_ptr) { if (DART_SERVER_DEBUG) { - println("[Server_Side_Query_%d]query string '%s' is not valid.", idioms->server_id_g, query); + LOG_INFO("[Server_Side_Query_%d]query string '%s' is not valid\n", idioms->server_id_g, query); } FUNC_LEAVE(result_count); } @@ -834,8 +833,8 @@ idioms_local_index_search(IDIOMS_t *idioms, IDIOMS_md_idx_record_t *idx_record) char *v_query = get_value(query, KV_DELIM); if (DART_SERVER_DEBUG) { - println("[Server_Side_Query_%d] k_query = '%s' | v_query = '%s' ", idioms->server_id_g, k_query, - v_query); + LOG_INFO("[Server_Side_Query_%d] k_query = '%s' | v_query = '%s'\n", idioms->server_id_g, k_query, + v_query); } idx_record->key = k_query; diff --git a/src/commons/index/dart/index/idioms/idioms_local_index_test.c b/src/commons/index/dart/index/idioms/idioms_local_index_test.c index 1587893df..3fe7dd84f 100644 --- a/src/commons/index/dart/index/idioms/idioms_local_index_test.c +++ b/src/commons/index/dart/index/idioms/idioms_local_index_test.c @@ -525,21 +525,20 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) switch (query_series) { case 0: if (nres != 1) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d. Expect 1 result but got %d result\n", + LOG_ERROR("Failed to query kvtag [%s]. Expect 1 result but got %d result\n", "str109str=str109str", world_rank, nres); step_failed = 0; } if (pdc_ids[0] != 109) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. Expect 1 result which is 109, but got result " - "%" PRIu64 ".\n", - "str109str=str109str", world_rank, pdc_ids[0]); + LOG_ERROR("Failed to query kvtag [%s]. Expect 1 result which is 109, but got result " + "%" PRIu64 ".\n", + "str109str=str109str", world_rank, pdc_ids[0]); step_failed = 0; } break; case 1: if (nres != 10) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d. Expect 10 Result, but got %d result.\n", + LOG_ERROR("Failed to query kvtag [%s]. Expect 10 Result, but got %d result.\n", "str09*=str09*", world_rank, nres); step_failed = 1; } @@ -547,10 +546,9 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) qsort(pdc_ids, nres, sizeof(uint64_t), compare_uint64); for (i = 0; i < nres; i++) { if (pdc_ids[i] != i + 90) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. The %d th result does not match. Expect " - "%d, but got %" PRIu64 "\n", - "str09*=str09*", world_rank, i, i + 90, pdc_ids[i]); + LOG_ERROR("Failed to query kvtag [%s]. The %d th result does not match. Expect " + "%d, but got %" PRIu64 "\n", + "str09*=str09*", world_rank, i, i + 90, pdc_ids[i]); step_failed = 1; break; } @@ -558,7 +556,7 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) break; case 2: if (nres != 10) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d. Expect 10 result, but got %d result.\n", + LOG_ERROR("Failed to query kvtag [%s]. Expect 10 result, but got %d result.\n", "*09str=*09str", world_rank, nres); step_failed = 2; } @@ -566,10 +564,9 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) qsort(pdc_ids, nres, sizeof(uint64_t), compare_uint64); for (i = 0; i < nres; i++) { if (pdc_ids[i] != i * 10 + 9) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. The $d th result does not match. Expect " - "%d, but got %" PRIu64 "\n", - "*09str=*09str", world_rank, i, i * 10 + 9, pdc_ids[i]); + LOG_ERROR("Failed to query kvtag [%s]. The $d th result does not match. Expect " + "%d, but got %" PRIu64 "\n", + "*09str=*09str", world_rank, i, i * 10 + 9, pdc_ids[i]); step_failed = 2; break; } @@ -577,9 +574,8 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) break; case 3: if (nres != 20) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. Expected 20 results, but got %d results\n", - "*09*=*09*", world_rank, nres); + LOG_ERROR("Failed to query kvtag [%s]. Expected 20 results, but got %d results\n", + "*09*=*09*", world_rank, nres); step_failed = 3; } // the result is not in order, so we need to sort the result first @@ -588,10 +584,9 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) 99, 109, 209, 309, 409, 509, 609, 709, 809, 909}; for (i = 0; i < nres; i++) { if (pdc_ids[i] != expected[i]) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. The %d th result does not match. Expect " - "%" PRIu64 ", but got %" PRIu64 " results.\n", - "*09*=*09*", world_rank, i, expected[i], pdc_ids[i]); + LOG_ERROR("Failed to query kvtag [%s]. The %d th result does not match. Expect " + "%" PRIu64 ", but got %" PRIu64 " results.\n", + "*09*=*09*", world_rank, i, expected[i], pdc_ids[i]); step_failed = 3; break; } @@ -599,12 +594,12 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) break; case 4: if (nres != 1) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d. Expected 1 result, but got %d results\n", - "intkey=109", world_rank, nres); + LOG_ERROR("Failed to query kvtag [%s]. Expected 1 result, but got %d results\n", "intkey=109", + world_rank, nres); step_failed = 4; } if (pdc_ids[0] != 109) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d. Expected 1 result which is 109, but got " + LOG_ERROR("Failed to query kvtag [%s]. Expected 1 result which is 109, but got " "%" PRIu64 "\n", "intkey=109", world_rank, pdc_ids[0]); step_failed = 4; @@ -612,19 +607,17 @@ validate_query_result(int world_rank, int nres, uint64_t *pdc_ids) break; case 5: if (nres != 10) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. Expected 10 results, but got %d results. \n", - "intkey=90|~|99", world_rank, nres); + LOG_ERROR("Failed to query kvtag [%s]. Expected 10 results, but got %d results. \n", + "intkey=90|~|99", world_rank, nres); step_failed = 5; } // the result is not in order, so we need to sort the result first qsort(pdc_ids, nres, sizeof(uint64_t), compare_uint64); for (i = 0; i < nres; i++) { if (pdc_ids[i] != i + 90) { - LOG_ERROR( - "Failed to query kvtag [%s] with rank %d. The %d th result does not match, expect " - "%d but got %" PRIu64 "\n", - "intkey=90|~|99", world_rank, i, i + 90, pdc_ids[i]); + LOG_ERROR("Failed to query kvtag [%s]. The %d th result does not match, expect " + "%d but got %" PRIu64 "\n", + "intkey=90|~|99", world_rank, i, i + 90, pdc_ids[i]); step_failed = 5; break; } diff --git a/src/commons/index/dart/index/idioms/idioms_persistence.c b/src/commons/index/dart/index/idioms/idioms_persistence.c index 23cf9173a..a45cf0e07 100644 --- a/src/commons/index/dart/index/idioms/idioms_persistence.c +++ b/src/commons/index/dart/index/idioms/idioms_persistence.c @@ -270,8 +270,8 @@ idioms_metadata_index_dump(IDIOMS_t *idioms, char *dir_path, uint32_t serverID) dump_attr_root_tree(idioms->art_key_suffix_tree_g, dir_path, "idioms_suffix", serverID); timer_pause(&timer); - println("[IDIOMS_Index_Dump_%d] Timer to dump index = %.4f microseconds\n", serverID, - timer_delta_us(&timer)); + LOG_INFO("[IDIOMS_Index_Dump_%d] Timer to dump index = %.4f microseconds\n", serverID, + timer_delta_us(&timer)); FUNC_LEAVE(ret_value); } @@ -546,8 +546,8 @@ idioms_metadata_index_recover(IDIOMS_t *idioms, char *dir_path, int num_server, } } timer_pause(&timer); - println("[IDIOMS_Index_Recover_%d] Timer to recover index = %.4f microseconds\n", serverID, - timer_delta_us(&timer)); + LOG_JUST_PRINT("[IDIOMS_Index_Recover_%d] Timer to recover index = %.4f microseconds\n", serverID, + timer_delta_us(&timer)); FUNC_LEAVE(ret_value); } diff --git a/src/commons/logging/include/pdc_logger.h b/src/commons/logging/include/pdc_logger.h index 8d7ac720b..161945e85 100644 --- a/src/commons/logging/include/pdc_logger.h +++ b/src/commons/logging/include/pdc_logger.h @@ -18,25 +18,37 @@ static char logFilenames[4][MAX_LOG_FILE_NAME_LENGTH]; static PDC_LogLevel logLevel = LOG_LEVEL_INFO; void setLogFile(PDC_LogLevel level, const char *fileName); - void setLogLevel(PDC_LogLevel level); /** * just_print is equivalent to calling printf("%s", args) meaning no extra information * such as the file and line number will be printed */ -void log_message(bool just_print, PDC_LogLevel level, const char *file, const char *func, int line_number, - const char *format, ...); +void log_message(bool is_server, bool just_print, PDC_LogLevel level, const char *file, const char *func, + int line_number, const char *format, ...); +#ifdef IS_PDC_SERVER +#define LOG_ERROR(format, ...) \ + log_message(true, false, LOG_LEVEL_ERROR, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) +#define LOG_WARNING(format, ...) \ + log_message(true, false, LOG_LEVEL_WARNING, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) +#define LOG_INFO(format, ...) \ + log_message(true, false, LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) +#define LOG_DEBUG(format, ...) \ + log_message(true, false, LOG_LEVEL_DEBUG, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) +#define LOG_JUST_PRINT(format, ...) \ + log_message(true, true, LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) +#else #define LOG_ERROR(format, ...) \ - log_message(false, LOG_LEVEL_ERROR, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) + log_message(false, false, LOG_LEVEL_ERROR, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) #define LOG_WARNING(format, ...) \ - log_message(false, LOG_LEVEL_WARNING, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) + log_message(false, false, LOG_LEVEL_WARNING, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) #define LOG_INFO(format, ...) \ - log_message(false, LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) + log_message(false, false, LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) #define LOG_DEBUG(format, ...) \ - log_message(false, LOG_LEVEL_DEBUG, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) + log_message(false, false, LOG_LEVEL_DEBUG, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) #define LOG_JUST_PRINT(format, ...) \ - log_message(true, LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) + log_message(false, true, LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__) +#endif #endif // PDC_LOGGER_H \ No newline at end of file diff --git a/src/commons/logging/pdc_logger.c b/src/commons/logging/pdc_logger.c index bb6fac353..ce3b3d05e 100644 --- a/src/commons/logging/pdc_logger.c +++ b/src/commons/logging/pdc_logger.c @@ -87,9 +87,9 @@ get_cur_log_file(PDC_LogLevel level) FUNC_LEAVE(logFiles[level] ? logFiles[level] : stdout); } -void -_log_message(PDC_LogLevel level, const char *file, const char *func, int line_number, const char *format, - va_list args, bool just_print) +static void +_log_message(bool is_server, PDC_LogLevel level, const char *file, const char *func, int line_number, + const char *format, va_list args, bool just_print) { FUNC_ENTER(NULL); @@ -115,36 +115,64 @@ _log_message(PDC_LogLevel level, const char *file, const char *func, int line_nu break; } - // Extract only the filename (stem) from the full path + // Extract only the filename from the full path const char *filename = strrchr(file, '/'); - if (filename) { - filename++; - } - else { - filename = file; - } + filename = filename ? filename + 1 : file; - // Properly format timestamp + // Format timestamp struct timeval tv; gettimeofday(&tv, NULL); struct tm timeinfo; localtime_r(&tv.tv_sec, &timeinfo); char timestr[30]; - strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", &timeinfo); - - const char *log_format = "[%s.%06ld] [%s] [%s:%s:%d] %s"; + strftime(timestr, sizeof(timestr), "%H:%M:%S", &timeinfo); char message[MAX_LOG_MSG_LENGTH + 1]; vsnprintf(message, MAX_LOG_MSG_LENGTH, format, args); - fprintf(logFile, log_format, timestr, tv.tv_usec, prefix, filename, func, line_number, message); +#ifdef ENABLE_MPI + static int my_rank = -1; + if (my_rank == -1) + my_rank = PDC_get_rank(); +#endif + + // Print differently based on log level + if (level == LOG_LEVEL_ERROR || level == LOG_LEVEL_DEBUG) { +#ifdef ENABLE_MPI + if (is_server) + fprintf(logFile, "[%s.%06ld] [%s] [%s:%d] PDC_SERVER[%d]: %s", timestr, tv.tv_usec, prefix, + filename, line_number, my_rank, message); + else + fprintf(logFile, "[%s.%06ld] [%s] [%s:%d] PDC_CLIENT[%d]: %s", timestr, tv.tv_usec, prefix, + filename, line_number, my_rank, message); +#else + if (is_server) + fprintf(logFile, "[%s.%06ld] [%s] [%s:%d] PDC_SERVER: %s", timestr, tv.tv_usec, prefix, + filename, line_number, message); + else + fprintf(logFile, "[%s.%06ld] [%s] [%s:%d] PC_CLIENT: %s", timestr, tv.tv_usec, prefix, + filename, line_number, message); +#endif + } + else { +#ifdef ENABLE_MPI + if (is_server) + fprintf(logFile, "[%s] PDC_SERVER[%d]: %s", prefix, my_rank, message); + else + fprintf(logFile, "[%s] PDC_CLIENT[%d]: %s", prefix, my_rank, message); +#else + if (is_server) + fprintf(logFile, "[%s] PDC_SERVER: %s", prefix, message); + else + fprintf(logFile, "[%s] PC_CLIENT: %s", prefix, message); +#endif + } } else { const char *log_format = "%s"; char message[MAX_LOG_MSG_LENGTH + 1]; vsnprintf(message, MAX_LOG_MSG_LENGTH, format, args); - fprintf(logFile, log_format, message); } @@ -154,14 +182,14 @@ _log_message(PDC_LogLevel level, const char *file, const char *func, int line_nu } void -log_message(bool just_print, PDC_LogLevel level, const char *file, const char *func, int line_number, - const char *format, ...) +log_message(bool is_server, bool just_print, PDC_LogLevel level, const char *file, const char *func, + int line_number, const char *format, ...) { FUNC_ENTER(NULL); va_list args; va_start(args, format); - _log_message(level, file, func, line_number, format, args, just_print); + _log_message(is_server, level, file, func, line_number, format, args, just_print); va_end(args); FUNC_LEAVE_VOID(); diff --git a/src/commons/utils/include/string_utils.h b/src/commons/utils/include/string_utils.h index ce264d449..6072220b2 100644 --- a/src/commons/utils/include/string_utils.h +++ b/src/commons/utils/include/string_utils.h @@ -124,23 +124,6 @@ int equals(const char *str, const char *tok); */ char *dsprintf(const char *format, ...); -/** - * Print anything on stdout. - * Always put a line feed after the string you want to print. - * - * @param format - * @param ... - */ -void println(const char *format, ...); - -/** - * Print anything on stderr. - * Always put a line feed after the string you want to print. - * - * @param format - * @param ... - */ -void stderr_println(const char *format, ...); /** * Only support expressions like: * diff --git a/src/commons/utils/query_utils.c b/src/commons/utils/query_utils.c index 0b5e7f4ea..18a04a6e5 100644 --- a/src/commons/utils/query_utils.c +++ b/src/commons/utils/query_utils.c @@ -47,7 +47,7 @@ _gen_affix_for_token(char *token_str, int affix_type, size_t affix_len, char **o affix_str[affix_len + 2] = '\0'; } else { - LOG_ERROR("Invalid affix type %d!\n", affix_type); + LOG_ERROR("Invalid affix type %d\n", affix_type); FUNC_LEAVE(0); } @@ -84,7 +84,7 @@ gen_query_key_value(query_gen_input_t *input, query_gen_output_t *output) // "hello" key_ptr_len = _gen_affix_for_token(input->base_tag->name, input->key_query_type, affix_len, &key_ptr); if (key_ptr_len == 0) { - LOG_ERROR("Failed to generate key query!\n"); + LOG_ERROR("Failed to generate key query\n"); FUNC_LEAVE_VOID(); } @@ -100,7 +100,7 @@ gen_query_key_value(query_gen_input_t *input, query_gen_output_t *output) value_ptr[value_ptr_len + 2] = '\0'; if (value_ptr_len == 0) { - LOG_ERROR("Failed to generate value query!\n"); + LOG_ERROR("Failed to generate value query\n"); FUNC_LEAVE_VOID(); } } @@ -115,7 +115,7 @@ gen_query_key_value(query_gen_input_t *input, query_gen_output_t *output) input->base_tag->type = PDC_DOUBLE; } else { - LOG_ERROR("Invalid tag type!\n"); + LOG_ERROR("Invalid tag type\n"); FUNC_LEAVE_VOID(); } char *format_str = get_format_by_dtype(input->base_tag->type); @@ -134,7 +134,7 @@ gen_query_key_value(query_gen_input_t *input, query_gen_output_t *output) snprintf(value_ptr, value_ptr_len + 1, fmt_str, input->range_lo, input->range_hi); } else { - LOG_ERROR("Invalid value query type for integer!\n"); + LOG_ERROR("Invalid value query type for integer\n"); FUNC_LEAVE_VOID(); } } @@ -270,7 +270,6 @@ gen_tags_in_loop() for (i = 0; i < my_count; i++) { int tag_num = i % 20; char *ret = gen_tags(tag_num); - println("helloworld, %s", ret); if (ret != NULL) { ret = (char *)PDC_free(ret); } @@ -436,12 +435,6 @@ parse_and_run_number_value_query(char *num_val_query, pdc_c_var_type_t num_type, size_t klen1 = get_number_from_string(num_str, num_type, &val1); action_collection->exact_action(val1, NULL, NULL, 1, 1, num_type, cb_input, cb_out, cb_out_len); - - // value_index_leaf_content_t *value_index_leaf = NULL; - // rbt_find(leafcnt->primary_rbt, val1, klen1, (void **)&value_index_leaf); - // if (value_index_leaf != NULL) { - // collect_obj_ids(value_index_leaf, idx_record); - // } } else if (startsWith(num_val_query, "~")) { // LESS THAN int endInclusive = num_val_query[1] == '|'; @@ -451,8 +444,6 @@ parse_and_run_number_value_query(char *num_val_query, pdc_c_var_type_t num_type, size_t klen1 = get_number_from_string(numstr, num_type, &val1); action_collection->lt_action(NULL, NULL, val1, 0, endInclusive, num_type, cb_input, cb_out, cb_out_len); - - // rbt_range_lt(leafcnt->primary_rbt, val1, klen1, value_rbt_callback, idx_record, endInclusive); } else if (endsWith(num_val_query, "~")) { // GEATER THAN int beginInclusive = num_val_query[strlen(num_val_query) - 2] == '|'; @@ -463,7 +454,6 @@ parse_and_run_number_value_query(char *num_val_query, pdc_c_var_type_t num_type, action_collection->gt_action(NULL, val1, NULL, beginInclusive, 0, num_type, cb_input, cb_out, cb_out_len); - // rbt_range_gt(leafcnt->primary_rbt, val1, klen1, value_rbt_callback, idx_record, beginInclusive); } else if (contains(num_val_query, "~")) { // BETWEEN int num_tokens = 0; @@ -471,7 +461,7 @@ parse_and_run_number_value_query(char *num_val_query, pdc_c_var_type_t num_type, // the string is not ended or started with '~', and if it contains '~', it is a in-between query. split_string(num_val_query, "~", &tokens, &num_tokens); if (num_tokens != 2) { - LOG_ERROR("ERROR: invalid range query: %s\n", num_val_query); + LOG_ERROR("Error invalid range query: %s\n", num_val_query); return -1; } char *lo_tok = tokens[0]; @@ -486,10 +476,6 @@ parse_and_run_number_value_query(char *num_val_query, pdc_c_var_type_t num_type, action_collection->between_action(NULL, val1, val2, beginInclusive, endInclusive, num_type, cb_input, cb_out, cb_out_len); - // int num_visited_node = rbt_range_walk(leafcnt->primary_rbt, val1, klen1, val2, klen2, - // value_rbt_callback, idx_record, beginInclusive, - // endInclusive); - // println("[value_number_query] num_visited_node: %d\n", num_visited_node); } else { // exact query by default diff --git a/src/commons/utils/query_utils_test.c b/src/commons/utils/query_utils_test.c index 1e29e5ecb..5b7a6ba5d 100644 --- a/src/commons/utils/query_utils_test.c +++ b/src/commons/utils/query_utils_test.c @@ -1,4 +1,5 @@ #include "query_utils.h" +#include "pdc_logger.h" #include "pdc_timing.h" #include "pdc_malloc.h" @@ -7,10 +8,11 @@ print_query_output(query_gen_output_t *output) { FUNC_ENTER(NULL); - println("key query: %s, len: %lu", output->key_query, output->key_query_len); - println("value query: %s, len: %lu", output->value_query, output->value_query_len); + LOG_JUST_PRINT("key query: %s, len: %lu\n", output->key_query, output->key_query_len); + LOG_JUST_PRINT("value query: %s, len: %lu\n", output->value_query, output->value_query_len); + char *final_query_str = gen_query_str(output); - println("final query: %s, len: %lu", final_query_str, strlen(final_query_str)); + LOG_JUST_PRINT("final query: %s, len: %lu", final_query_str, strlen(final_query_str)); final_query_str = (char *)PDC_free(final_query_str); FUNC_LEAVE_VOID(); diff --git a/src/commons/utils/string_utils.c b/src/commons/utils/string_utils.c index 21b1eddfd..633a5a8c1 100644 --- a/src/commons/utils/string_utils.c +++ b/src/commons/utils/string_utils.c @@ -201,44 +201,6 @@ dsprintf(const char *format, ...) FUNC_LEAVE(ret); } -void -println(const char *format, ...) -{ - FUNC_ENTER(NULL); - - // 1. declare argument list - va_list args; - // 2. starting argument list - va_start(args, format); - // 3. get arguments value - vfprintf(stdout, format, args); - // 4. ending argument list - va_end(args); - fputc('\n', stdout); - fflush(stdout); - - FUNC_LEAVE_VOID(); -} - -void -stderr_println(const char *format, ...) -{ - FUNC_ENTER(NULL); - - // 1. declare argument list - va_list args; - // 2. starting argument list - va_start(args, format); - // 3. get arguments value - vfprintf(stderr, format, args); - // 4. ending argument list - va_end(args); - fputc('\n', stderr); - fflush(stderr); - - FUNC_LEAVE_VOID(); -} - char * reverse_str(char *str) { diff --git a/src/server/pdc_client_server_common.c b/src/server/pdc_client_server_common.c index c56cf2a61..b75c8f567 100644 --- a/src/server/pdc_client_server_common.c +++ b/src/server/pdc_client_server_common.c @@ -166,7 +166,6 @@ hg_proc_send_shm_in_t(hg_proc_t proc, void *data) PGOTO_ERROR(ret_value, "Proc error"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -238,48 +237,37 @@ PDC_get_var_type_size(pdc_var_type_t dtype) */ switch (dtype) { case PDC_INT: - ret_value = sizeof(int); - goto done; + PGOTO_DONE(sizeof(int)); break; case PDC_FLOAT: - ret_value = sizeof(float); - goto done; + PGOTO_DONE(sizeof(float)); break; case PDC_DOUBLE: - ret_value = sizeof(double); - goto done; + PGOTO_DONE(sizeof(double)); break; case PDC_CHAR: - ret_value = sizeof(char); - goto done; + PGOTO_DONE(sizeof(char)); break; case PDC_INT16: - ret_value = sizeof(int16_t); - goto done; + PGOTO_DONE(sizeof(int16_t)); break; case PDC_INT8: - ret_value = sizeof(int8_t); - goto done; + PGOTO_DONE(sizeof(int8_t)); break; case PDC_UINT8: - ret_value = sizeof(uint8_t); - goto done; + PGOTO_DONE(sizeof(uint8_t)); break; case PDC_UINT16: - ret_value = sizeof(uint16_t); - goto done; + PGOTO_DONE(sizeof(uint16_t)); break; case PDC_INT64: - ret_value = sizeof(int64_t); - goto done; + PGOTO_DONE(sizeof(int64_t)); break; case PDC_UINT64: - ret_value = sizeof(uint64_t); - goto done; + PGOTO_DONE(sizeof(uint64_t)); break; case PDC_UINT: - ret_value = sizeof(uint); - goto done; + PGOTO_DONE(sizeof(uint)); break; case PDC_UNKNOWN: default: @@ -290,7 +278,6 @@ PDC_get_var_type_size(pdc_var_type_t dtype) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -418,7 +405,7 @@ PDC_print_metadata(pdc_metadata_t *a) region_list_t *elt; if (a == NULL) - PGOTO_ERROR_VOID("==Empty metadata structure"); + PGOTO_ERROR_VOID("Empty metadata structure"); LOG_JUST_PRINT("================================\n"); LOG_JUST_PRINT(" data_type = [%d]\n", a->data_type); @@ -434,14 +421,12 @@ PDC_print_metadata(pdc_metadata_t *a) LOG_JUST_PRINT(" dims = %" PRIu64 "", a->dims[0]); for (i = 1; i < a->ndim; i++) LOG_JUST_PRINT(", %" PRIu64 "", a->dims[i]); - // print regiono info + DL_FOREACH(a->storage_region_list_head, elt) PDC_print_region_list(elt); LOG_JUST_PRINT("\n================================\n\n"); - fflush(stdout); done: - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -453,7 +438,7 @@ PDC_metadata_init(pdc_metadata_t *a) perr_t ret_value = SUCCEED; if (a == NULL) - PGOTO_ERROR(FAIL, "Unable to init NULL pdc_metadata_t\n"); + PGOTO_ERROR(FAIL, "Unable to init NULL pdc_metadata_t"); memset(a, 0, sizeof(pdc_metadata_t)); @@ -482,7 +467,6 @@ PDC_metadata_init(pdc_metadata_t *a) a->bloom = NULL; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -514,7 +498,7 @@ PDC_is_same_region_shape(region_list_t *a, size_t extent_a, region_list_t *b, si size_t i = 0; if (NULL == a || NULL == b) - PGOTO_ERROR(-1, "==Empty region_list_t structure"); + PGOTO_ERROR(-1, "Empty region_list_t structure"); if (a->ndim != b->ndim) PGOTO_DONE(-1); @@ -527,7 +511,6 @@ PDC_is_same_region_shape(region_list_t *a, size_t extent_a, region_list_t *b, si } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -542,7 +525,7 @@ PDC_is_same_region_list(region_list_t *a, region_list_t *b) size_t i = 0; if (NULL == a || NULL == b) - PGOTO_ERROR(FAIL, "==Empty region_list_t structure"); + PGOTO_ERROR(FAIL, "Empty region_list_t structure"); if (a->ndim != b->ndim) PGOTO_DONE(-1); @@ -555,7 +538,6 @@ PDC_is_same_region_list(region_list_t *a, region_list_t *b) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -567,11 +549,11 @@ PDC_print_storage_region_list(region_list_t *a) size_t i; if (a == NULL) { - PGOTO_ERROR_VOID("==Empty region_list_t structure"); + PGOTO_ERROR_VOID("Empty region_list_t structure"); } if (a->ndim > 4) { - PGOTO_ERROR_VOID("==Error with ndim %lu", a->ndim); + PGOTO_ERROR_VOID("Error with ndim %lu", a->ndim); } LOG_JUST_PRINT("================================\n"); @@ -588,10 +570,8 @@ PDC_print_storage_region_list(region_list_t *a) LOG_JUST_PRINT(" offset: %" PRIu64 "\n", a->offset); LOG_JUST_PRINT("================================\n\n"); - fflush(stdout); done: - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -603,12 +583,12 @@ PDC_print_region_list(region_list_t *a) size_t i; if (a == NULL) - PGOTO_ERROR_VOID("==Empty region_list_t structure"); + PGOTO_ERROR_VOID("Empty region_list_t structure"); LOG_JUST_PRINT("\n == Region Info ==\n"); LOG_JUST_PRINT(" ndim = %lu\n", a->ndim); if (a->ndim > 4) - PGOTO_ERROR_VOID("Error with dim %lu\n", a->ndim); + PGOTO_ERROR_VOID("Error with dim %lu", a->ndim); for (i = 0; i < a->ndim; i++) { LOG_JUST_PRINT(" %5" PRIu64 " %5" PRIu64 "\n", a->start[i], a->count[i]); } @@ -625,7 +605,6 @@ PDC_print_region_list(region_list_t *a) LOG_JUST_PRINT("\n =================\n"); done: - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -655,10 +634,10 @@ PDC_region_list_t_deep_cp(region_list_t *from, region_list_t *to) perr_t ret_value = SUCCEED; if (NULL == from || NULL == to) - PGOTO_ERROR(FAIL, "PDC_region_list_t_deep_cp(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); if (from->ndim > 4 || from->ndim <= 0) - PGOTO_ERROR(FAIL, "PDC_region_list_t_deep_cp(): ndim %zu ERROR!", from->ndim); + PGOTO_ERROR(FAIL, "ndim %zu error", from->ndim); memcpy(to, from, sizeof(region_list_t)); @@ -672,7 +651,6 @@ PDC_region_list_t_deep_cp(region_list_t *from, region_list_t *to) to->next = NULL; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -694,7 +672,7 @@ PDC_region_transfer_t_to_list_t(region_info_transfer_t *transfer, region_list_t perr_t ret_value = SUCCEED; if (NULL == region || NULL == transfer) - PGOTO_ERROR(FAIL, "PDC_region_transfer_t_to_list_t(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); region->ndim = transfer->ndim; @@ -702,7 +680,6 @@ PDC_region_transfer_t_to_list_t(region_info_transfer_t *transfer, region_list_t PDC_copy_region_desc(transfer->count, region->count, region->ndim, region->ndim); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -715,11 +692,11 @@ PDC_region_info_to_list_t(struct pdc_region_info *region, region_list_t *list) size_t i; if (NULL == region || NULL == list) - PGOTO_ERROR(FAIL, "PDC_region_info_to_list_t(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); size_t ndim = region->ndim; if (ndim <= 0 || ndim >= 5) - PGOTO_ERROR(FAIL, "PDC_region_info_to_list_t() unsupported dim: %lu", ndim); + PGOTO_ERROR(FAIL, "Unsupported dim: %lu", ndim); list->ndim = ndim; for (i = 0; i < ndim; i++) { @@ -728,7 +705,6 @@ PDC_region_info_to_list_t(struct pdc_region_info *region, region_list_t *list) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -741,10 +717,10 @@ PDC_region_info_t_to_transfer(struct pdc_region_info *region, region_info_transf size_t ndim = region->ndim; if (NULL == region || NULL == transfer) - PGOTO_ERROR(FAIL, "PDC_region_info_t_to_transfer(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); if (ndim <= 0 || ndim >= 5) - PGOTO_ERROR(FAIL, "PDC_region_info_t_to_transfer() unsupported dim: %lu", ndim); + PGOTO_ERROR(FAIL, "Unsupported dim: %lu", ndim); transfer->ndim = ndim; @@ -752,7 +728,6 @@ PDC_region_info_t_to_transfer(struct pdc_region_info *region, region_info_transf PDC_copy_region_desc(region->size, transfer->count, transfer->ndim, transfer->ndim); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -765,18 +740,17 @@ PDC_region_info_t_to_transfer_unit(struct pdc_region_info *region, region_info_t perr_t ret_value = SUCCEED; if (NULL == region || NULL == transfer) - PGOTO_ERROR(FAIL, "PDC_region_info_t_to_transfer_unit(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); size_t ndim = region->ndim; if (ndim <= 0 || ndim >= 5) - PGOTO_ERROR(FAIL, "PDC_region_info_t_to_transfer() unsupported dim: %lu", ndim); + PGOTO_ERROR(FAIL, "Unsupported dim: %lu", ndim); transfer->ndim = ndim; PDC_copy_region_desc_elements_to_bytes(region->offset, transfer->start, unit, ndim); PDC_copy_region_desc_elements_to_bytes(region->size, transfer->count, unit, ndim); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -790,7 +764,7 @@ PDC_region_transfer_t_to_region_info(region_info_transfer_t *transfer) struct pdc_region_info *region; if (NULL == transfer) - PGOTO_ERROR(NULL, "PDC_region_transfer_t_to_region_info(): NULL input!"); + PGOTO_ERROR(NULL, "NULL input"); region = (struct pdc_region_info *)PDC_calloc(1, sizeof(struct pdc_region_info)); ndim = region->ndim = transfer->ndim; @@ -803,7 +777,6 @@ PDC_region_transfer_t_to_region_info(region_info_transfer_t *transfer) ret_value = region; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -815,14 +788,13 @@ PDC_region_list_t_to_transfer(region_list_t *region, region_info_transfer_t *tra perr_t ret_value = SUCCEED; if (NULL == region || NULL == transfer) - PGOTO_ERROR(FAIL, "PDC_region_list_t_to_transfer(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); transfer->ndim = region->ndim; PDC_copy_region_desc(region->start, transfer->start, transfer->ndim, transfer->ndim); PDC_copy_region_desc(region->count, transfer->count, transfer->ndim, transfer->ndim); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -835,7 +807,7 @@ PDC_metadata_t_to_transfer_t(pdc_metadata_t *meta, pdc_metadata_transfer_t *tran perr_t ret_value = SUCCEED; if (NULL == meta || NULL == transfer) - PGOTO_ERROR(FAIL, "PDC_metadata_t_to_transfer_t(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); transfer->user_id = meta->user_id; transfer->app_name = meta->app_name; @@ -865,7 +837,6 @@ PDC_metadata_t_to_transfer_t(pdc_metadata_t *meta, pdc_metadata_transfer_t *tran transfer->t_meta_index = meta->current_state.meta_index; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -877,7 +848,7 @@ PDC_transfer_t_to_metadata_t(pdc_metadata_transfer_t *transfer, pdc_metadata_t * perr_t ret_value = SUCCEED; if (NULL == meta || NULL == transfer) - PGOTO_ERROR(FAIL, "PDC_transfer_t_to_metadata_t(): NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); meta->user_id = transfer->user_id; meta->data_type = transfer->data_type; @@ -913,7 +884,6 @@ PDC_transfer_t_to_metadata_t(pdc_metadata_transfer_t *transfer, pdc_metadata_t * } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1504,14 +1474,13 @@ HG_TEST_RPC_CB(gen_cont_id, handle) // Insert to hash table ret_value = PDC_Server_create_container(&in, &out); if (ret_value != SUCCEED) - PGOTO_ERROR(ret_value, "==PDC_SERVER: error with container object creation"); + PGOTO_ERROR(ret_value, "Error with container object creation"); HG_Respond(handle, NULL, NULL, &out); HG_Free_input(handle, &in); HG_Destroy(handle); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1681,7 +1650,7 @@ HG_TEST_RPC_CB(obj_reset_dims, handle) if (!try_reset_dims()) { out.ret = 0; - goto done; + PGOTO_DONE(ret_value); } // Get the metdata_t struct. @@ -1771,7 +1740,7 @@ HG_TEST_RPC_CB(send_rpc, handle) hg_return_t ret_value = HG_SUCCESS; HG_Get_input(handle, &in); - LOG_ERROR("==PDC_Server: received value from client %d\n", in.value); + LOG_ERROR("Received value from client %d\n", in.value); out.value = 1; HG_Respond(handle, NULL, NULL, &out); @@ -1863,7 +1832,7 @@ HG_TEST_RPC_CB(metadata_add_kvtag, handle) PDC_Server_add_kvtag(&in, &out); } else { - LOG_INFO("==PDC_SERVER[]: received NOOP\n"); + LOG_INFO("Received NOOP\n"); out.ret = 1; } @@ -1903,12 +1872,11 @@ HG_TEST_RPC_CB(notify_io_complete, handle) HG_Respond(handle, PDC_Client_work_done_cb, read_info, &out); } else { - LOG_ERROR("==PDC_CLIENT: notify_io_complete_cb() - error with io type!\n"); + LOG_ERROR("Error with io type\n"); HG_Respond(handle, NULL, NULL, &out); } done: - fflush(stdout); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -1971,13 +1939,13 @@ HG_TEST_RPC_CB(flush_obj_all, handle) HG_Get_input(handle, &in); if (in.tag != 44) { - PGOTO_ERROR(ret_value, "==PDC_SERVER[x]: Error with input tag"); + PGOTO_ERROR(ret_value, "Error with input tag"); } ret_value = HG_Free_input(handle, &in); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_SERVER[x]: Error with HG_Destroy"); + PGOTO_ERROR(ret_value, "Error with HG_Destroy"); out.ret = 1; HG_Respond(handle, NULL, NULL, &out); @@ -1988,7 +1956,6 @@ HG_TEST_RPC_CB(flush_obj_all, handle) #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2010,7 +1977,7 @@ HG_TEST_RPC_CB(flush_obj, handle) ret_value = HG_Free_input(handle, &in); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_SERVER[x]: Error with HG_Destroy"); + PGOTO_ERROR(ret_value, "Error with HG_Destroy"); out.ret = 1; HG_Respond(handle, NULL, NULL, &out); @@ -2023,7 +1990,6 @@ HG_TEST_RPC_CB(flush_obj, handle) #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2045,10 +2011,9 @@ HG_TEST_RPC_CB(close_server, handle) PDC_Server_set_close(); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_SERVER[x]: Error with HG_Destroy"); + PGOTO_ERROR(ret_value, "Error with HG_Destroy"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2096,7 +2061,6 @@ pdc_region_write_out_progress(void *arg) remote_reg_info = (struct pdc_region_info *)PDC_free(remote_reg_info); done: - fflush(stdout); HG_Bulk_free(bulk_args->remote_bulk_handle); HG_Free_input(bulk_args->handle, &(bulk_args->in)); HG_Destroy(bulk_args->handle); @@ -2136,7 +2100,6 @@ obj_map_region_release_bulk_transfer_thread_cb(const struct hg_cb_info *hg_cb_in PDC_Server_release_lock_request(bulk_args->remote_obj_id, bulk_args->remote_reg_info); done: - fflush(stdout); bulk_args->remote_reg_info->offset = (uint64_t *)PDC_free(bulk_args->remote_reg_info->offset); bulk_args->remote_reg_info->size = (uint64_t *)PDC_free(bulk_args->remote_reg_info->size); bulk_args->remote_reg_info = (struct pdc_region_info *)PDC_free(bulk_args->remote_reg_info); @@ -2174,8 +2137,7 @@ pdc_region_read_from_progress(void *arg) size = HG_Bulk_get_size(bulk_args->local_bulk_handle); if (size != HG_Bulk_get_size(bulk_args->remote_bulk_handle)) { error = 1; - PGOTO_ERROR(ret_value, - "===PDC SERVER: pdc_region_read_from_progress local and remote bulk size does not match"); + PGOTO_ERROR(ret_value, "pdc_region_read_from_progress local and remote bulk size does not match"); } hg_ret = HG_Bulk_transfer(hg_info->context, obj_map_region_release_bulk_transfer_thread_cb, bulk_args, @@ -2183,13 +2145,11 @@ pdc_region_read_from_progress(void *arg) bulk_args->remote_bulk_handle, 0, size, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(ret_value, "===PDC SERVER: pdc_region_read_from_progress push data failed"); + PGOTO_ERROR(ret_value, "pdc_region_read_from_progress push data failed"); } done: - fflush(stdout); if (error == 1) { - fflush(stdout); HG_Bulk_free(bulk_args->remote_bulk_handle); HG_Free_input(bulk_args->handle, &(bulk_args->in)); HG_Destroy(bulk_args->handle); @@ -2322,8 +2282,7 @@ transform_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_inf registry[transform_id]->ftnPtr; size_t result = this_transform(buf, bulk_args->in.data_type, ndim, dims, &data_buf, bulk_args->in.dest_type); - LOG_INFO("==PDC_SERVER: transform returned %ld\n", result); - puts("----------------"); + LOG_INFO("Transform returned %ld\n", result); if (use_transform_size == 0 && dims) dims = (uint64_t *)PDC_free(dims); @@ -2372,8 +2331,6 @@ transform_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_inf #endif done: - fflush(stdout); - #ifndef ENABLE_MULTITHREAD if (remote_reg_info) { remote_reg_info->offset = (uint64_t *)PDC_free(remote_reg_info->offset); @@ -2411,7 +2368,7 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info if (hg_cb_info->ret == HG_CANCELED) { out.ret = 0; - PGOTO_ERROR(HG_OTHER_ERROR, "HG_Bulk_transfer() was successfully canceled\n"); + PGOTO_ERROR(HG_OTHER_ERROR, "HG_Bulk_transfer() was successfully canceled"); } else if (hg_cb_info->ret != HG_SUCCESS) { out.ret = 0; @@ -2457,7 +2414,7 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info 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); + LOG_INFO("Analysis returned %d\n", result); } } #ifdef ENABLE_MPI @@ -2524,8 +2481,6 @@ analysis_and_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info #endif done: - fflush(stdout); - #ifndef ENABLE_MULTITHREAD remote_reg_info->offset = (uint64_t *)PDC_free(remote_reg_info->offset); remote_reg_info->size = (uint64_t *)PDC_free(remote_reg_info->size); @@ -2601,7 +2556,7 @@ buf_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) #else remote_reg_info = (struct pdc_region_info *)PDC_malloc(sizeof(struct pdc_region_info)); if (remote_reg_info == NULL) - PGOTO_ERROR(HG_OTHER_ERROR, "remote_reg_info memory allocation failed\n"); + PGOTO_ERROR(HG_OTHER_ERROR, "remote_reg_info memory allocation failed"); remote_reg_info->ndim = (bulk_args->remote_region_nounit).ndim; remote_reg_info->offset = (uint64_t *)PDC_malloc(remote_reg_info->ndim * sizeof(uint64_t)); @@ -2632,8 +2587,6 @@ buf_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) #endif done: - fflush(stdout); - #ifndef ENABLE_MULTITHREAD remote_reg_info->offset = (uint64_t *)PDC_free(remote_reg_info->offset); remote_reg_info->size = (uint64_t *)PDC_free(remote_reg_info->size); @@ -2673,7 +2626,7 @@ obj_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) if (hg_cb_info->ret == HG_CANCELED) { out.ret = 0; - PGOTO_ERROR(HG_OTHER_ERROR, "HG_Bulk_transfer() was successfully canceled\n"); + PGOTO_ERROR(HG_OTHER_ERROR, "HG_Bulk_transfer() was successfully canceled"); } else if (hg_cb_info->ret != HG_SUCCESS) { out.ret = 0; @@ -2691,7 +2644,6 @@ obj_map_region_release_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info) #endif done: - fflush(stdout); bulk_args->remote_reg_info = (struct pdc_region_info *)PDC_free(bulk_args->remote_reg_info); HG_Free_input(bulk_args->handle, &(bulk_args->in)); HG_Destroy(bulk_args->handle); @@ -2799,11 +2751,11 @@ HG_TEST_RPC_CB(region_release, handle) ret_value = PDC_Server_data_read_direct(elt->from_obj_id, server_region, data_buf); if (ret_value != SUCCEED) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER: PDC_Server_data_read_direct() failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "PDC_Server_data_read_direct failed"); hg_ret = HG_Bulk_create(hg_info->hg_class, 1, &data_buf, &size, HG_BULK_READWRITE, &lock_local_bulk_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(hg_ret, "==PDC SERVER ERROR: Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "Could not create bulk data handle"); lock_update_bulk_args = (struct region_lock_update_bulk_args *)PDC_malloc( sizeof(struct region_lock_update_bulk_args)); @@ -2819,8 +2771,7 @@ HG_TEST_RPC_CB(region_release, handle) lock_update_bulk_args, HG_BULK_PUSH, elt->addr, elt->bulk_handle, 0, lock_local_bulk_handle, 0, size, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(hg_ret, "==PDC SERVER ERROR: HG_TEST_RPC_CB(region_release, handle) could " - "not write bulk data"); + PGOTO_ERROR(hg_ret, "Could not write bulk data"); } if (PDC_is_same_region_list(request_region, elt) == 1 && elt->reg_dirty_from_buf == 1 && @@ -2848,7 +2799,7 @@ HG_TEST_RPC_CB(region_release, handle) (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "==PDC SERVER: obj map Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "obj map Could not create bulk data handle"); } data_ptrs_to = (void **)PDC_free(data_ptrs_to); data_size_to = (size_t *)PDC_free(data_size_to); @@ -2857,8 +2808,7 @@ HG_TEST_RPC_CB(region_release, handle) (struct pdc_region_info *)PDC_malloc(sizeof(struct pdc_region_info)); if (remote_reg_info == NULL) { error = 1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER:HG_TEST_RPC_CB(region_release, handle) " - "remote_reg_info memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "remote_reg_info memory allocation failed"); } obj_map_bulk_args = (struct buf_map_release_bulk_args *)PDC_malloc( @@ -2916,9 +2866,8 @@ HG_TEST_RPC_CB(region_release, handle) size2 = HG_Bulk_get_size(remote_bulk_handle); if (size != size2) { error = 1; - LOG_INFO("==PDC_SERVER: local size %llu, remote %llu\n", size, size2); - PGOTO_ERROR(HG_OTHER_ERROR, "===PDC SERVER: HG_TEST_RPC_CB(region_release, " - "handle) local and remote bulk size does not match"); + LOG_INFO("Local size %llu, remote %llu\n", size, size2); + PGOTO_ERROR(HG_OTHER_ERROR, "Local and remote bulk size does not match"); } hg_ret = HG_Bulk_transfer(hg_info->context, obj_map_region_release_bulk_transfer_cb, @@ -2927,8 +2876,7 @@ HG_TEST_RPC_CB(region_release, handle) HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "===PDC SERVER: HG_TEST_RPC_CB(region_release, handle) obj " - "map Could not write bulk data"); + PGOTO_ERROR(hg_ret, "Map Could not write bulk data"); } #endif break; @@ -2987,7 +2935,7 @@ HG_TEST_RPC_CB(region_release, handle) (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "==PDC SERVER ERROR: Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "Could not create bulk data handle"); } data_ptrs_to = (void **)PDC_free(data_ptrs_to); data_size_to = (size_t *)PDC_free(data_size_to); @@ -3021,9 +2969,7 @@ HG_TEST_RPC_CB(region_release, handle) size2 = HG_Bulk_get_size(remote_bulk_handle); if (size != size2) { error = 1; - LOG_INFO("==PDC_SERVER: local size %llu, remote %llu\n", size, size2); - /* PGOTO_ERROR(HG_OTHER_ERROR, "===PDC SERVER: HG_TEST_RPC_CB(region_release, - * handle) local and remote bulk size does not match"); */ + LOG_INFO("Local size %llu, remote %llu\n", size, size2); } hg_ret = HG_Bulk_transfer(hg_info->context, buf_map_region_release_bulk_transfer_cb, buf_map_bulk_args, HG_BULK_PULL, eltt->local_addr, @@ -3031,8 +2977,7 @@ HG_TEST_RPC_CB(region_release, handle) HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "===PDC SERVER: HG_TEST_RPC_CB(region_release, handle) buf " - "map Could not read bulk data"); + PGOTO_ERROR(hg_ret, "buf map could not read bulk data"); } break; } @@ -3131,8 +3076,7 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha // check region is dirty or not, if dirty then transfer data if ((PDC_is_same_region_list(request_region, elt)) == 1 && (elt->reg_dirty_from_buf == 1) && (hg_atomic_get32(&(elt->buf_map_refcount)) == 0)) { - PGOTO_ERROR(HG_OTHER_ERROR, - "==PDC SERVER: release %" PRId64 " access_type==READ (dirty) NOT SUPPORTED YET!", + PGOTO_ERROR(HG_OTHER_ERROR, "Release %" PRId64 " access_type==READ (dirty) NOT SUPPORTED YET", in->obj_id); } if ((PDC_is_same_region_list(request_region, elt) == 1) && (elt->reg_dirty_from_buf == 1) && @@ -3150,7 +3094,7 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha data_ptrs_to = (void **)PDC_malloc(sizeof(void *)); data_size_to = (size_t *)PDC_malloc(sizeof(size_t)); if ((data_ptrs_to == NULL) || (data_size_to == NULL)) { - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER: Memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Memory allocation failed"); } data_ptrs_to[0] = data_buf; @@ -3167,7 +3111,7 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha HG_Bulk_create(hg_info->hg_class, remote_count, data_ptrs_to, (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(hg_ret, "==PDC SERVER: Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "Could not create bulk data handle"); data_ptrs_to = (void **)PDC_free(data_ptrs_to); data_size_to = (size_t *)PDC_free(data_size_to); @@ -3177,7 +3121,7 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha (struct buf_map_transform_and_release_bulk_args *)PDC_malloc( sizeof(struct buf_map_transform_and_release_bulk_args)); if ((remote_reg_info == NULL) || (transform_release_bulk_args == NULL)) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER: Memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Memory allocation failed"); transform_release_bulk_args->handle = handle; transform_release_bulk_args->data_buf = data_buf; @@ -3194,7 +3138,7 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha remote_reg_info->offset = (uint64_t *)PDC_malloc(sizeof(uint64_t)); remote_reg_info->size = (uint64_t *)PDC_malloc(sizeof(uint64_t)); if ((remote_reg_info->offset == NULL) || (remote_reg_info->size == NULL)) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER: Memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Memory allocation failed"); if (in->transform_state && (in->transform_data_size > 0)) { remote_reg_info->ndim = 1; @@ -3226,15 +3170,14 @@ region_read_transform_release(region_transform_and_lock_in_t *in, hg_handle_t ha else size = HG_Bulk_get_size(eltt2->local_bulk_handle); if (size != HG_Bulk_get_size(remote_bulk_handle)) - PGOTO_ERROR(HG_OTHER_ERROR, - "===PDC SERVER: local and remote bulk size does not match"); + PGOTO_ERROR(HG_OTHER_ERROR, "Local and remote bulk size does not match"); hg_ret = HG_Bulk_transfer(hg_info->context, obj_map_region_release_bulk_transfer_cb, transform_release_bulk_args, HG_BULK_PUSH, hg_info->addr, in->local_bulk_handle, 0, remote_bulk_handle, 0, size, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(hg_ret, "===PDC SERVER: obj map Could not write bulk data"); + PGOTO_ERROR(hg_ret, "obj map could not write bulk data"); #endif } } @@ -3315,7 +3258,7 @@ HG_TEST_RPC_CB(transform_region_release, handle) data_ptrs_to = (void **)PDC_malloc(sizeof(void *)); data_size_to = (size_t *)PDC_malloc(sizeof(size_t)); if ((data_buf == NULL) || (data_ptrs_to == NULL) || (data_size_to == NULL)) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER: Memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Memory allocation failed"); *data_ptrs_to = data_buf; *data_size_to = in.transform_data_size; @@ -3326,14 +3269,13 @@ HG_TEST_RPC_CB(transform_region_release, handle) (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "==PDC SERVER ERROR: Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "Could not create bulk data handle"); } /* Args that get passed to the callback function */ buf_map_bulk_args = (struct buf_map_transform_and_release_bulk_args *)PDC_malloc( sizeof(struct buf_map_transform_and_release_bulk_args)); if (buf_map_bulk_args == NULL) { - PGOTO_ERROR(HG_OTHER_ERROR, "HG_TEST_RPC_CB(transform_region_release, handle): " - "buf_map_bulk_args memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "buf_map_bulk_args memory allocation failed"); } memset(buf_map_bulk_args, 0, sizeof(struct buf_map_transform_and_release_bulk_args)); buf_map_bulk_args->handle = handle; @@ -3366,8 +3308,7 @@ HG_TEST_RPC_CB(transform_region_release, handle) size, HG_OP_ID_IGNORE); /* */ if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(HG_OTHER_ERROR, "===PDC SERVER: HG_TEST_RPC_CB(region_release, " - "handle) buf map Could not read bulk data"); + PGOTO_ERROR(HG_OTHER_ERROR, "buf map could not read bulk data"); } } } @@ -3390,7 +3331,6 @@ HG_TEST_RPC_CB(transform_region_release, handle) } done: - fflush(stdout); if (error == 1) { out.ret = 0; HG_Respond(handle, NULL, NULL, &out); @@ -3435,7 +3375,7 @@ HG_TEST_RPC_CB(region_transform_release, handle) hg_info = HG_Get_info(handle); if (in.access_type == PDC_READ) - PGOTO_ERROR(HG_OTHER_ERROR, "release %" PRId64 " access_type==READ NOT SUPPORTED YET!", in.obj_id); + PGOTO_ERROR(HG_OTHER_ERROR, "release %" PRId64 " access_type==READ NOT SUPPORTED YET", in.obj_id); // ************************************************************ // write lock release with mapping case @@ -3492,7 +3432,7 @@ HG_TEST_RPC_CB(region_transform_release, handle) (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(FAIL, "==PDC SERVER ERROR: Could not create bulk data handle"); + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); } data_ptrs_to = (void **)PDC_free(data_ptrs_to); data_size_to = (size_t *)PDC_free(data_size_to); @@ -3500,8 +3440,7 @@ HG_TEST_RPC_CB(region_transform_release, handle) buf_map_bulk_args = (struct buf_map_release_bulk_args *)PDC_malloc( sizeof(struct buf_map_release_bulk_args)); if (buf_map_bulk_args == NULL) { - PGOTO_ERROR(HG_OTHER_ERROR, "HG_TEST_RPC_CB(region_release, handle): " - "buf_map_bulk_args memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "buf_map_bulk_args memory allocation failed"); } memset(buf_map_bulk_args, 0, sizeof(struct buf_map_release_bulk_args)); buf_map_bulk_args->handle = handle; @@ -3529,8 +3468,7 @@ HG_TEST_RPC_CB(region_transform_release, handle) HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "===PDC SERVER: HG_TEST_RPC_CB(region_release, handle) buf " - "map Could not read bulk data"); + PGOTO_ERROR(hg_ret, "buf map could not read bulk data"); } } } @@ -3552,7 +3490,6 @@ HG_TEST_RPC_CB(region_transform_release, handle) } done: - fflush(stdout); if (error == 1) { out.ret = 0; HG_Respond(handle, NULL, NULL, &out); @@ -3627,11 +3564,11 @@ HG_TEST_RPC_CB(region_analysis_release, handle) (server_region->offset)[0] = in.lock_release.region.start[0]; ret_value = PDC_Server_data_read_direct(elt->from_obj_id, server_region, data_buf); if (ret_value != SUCCEED) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER: PDC_Server_data_read_direct() failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with PDC_Server_data_read_direct"); hg_ret = HG_Bulk_create(hg_info->hg_class, 1, &data_buf, &size, HG_BULK_READWRITE, &lock_local_bulk_handle); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR(hg_ret, "==PDC SERVER ERROR: Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "Could not create bulk data handle"); lock_update_bulk_args = (struct region_lock_update_bulk_args *)PDC_malloc( sizeof(struct region_lock_update_bulk_args)); @@ -3647,9 +3584,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) lock_update_bulk_args, HG_BULK_PUSH, elt->addr, elt->bulk_handle, 0, lock_local_bulk_handle, 0, size, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) - PGOTO_ERROR( - hg_ret, - "==PDC SERVER ERROR: region_release_bulk_transfer_cb() could not write bulk data"); + PGOTO_ERROR(hg_ret, "Could not write bulk data"); } if (PDC_is_same_region_list(request_region, elt) == 1 && elt->reg_dirty_from_buf == 1 && @@ -3678,7 +3613,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "==PDC SERVER: obj map Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "obj map could not create bulk data handle"); } data_ptrs_to = (void **)PDC_free(data_ptrs_to); data_size_to = (size_t *)PDC_free(data_size_to); @@ -3687,8 +3622,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) (struct pdc_region_info *)PDC_malloc(sizeof(struct pdc_region_info)); if (remote_reg_info == NULL) { error = 1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC SERVER:HG_TEST_RPC_CB(region_release, handle) " - "remote_reg_info memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "remote_reg_info memory allocation failed"); } obj_map_bulk_args = (struct buf_map_analysis_and_release_bulk_args *)PDC_malloc( @@ -3738,9 +3672,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) size = HG_Bulk_get_size(eltt2->local_bulk_handle); if (size != HG_Bulk_get_size(remote_bulk_handle)) { error = 1; - PGOTO_ERROR(HG_OTHER_ERROR, - "===PDC SERVER: HG_TEST_RPC_CB(region_release, handle) local and " - "remote bulk size does not match\n"); + PGOTO_ERROR(HG_OTHER_ERROR, "remote bulk size does not match\n"); } hg_ret = HG_Bulk_transfer(hg_info->context, obj_map_region_release_bulk_transfer_cb, @@ -3749,8 +3681,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "===PDC SERVER: HG_TEST_RPC_CB(region_release, handle) obj " - "map Could not write bulk data"); + PGOTO_ERROR(hg_ret, "obj map could not write bulk data"); } #endif } @@ -3853,7 +3784,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) (hg_size_t *)data_size_to, HG_BULK_READWRITE, &remote_bulk_handle); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "==PDC SERVER ERROR: Could not create bulk data handle"); + PGOTO_ERROR(hg_ret, "=Could not create bulk data handle"); } data_ptrs_to = (void **)PDC_free(data_ptrs_to); data_size_to = (size_t *)PDC_free(data_size_to); @@ -3861,8 +3792,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) buf_map_bulk_args = (struct buf_map_analysis_and_release_bulk_args *)PDC_malloc( sizeof(struct buf_map_analysis_and_release_bulk_args)); if (buf_map_bulk_args == NULL) - PGOTO_ERROR(HG_OTHER_ERROR, "HG_TEST_RPC_CB(region_release, handle): " - "buf_map_bulk_args memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "buf_map_bulk_args memory allocation failed"); // memset(buf_map_bulk_args, 0, sizeof(struct buf_map_release_bulk_args)); memset(buf_map_bulk_args, 0, sizeof(struct buf_map_analysis_and_release_bulk_args)); @@ -3882,8 +3812,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) size = HG_Bulk_get_size(eltt->local_bulk_handle); if (size != HG_Bulk_get_size(remote_bulk_handle)) { error = 1; - PGOTO_ERROR(HG_OTHER_ERROR, "===PDC SERVER: HG_TEST_RPC_CB(region_release, " - "handle) local and remote bulk size does not match"); + PGOTO_ERROR(HG_OTHER_ERROR, "Local and remote bulk size does not match"); } hg_ret = HG_Bulk_transfer( @@ -3893,8 +3822,7 @@ HG_TEST_RPC_CB(region_analysis_release, handle) if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR(hg_ret, "===PDC SERVER: HG_TEST_RPC_CB(region_release, handle) buf " - "map Could not read bulk data"); + PGOTO_ERROR(hg_ret, "buf map Could not read bulk data"); } } } @@ -3917,7 +3845,6 @@ HG_TEST_RPC_CB(region_analysis_release, handle) } done: - fflush(stdout); if (error == 1) { out.ret = 0; HG_Respond(handle, NULL, NULL, &out); @@ -3995,10 +3922,7 @@ HG_TEST_RPC_CB(buf_unmap, handle) ret = PDC_Data_Server_buf_unmap(info, &in); if (ret != SUCCEED) { out.ret = 0; - PGOTO_ERROR( - HG_OTHER_ERROR, - "===PDC_DATA_SERVER: HG_TEST_RPC_CB(buf_unmap, handle) - PDC_Data_Server_buf_unmap() failed"); - fflush(stdout); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with PDC_Data_Server_buf_unmap"); HG_Respond(handle, NULL, NULL, &out); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -4009,12 +3933,9 @@ HG_TEST_RPC_CB(buf_unmap, handle) } ret = PDC_Meta_Server_buf_unmap(&in, &handle); if (ret != SUCCEED) - PGOTO_ERROR( - HG_OTHER_ERROR, - "===PDC_DATA_SERVER: HG_TEST_RPC_CB(buf_unmap, handle) - PDC_Meta_Server_buf_unmap() failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with PDC_Meta_Server_buf_unmap"); done: - fflush(stdout); #ifdef PDC_TIMING end = MPI_Wtime(); pdc_server_timings->PDCbuf_obj_unmap_rpc += end - start; @@ -4076,9 +3997,7 @@ HG_TEST_RPC_CB(buf_unmap_server, handle) target_obj = PDC_Server_get_obj_metadata(in.remote_obj_id); if (target_obj == NULL) { out.ret = 0; - PGOTO_ERROR( - HG_OTHER_ERROR, - "==PDC_SERVER: HG_TEST_RPC_CB(buf_unmap_server, handle) - requested object does not exist"); + PGOTO_ERROR(HG_OTHER_ERROR, "Requested object does not exist"); } out.ret = 1; #ifdef ENABLE_MULTITHREAD @@ -4099,7 +4018,6 @@ HG_TEST_RPC_CB(buf_unmap_server, handle) #endif done: - fflush(stdout); HG_Respond(handle, NULL, NULL, &out); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -4126,10 +4044,7 @@ HG_TEST_RPC_CB(buf_map_server, handle) target_obj = PDC_Server_get_obj_metadata(in.remote_obj_id); if (target_obj == NULL) { out.ret = 0; - PGOTO_ERROR(HG_OTHER_ERROR, - "==PDC_SERVER: HG_TEST_RPC_CB(buf_map_server, handle) - requested object (id=%" PRIu64 - ") does not exist\n", - in.remote_obj_id); + PGOTO_ERROR(HG_OTHER_ERROR, "Requested object (id=%" PRIu64 ") does not exist", in.remote_obj_id); } request_region = (region_list_t *)PDC_malloc(sizeof(region_list_t)); PDC_region_transfer_t_to_list_t(&in.remote_region_unit, request_region); @@ -4163,7 +4078,6 @@ HG_TEST_RPC_CB(buf_map_server, handle) request_region = (region_list_t *)PDC_free(request_region); done: - fflush(stdout); HG_Respond(handle, NULL, NULL, &out); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -4203,7 +4117,7 @@ HG_TEST_RPC_CB(buf_map, handle) if (data_ptr == NULL) { out.ret = 0; - PGOTO_ERROR(HG_OTHER_ERROR, "===PDC Data Server: object memory allocation failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Object memory allocation failed"); } request_region = (region_list_t *)PDC_malloc(sizeof(region_list_t)); @@ -4224,7 +4138,7 @@ HG_TEST_RPC_CB(buf_map, handle) HG_Respond(handle, NULL, NULL, &out); ret = PDC_Meta_Server_buf_map(&in, new_buf_map_ptr, &handle); if (ret != SUCCEED) - PGOTO_ERROR(HG_OTHER_ERROR, "===PDC Data Server: PDC_Meta_Server_buf_map() failed"); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with PDC_Meta_Server_buf_map"); } #ifdef PDC_TIMING end = MPI_Wtime(); @@ -4232,7 +4146,6 @@ HG_TEST_RPC_CB(buf_map, handle) pdc_timestamp_register(pdc_buf_obj_map_timestamps, start, end); #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4327,7 +4240,6 @@ HG_TEST_RPC_CB(query_partial, handle) ret_value = HG_Respond(handle, NULL, NULL, &out); done: - fflush(stdout); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -4383,7 +4295,6 @@ HG_TEST_RPC_CB(query_kvtag, handle) ret_value = HG_Respond(handle, NULL, NULL, &out); done: - fflush(stdout); HG_Free_input(handle, &in); HG_Destroy(handle); @@ -4429,7 +4340,7 @@ update_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) // First elem is the obj id, following by cnt region infos obj_id_ptr = (uint64_t *)buf[0]; if (*obj_id_ptr <= 0) - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_SERVER[ ]: error with bulk access, obj id invalid!"); + PGOTO_ERROR(HG_OTHER_ERROR, "Error with bulk access, obj id invalid"); if (PDC_Server_update_region_storage_meta_bulk_local((update_region_storage_meta_bulk_t **)buf, cnt) == SUCCEED) { @@ -4440,7 +4351,6 @@ update_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) } // end of else done: - fflush(stdout); HG_Bulk_free(local_bulk_handle); HG_Respond(bulk_args->handle, NULL, NULL, &out_struct); HG_Destroy(bulk_args->handle); @@ -4485,7 +4395,7 @@ HG_TEST_RPC_CB(bulk_rpc, handle) bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->cnt = cnt; - LOG_INFO("==PDC_SERVER: bulk_rpc_cb, nbytes %lu\n", bulk_args->nbytes); + LOG_INFO("bulk_rpc_cb, nbytes %lu\n", bulk_args->nbytes); /* Create a new block handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, (hg_size_t *)&bulk_args->nbytes, HG_BULK_READWRITE, @@ -4501,7 +4411,6 @@ HG_TEST_RPC_CB(bulk_rpc, handle) HG_Free_input(handle, &in_struct); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4545,10 +4454,9 @@ HG_TEST_RPC_CB(data_server_read, handle) HG_Free_input(handle, &in); ret_value = HG_Destroy(handle); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_SERVER: data_server_read_cb - Error with HG_Destroy"); + PGOTO_ERROR(ret_value, "Error with HG_Destroy"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4590,10 +4498,9 @@ HG_TEST_RPC_CB(data_server_write, handle) HG_Free_input(handle, &in); ret_value = HG_Destroy(handle); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_SERVER: data_server_write_cb - Error with HG_Destroy"); + PGOTO_ERROR(ret_value, "Error with HG_Destroy"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4683,8 +4590,7 @@ HG_TEST_RPC_CB(update_region_loc, handle) ret_value = PDC_Server_update_local_region_storage_loc(input_region, in.obj_id, in.type); if (ret_value != SUCCEED) { out.ret = -1; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_SERVER: FAILED to update region location: obj_id=%" PRIu64 "", - in.obj_id); + PGOTO_ERROR(HG_OTHER_ERROR, "Failed to update region location: obj_id=%" PRIu64 "", in.obj_id); } /* HG_Respond(handle, NULL, NULL, &out); */ @@ -4696,7 +4602,6 @@ HG_TEST_RPC_CB(update_region_loc, handle) input_region = (region_list_t *)PDC_free(input_region); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4718,7 +4623,7 @@ HG_TEST_RPC_CB(get_metadata_by_id, handle) if (target != NULL) PDC_metadata_t_to_transfer_t(target, &out.res_meta); else { - LOG_INFO("==PDC_SERVER: no matching metadata of obj_id=%" PRIu64 "\n", in.obj_id); + LOG_INFO("No matching metadata of obj_id=%" PRIu64 "\n", in.obj_id); out.res_meta.user_id = -1; out.res_meta.obj_id = 0; out.res_meta.cont_id = 0; @@ -4857,7 +4762,6 @@ PDC_find_in_path(char *workingDir, char *application) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4893,17 +4797,17 @@ cont_add_del_objs_bulk_cb(const struct hg_cb_info *hg_cb_info) if (PDC_Server_container_add_objs(cnt, obj_ids, cont_id) == SUCCEED) out_struct.ret = 1; else - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_SERVER[ ]: error updating objects to container"); + PGOTO_ERROR(HG_OTHER_ERROR, "Error updating objects to container"); } else if (op == DEL_OBJ) { if (PDC_Server_container_del_objs(cnt, obj_ids, cont_id) == SUCCEED) out_struct.ret = 1; else - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_SERVER[ ]: error updating objects to container"); + PGOTO_ERROR(HG_OTHER_ERROR, "Error updating objects to container"); } else { out_struct.ret = 0; - PGOTO_ERROR(HG_OTHER_ERROR, "==PDC_SERVER[ ]: unsupported container operation type"); + PGOTO_ERROR(HG_OTHER_ERROR, "Unsupported container operation type"); } } // end of else @@ -4913,7 +4817,6 @@ cont_add_del_objs_bulk_cb(const struct hg_cb_info *hg_cb_info) HG_Respond(bulk_args->handle, NULL, NULL, &out_struct); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4968,7 +4871,6 @@ HG_TEST_RPC_CB(cont_add_del_objs_rpc, handle) HG_Free_input(handle, &in_struct); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5053,7 +4955,6 @@ query_read_obj_name_bulk_cb(const struct hg_cb_info *hg_cb_info) PGOTO_ERROR(ret, "Could not free HG bulk handle"); done: - fflush(stdout); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); @@ -5107,7 +5008,6 @@ HG_TEST_RPC_CB(query_read_obj_name_rpc, handle) HG_Free_input(handle, &in_struct); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5153,13 +5053,12 @@ PDC_check_int_ret_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "== Error with HG_Get_output"); + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); if (output.ret != 1) - PGOTO_ERROR(ret_value, "== Return value [%d] is NOT expected", output.ret); + PGOTO_ERROR(ret_value, "Return value [%d] is NOT expected", output.ret); done: - fflush(stdout); HG_Free_output(handle, &output); FUNC_LEAVE(ret_value); @@ -5237,7 +5136,6 @@ get_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) PGOTO_ERROR(ret_value, "Could not free HG bulk handle"); done: - fflush(stdout); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); @@ -5290,7 +5188,6 @@ HG_TEST_RPC_CB(get_storage_meta_name_query_bulk_result_rpc, handle) HG_Free_input(handle, &in_struct); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5334,7 +5231,6 @@ notify_client_multi_io_complete_bulk_cb(const struct hg_cb_info *hg_cb_info) PGOTO_ERROR(ret_value, "Could not free HG bulk handle"); done: - fflush(stdout); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); @@ -5378,7 +5274,6 @@ HG_TEST_RPC_CB(notify_client_multi_io_complete_rpc, handle) PGOTO_ERROR(ret_value, "Could not read bulk data"); done: - fflush(stdout); HG_Free_input(handle, &in_struct); FUNC_LEAVE(ret_value); @@ -5403,7 +5298,7 @@ PDC_add_task_to_list(pdc_task_list_t **target_list, perr_t (*cb)(), void *cb_arg #endif if (target_list == NULL) - PGOTO_ERROR(-1, "== NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); new_task = (pdc_task_list_t *)PDC_calloc(1, sizeof(pdc_task_list_t)); new_task->cb = cb; @@ -5424,7 +5319,6 @@ PDC_add_task_to_list(pdc_task_list_t **target_list, perr_t (*cb)(), void *cb_arg ret_value = new_task->task_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5445,7 +5339,7 @@ PDC_del_task_from_list(pdc_task_list_t **target_list, pdc_task_list_t *del, #endif if (target_list == NULL || del == NULL) - PGOTO_ERROR(FAIL, "== NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(mutex); @@ -5460,7 +5354,6 @@ PDC_del_task_from_list(pdc_task_list_t **target_list, pdc_task_list_t *del, tmp = (pdc_task_list_t *)PDC_free(tmp); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5469,14 +5362,11 @@ PDC_is_valid_task_id(int id) { FUNC_ENTER(NULL); - int ret_value = 0; + int ret_value = SUCCEED; if (id < PDC_SERVER_TASK_INIT_VALUE || id > 10000) - PGOTO_ERROR(-1, "== id %d is invalid!", id); - - ret_value = 1; + PGOTO_ERROR(FAIL, "id %d is invalid", id); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5497,7 +5387,7 @@ PDC_find_task_from_list(pdc_task_list_t **target_list, int id, #endif if (PDC_is_valid_task_id(id) != 1) - PGOTO_ERROR(NULL, "== NULL input!"); + PGOTO_ERROR(NULL, "NULL input"); #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(mutex); @@ -5515,7 +5405,6 @@ PDC_find_task_from_list(pdc_task_list_t **target_list, int id, #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5528,7 +5417,7 @@ PDC_del_task_from_list_id(pdc_task_list_t **target_list, int id, hg_thread_mutex pdc_task_list_t *tmp; if (target_list == NULL || PDC_is_valid_task_id(id) != 1) - PGOTO_ERROR(FAIL, "== NULL input!"); + PGOTO_ERROR(FAIL, "NULL input"); #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(mutex); @@ -5544,7 +5433,6 @@ PDC_del_task_from_list_id(pdc_task_list_t **target_list, int id, hg_thread_mutex tmp = (pdc_task_list_t *)PDC_free(tmp); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5553,14 +5441,11 @@ PDC_is_valid_obj_id(uint64_t id) { FUNC_ENTER(NULL); - int ret_value = 0; + int ret_value = SUCCEED; if (id < PDC_SERVER_ID_INTERVEL) - PGOTO_ERROR(-1, "== id %" PRIu64 " is invalid!", id); - - ret_value = 1; + PGOTO_ERROR(FAIL, "id %" PRIu64 " is invalid", id); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5666,7 +5551,6 @@ query_read_obj_name_client_bulk_cb(const struct hg_cb_info *hg_cb_info) PGOTO_ERROR(ret_value, "Could not free HG bulk handle"); done: - fflush(stdout); HG_Destroy(bulk_args->handle); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); @@ -5718,7 +5602,6 @@ HG_TEST_RPC_CB(query_read_obj_name_client_rpc, handle) HG_Free_input(handle, &in_struct); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5741,7 +5624,7 @@ send_client_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) ret_value = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READ_ONLY, 1, &buf, NULL, NULL); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_CLIENT[x]: Error with bulk access"); + PGOTO_ERROR(ret_value, "Error with bulk access"); buf_cp = PDC_malloc(bulk_args->nbytes); memcpy(buf_cp, buf, bulk_args->nbytes); @@ -5758,7 +5641,6 @@ send_client_storage_meta_bulk_cb(const struct hg_cb_info *hg_cb_info) PDC_Client_recv_bulk_storage_meta(process_args); done: - fflush(stdout); /* Free bulk handle */ HG_Bulk_free(local_bulk_handle); HG_Destroy(bulk_args->handle); @@ -5822,7 +5704,6 @@ HG_TEST_RPC_CB(send_client_storage_meta_rpc, handle) PGOTO_ERROR(ret_value, "Could not respond"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5842,7 +5723,7 @@ server_recv_shm_bulk_cb(const struct hg_cb_info *hg_cb_info) ret_value = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READ_ONLY, 1, &buf, NULL, NULL); if (ret_value != HG_SUCCESS) - PGOTO_ERROR(ret_value, "==PDC_CLIENT[x]: Error with bulk access"); + PGOTO_ERROR(ret_value, "Error with bulk access"); buf_cp = PDC_malloc(bulk_args->nbytes); memcpy(buf_cp, buf, bulk_args->nbytes); @@ -5853,7 +5734,6 @@ server_recv_shm_bulk_cb(const struct hg_cb_info *hg_cb_info) } // end else done: - fflush(stdout); /* Free bulk handle */ HG_Bulk_free(local_bulk_handle); HG_Destroy(bulk_args->handle); @@ -5897,7 +5777,7 @@ HG_TEST_RPC_CB(send_shm_bulk_rpc, handle) bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->cnt = cnt; - LOG_ERROR("==PDC_SERVER: send_bulk_rpc_cb, nbytes %lu\n", bulk_args->nbytes); + LOG_ERROR("send_bulk_rpc_cb, nbytes %lu\n", bulk_args->nbytes); /* Create a new bulk handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, (hg_size_t *)&bulk_args->nbytes, HG_BULK_READWRITE, @@ -5919,7 +5799,6 @@ HG_TEST_RPC_CB(send_shm_bulk_rpc, handle) PGOTO_ERROR(ret_value, "Could not respond"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6074,7 +5953,7 @@ HG_TEST_RPC_CB(send_bulk_rpc, handle) func_ptr = &PDC_recv_query_metadata_bulk; } else - PGOTO_ERROR(HG_OTHER_ERROR, "== Invalid bulk op ID!"); + PGOTO_ERROR(HG_OTHER_ERROR, "Invalid bulk op ID"); if (in_struct.cnt > 0) { bulk_arg->nbytes = HG_Bulk_get_size(origin_bulk_handle); @@ -6095,7 +5974,6 @@ HG_TEST_RPC_CB(send_bulk_rpc, handle) } done: - fflush(stdout); HG_Free_input(handle, &in_struct); FUNC_LEAVE(ret_value); @@ -6132,8 +6010,8 @@ HG_TEST_RPC_CB(dart_perform_one_server, handle) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; - hg_return_t hg_ret = HG_SUCCESS; + hg_return_t ret_value = HG_SUCCESS; + hg_return_t hg_ret = HG_SUCCESS; dart_perform_one_server_in_t in; dart_perform_one_server_out_t out; @@ -6164,8 +6042,7 @@ HG_TEST_RPC_CB(dart_perform_one_server, handle) if (*n_obj_ids_ptr == 0) { out.bulk_handle = HG_BULK_NULL; out.ret = 0; - ret = HG_Respond(handle, NULL, NULL, &out); - goto done; + PGOTO_DONE(HG_Respond(handle, NULL, NULL, &out)); } n_buf = 1; @@ -6188,7 +6065,7 @@ HG_TEST_RPC_CB(dart_perform_one_server, handle) // TODO: To confirm how we can know the bulk data has been sent to client completely // Send bulk handle to client - ret = HG_Respond(handle, NULL, NULL, &out); + ret_value = HG_Respond(handle, NULL, NULL, &out); done: // Free input @@ -6196,7 +6073,7 @@ HG_TEST_RPC_CB(dart_perform_one_server, handle) // Free handle HG_Destroy(handle); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } HG_TEST_THREAD_CB(server_lookup_client) @@ -6439,10 +6316,10 @@ PDC_is_contiguous_region_overlap(region_list_t *a, region_list_t *b) uint64_t zmin1 = 0, zmin2 = 0, zmax1 = 0, zmax2 = 0; if (a == NULL || b == NULL) - PGOTO_ERROR(-1, "==PDC_SERVER: PDC_is_contiguous_region_overlap() - passed NULL value!"); + PGOTO_ERROR(-1, "Passed NULL value"); if (a->ndim != b->ndim || a->ndim <= 0 || b->ndim <= 0) - PGOTO_ERROR(-1, "==PDC_SERVER: PDC_is_contiguous_region_overlap() - dimension does not match"); + PGOTO_ERROR(-1, "Dimension does not match"); if (a->ndim >= 1) { xmin1 = a->start[0]; @@ -6472,7 +6349,6 @@ PDC_is_contiguous_region_overlap(region_list_t *a, region_list_t *b) is_overlap_3D(xmin1, xmax1, ymin1, ymax1, zmin1, zmax1, xmin2, xmax2, ymin2, ymax2, zmin2, zmax2); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6485,7 +6361,7 @@ PDC_is_contiguous_start_count_overlap(uint32_t ndim, uint64_t *a_start, uint64_t int ret_value = 1; if (ndim > DIM_MAX || NULL == a_start || NULL == a_count || NULL == b_start || NULL == b_count) - PGOTO_ERROR(-1, "PDC_is_contiguous_start_count_overlap: invalid input!"); + PGOTO_ERROR(-1, "Invalid input"); uint64_t xmin1 = 0, xmin2 = 0, xmax1 = 0, xmax2 = 0; uint64_t ymin1 = 0, ymin2 = 0, ymax1 = 0, ymax2 = 0; @@ -6520,7 +6396,6 @@ PDC_is_contiguous_start_count_overlap(uint32_t ndim, uint64_t *a_start, uint64_t is_overlap_3D(xmin1, xmax1, ymin1, ymax1, zmin1, zmax1, xmin2, xmax2, ymin2, ymax2, zmin2, zmax2); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6538,11 +6413,11 @@ PDC_get_overlap_start_count(uint32_t ndim, uint64_t *start_a, uint64_t *count_a, if (NULL == start_a || NULL == count_a || NULL == start_b || NULL == count_b || NULL == overlap_start || NULL == overlap_count) - PGOTO_ERROR(FAIL, "get_overlap NULL input!"); + PGOTO_ERROR(FAIL, "get_overlap NULL input"); // Check if they are truly overlapping regions if (PDC_is_contiguous_start_count_overlap(ndim, start_a, count_a, start_b, count_b) != 1) { - LOG_INFO("non-overlap regions!\n"); + LOG_INFO("non-overlap regions\n"); for (i = 0; i < ndim; i++) { LOG_INFO("\t\tdim%" PRIu64 " - start_a: %" PRIu64 " count_a: %" PRIu64 ", " "\t\tstart_b:%" PRIu64 " count_b:%" PRIu64 "\n", @@ -6576,7 +6451,7 @@ PDC_create_shm_segment_ind(uint64_t size, char *shm_addr, void **buf) int shm_fd = -1; if (shm_addr == NULL) - PGOTO_ERROR(FAIL, "== Shared memory addr is NULL!"); + PGOTO_ERROR(FAIL, "Shared memory addr is NULL"); /* create the shared memory segment as if it was a file */ retry = 0; @@ -6590,21 +6465,20 @@ PDC_create_shm_segment_ind(uint64_t size, char *shm_addr, void **buf) } if (shm_fd == -1) - PGOTO_ERROR(FAIL, "== Shared memory create failed"); + PGOTO_ERROR(FAIL, "Shared memory create failed"); /* configure the size of the shared memory segment */ if (ftruncate(shm_fd, size) != 0) { - PGOTO_ERROR(FAIL, "== Truncate memory failed"); + PGOTO_ERROR(FAIL, "Truncate memory failed"); } /* map the shared memory segment to the address space of the process */ *buf = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0); if (*buf == MAP_FAILED) - PGOTO_ERROR(FAIL, "== Shared memory mmap failed [%s]\n", shm_addr); + PGOTO_ERROR(FAIL, "Shared memory mmap failed [%s]", shm_addr); // close and shm_unlink? done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6618,7 +6492,7 @@ PDC_create_shm_segment(region_list_t *region) int retry; if (region->shm_addr[0] == 0) - PGOTO_ERROR(FAIL, "== Shared memory addr is NULL!"); + PGOTO_ERROR(FAIL, "Shared memory addr is NULL"); /* create the shared memory segment as if it was a file */ retry = 0; @@ -6630,7 +6504,7 @@ PDC_create_shm_segment(region_list_t *region) } if (region->shm_fd == -1) - PGOTO_ERROR(FAIL, "== Shared memory create failed"); + PGOTO_ERROR(FAIL, "Shared memory create failed"); // Calculate the actual size for reading the data if needed if (region->data_size == 0) { @@ -6641,17 +6515,16 @@ PDC_create_shm_segment(region_list_t *region) /* configure the size of the shared memory segment */ if (ftruncate(region->shm_fd, region->data_size) != 0) { - PGOTO_ERROR(FAIL, "== Truncate memory failed"); + PGOTO_ERROR(FAIL, "Truncate memory failed"); } /* map the shared memory segment to the address space of the process */ region->buf = mmap(0, region->data_size, PROT_READ | PROT_WRITE, MAP_SHARED, region->shm_fd, 0); if (region->buf == MAP_FAILED) - PGOTO_ERROR(FAIL, "== Shared memory mmap failed"); + PGOTO_ERROR(FAIL, "Shared memory mmap failed"); // close and shm_unlink? done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6872,7 +6745,6 @@ PDCquery_print(pdc_query_t *query) } LOG_JUST_PRINT("\n"); - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -6908,8 +6780,6 @@ PDC_serialize_query(pdc_query_t *query) ret_value = query_xfer; done: - - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6932,7 +6802,6 @@ PDC_deserialize_query(pdc_query_xfer_t *query_xfer) ret_value = new_root; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7017,9 +6886,8 @@ PDCselection_print(pdc_selection_t *sel) uint64_t i; - LOG_JUST_PRINT("== %" PRIu64 " hits, allocated %" PRIu64 " coordinates!\n", sel->nhits, - sel->coords_alloc); - LOG_JUST_PRINT("== Coordinates:\n"); + LOG_JUST_PRINT("%" PRIu64 " hits, allocated %" PRIu64 " coordinates\n", sel->nhits, sel->coords_alloc); + LOG_JUST_PRINT("Coordinates:\n"); if (sel->nhits > 10) { for (i = 0; i < 10; i++) @@ -7044,9 +6912,8 @@ PDCselection_print_all(pdc_selection_t *sel) uint64_t i; - LOG_JUST_PRINT("== %" PRIu64 " hits, allocated %" PRIu64 " coordinates!\n", sel->nhits, - sel->coords_alloc); - LOG_JUST_PRINT("== Coordinates:\n"); + LOG_JUST_PRINT("%" PRIu64 " hits, allocated %" PRIu64 " coordinates\n", sel->nhits, sel->coords_alloc); + LOG_JUST_PRINT("Coordinates:\n"); for (i = 0; i < sel->nhits; i++) LOG_JUST_PRINT(" ,%" PRIu64 "", sel->coords[i]); diff --git a/src/server/pdc_server.c b/src/server/pdc_server.c index b36de8c08..ffb967dbd 100644 --- a/src/server/pdc_server.c +++ b/src/server/pdc_server.c @@ -183,11 +183,8 @@ PDC_Server_remote_server_info_init(pdc_remote_server_info_t *info) FUNC_ENTER(NULL); perr_t ret_value = SUCCEED; - if (info == NULL) { - ret_value = FAIL; - LOG_ERROR("==PDC_SERVER: NULL info, unable to init pdc_remote_server_info_t!\n"); - goto done; - } + if (info == NULL) + PGOTO_ERROR(FAIL, "info was NULL, unable to init pdc_remote_server_info_t"); info->addr_string = NULL; info->addr_valid = 0; @@ -218,11 +215,8 @@ PDC_Server_destroy_client_info(pdc_client_info_t *info) if (info[i].addr_valid == 1) { hg_ret = HG_Addr_free(hg_class_g, info[i].addr); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER: PDC_Server_destroy_client_info() error with HG_Addr_free\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Addr_free"); info[i].addr_valid = 0; } } // end of for @@ -240,20 +234,18 @@ PDC_Server_destroy_client_info(pdc_client_info_t *info) * \return Non-negative on success/Negative on failure */ perr_t -PDC_client_info_init(pdc_client_info_t *a) +PDC_client_info_init(pdc_client_info_t *pdc_client_info) { FUNC_ENTER(NULL); perr_t ret_value = SUCCEED; - if (a == NULL) { - LOG_ERROR("==PDC_SERVER: PDC_client_info_init() NULL input!\n"); - ret_value = FAIL; - goto done; - } + if (pdc_client_info == NULL) + PGOTO_ERROR(FAIL, "pdc_client_info was NULL"); + + memset(pdc_client_info->addr_string, 0, ADDR_MAX); + pdc_client_info->addr_valid = 0; - memset(a->addr_string, 0, ADDR_MAX); - a->addr_valid = 0; done: FUNC_LEAVE(ret_value); } @@ -281,11 +273,8 @@ PDC_Server_get_client_addr(const struct hg_cb_info *callback_info) #endif if (pdc_client_info_g && in->is_init == 1) { - if (is_debug_g && pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER[%d]: new application run detected, create new client info\n", - pdc_server_rank_g); - fflush(stdout); - } + if (is_debug_g && pdc_server_rank_g == 0) + LOG_INFO("New application run detected, create new client info\n"); PDC_Server_destroy_client_info(pdc_client_info_g); pdc_client_info_g = NULL; @@ -297,11 +286,8 @@ PDC_Server_get_client_addr(const struct hg_cb_info *callback_info) if (pdc_client_info_g == NULL) { pdc_client_num_g = in->nclient; pdc_client_info_g = (pdc_client_info_t *)PDC_calloc(sizeof(pdc_client_info_t), in->nclient); - if (pdc_client_info_g == NULL) { - LOG_ERROR("==PDC_SERVER: PDC_Server_get_client_addr - unable to allocate space\n"); - ret_value = FAIL; - goto done; - } + if (pdc_client_info_g == NULL) + PGOTO_ERROR(FAIL, "PDC_Calloc failed"); for (i = 0; i < in->nclient; i++) PDC_client_info_init(&pdc_client_info_g[i]); @@ -360,10 +346,8 @@ PDC_Server_write_addr_to_file(char **addr_strings, int n) // write to file snprintf(config_fname, ADDR_MAX, "%s%s", pdc_server_tmp_dir_g, pdc_server_cfg_name_g); FILE *na_config = fopen(config_fname, "w+"); - if (!na_config) { - LOG_ERROR("Could not open config file from: %s\n", config_fname); - goto done; - } + if (!na_config) + PGOTO_ERROR(FAIL, "Could not open config file from: %s", config_fname); fprintf(na_config, "%d\n", n); for (i = 0; i < n; i++) { @@ -376,13 +360,13 @@ PDC_Server_write_addr_to_file(char **addr_strings, int n) FUNC_LEAVE(ret_value); } -static int +static perr_t remove_directory(const char *dir) { FUNC_ENTER(NULL); - int ret = 0; - FTS * ftsp = NULL; + int ret_value = 0; + FTS * ftsp = NULL; FTSENT *curr; // Cast needed (in C) because fts_open() takes a "char * const *", instead @@ -396,11 +380,8 @@ remove_directory(const char *dir) // of the specified directory // FTS_XDEV - Don't cross filesystem boundaries ftsp = fts_open(files, FTS_NOCHDIR | FTS_PHYSICAL | FTS_XDEV, NULL); - if (!ftsp) { - LOG_ERROR("PDC_SERVER: %s: fts_open failed: %s\n", dir, strerror(curr->fts_errno)); - ret = -1; - goto done; - } + if (!ftsp) + PGOTO_ERROR(FAIL, "Error with fts_open [%s], errno: [%s]", dir, strerror(curr->fts_errno)); while ((curr = fts_read(ftsp))) { switch (curr->fts_info) { @@ -408,39 +389,34 @@ remove_directory(const char *dir) case FTS_DNR: case FTS_ERR: break; - case FTS_DC: case FTS_DOT: case FTS_NSOK: // Not reached unless FTS_LOGICAL, FTS_SEEDOT, or FTS_NOSTAT were // passed to fts_open() break; - case FTS_D: // Do nothing. Need depth-first search, so directories are deleted // in FTS_DP break; - case FTS_DP: case FTS_F: case FTS_SL: case FTS_SLNONE: case FTS_DEFAULT: if (remove(curr->fts_accpath) < 0) { - LOG_ERROR("PDC_SERVER: %s: Failed to remove: %s\n", curr->fts_path, - strerror(curr->fts_errno)); - ret = -1; + PGOTO_ERROR(FAIL, "Error with remove: %s: errno: %s\n", curr->fts_path, + strerror(curr->fts_errno)); } break; } } done: - if (ftsp) { + if (ftsp) fts_close(ftsp); - } - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } /* @@ -458,11 +434,8 @@ PDC_Server_rm_config_file() snprintf(config_fname, ADDR_MAX, "%s%s", pdc_server_tmp_dir_g, pdc_server_cfg_name_g); - if (remove(config_fname) != 0) { - LOG_ERROR("==PDC_SERVER[%d]: Unable to delete the config file[%s]", pdc_server_rank_g, config_fname); - ret_value = FAIL; - goto done; - } + if (remove(config_fname) != 0) + PGOTO_ERROR(FAIL, "Unable to delete the config file[%s]", config_fname); #ifdef ENABLE_ROCKSDB if (use_rocksdb_g) { @@ -510,11 +483,8 @@ lookup_remote_server_cb(const struct hg_cb_info *callback_info) hg_thread_mutex_unlock(&update_remote_server_addr_mutex_g); #endif - if (pdc_remote_server_info_g[server_id].addr == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: remote server addr is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (pdc_remote_server_info_g[server_id].addr == NULL) + PGOTO_ERROR(FAIL, "Remote server addr is NULL"); lookup_args->ret_int = 1; @@ -547,16 +517,12 @@ 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); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER: Connection to remote server FAILED!\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Connection to remote server FAILED"); hg_ret = HG_Trigger(hg_context_g, 0 /* timeout */, 1 /* max count */, &actual_count); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -587,20 +553,14 @@ PDC_Server_lookup_all_servers() continue; if (PDC_Server_lookup_server_id(i) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error when lookup remote server %d!\n", pdc_server_rank_g, - i); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error when lookup remote server %d", i); } } } } - if (pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER[%d]: Successfully established connection to %d other PDC servers\n", - pdc_server_rank_g, pdc_server_size_g - 1); - fflush(stdout); - } + if (pdc_server_rank_g == 0) + LOG_INFO("Successfully established connection to %d other PDC servers\n", pdc_server_size_g - 1); done: FUNC_LEAVE(ret_value); @@ -626,15 +586,13 @@ PDC_Server_lookup_client_cb(const struct hg_cb_info *callback_info) server_lookup_args = (server_lookup_args_t *)callback_info->arg; client_id = server_lookup_args->client_id; - if (client_id >= (uint32_t)pdc_client_num_g) { - LOG_ERROR("==PDC_SERVER[%d]: invalid input client id %d\n", pdc_server_rank_g, client_id); - goto done; - } + if (client_id >= (uint32_t)pdc_client_num_g) + PGOTO_ERROR(HG_OTHER_ERROR, "Invalid input client id %d", client_id); + pdc_client_info_g[client_id].addr = callback_info->info.lookup.addr; pdc_client_info_g[client_id].addr_valid = 1; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -655,14 +613,10 @@ PDC_Server_lookup_client(uint32_t client_id) hg_return_t hg_ret; unsigned actual_count; - if (pdc_client_num_g <= 0) { - LOG_ERROR("==PDC_SERVER[%d]: number of client <= 0!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - + if (pdc_client_num_g <= 0) + PGOTO_ERROR(FAIL, "Number of client <= 0"); if (pdc_client_info_g[client_id].addr_valid == 1) - goto done; + PGOTO_DONE(SUCCEED); // Lookup and fill the client info server_lookup_args_t lookup_args; @@ -675,16 +629,12 @@ PDC_Server_lookup_client(uint32_t client_id) hg_ret = HG_Addr_lookup(hg_context_g, PDC_Server_lookup_client_cb, &lookup_args, target_addr_string, HG_OP_ID_IGNORE); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: Connection to client %d FAILED!\n", pdc_server_rank_g, client_id); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Connection to client %d failed", client_id); hg_ret = HG_Trigger(hg_context_g, 0 /* timeout */, 1 /* max count */, &actual_count); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -694,19 +644,16 @@ PDC_hg_handle_create_cb(hg_handle_t handle, void *arg) FUNC_ENTER(NULL); struct hg_thread_work *hg_thread_work = PDC_malloc(sizeof(struct hg_thread_work)); - hg_return_t ret = HG_SUCCESS; + hg_return_t ret_value = HG_SUCCESS; - if (!hg_thread_work) { - // HG_LOG_ERROR("Could not allocate hg_thread_work"); - ret = HG_NOMEM_ERROR; - goto done; - } + if (hg_thread_work == NULL) + PGOTO_ERROR(HG_NOMEM_ERROR, "Failed to PDC_malloc hg_thread_work"); (void)arg; HG_Set_data(handle, hg_thread_work, free); done: - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } perr_t @@ -827,18 +774,24 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) total_mem_usage_g += (sizeof(char) + sizeof(char *)); if ((hg_transport = getenv("HG_TRANSPORT")) == NULL) { + LOG_INFO("Environment variable HG_TRANSPORT was NOT set\n"); hg_transport = default_hg_transport; } + else + LOG_INFO("Environment variable HG_TRANSPORT was set\n"); if ((hostname = getenv("HG_HOST")) == NULL) { + LOG_INFO("Environment variable HG_HOST was NOT set\n"); hostname = PDC_malloc(HOSTNAME_LEN); memset(hostname, 0, HOSTNAME_LEN); gethostname(hostname, HOSTNAME_LEN - 1); free_hostname = true; } + else + LOG_INFO("Environment variable HG_HOST was set\n"); snprintf(na_info_string, NA_STRING_INFO_LEN, "%s://%s:%d", hg_transport, hostname, port); if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: using %s\n", pdc_server_rank_g, na_info_string); + LOG_INFO("Connection string: %s\n", na_info_string); if (free_hostname) hostname = PDC_free(hostname); @@ -859,24 +812,19 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) sleep(1); goto drc_access_again; } - LOG_ERROR("server drc_access() failed (%d, %s)", rc, drc_strerror(-rc)); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "drc_access failed (%d, %s)", rc, drc_strerror(-rc)); } cookie = drc_get_first_cookie(credential_info); if (pdc_server_rank_g == 0) { LOG_INFO("# Credential is %u\n", credential); LOG_INFO("# Cookie is %u\n", cookie); - fflush(stdout); } sprintf(pdc_auth_key, "%u", cookie); init_info.na_init_info.auth_key = strdup(pdc_auth_key); #endif // end of gni - // Init server -// *hg_class = HG_Init(na_info_string, NA_TRUE); #ifndef ENABLE_MULTITHREAD init_info.na_init_info.progress_mode = NA_NO_BLOCK; // busy mode #endif @@ -909,10 +857,8 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) for (i = 0; i < pdc_server_size_g; i++) { ret_value = PDC_Server_remote_server_info_init(&pdc_remote_server_info_g[i]); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_remote_server_info_init\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_remote_server_info_init"); } // Gather addresses @@ -941,7 +887,7 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) hg_thread_pool_init(n_thread, &hg_test_thread_pool_g); hg_thread_pool_init(1, &hg_test_thread_pool_fs_g); if (pdc_server_rank_g == 0) - LOG_INFO("\n==PDC_SERVER[%d]: Starting server with %d threads...\n", pdc_server_rank_g, n_thread); + LOG_INFO("\nStarting server with %d threads...\n", n_thread); hg_thread_mutex_init(&hash_table_new_mutex_g); hg_thread_mutex_init(&pdc_client_info_mutex_g); hg_thread_mutex_init(&pdc_metadata_hash_table_mutex_g); @@ -968,12 +914,12 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) hg_thread_mutex_init(&update_remote_server_addr_mutex_g); #else if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: without multi-thread!\n", pdc_server_rank_g); + LOG_INFO("Without multi-thread\n"); #endif #ifdef PDC_SERVER_CACHE if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: Read cache enabled!\n", pdc_server_rank_g); + LOG_INFO("Read cache enabled\n"); #endif // Initialize IDIOMS @@ -986,22 +932,17 @@ PDC_Server_init(int port, hg_class_t **hg_class, hg_context_t **hg_context) pdc_server_rank_g, pdc_server_rank_g); ret_value = PDC_Server_restart(checkpoint_file); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_restart\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_restart"); metadata_index_recover(pdc_server_tmp_dir_g, pdc_server_size_g, pdc_server_rank_g); } else { // We are starting a brand new server transfer_request_metadata_query_init(pdc_server_size_g, NULL); if (is_hash_table_init_g != 1) { - // Hash table init ret_value = PDC_Server_init_hash_table(); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_init_hash_table\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_init_hash_table"); } } @@ -1045,13 +986,12 @@ PDC_Server_destroy_remote_server_info() // Destroy addr and handle for (i = 0; i < pdc_server_size_g; i++) { + if (pdc_remote_server_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_remote_server_info_g was NULL"); if (pdc_remote_server_info_g[i].addr_valid == 1) { hg_ret = HG_Addr_free(hg_class_g, pdc_remote_server_info_g[i].addr); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER: PDC_Server_destroy_remote_server_info() error with HG_Addr_free\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error when calling HG_Addr_free err_code: %d", hg_ret); pdc_remote_server_info_g[i].addr_valid = 0; } } @@ -1078,10 +1018,8 @@ PDC_Server_finalize() transfer_request_metadata_query_finalize(); // Debug: check duplicates - if (is_debug_g == 1) { + if (is_debug_g == 1) PDC_Server_metadata_duplicate_check(); - fflush(stdout); - } // Remove the opened shm DL_FOREACH(pdc_data_server_read_list_head_g, io_elt) @@ -1101,16 +1039,12 @@ PDC_Server_finalize() hash_table_free(metadata_hash_table_g); ret_value = PDC_Server_destroy_client_info(pdc_client_info_g); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER: Error with PDC_Server_destroy_client_info\n"); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_destroy_client_info"); ret_value = PDC_Server_destroy_remote_server_info(); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_destroy_client_info\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_destroy_client_info"); PDC_Close_cache_file(); @@ -1136,7 +1070,6 @@ PDC_Server_finalize() MPI_COMM_WORLD); MPI_Reduce(&server_hash_insert_time_g, &all_server_hash_insert_time_min, 1, MPI_DOUBLE, MPI_MIN, 0, MPI_COMM_WORLD); - #else all_bloom_check_time_min = server_bloom_check_time_g; all_bloom_check_time_max = server_bloom_check_time_g; @@ -1187,14 +1120,12 @@ PDC_Server_finalize() PDC_Server_rm_config_file(); hg_ret = HG_Context_destroy(hg_context_g); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: Error with HG_Context_destroy\n", pdc_server_rank_g); - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Context_destroy"); hg_ret = HG_Finalize(hg_class_g); if (hg_ret != HG_SUCCESS) - LOG_ERROR("==PDC_SERVER[%d]: Error with HG_Finalize\n", pdc_server_rank_g); + LOG_WARNING("Error with HG_Finalize\n"); done: all_addr_strings_g = (char **)PDC_free(all_addr_strings_g); @@ -1212,8 +1143,8 @@ PDC_Server_recv_shm_cb(const struct hg_cb_info *callback_info) shm_info = (pdc_shm_info_t *)callback_info->arg; - LOG_INFO("==PDC_SERVER[%d]: recv shm from %d: [%s], %" PRIu64 "\n", pdc_server_rank_g, - shm_info->client_id, shm_info->shm_addr, shm_info->size); + LOG_INFO("recv shm from %d: [%s], %" PRIu64 "\n", shm_info->client_id, shm_info->shm_addr, + shm_info->size); FUNC_LEAVE(HG_SUCCESS); } @@ -1281,21 +1212,16 @@ PDC_Server_checkpoint() snprintf(checkpoint_file, ADDR_MAX, "%s/%d/metadata_checkpoint.%d", pdc_server_tmp_dir_g, pdc_server_rank_g, pdc_server_rank_g); snprintf(checkpoint_file_local, ADDR_MAX, "/tmp/metadata_checkpoint.%d", pdc_server_rank_g); - if (pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER[%4d]: Checkpoint file [%s]\n", pdc_server_rank_g, checkpoint_file); - fflush(stdout); - } + if (pdc_server_rank_g == 0) + LOG_INFO("Checkpoint file [%s]\n", checkpoint_file); if (use_tmpfs) file = fopen(checkpoint_file_local, "w+"); else file = fopen(checkpoint_file, "w+"); - if (file == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file open error", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (file == NULL) + PGOTO_ERROR(FAIL, "Checkpoint file open error"); // Checkpoint containers n_entry = hash_table_num_entries(container_hash_table_g); @@ -1370,7 +1296,7 @@ PDC_Server_checkpoint() } if (n_write_region != n_region) - LOG_ERROR("==PDC_SERVER[%d]: ERROR with number of regions", pdc_server_rank_g); + LOG_ERROR("Error with number of regions\n"); } metadata_size++; region_count += n_region; @@ -1402,7 +1328,7 @@ PDC_Server_checkpoint() #ifdef PDC_TIMING gettimeofday(&pdc_timer_end_rank, 0); checkpoint_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end_rank); - LOG_INFO("==PDC_SERVER[%4d]: write to tmpfs took %7.2fs\n", pdc_server_rank_g, checkpoint_time); + LOG_INFO("Write to tmpfs took %7.2fs\n", checkpoint_time); #endif // Copy from /tmp to target under $PDC_TMPDIR snprintf(cmd, 4096, "mv %s %s", checkpoint_file_local, checkpoint_file); @@ -1424,27 +1350,23 @@ PDC_Server_checkpoint() #endif #ifdef PDC_TIMING - LOG_INFO("==PDC_SERVER[%4d]: checkpointed %10d objects, with %10d regions, took %7.2fs\n", - pdc_server_rank_g, metadata_size, region_count, checkpoint_time_rank); + LOG_INFO("Checkpointed %10d objects, with %10d regions, took %7.2fs\n", metadata_size, region_count, + checkpoint_time_rank); gettimeofday(&pdc_timer_end, 0); checkpoint_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - fflush(stdout); if (pdc_server_rank_g == 0) - LOG_ERROR("==PDC_SERVER[ ALL]: total checkpoint time = %.6f\n", checkpoint_time); + LOG_ERROR("Rank[ ALL]: Total checkpoint time = %.6f\n", checkpoint_time); #endif if (pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER[ ALL]: checkpointed %10d objects, with %10d regions \n", all_metadata_size, - all_region_count); - fflush(stdout); + LOG_INFO("Checkpointed %10d objects, with %10d regions \n", all_metadata_size, all_region_count); } metadata_index_dump(pdc_server_tmp_dir_g, pdc_server_rank_g); done: - fflush(stdout); FUNC_LEAVE(ret_value); } // End Checkpoint @@ -1488,22 +1410,16 @@ PDC_Server_restart(char *filename) // init hash table ret_value = PDC_Server_init_hash_table(); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_init_hash_table FAILED!", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error wtih PDC_Server_init_hash_table"); FILE *file = fopen(filename, "r"); - if (file == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file open FAILED [%s]!", pdc_server_rank_g, filename); - ret_value = FAIL; - goto done; - } + if (file == NULL) + PGOTO_ERROR(FAIL, "Error with fopen, filename: [%s]", filename); char *slurm_jobid = getenv("SLURM_JOB_ID"); if (slurm_jobid == NULL) { - LOG_ERROR("Error getting slurm job id from SLURM_JOB_ID!\n"); + LOG_ERROR("Error getting slurm job id from SLURM_JOB_ID\n"); } if (fread(&n_cont, sizeof(int), 1, file) != 1) { @@ -1528,7 +1444,7 @@ PDC_Server_restart(char *filename) hg_thread_mutex_lock(&pdc_container_hash_table_mutex_g); #endif if (hash_table_insert(container_hash_table_g, hash_key, cont_entry) != 1) { - LOG_ERROR("==PDC_SERVER[%d]: hash table insert failed\n", pdc_server_rank_g); + LOG_ERROR("Hash table insert failed\n"); ret_value = FAIL; } #ifdef ENABLE_MULTITHREAD @@ -1606,11 +1522,8 @@ PDC_Server_restart(char *filename) if (fread(&n_region, sizeof(int), 1, file) != 1) { LOG_ERROR("Read failed for n_region\n"); } - if (n_region < 0) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file region number ERROR!", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (n_region < 0) + PGOTO_ERROR(FAIL, "Checkpoint file region was less than 0"); /* if (n_region == 0) */ /* continue; */ @@ -1636,8 +1549,7 @@ PDC_Server_restart(char *filename) LOG_ERROR("Read failed for region_list->region_hist->nbin\n"); } if (region_list->region_hist->nbin == 0) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file histogram size is 0!", - pdc_server_rank_g); + LOG_ERROR("Checkpoint file histogram size is 0\n"); } region_list->region_hist->range = @@ -1710,10 +1622,8 @@ PDC_Server_restart(char *filename) elt = metadata + i; // Add to hash list and bloom filter ret_value = PDC_Server_hash_table_list_insert(entry, elt); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER: error with hash table recovering from checkpoint file\n"); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with hash table recovering from checkpoint file"); } n_entry--; } @@ -1765,7 +1675,7 @@ PDC_Server_restart(char *filename) #endif if (pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER[0]: Server restarted from saved session, " + LOG_INFO("Server restarted from saved session, " "successfully loaded %d containers, %d objects, %d regions...\n", all_cont, all_nobj, all_n_region); } @@ -1775,8 +1685,6 @@ PDC_Server_restart(char *filename) pdc_server_timings->PDCserver_restart += MPI_Wtime() - start; #endif - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -1975,7 +1883,7 @@ PDC_print_IO_stats() #endif if (pdc_server_rank_g == 0) { - LOG_JUST_PRINT("==PDC_SERVER[0]: IO STATS (MIN, AVG, MAX)\n" + LOG_JUST_PRINT("IO STATS (MIN, AVG, MAX)\n" " #fwrite %4d, Tfwrite (%6.2f, %6.2f, %6.2f), %.0f MB\n" " #fread %4d, Tfread (%6.2f, %6.2f, %6.2f), %.0f MB\n" " #fopen %4d, Tfopen (%6.2f, %6.2f, %6.2f)\n" @@ -2167,7 +2075,7 @@ PDC_Server_get_env() if (is_debug_env != NULL) { is_debug_g = atoi(is_debug_env); if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: PDC_DEBUG set to %d!\n", pdc_server_rank_g, is_debug_g); + LOG_INFO("PDC_DEBUG set to %d\n", is_debug_g); } tmp_env_char = getenv("PDC_GEN_HIST"); @@ -2181,34 +2089,33 @@ PDC_Server_get_env() tmp_env_char = getenv("PDC_USE_FASTBIT_IDX"); if (tmp_env_char != NULL) { use_fastbit_idx_g = 1; - LOG_INFO("==PDC_SERVER[%d]: using FastBit for data indexing and querying\n"); + LOG_INFO("Using FastBit for data indexing and querying\n"); } tmp_env_char = getenv("PDC_USE_ROCKSDB"); if (tmp_env_char != NULL && strcmp(tmp_env_char, "1") == 0) { use_rocksdb_g = 1; if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: using RocksDB for kvtag\n"); + LOG_INFO("Using RocksDB for kvtag\n"); } tmp_env_char = getenv("PDC_USE_SQLITE3"); if (tmp_env_char != NULL && strcmp(tmp_env_char, "1") == 0) { use_sqlite3_g = 1; if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: using SQLite3 for kvtag\n", pdc_server_rank_g); + LOG_INFO("Using SQLite3 for kvtag\n"); } tmp_env_char = getenv("PDC_DISABLE_CHECKPOINT"); if (tmp_env_char != NULL && strcmp(tmp_env_char, "TRUE") == 0) { pdc_disable_checkpoint_g = 1; if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[0]: checkpoint disabled!\n"); + LOG_INFO("Checkpoint disabled\n"); } if (pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER[%d]: using [%s] as tmp dir, %d OSTs, %d OSTs per data file, %d%% to BB\n", - pdc_server_rank_g, pdc_server_tmp_dir_g, lustre_total_ost_g, pdc_nost_per_file_g, - write_to_bb_percentage_g); + LOG_INFO("Using [%s] as tmp dir, %d OSTs, %d OSTs per data file, %d%% to BB\n", pdc_server_tmp_dir_g, + lustre_total_ost_g, pdc_nost_per_file_g, write_to_bb_percentage_g); } FUNC_LEAVE_VOID(); @@ -2220,7 +2127,7 @@ server_run(int argc, char *argv[]) FUNC_ENTER(NULL); int port; - perr_t ret; + perr_t ret_value = SUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -2242,9 +2149,8 @@ server_run(int argc, char *argv[]) PDC_server_timing_init(); #endif #endif - if (argc > 1) - if (strcmp(argv[1], "restart") == 0) - is_restart_g = 1; + if (argc > 1 && strcmp(argv[1], "restart") == 0) + is_restart_g = 1; // Init rand seed srand(time(NULL)); @@ -2252,12 +2158,10 @@ server_run(int argc, char *argv[]) // Get environmental variables PDC_Server_get_env(); - port = pdc_server_rank_g % 32 + 7000; - ret = PDC_Server_init(port, &hg_class_g, &hg_context_g); - if (ret != SUCCEED || hg_class_g == NULL || hg_context_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Error with Mercury init\n", pdc_server_rank_g); - goto done; - } + port = pdc_server_rank_g % 32 + 7000; + ret_value = PDC_Server_init(port, &hg_class_g, &hg_context_g); + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_init"); // Register Mercury RPC/bulk PDC_Server_mercury_register(); @@ -2268,17 +2172,16 @@ server_run(int argc, char *argv[]) // Lookup and get addresses of other servers char *lookup_on_demand = getenv("PDC_LOOKUP_ON_DEMAND"); - if (lookup_on_demand != NULL) { - if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[0]: will lookup other PDC servers on demand\n"); - } + if (lookup_on_demand != NULL && pdc_server_rank_g == 0) + LOG_INFO("Rank 0 will lookup other PDC servers on demand\n"); else PDC_Server_lookup_all_servers(); // Write server addrs to the config file for client to read from - if (pdc_server_rank_g == 0) - if (PDC_Server_write_addr_to_file(all_addr_strings_g, pdc_server_size_g) != SUCCEED) - LOG_ERROR("==PDC_SERVER[%d]: Error with write config file\n", pdc_server_rank_g); + if (pdc_server_rank_g == 0 && + PDC_Server_write_addr_to_file(all_addr_strings_g, pdc_server_size_g) != SUCCEED) { + LOG_ERROR("Error with write config file\n"); + } #ifdef ENABLE_ROCKSDB if (use_rocksdb_g) { @@ -2307,7 +2210,7 @@ server_run(int argc, char *argv[]) rocksdb_g = rocksdb_open(options, rocksdb_path, &err); assert(!err); if (pdc_server_rank_g == 0) - LOG_INFO("==PDC_SERVER[%d]: RocksDB initialized\n", pdc_server_rank_g); + LOG_INFO("RocksDB initialized\n"); } #endif @@ -2324,27 +2227,27 @@ server_run(int argc, char *argv[]) "value_int INTEGER, value_float REAL, value_double REAL, value_blob BLOB);", 0, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); // Create indexes sqlite3_exec(sqlite3_db_g, "CREATE INDEX index_name ON objects(name);", 0, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); sqlite3_exec(sqlite3_db_g, "CREATE INDEX index_value_int ON objects(value_int);", 0, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); sqlite3_exec(sqlite3_db_g, "CREATE INDEX index_value_text ON objects(value_text);", 0, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); sqlite3_exec(sqlite3_db_g, "CREATE INDEX index_value_float ON objects(value_float);", 0, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); sqlite3_exec(sqlite3_db_g, "CREATE INDEX index_value_double ON objects(value_double);", 0, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); } #endif @@ -2359,15 +2262,14 @@ server_run(int argc, char *argv[]) if (pdc_server_rank_g == 0) { #ifdef PDC_TIMING - LOG_INFO("==PDC_SERVER[%d]: total startup time = %.6f\n", pdc_server_rank_g, server_init_time); + LOG_INFO("Total startup time = %.6f\n", server_init_time); #endif #ifdef ENABLE_MPI - LOG_INFO("==PDC_SERVER[%d]: Server ready!\n\n\n", pdc_server_rank_g); + LOG_INFO("Server ready!\n\n\n"); #else - LOG_INFO("==PDC_SERVER[%d]: Server ready (no MPI)!\n\n\n", pdc_server_rank_g); + LOG_INFO("Server ready (MPI disabled)\n\n\n"); #endif } - fflush(stdout); // Main loop to handle Mercury RPC/Bulk requests #ifdef ENABLE_MULTITHREAD @@ -2387,7 +2289,7 @@ server_run(int argc, char *argv[]) struct stat st; snprintf(rocksdb_fname, ADDR_MAX, "/tmp/PDC_rocksdb_%d", pdc_server_rank_g); stat(rocksdb_fname, &st); - LOG_INFO("==PDC_SERVER[%d]: RocksDB file size %lu\n", pdc_server_rank_g, st.st_size); + LOG_INFO("RocksDB file size %lu\n", st.st_size); rocksdb_close(rocksdb_g); } @@ -2399,8 +2301,8 @@ server_run(int argc, char *argv[]) struct stat st; snprintf(sqlite3_fname, ADDR_MAX, "/tmp/PDC_sqlite3_%d", pdc_server_rank_g); stat(sqlite3_fname, &st); - LOG_INFO("==PDC_SERVER[%d]: SQLite3 max memory usage: %llu, DB file size %lu\n", pdc_server_rank_g, - sqlite3_memory_highwater(0), st.st_size); + LOG_INFO("SQLite3 max memory usage: %llu, DB file size %lu\n", sqlite3_memory_highwater(0), + st.st_size); sqlite3_close(sqlite3_db_g); } #endif @@ -2413,5 +2315,5 @@ server_run(int argc, char *argv[]) MPI_Finalize(); #endif - FUNC_LEAVE(0); + FUNC_LEAVE(ret_value); } diff --git a/src/server/pdc_server_analysis/pdc_server_analysis.c b/src/server/pdc_server_analysis/pdc_server_analysis.c index 31e6f829b..ae6a98632 100644 --- a/src/server/pdc_server_analysis/pdc_server_analysis.c +++ b/src/server/pdc_server_analysis/pdc_server_analysis.c @@ -120,7 +120,7 @@ PDC_Server_instantiate_data_iterator(obj_data_iterator_in_t *in, obj_data_iterat thisIter->storage_order = (_pdc_major_type_t)((in->storageinfo >> 8) & 0xFF); region_reference = PDC_Server_get_obj_region(in->object_id); if (region_reference == NULL) { - LOG_ERROR("==PDC_ANALYSIS_SERVER: Unable to locate object region (id=%" PRIu64 ")\n", in->object_id); + LOG_ERROR("Unable to locate object region (id=%" PRIu64 ")\n", in->object_id); /* The most likely cause of this condition is that the client never * created an object mapping which would move the client data to the data-server. * We now have the option to either fail, or to create a new temporary region. @@ -130,7 +130,7 @@ PDC_Server_instantiate_data_iterator(obj_data_iterator_in_t *in, obj_data_iterat out->server_region_id = -1; } else { - LOG_INFO("==PDC_ANALYSIS_SERVER: Found object region for id=%" PRIu64 "\n", in->object_id); + LOG_INFO("Found object region for id=%" PRIu64 "\n", in->object_id); out->server_region_id = in->object_id; } @@ -181,7 +181,6 @@ PDC_Server_get_ftn_reference(char *ftn) if ((appHandle = dlopen(0, RTLD_NOW)) == NULL) { char *this_error = dlerror(); LOG_ERROR("dlopen failed: %s\n", this_error); - fflush(stderr); FUNC_LEAVE(NULL); } } @@ -214,6 +213,7 @@ size_t PDCobj_data_getNextBlock(pdcid_t iter, void **nextBlock, size_t *dims) { FUNC_ENTER(NULL); + int ret_value = SUCCEED; struct _pdc_iterator_info *thisIter = NULL; /* Special case to handle a NULL iterator */ @@ -233,7 +233,7 @@ PDCobj_data_getNextBlock(pdcid_t iter, void **nextBlock, size_t *dims) if ((thisIter->srcNext = PDC_Server_get_region_data_ptr(thisIter->objectId)) == NULL) thisIter->srcNext = PDC_malloc(thisIter->totalElements * thisIter->element_size); if ((thisIter->srcStart = thisIter->srcNext) == NULL) { - LOG_ERROR("==PDC_ANALYSIS_SERVER: Unable to allocate iterator storage\n"); + LOG_ERROR("Unable to allocate iterator storage\n"); FUNC_LEAVE(0); } thisIter->srcNext += thisIter->startOffset + thisIter->skipCount; @@ -252,7 +252,7 @@ PDCobj_data_getNextBlock(pdcid_t iter, void **nextBlock, size_t *dims) *nextBlock = NULL; thisIter->sliceNext = 0; thisIter->srcNext = NULL; - goto done; + PGOTO_DONE(ret_value); } if (nextBlock) *nextBlock = thisIter->srcNext; @@ -296,7 +296,7 @@ PDCobj_data_getNextBlock(pdcid_t iter, void **nextBlock, size_t *dims) if (nextBlock) *nextBlock = NULL; - FUNC_LEAVE(0); + FUNC_LEAVE(ret_value); } int diff --git a/src/server/pdc_server_metadata.c b/src/server/pdc_server_metadata.c index 50bbd18f6..efec78ff5 100644 --- a/src/server/pdc_server_metadata.c +++ b/src/server/pdc_server_metadata.c @@ -250,17 +250,13 @@ find_metadata_by_id_from_list(pdc_metadata_t *mlist, uint64_t obj_id) pdc_metadata_t *ret_value, *elt; ret_value = NULL; - if (mlist == NULL) { - ret_value = NULL; - goto done; - } + if (mlist == NULL) + PGOTO_DONE(NULL); DL_FOREACH(mlist, elt) { - if (elt->obj_id == obj_id) { - ret_value = elt; - goto done; - } + if (elt->obj_id == obj_id) + PGOTO_DONE(elt); } done: @@ -296,10 +292,10 @@ find_metadata_by_id(uint64_t obj_id) } } } - } // if (metadata_hash_table_g != NULL) + } else { - LOG_INFO("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); - goto done; + LOG_WARNING("metadata_hash_table_g not initialized\n"); + PGOTO_DONE(ret_value); } done: @@ -381,19 +377,15 @@ find_identical_metadata(pdc_hash_table_entry_head *entry, pdc_metadata_t *a) #endif n_bloom_total_g++; - if (bloom_check == 0) { - ret_value = NULL; - goto done; - } + if (bloom_check == 0) + PGOTO_DONE(NULL); else { // bloom filter says maybe, so need to check entire list n_bloom_maybe_g++; DL_FOREACH(entry->metadata, elt) { - if (PDC_metadata_cmp(elt, a) == 0) { - ret_value = elt; - goto done; - } + if (PDC_metadata_cmp(elt, a) == 0) + PGOTO_DONE(elt); } } } @@ -401,12 +393,10 @@ find_identical_metadata(pdc_hash_table_entry_head *entry, pdc_metadata_t *a) // Bloom has not been created DL_FOREACH(entry->metadata, elt) { - if (PDC_metadata_cmp(elt, a) == 0) { - ret_value = elt; - goto done; - } + if (PDC_metadata_cmp(elt, a) == 0) + PGOTO_DONE(elt); } - } // if bloom==NULL + } done: FUNC_LEAVE(ret_value); @@ -446,19 +436,15 @@ PDC_Server_init_hash_table() // Metadata hash table metadata_hash_table_g = hash_table_new(PDC_Server_metadata_int_hash, PDC_Server_metadata_int_equal); - if (metadata_hash_table_g == NULL) { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g init error! Exit...\n"); - goto done; - } + if (metadata_hash_table_g == NULL) + PGOTO_ERROR(FAIL, "metadata_hash_table_g init error, exit..."); hash_table_register_free_functions(metadata_hash_table_g, PDC_Server_metadata_int_hash_key_free, PDC_Server_metadata_hash_value_free); // Container hash table container_hash_table_g = hash_table_new(PDC_Server_metadata_int_hash, PDC_Server_metadata_int_equal); - if (container_hash_table_g == NULL) { - LOG_ERROR("==PDC_SERVER: container_hash_table_g init error! Exit...\n"); - goto done; - } + if (container_hash_table_g == NULL) + PGOTO_ERROR(FAIL, "metadata_hash_table_g init error, exit..."); hash_table_register_free_functions(container_hash_table_g, PDC_Server_metadata_int_hash_key_free, PDC_Server_container_hash_value_free); @@ -483,20 +469,15 @@ PDC_Server_remove_from_bloom(pdc_metadata_t *metadata, BLOOM_TYPE_T *bloom) perr_t ret_value = SUCCEED; - if (bloom == NULL) { - LOG_ERROR("==PDC_SERVER: PDC_Server_remove_from_bloom(): bloom pointer is NULL\n"); - ret_value = FAIL; - goto done; - } + if (bloom == NULL) + PGOTO_ERROR(FAIL, "PDC_Server_remove_from_bloom pointer is NULL\n"); char combined_string[TAG_LEN_MAX]; combine_obj_info_to_string(metadata, combined_string); ret_value = BLOOM_REMOVE(bloom, combined_string, strlen(combined_string)); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_remove_from_bloom() - error\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Rank [%d]: PDC_Server_remove_from_bloom() - error\n", pdc_server_rank_g); done: FUNC_LEAVE(ret_value); @@ -518,17 +499,14 @@ PDC_Server_add_to_bloom(pdc_metadata_t *metadata, BLOOM_TYPE_T *bloom) perr_t ret_value = SUCCEED; char combined_string[TAG_LEN_MAX]; - if (bloom == NULL) { - goto done; - } + if (bloom == NULL) + PGOTO_ERROR(FAIL, "bloom was NULL"); combine_obj_info_to_string(metadata, combined_string); ret_value = BLOOM_ADD(bloom, combined_string, strlen(combined_string)); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_add_to_bloom() - error \n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with BLOOM_ADD"); done: FUNC_LEAVE(ret_value); @@ -546,7 +524,7 @@ PDC_Server_bloom_init(pdc_hash_table_entry_head *entry) { FUNC_ENTER(NULL); - perr_t ret_value = 0; + perr_t ret_value = SUCCEED; int capacity = 500000; double error_rate = 0.05; @@ -564,11 +542,8 @@ PDC_Server_bloom_init(pdc_hash_table_entry_head *entry) #endif entry->bloom = (BLOOM_TYPE_T *)BLOOM_NEW(capacity, error_rate); - if (!entry->bloom) { - LOG_ERROR("ERROR: Could not create bloom filter\n"); - ret_value = -1; - goto done; - } + if (entry->bloom == NULL) + PGOTO_ERROR(FAIL, "Could not create bloom filter"); #ifdef ENABLE_TIMING // Timing @@ -598,19 +573,13 @@ PDC_Server_hash_table_list_insert(pdc_hash_table_entry_head *head, pdc_metadata_ PDC_Server_add_to_bloom(elt, head->bloom); } ret_value = PDC_Server_add_to_bloom(new, head->bloom); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_hash_table_list_insert() - error add to bloom\n", - pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error add to bloom"); } else if (head->n_obj >= CREATE_BLOOM_THRESHOLD || head->bloom != NULL) { ret_value = PDC_Server_add_to_bloom(new, head->bloom); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_hash_table_list_insert() - error add to bloom\n", - pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error add to bloom\n"); } #ifdef ENABLE_MULTITHREAD @@ -625,7 +594,6 @@ PDC_Server_hash_table_list_insert(pdc_hash_table_entry_head *head, pdc_metadata_ #endif done: - FUNC_LEAVE(ret_value); } @@ -648,11 +616,8 @@ PDC_Server_hash_table_list_init(pdc_hash_table_entry_head *entry, uint32_t *hash // Insert to hash table ret = hash_table_insert(metadata_hash_table_g, hash_key, entry); - if (ret != 1) { - LOG_ERROR("PDC_Server_hash_table_list_init(): Error with hash table insert!\n"); - ret_value = FAIL; - goto done; - } + if (ret != 1) + PGOTO_ERROR(FAIL, "PDC_Server_hash_table_list_init error with hash table insert"); #ifdef ENABLE_TIMING // Timing @@ -687,10 +652,8 @@ PDC_Server_add_tag_metadata(metadata_add_tag_in_t *in, metadata_add_tag_out_t *o #endif hash_key = (uint32_t *)PDC_malloc(sizeof(uint32_t)); - if (hash_key == NULL) { - LOG_ERROR("==PDC_SERVER: Cannot allocate hash_key!\n"); - goto done; - } + if (hash_key == NULL) + PGOTO_ERROR(FAIL, "Cannot allocate hash_key"); total_mem_usage_g += sizeof(uint32_t); *hash_key = in->hash_value; uint64_t obj_id = in->obj_id; @@ -729,28 +692,24 @@ PDC_Server_add_tag_metadata(metadata_add_tag_in_t *in, metadata_add_tag_out_t *o } // end if (target != NULL) else { // Object not found for deletion request - LOG_ERROR("==PDC_SERVER: add tag target not found 1!\n"); + LOG_ERROR("Add tag target not found \n"); out->ret = -1; } } // end if lookup_value != NULL else { - LOG_ERROR("==PDC_SERVER: add tag target not found 2!\n"); + LOG_ERROR("Add tag target not found 2\n"); out->ret = -1; } } // if (metadata_hash_table_g != NULL) else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initilized!\n"); - ret_value = FAIL; - out->ret = -1; - goto done; + out->ret = -1; + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initilized"); } - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: error \n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_DONE(FAIL); #ifdef ENABLE_MULTITHREAD // ^ Release hash table lock @@ -781,8 +740,6 @@ PDC_Server_add_tag_metadata(metadata_add_tag_in_t *in, metadata_add_tag_out_t *o if (unlocked == 0) hg_thread_mutex_unlock(&pdc_metadata_hash_table_mutex_g); #endif - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -807,10 +764,8 @@ PDC_Server_update_metadata(metadata_update_in_t *in, metadata_update_out_t *out) #endif hash_key = (uint32_t *)PDC_malloc(sizeof(uint32_t)); - if (hash_key == NULL) { - LOG_ERROR("==PDC_SERVER: Cannot allocate hash_key!\n"); - goto done; - } + if (hash_key == NULL) + PGOTO_ERROR(FAIL, "Cannot allocate hash_key"); total_mem_usage_g += sizeof(uint32_t); *hash_key = in->hash_value; obj_id = in->obj_id; @@ -874,10 +829,8 @@ PDC_Server_update_metadata(metadata_update_in_t *in, metadata_update_out_t *out) } // if (metadata_hash_table_g != NULL) else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); - ret_value = -1; - out->ret = -1; - goto done; + out->ret = -1; + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); } #ifdef ENABLE_MULTITHREAD @@ -909,7 +862,6 @@ PDC_Server_update_metadata(metadata_update_in_t *in, metadata_update_out_t *out) if (unlocked == 0) hg_thread_mutex_unlock(&pdc_metadata_hash_table_mutex_g); #endif - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -959,14 +911,12 @@ PDC_Server_delete_metadata_by_id(metadata_delete_by_id_in_t *in, metadata_delete if (cont_entry->cont_id == target_obj_id) { hash_table_remove(container_hash_table_g, pair.key); - out->ret = 1; - ret_value = SUCCEED; - goto done; + out->ret = 1; + PGOTO_DONE(SUCCEED); } } } if (out->ret == -1 && metadata_hash_table_g != NULL) { - // Since we only have the obj id, need to iterate the entire hash table pdc_hash_table_entry_head *head; @@ -1006,10 +956,8 @@ PDC_Server_delete_metadata_by_id(metadata_delete_by_id_in_t *in, metadata_delete } // while } // if (metadata_hash_table_g != NULL) else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); - ret_value = FAIL; - out->ret = -1; - goto done; + out->ret = -1; + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); } done: @@ -1073,10 +1021,8 @@ PDC_delete_metadata_from_hash_table(metadata_delete_in_t *in, metadata_delete_ou #endif hash_key = (uint32_t *)PDC_malloc(sizeof(uint32_t)); - if (hash_key == NULL) { - LOG_ERROR("==PDC_SERVER: Cannot allocate hash_key!\n"); - goto done; - } + if (hash_key == NULL) + PGOTO_ERROR(FAIL, "Cannot allocate hash_key"); total_mem_usage_g += sizeof(uint32_t); *hash_key = in->hash_value; @@ -1122,24 +1068,22 @@ PDC_delete_metadata_from_hash_table(metadata_delete_in_t *in, metadata_delete_ou } // if (lookup_value != NULL) else { // Object not found for deletion request - LOG_ERROR("==PDC_SERVER: delete target not found!\n"); + LOG_ERROR("Delete target not found\n"); ret_value = -1; out->ret = -1; } } // if lookup_value != NULL else { - LOG_ERROR("==PDC_SERVER: delete target not found!\n"); + LOG_ERROR("Delete target not found\n"); ret_value = -1; out->ret = -1; } } // if (metadata_hash_table_g != NULL) else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); - ret_value = -1; - out->ret = -1; - goto done; + out->ret = -1; + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); } #ifdef ENABLE_MULTITHREAD @@ -1206,10 +1150,8 @@ PDC_insert_metadata_to_hash_table(gen_obj_id_in_t *in, gen_obj_id_out_t *out) #endif metadata = (pdc_metadata_t *)PDC_malloc(sizeof(pdc_metadata_t)); - if (metadata == NULL) { - LOG_ERROR("Cannot allocate pdc_metadata_t!\n"); - goto done; - } + if (metadata == NULL) + PGOTO_ERROR(FAIL, "Cannot allocate pdc_metadata_t"); #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(&total_mem_usage_mutex_g); @@ -1241,10 +1183,8 @@ PDC_insert_metadata_to_hash_table(gen_obj_id_in_t *in, gen_obj_id_out_t *out) strcpy(metadata->data_location, in->data.data_location); hash_key = (uint32_t *)PDC_malloc(sizeof(uint32_t)); - if (hash_key == NULL) { - LOG_ERROR("Cannot allocate hash_key!\n"); - goto done; - } + if (hash_key == NULL) + PGOTO_ERROR(FAIL, "Cannot allocate hash_key"); total_mem_usage_g += sizeof(uint32_t); *hash_key = in->hash_value; @@ -1265,15 +1205,14 @@ PDC_insert_metadata_to_hash_table(gen_obj_id_in_t *in, gen_obj_id_out_t *out) // Is this hash value exist in the Hash table? if (lookup_value != NULL) { if (debug_flag == 1) - LOG_DEBUG("lookup_value not NULL!\n"); + LOG_DEBUG("lookup_value not NULL\n"); // Check if there exist metadata identical to current one found_identical = find_identical_metadata(lookup_value, metadata); if (found_identical != NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Found identical metadata with name %s!\n", pdc_server_rank_g, - metadata->obj_name); out->obj_id = 0; metadata = (pdc_metadata_t *)PDC_free(metadata); - goto done; + PGOTO_ERROR(FAIL, "Found identical metadata with name %s", pdc_server_rank_g, + metadata->obj_name); } else { PDC_Server_hash_table_list_insert(lookup_value, metadata); @@ -1281,10 +1220,8 @@ PDC_insert_metadata_to_hash_table(gen_obj_id_in_t *in, gen_obj_id_out_t *out) } else { // First entry for current hasy_key, init linked list, and insert to hash table - if (debug_flag == 1) { + if (debug_flag == 1) LOG_DEBUG("lookup_value is NULL! Init linked list\n"); - } - fflush(stdout); pdc_hash_table_entry_head *entry = (pdc_hash_table_entry_head *)PDC_malloc(sizeof(pdc_hash_table_entry_head)); @@ -1297,10 +1234,8 @@ PDC_insert_metadata_to_hash_table(gen_obj_id_in_t *in, gen_obj_id_out_t *out) PDC_Server_hash_table_list_insert(entry, metadata); } } - else { - LOG_ERROR("metadata_hash_table_g not initialized!\n"); - goto done; - } + else + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); // Generate object id (uint64_t) metadata->obj_id = PDC_Server_gen_obj_id(); @@ -1428,12 +1363,10 @@ PDC_Server_metadata_duplicate_check() #endif if (pdc_server_rank_g == 0) { - LOG_INFO("==PDC_SERVER: Bloom filter says maybe %d times out of %d\n", all_maybe, all_total); - LOG_INFO("==PDC_SERVER: Metadata duplicate check with %d hash entries ", all_entry); + LOG_INFO("Bloom filter says maybe %d times out of %d\n", all_maybe, all_total); + LOG_INFO("Metadata duplicate check with %d hash entries\n", all_entry); } - fflush(stdout); - hash_table_iterate(metadata_hash_table_g, &hash_table_iter); while (n_entry != 0 && hash_table_iter_has_more(&hash_table_iter)) { @@ -1447,16 +1380,13 @@ PDC_Server_metadata_duplicate_check() if (elt_next != NULL) { if (PDC_metadata_cmp(elt, elt_next) == 0) { has_dup_obj = 1; - ret_value = FAIL; - goto done; + PGOTO_DONE(FAIL); } } } count++; } - fflush(stdout); - done: #ifdef ENABLE_MPI MPI_Reduce(&has_dup_obj, &all_dup_obj, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); @@ -1465,10 +1395,10 @@ PDC_Server_metadata_duplicate_check() #endif if (pdc_server_rank_g == 0) { if (all_dup_obj > 0) { - LOG_INFO(" ...Found duplicates!\n"); + LOG_INFO(" ...Found duplicates\n"); } else { - LOG_INFO(" ...No duplicates found!\n"); + LOG_INFO(" ...No duplicates found\n"); } } @@ -1490,34 +1420,22 @@ is_metadata_satisfy_constraint(pdc_metadata_t *metadata, metadata_query_transfer int ret_value = 1; - if (constraints->user_id > 0 && constraints->user_id != metadata->user_id) { - ret_value = -1; - goto done; - } - if (strcmp(constraints->app_name, " ") != 0 && strcmp(metadata->app_name, constraints->app_name) != 0) { - ret_value = -1; - goto done; - } - if (strcmp(constraints->obj_name, " ") != 0 && strcmp(metadata->obj_name, constraints->obj_name) != 0) { - ret_value = -1; - goto done; - } + if (constraints->user_id > 0 && constraints->user_id != metadata->user_id) + PGOTO_DONE(-1); + if (strcmp(constraints->app_name, " ") != 0 && strcmp(metadata->app_name, constraints->app_name) != 0) + PGOTO_DONE(-1); + if (strcmp(constraints->obj_name, " ") != 0 && strcmp(metadata->obj_name, constraints->obj_name) != 0) + PGOTO_DONE(-1); if (constraints->time_step_from > 0 && constraints->time_step_to > 0 && (metadata->time_step < constraints->time_step_from || metadata->time_step > constraints->time_step_to)) { - ret_value = -1; - goto done; - } - if (constraints->ndim > 0 && metadata->ndim != constraints->ndim) { - ret_value = -1; - goto done; + PGOTO_DONE(-1); } + if (constraints->ndim > 0 && metadata->ndim != constraints->ndim) + PGOTO_DONE(-1); // TODO: Currently only supports searching with one tag - if (strcmp(constraints->tags, " ") != 0 && strstr(metadata->tags, constraints->tags) == NULL) { - - ret_value = -1; - goto done; - } + if (strcmp(constraints->tags, " ") != 0 && strstr(metadata->tags, constraints->tags) == NULL) + PGOTO_DONE(-1); done: FUNC_LEAVE(ret_value); @@ -1528,7 +1446,7 @@ PDC_Server_get_partial_query_result(metadata_query_transfer_in_t *in, uint32_t * { FUNC_ENTER(NULL); - perr_t ret_value = FAIL; + perr_t ret_value = SUCCEED; uint32_t i; uint32_t n_buf, iter = 0; pdc_hash_table_entry_head *head; @@ -1545,7 +1463,6 @@ PDC_Server_get_partial_query_result(metadata_query_transfer_in_t *in, uint32_t * } // TODO: free buf_ptrs if (metadata_hash_table_g != NULL) { - n_entry = hash_table_num_entries(metadata_hash_table_g); hash_table_iterate(metadata_hash_table_g, &hash_table_iter); @@ -1566,13 +1483,8 @@ PDC_Server_get_partial_query_result(metadata_query_transfer_in_t *in, uint32_t * } *n_meta = iter; } // if (metadata_hash_table_g != NULL) - else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); - ret_value = FAIL; - goto done; - } - - ret_value = SUCCEED; + else + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); done: FUNC_LEAVE(ret_value); @@ -1728,7 +1640,7 @@ PDC_Server_query_kvtag_rocksdb(pdc_kvtag_t *in, uint32_t *n_meta, uint64_t **obj if (rocksdb_iter) rocksdb_iter_destroy(rocksdb_iter); #else - LOG_ERROR("==PDC_SERVER[%d]: enabled rocksdb but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled rocksdb but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -1828,11 +1740,11 @@ PDC_Server_query_kvtag_sqlite(pdc_kvtag_t *in, uint32_t *n_meta, uint64_t **obj_ // Construct a SQL query sqlite3_exec(sqlite3_db_g, sql, sqlite_query_kvtag_callback, &query_data, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); *n_meta = query_data.nobj; #else - LOG_ERROR("==PDC_SERVER[%d]: enabled SQLite3 but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled SQLite3 but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -1864,7 +1776,7 @@ PDC_Server_query_kvtag_someta(pdc_kvtag_t *in, uint32_t *n_meta, uint64_t **obj_ DL_FOREACH(head->metadata, elt) { #ifdef PDC_DEBUG_OUTPUT - LOG_DEBUG("==PDC_SERVER: Matching kvtag [\"%s\":\"%s\"] of object %s on condition in->key: " + LOG_DEBUG("Matching kvtag [\"%s\":\"%s\"] of object %s on condition in->key: " "%s, in->value: %s ", (char *)kvtag_list_elt->kvtag->name, (char *)kvtag_list_elt->kvtag->value, elt->obj_name, in->name, in->value); @@ -1873,7 +1785,7 @@ PDC_Server_query_kvtag_someta(pdc_kvtag_t *in, uint32_t *n_meta, uint64_t **obj_ { if (_is_matching_kvtag(in, kvtag_list_elt->kvtag) == TRUE) { #ifdef PDC_DEBUG_OUTPUT - println("[Found]"); + LOG_JUST_PRINT("[Found]\n"); #endif if (iter >= alloc_size) { alloc_size *= 2; @@ -1884,7 +1796,7 @@ PDC_Server_query_kvtag_someta(pdc_kvtag_t *in, uint32_t *n_meta, uint64_t **obj_ } else { #ifdef PDC_DEBUG_OUTPUT - println("[NOT FOUND]"); + LOG_JUST_PRINT("[NOT FOUND]\n"); #endif } } // End for each kvtag in list @@ -1892,11 +1804,11 @@ PDC_Server_query_kvtag_someta(pdc_kvtag_t *in, uint32_t *n_meta, uint64_t **obj_ } // End looping metadata hash table *n_meta = iter; #ifdef PDC_DEBUG_OUTPUT - LOG_DEBUG("==PDC_SERVER[%d]: found %d objids \n", pdc_server_rank_g, iter); + LOG_DEBUG("Found %d objids\n", iter); #endif - } // if (metadata_hash_table_g != NULL) + } else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); + LOG_ERROR("metadata_hash_table_g not initialized\n"); ret_value = FAIL; } @@ -1916,42 +1828,32 @@ PDC_Server_get_kvtag_query_result(pdc_kvtag_t *in /*FIXME: query input should be *obj_ids = (void *)PDC_calloc(alloc_size, sizeof(uint64_t)); char *v_query = (char *)in->value; - LOG_INFO("==PDC_SERVER[%d] before stripQuotes: Querying kvtag with key [%s], value [%s]\n", - pdc_server_rank_g, in->name, (char *)in->value); + LOG_INFO("Before stripQuotes: Querying kvtag with key [%s], value [%s]\n", in->name, (char *)in->value); if (is_string_query(v_query)) { in->value = stripQuotes(v_query); in->type = PDC_STRING; } - LOG_INFO("==PDC_SERVER[%d] after stripQuotes: Querying kvtag with key [%s], value [%s]\n", - pdc_server_rank_g, in->name, (char *)in->value); + LOG_INFO("After stripQuotes: Querying kvtag with key [%s], value [%s]\n", in->name, (char *)in->value); if (use_rocksdb_g == 1) { ret_value = PDC_Server_query_kvtag_rocksdb(in, n_meta, obj_ids, alloc_size); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_query_kvtag_rocksdb!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_query_kvtag_rocksdb"); } else if (use_sqlite3_g) { ret_value = PDC_Server_query_kvtag_sqlite(in, n_meta, obj_ids, alloc_size); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_query_kvtag_sqlite!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_query_kvtag_sqlite"); } // End if SQLite3 else { // SoMeta backend ret_value = PDC_Server_query_kvtag_someta(in, n_meta, obj_ids, alloc_size); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_query_kvtag_someta!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_query_kvtag_someta"); } done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -1983,27 +1885,20 @@ PDC_Server_search_with_name_timestep(const char *obj_name, uint32_t hash_key, ui // Is this hash value exist in the Hash table? if (lookup_value != NULL) { *out = find_identical_metadata(lookup_value, &metadata); - - if (*out == NULL) { - ret_value = FAIL; - goto done; - } + if (*out == NULL) + PGOTO_DONE(FAIL); } else { *out = NULL; } } - else { - LOG_ERROR("metadata_hash_table_g not initialized!\n"); - ret_value = -1; - goto done; - } + else + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); if (*out == NULL) - LOG_ERROR("==PDC_SERVER[%d]: Queried object with name [%s] not found! \n", pdc_server_rank_g, name); + PGOTO_ERROR(FAIL, "Queried object with name [%s] not found", name); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2035,27 +1930,20 @@ PDC_Server_search_with_name_hash(const char *obj_name, uint32_t hash_key, pdc_me // Is this hash value exist in the Hash table? if (lookup_value != NULL) { *out = find_identical_metadata(lookup_value, &metadata); - - if (*out == NULL) { - ret_value = FAIL; - goto done; - } + if (*out == NULL) + PGOTO_DONE(FAIL); } else { *out = NULL; } } - else { - LOG_ERROR("metadata_hash_table_g not initialized!\n"); - ret_value = -1; - goto done; - } + else + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); if (*out == NULL) - LOG_ERROR("==PDC_SERVER[%d]: Queried object with name [%s] not found! \n", pdc_server_rank_g, name); + PGOTO_ERROR(FAIL, "Queried object with name [%s] not found", name); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2087,16 +1975,14 @@ PDC_Server_get_local_metadata_by_id(uint64_t obj_id, pdc_metadata_t **res_meta_p { if (elt->obj_id == obj_id) { *res_meta_ptr = elt; - goto done; + PGOTO_DONE(ret_value); } } } } else { - LOG_ERROR("==PDC_SERVER: metadata_hash_table_g not initialized!\n"); - ret_value = FAIL; *res_meta_ptr = NULL; - goto done; + PGOTO_ERROR(FAIL, "metadata_hash_table_g not initialized"); } done: @@ -2125,31 +2011,24 @@ PDC_Server_get_metadata_by_id_cb(const struct hg_cb_info *callback_info) handle = callback_info->info.forward.handle; ret_value = HG_Get_output(handle, &output); - if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_get_metadata_by_id_cb - error HG_Get_output\n", - pdc_server_rank_g); - goto done; - } + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Error HG_Get_output"); if (output.res_meta.obj_id != 0) { // TODO free metdata meta = (pdc_metadata_t *)PDC_malloc(sizeof(pdc_metadata_t)); PDC_transfer_t_to_metadata_t(&output.res_meta, meta); } - else { - LOG_ERROR("==PDC_SERVER[%d]: no valid metadata is retrieved\n", pdc_server_rank_g); - goto done; - } + else + PGOTO_ERROR(ret_value, "No valid metadata is retrieved"); // Execute the callback function if (NULL != cb_args->cb) { ((region_list_t *)(cb_args->args))->meta = meta; cb_args->cb(cb_args->args, PDC_POSIX); } - else { - LOG_ERROR("==PDC_SERVER[%d]: NULL callback ptr\n", pdc_server_rank_g); - goto done; - } + else + PGOTO_ERROR(ret_value, "NULL callback ptr"); done: HG_Free_output(handle, &output); @@ -2176,10 +2055,8 @@ PDC_Server_get_metadata_by_id_with_cb(uint64_t obj_id, perr_t (*cb)(), void *arg if (server_id == (uint32_t)pdc_server_rank_g) { // Metadata object is local, no need to send update RPC ret_value = PDC_Server_get_local_metadata_by_id(obj_id, &res_meta_ptr); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_get_local_metadata_by_id FAILED!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_get_local_metadata_by_id"); ((region_list_t *)args)->meta = res_meta_ptr; // Call the callback function directly and pass in the result metadata ptr @@ -2187,10 +2064,7 @@ PDC_Server_get_metadata_by_id_with_cb(uint64_t obj_id, perr_t (*cb)(), void *arg } else { if (PDC_Server_lookup_server_id(server_id) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting remote server %d addr via lookup\n", pdc_server_rank_g, - server_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error getting remote server %d addr via lookup", server_id); } HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, get_metadata_by_id_register_id_g, @@ -2205,16 +2079,13 @@ PDC_Server_get_metadata_by_id_with_cb(uint64_t obj_id, perr_t (*cb)(), void *arg hg_ret = HG_Forward(get_metadata_by_id_handle, PDC_Server_get_metadata_by_id_cb, &cb_args, &in); if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: Could not forward\n", pdc_server_rank_g); res_meta_ptr = NULL; HG_Destroy(get_metadata_by_id_handle); - FUNC_LEAVE(FAIL); + PGOTO_ERROR(FAIL, "Could not forward"); } } done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -2262,11 +2133,8 @@ PDC_Server_create_container(gen_cont_id_in_t *in, gen_cont_id_out_t *out) } else { hash_key = (uint32_t *)PDC_malloc(sizeof(uint32_t)); - if (hash_key == NULL) { - LOG_ERROR("Cannot allocate hash_key!\n"); - ret_value = FAIL; - goto done; - } + if (hash_key == NULL) + PGOTO_ERROR(FAIL, "Cannot allocate hash_key"); *hash_key = in->hash_value; pdc_cont_hash_table_entry_t *entry = @@ -2284,18 +2152,14 @@ PDC_Server_create_container(gen_cont_id_in_t *in, gen_cont_id_out_t *out) hg_thread_mutex_unlock(&total_mem_usage_mutex_g); #endif // Insert to hash table - if (hash_table_insert(container_hash_table_g, hash_key, entry) != 1) { - LOG_ERROR("==PDC_SERVER[%d]: hash table insert failed\n", pdc_server_rank_g); - ret_value = FAIL; - } + if (hash_table_insert(container_hash_table_g, hash_key, entry) != 1) + PGOTO_ERROR(FAIL, "Hash table insert failed"); else out->cont_id = entry->cont_id; } } - else { - LOG_ERROR("==PDC_SERVER[%d]: container_hash_table_g not initialized!\n", pdc_server_rank_g); - goto done; - } + else + PGOTO_ERROR(FAIL, "container_hash_table_g not initialized"); #ifdef ENABLE_MULTITHREAD // ^ Release hash table lock @@ -2350,24 +2214,19 @@ PDC_Server_delete_container_by_name(gen_cont_id_in_t *in, gen_cont_id_out_t *out // Is this hash value exist in the Hash table? if (lookup_value != NULL) { - // Check if there exist metadata identical to current one - LOG_INFO("==PDC_SERVER[%d]: Found existing container with same hash value, name=%s!\n", - pdc_server_rank_g, lookup_value->cont_name); + LOG_INFO("Found existing container with same hash value, name=%s\n", lookup_value->cont_name); out->cont_id = 0; - goto done; + PGOTO_DONE(ret_value); } else { // Check if there exist metadata identical to current one - LOG_ERROR("==PDC_SERVER[%d]: Did not found existing container with same hash value, name=%s!\n", - pdc_server_rank_g, lookup_value->cont_name); - ret_value = FAIL; + PGOTO_ERROR(FAIL, "Did not found existing container with same hash value, name=%s", + lookup_value->cont_name); } } - else { - LOG_ERROR("==PDC_SERVER[%d]: container_hash_table_g not initialized!\n", pdc_server_rank_g); - goto done; - } + else + PGOTO_ERROR(FAIL, "container_hash_table_g not initialized"); #ifdef ENABLE_MULTITHREAD // ^ Release hash table lock @@ -2386,10 +2245,8 @@ PDC_Server_find_container_by_name(const char *cont_name, pdc_cont_hash_table_ent perr_t ret_value = SUCCEED; uint32_t hash_key; - if (NULL == cont_name || NULL == out) { - LOG_ERROR("==PDC_SERVER[%d]: input is NULL! \n", pdc_server_rank_g); - goto done; - } + if (NULL == cont_name || NULL == out) + PGOTO_ERROR(FAIL, "Input is NULL"); if (container_hash_table_g != NULL) { // lookup @@ -2402,17 +2259,13 @@ PDC_Server_find_container_by_name(const char *cont_name, pdc_cont_hash_table_ent } } } - else { - LOG_ERROR("container_hash_table_g not initialized!\n"); - ret_value = -1; - goto done; - } + else + PGOTO_ERROR(FAIL, "container_hash_table_g not initialized"); if (*out == NULL) - LOG_ERROR("==PDC_SERVER[%d]: container [%s] not found! \n", pdc_server_rank_g, cont_name); + PGOTO_ERROR(FAIL, "Container [%s] not found", cont_name); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2436,10 +2289,8 @@ PDC_Server_find_container_by_id(uint64_t cont_id, pdc_cont_hash_table_entry_t ** int n_entry; HashTablePair pair; - if (NULL == out) { - LOG_ERROR("==PDC_SERVER[%d]: input is NULL! \n", pdc_server_rank_g); - goto done; - } + if (NULL == out) + PGOTO_ERROR(FAIL, "Input is NULL"); if (container_hash_table_g != NULL) { // Since we only have the obj id, need to iterate the entire hash table @@ -2454,20 +2305,16 @@ PDC_Server_find_container_by_id(uint64_t cont_id, pdc_cont_hash_table_entry_t ** if (cont_entry->cont_id == cont_id) { *out = cont_entry; - goto done; + PGOTO_DONE(ret_value); } } } else { - LOG_ERROR("==PDC_SERVER[%d]: container_hash_table_g not initialized!\n", pdc_server_rank_g); - ret_value = FAIL; - out = NULL; - goto done; + out = NULL; + PGOTO_ERROR(FAIL, "container_hash_table_g not initialized"); } done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -2496,16 +2343,13 @@ PDC_Server_container_add_objs(int n_obj, uint64_t *obj_ids, uint64_t cont_id) realloc_size *= (sizeof(uint64_t) * 2); if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: realloc from %d to %ld!\n", pdc_server_rank_g, - cont_entry->n_allocated, realloc_size / sizeof(uint64_t)); + LOG_DEBUG("RRealloc from %d to %ld\n", cont_entry->n_allocated, + realloc_size / sizeof(uint64_t)); } cont_entry->obj_ids = (uint64_t *)PDC_realloc(cont_entry->obj_ids, realloc_size); - if (NULL == cont_entry->obj_ids) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with realloc!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (NULL == cont_entry->obj_ids) + PGOTO_ERROR(FAIL, "PDC_realloc failed"); total_mem_usage_g -= sizeof(uint64_t) * cont_entry->n_allocated; cont_entry->n_allocated = realloc_size / sizeof(uint64_t); @@ -2518,20 +2362,14 @@ PDC_Server_container_add_objs(int n_obj, uint64_t *obj_ids, uint64_t cont_id) // Debug prints if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: add %d objects to container %" PRIu64 ", total %d !\n", - pdc_server_rank_g, n_obj, cont_id, cont_entry->n_obj - cont_entry->n_deleted); + LOG_DEBUG("Add %d objects to container %" PRIu64 ", total %d\n", n_obj, cont_id, + cont_entry->n_obj - cont_entry->n_deleted); } - - // TODO: find duplicates - } - else { - LOG_ERROR("==PDC_SERVER[%d]: container %" PRIu64 " not found!\n", pdc_server_rank_g, cont_id); - ret_value = FAIL; - goto done; } + else + PGOTO_ERROR(FAIL, "Container %" PRIu64 " not found", cont_id); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2558,23 +2396,16 @@ PDC_Server_container_del_objs(int n_obj, uint64_t *obj_ids, uint64_t cont_id) } } } - // Debug print - LOG_DEBUG("==PDC_SERVER[%d]: successfully deleted %d objects!\n", pdc_server_rank_g, n_deletes); + LOG_DEBUG("Successfully deleted %d objects\n", n_deletes); if (n_deletes != n_obj) { - LOG_INFO("==PDC_SERVER[%d]: %d objects are not found to be deleted!\n", pdc_server_rank_g, - n_obj - n_deletes); + LOG_INFO("%d objects are not found to be deleted\n", n_obj - n_deletes); } } - else { - LOG_ERROR("==PDC_SERVER[%d]: container %" PRIu64 " not found!\n", pdc_server_rank_g, cont_id); - ret_value = FAIL; - goto done; - } + else + PGOTO_ERROR(FAIL, "Container %" PRIu64 " not found", cont_id); done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -2588,21 +2419,12 @@ PDC_Server_container_add_tags(uint64_t cont_id, char *tags) ret_value = PDC_Server_find_container_by_id(cont_id, &cont_entry); - if (cont_entry != NULL) { - - if (tags != NULL) { - strcat(cont_entry->tags, tags); - } - } - else { - LOG_ERROR("==PDC_SERVER[%d]: container %" PRIu64 " not found!\n", pdc_server_rank_g, cont_id); - ret_value = FAIL; - goto done; - } + if (cont_entry != NULL && tags != NULL) + strcat(cont_entry->tags, tags); + else + PGOTO_ERROR(FAIL, "Container %" PRIu64 " not found", cont_id); done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -2615,10 +2437,10 @@ PDC_copy_all_storage_meta(pdc_metadata_t *meta, region_storage_meta_t **storage_ region_list_t *region_elt = NULL, *region_head = NULL; int i, region_cnt; - if (NULL == meta || NULL == storage_meta) { - ret_value = FAIL; - goto done; - } + if (meta == NULL) + PGOTO_ERROR(FAIL, "meta was NULL"); + if (storage_meta == NULL) + PGOTO_ERROR(FAIL, "storage_meta was NULL"); region_head = meta->storage_region_list_head; DL_COUNT(region_head, region_elt, region_cnt); @@ -2679,36 +2501,28 @@ PDC_Server_get_storage_meta_by_names(query_read_names_args_t *args) // FIXME: currently assumes timestep 0 PDC_Server_search_with_name_timestep(obj_name, PDC_get_hash_by_name(obj_name), 0, &meta); if (meta == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: No metadata with name [%s] found!\n", pdc_server_rank_g, obj_name); + LOG_ERROR("No metadata with name [%s] found\n", obj_name); continue; } ret_value = PDC_copy_all_storage_meta(meta, &(all_storage_meta[i]), &(all_nregion[i])); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error when getting storage meta for [%s]!\n", pdc_server_rank_g, - obj_name); + LOG_ERROR("Error when getting storage meta for [%s]\n", obj_name); continue; } total_region += all_nregion[i]; - if (all_storage_meta[i]->storage_location[1] != 'g') { - LOG_ERROR("==PDC_SERVER[%d]: Error with storage meta for [%s], obj_id %" PRIu64 - ", loc [%s], offset " + if (all_storage_meta[i]->storage_location[1] != 'g') + LOG_ERROR("Error with storage meta for [%s], obj_id %" PRIu64 ", loc [%s], offset " "%" PRIu64 "\n", - pdc_server_rank_g, obj_name, all_storage_meta[i]->obj_id, - all_storage_meta[i]->storage_location, all_storage_meta[i]->offset); - fflush(stdout); - } - + obj_name, all_storage_meta[i]->obj_id, all_storage_meta[i]->storage_location, + all_storage_meta[i]->offset); } // End for cnt // Now the storage meta is stored in all_storage_meta; client_id = args->client_id; if (PDC_Server_lookup_client(client_id) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting client %d addr via lookup\n", pdc_server_rank_g, - client_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error getting client %d addr via lookup", client_id); } // Now we have all the storage metadata of the queried objects, send them back to client with @@ -2732,24 +2546,14 @@ PDC_Server_get_storage_meta_by_names(query_read_names_args_t *args) /* Register memory */ hg_ret = HG_Bulk_create(hg_class_g, nbuf, buf_ptrs, buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } - - if (pdc_client_info_g[client_id].addr == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Error with client %d addr\n", pdc_server_rank_g, client_id); - goto done; - } - + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); + if (pdc_client_info_g[client_id].addr == NULL) + PGOTO_ERROR(FAIL, "Error with client %d addr", client_id); hg_ret = HG_Create(hg_context_g, pdc_client_info_g[client_id].addr, send_client_storage_meta_rpc_register_id_g, &rpc_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create handle"); /* Fill input structure */ bulk_rpc_in.cnt = total_region; @@ -2758,17 +2562,12 @@ PDC_Server_get_storage_meta_by_names(query_read_names_args_t *args) bulk_rpc_in.bulk_handle = bulk_handle; hg_ret = HG_Forward(rpc_handle, PDC_check_int_ret_cb, NULL, &bulk_rpc_in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not forward call\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not forward call"); HG_Destroy(rpc_handle); done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -2822,7 +2621,6 @@ PDC_add_kvtag_to_list(pdc_kvtag_list_t **list_head, pdc_kvtag_t *tag) new_list_item->kvtag = newtag; DL_APPEND(*list_head, new_list_item); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2841,14 +2639,13 @@ PDC_Server_add_kvtag_rocksdb(metadata_add_kvtag_in_t *in, metadata_add_tag_out_t rocksdb_put(rocksdb_g, writeoptions, rocksdb_key, strlen(rocksdb_key) + 1, in->kvtag.value, in->kvtag.size, &err); if (err != NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Error with rocksdb_put %s, [%s]!\n", pdc_server_rank_g, in->kvtag.name, - err); + LOG_ERROR("Error with rocksdb_put %s, [%s]\n", in->kvtag.name, err); ret_value = FAIL; } else out->ret = 1; #else - LOG_ERROR("==PDC_SERVER[%d]: enabled rocksdb but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled rocksdb but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -2881,22 +2678,19 @@ PDC_Server_add_kvtag_sqlite3(metadata_add_kvtag_in_t *in, metadata_add_tag_out_t sprintf(sql, "INSERT INTO objects (objid, name, value_double) VALUES (%llu, '%s', '%lf');", in->obj_id, in->kvtag.name, *((double *)in->kvtag.value)); } - else { - LOG_ERROR("==PDC_SERVER[%d]: datatype not supported %d!\n", pdc_server_rank_g, in->kvtag.type); - ret_value = FAIL; - goto done; - } + else + PGOTO_ERROR(FAIL, "Datatype not supported %d", in->kvtag.type); sqlite3_exec(sqlite3_db_g, sql, NULL, 0, &errMessage); if (errMessage) - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); else out->ret = 1; done: #else - LOG_ERROR("==PDC_SERVER[%d]: enabled SQLite3 but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled SQLite3 but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -2936,8 +2730,7 @@ PDC_Server_add_kvtag_someta(metadata_add_kvtag_in_t *in, metadata_add_tag_out_t out->ret = 1; } else { - LOG_ERROR("==PDC_SERVER[%d]: add tag target %" PRIu64 " not found!\n", pdc_server_rank_g, - in->obj_id); + LOG_ERROR("Add tag target %" PRIu64 " not found\n", in->obj_id); ret_value = FAIL; out->ret = -1; } @@ -2973,24 +2766,18 @@ PDC_Server_add_kvtag(metadata_add_kvtag_in_t *in, metadata_add_tag_out_t *out) if (use_rocksdb_g == 1) { ret_value = PDC_Server_add_kvtag_rocksdb(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_add_kvtag_rocksdb!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_add_kvtag_rocksdb"); } // End if rocksdb else if (use_sqlite3_g == 1) { ret_value = PDC_Server_add_kvtag_sqlite3(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_add_kvtag_sqlite3!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_add_kvtag_sqlite3"); } // End if sqlite3 else { ret_value = PDC_Server_add_kvtag_someta(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_add_kvtag_someta!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_add_kvtag_someta"); } done: @@ -3022,8 +2809,6 @@ PDC_Server_add_kvtag(metadata_add_kvtag_in_t *in, metadata_add_tag_out_t *out) if (unlocked == 0) hg_thread_mutex_unlock(&pdc_metadata_hash_table_mutex_g); #endif - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3046,8 +2831,6 @@ PDC_get_kvtag_value_from_list(pdc_kvtag_list_t **list_head, char *key, metadata_ } } - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3113,7 +2896,7 @@ PDC_Server_get_kvtag_rocksdb(metadata_get_kvtag_in_t *in, metadata_get_kvtag_out size_t len; char * value = rocksdb_get(rocksdb_g, readoptions, rocksdb_key, strlen(rocksdb_key) + 1, &len, &err); if (value == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Error with rocksdb_get %s, [%s]!\n", pdc_server_rank_g, in->key, err); + LOG_ERROR("Error with rocksdb_get %s, [%s]\n", in->key, err); ret_value = FAIL; } out->kvtag.name = in->key; @@ -3121,7 +2904,7 @@ PDC_Server_get_kvtag_rocksdb(metadata_get_kvtag_in_t *in, metadata_get_kvtag_out out->kvtag.value = value; out->ret = 1; #else - LOG_ERROR("==PDC_SERVER[%d]: enabled rocksdb but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled rocksdb but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -3144,7 +2927,7 @@ PDC_Server_get_kvtag_sqlite3(metadata_get_kvtag_in_t *in, metadata_get_kvtag_out sqlite3_exec(sqlite3_db_g, sql, sqlite_get_kvtag_callback, &out->kvtag, &errMessage); if (errMessage) { - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); } else { // size and value is filled in sqlite_get_kvtag_callback @@ -3152,7 +2935,7 @@ PDC_Server_get_kvtag_sqlite3(metadata_get_kvtag_in_t *in, metadata_get_kvtag_out out->ret = 1; } #else - LOG_ERROR("==PDC_SERVER[%d]: enabled SQLite3 but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled SQLite3 but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -3229,25 +3012,19 @@ PDC_Server_get_kvtag(metadata_get_kvtag_in_t *in, metadata_get_kvtag_out_t *out) if (use_rocksdb_g == 1) { ret_value = PDC_Server_get_kvtag_rocksdb(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_get_kvtag_rocksdb!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_get_kvtag_rocksdb"); } else if (use_sqlite3_g == 1) { ret_value = PDC_Server_get_kvtag_sqlite3(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_get_kvtag_sqlite3!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_get_kvtag_sqlite3"); } else { // Someta ret_value = PDC_Server_get_kvtag_someta(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_get_kvtag_someta!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_get_kvtag_someta"); } done: @@ -3279,8 +3056,6 @@ PDC_Server_get_kvtag(metadata_get_kvtag_in_t *in, metadata_get_kvtag_out_t *out) if (unlocked == 0) hg_thread_mutex_unlock(&pdc_metadata_hash_table_mutex_g); #endif - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3304,8 +3079,6 @@ PDC_del_kvtag_value_from_list(pdc_kvtag_list_t **list_head, char *key) } } - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3323,14 +3096,13 @@ PDC_Server_del_kvtag_rocksdb(metadata_get_kvtag_in_t *in, metadata_add_tag_out_t sprintf(rocksdb_key, "%lu`%s", in->obj_id, in->key); rocksdb_delete(rocksdb_g, writeoptions, rocksdb_key, strlen(rocksdb_key) + 1, &err); if (err != NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Error with rocksdb_delete [%s], [%s]!\n", pdc_server_rank_g, in->key, - err); + LOG_ERROR("Error with rocksdb_delete [%s], [%s]\n", in->key, err); ret_value = FAIL; } else out->ret = 1; #else - LOG_ERROR("==PDC_SERVER[%d]: enabled rocksdb but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled rocksdb but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -3351,13 +3123,13 @@ PDC_Server_del_kvtag_sqlite3(metadata_get_kvtag_in_t *in, metadata_add_tag_out_t sqlite3_exec(sqlite3_db_g, sql, NULL, 0, &errMessage); if (errMessage) { - LOG_ERROR("==PDC_SERVER[%d]: Error from SQLite %s!\n", pdc_server_rank_g, errMessage); + LOG_ERROR("Error from SQLite %s\n", errMessage); ret_value = FAIL; } else out->ret = 1; #else - LOG_ERROR("==PDC_SERVER[%d]: enabled SQLite3 but PDC is not compiled with it!\n", pdc_server_rank_g); + LOG_ERROR("Enabled SQLite3 but PDC is not compiled with it\n"); ret_value = FAIL; #endif @@ -3390,7 +3162,7 @@ PDC_Server_del_kvtag_someta(metadata_get_kvtag_in_t *in, metadata_add_tag_out_t else { ret_value = FAIL; out->ret = -1; - LOG_ERROR("==PDC_SERVER[%d]: failed to find requested kvtag [%s]\n", pdc_server_rank_g, in->key); + LOG_ERROR("Failed to find requested kvtag [%s]\n", in->key); } } else { @@ -3402,7 +3174,7 @@ PDC_Server_del_kvtag_someta(metadata_get_kvtag_in_t *in, metadata_add_tag_out_t else { ret_value = FAIL; out->ret = -1; - LOG_ERROR("==PDC_SERVER[%d]: failed to find requested kvtag [%s]\n", pdc_server_rank_g, in->key); + LOG_ERROR("Failed to find requested kvtag [%s]\n", in->key); } } @@ -3435,24 +3207,18 @@ PDC_Server_del_kvtag(metadata_get_kvtag_in_t *in, metadata_add_tag_out_t *out) if (use_rocksdb_g) { ret_value = PDC_Server_del_kvtag_rocksdb(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_del_kvtag_rocksdb!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_del_kvtag_rocksdb"); } else if (use_sqlite3_g) { ret_value = PDC_Server_del_kvtag_sqlite3(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_del_kvtag_sqlite3!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_del_kvtag_sqlite3"); } else { ret_value = PDC_Server_del_kvtag_someta(in, out); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_del_kvtag_someta!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_del_kvtag_someta"); } done: @@ -3476,8 +3242,5 @@ PDC_Server_del_kvtag(metadata_get_kvtag_in_t *in, metadata_add_tag_out_t *out) #endif #endif // End ENABLE_TIMING - - fflush(stdout); - FUNC_LEAVE(ret_value); } diff --git a/src/server/pdc_server_metadata_index_test.c b/src/server/pdc_server_metadata_index_test.c index 645aa02aa..d1e664aa2 100644 --- a/src/server/pdc_server_metadata_index_test.c +++ b/src/server/pdc_server_metadata_index_test.c @@ -38,7 +38,7 @@ delete_kv_from_index(char *kv, uint64_t obj_id) } } else { - LOG_ERROR("Invalid Key Value Pair!\n"); + LOG_ERROR("Invalid Key Value Pair\n"); return; } @@ -108,7 +108,7 @@ insert_kv_to_index(char *kv, uint64_t obj_id) } } else { - LOG_ERROR("Invalid Key Value Pair!\n"); + LOG_ERROR("Invalid Key Value Pair\n"); FUNC_LEAVE_VOID(); } @@ -215,7 +215,7 @@ test_PDC_Server_dart_perform_one_server() insert_kv_to_index("num000num=0", 30000); insert_kv_to_index("num433num=433", 30000); - LOG_INFO("Index Insertion Successful!\n"); + LOG_INFO("Index Insertion Successful\n"); // key000key val000val query_result_from_kvtag("key000key=\"val000val\"", OP_EXACT_QUERY); @@ -269,7 +269,7 @@ test_PDC_Server_dart_perform_one_server() delete_kv_from_index("num000num=0", 30000); delete_kv_from_index("num433num=433", 30000); - LOG_INFO("Index Deletion Successful!\n"); + LOG_INFO("Index Deletion Successful\n"); query_result_from_kvtag("key000key=\"val000val\"", OP_EXACT_QUERY); query_result_from_kvtag("0key=\"0val\"", OP_EXACT_QUERY); @@ -286,7 +286,7 @@ test_PDC_Server_dart_perform_one_server() metadata_index_recover("/workspaces/pdc/build/bin", 1, 0); - LOG_INFO("Index Recovery Done!\n"); + LOG_INFO("Index Recovery Done\n"); // key000key val000val query_result_from_kvtag("key000key=\"val000val\"", OP_EXACT_QUERY); diff --git a/src/server/pdc_server_region/pdc_server_data.c b/src/server/pdc_server_region/pdc_server_data.c index 7aae07bde..53fdf1e84 100644 --- a/src/server/pdc_server_region/pdc_server_data.c +++ b/src/server/pdc_server_region/pdc_server_data.c @@ -144,33 +144,26 @@ server_open_storage(char *storage_location, pdcid_t obj_id) * \return 1 if they are the same/-1 otherwise */ static int -region_list_t_is_equal(region_list_t *a, region_list_t *b) +region_list_t_is_equal(region_list_t *reg1, region_list_t *reg2) { FUNC_ENTER(NULL); int ret_value = -1; uint32_t i; - if (a == NULL || b == NULL) { - printf("==PDC_SERVER: region_list_t_is_equal() - passed NULL value!\n"); - ret_value = -1; - goto done; - } + if (reg1 == NULL) + PGOTO_ERROR(FAIL, "reg1 was NULL"); + if (reg2 == NULL) + PGOTO_ERROR(FAIL, "reg2 was NULL"); - if (a->ndim != b->ndim) { - ret_value = -1; - goto done; - } + if (reg1->ndim != reg2->ndim) + PGOTO_DONE(-1); - for (i = 0; i < a->ndim; i++) { - if (a->start[i] != b->start[i] || a->count[i] != b->count[i]) { - ret_value = -1; - goto done; - } + for (i = 0; i < reg1->ndim; i++) { + if (reg1->start[i] != reg2->start[i] || reg1->count[i] != reg2->count[i]) + PGOTO_DONE(-1); } - ret_value = 1; - done: FUNC_LEAVE(ret_value); } @@ -213,14 +206,10 @@ PDC_Server_set_lustre_stripe(const char *path, int stripe_count, int stripe_size snprintf(cmd, TAG_LEN_MAX, "lfs setstripe -S %dM -c %d -i %d %s", stripe_size_MB, stripe_count, index, tmp); - if (system(cmd) < 0) { - LOG_ERROR("==PDC_SERVER: Fail to set Lustre stripe parameters [%s]\n", tmp); - ret_value = FAIL; - goto done; - } + if (system(cmd) < 0) + PGOTO_ERROR(FAIL, "Failed to set Lustre stripe parameters [%s]\n", tmp); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -233,33 +222,26 @@ PDC_Server_set_lustre_stripe(const char *path, int stripe_count, int stripe_size * \return 1 if they are the same/-1 otherwise */ static int -is_region_identical(region_list_t *a, region_list_t *b) +is_region_identical(region_list_t *reg1, region_list_t *reg2) { FUNC_ENTER(NULL); int ret_value = -1; uint32_t i; - if (a == NULL || b == NULL) { - LOG_ERROR("==PDC_SERVER: is_region_identical() - passed NULL value!\n"); - ret_value = -1; - goto done; - } + if (reg1 == NULL) + PGOTO_ERROR(FAIL, "reg1 was NULL"); + if (reg2 == NULL) + PGOTO_ERROR(FAIL, "reg2 was NULL"); - if (a->ndim != b->ndim) { - ret_value = -1; - goto done; - } + if (reg1->ndim != reg2->ndim) + PGOTO_DONE(-1); - for (i = 0; i < a->ndim; i++) { - if (a->start[i] != b->start[i] || a->count[i] != b->count[i]) { - ret_value = -1; - goto done; - } + for (i = 0; i < reg1->ndim; i++) { + if (reg1->start[i] != reg2->start[i] || reg1->count[i] != reg2->count[i]) + PGOTO_DONE(-1); } - ret_value = 1; - done: FUNC_LEAVE(ret_value); } @@ -278,13 +260,8 @@ PDC_Server_local_region_lock_status(PDC_mapping_info_t *mapped_region, int *lock request_region = (region_list_t *)PDC_malloc(sizeof(region_list_t)); PDC_region_transfer_t_to_list_t(&(mapped_region->remote_region), request_region); res_meta = find_metadata_by_id(mapped_region->remote_obj_id); - if (res_meta == NULL || res_meta->region_lock_head == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_region_lock_status - metadata/region_lock is NULL!\n", - pdc_server_rank_g); - fflush(stdout); - ret_value = FAIL; - goto done; - } + if (res_meta == NULL || res_meta->region_lock_head == NULL) + PGOTO_ERROR(FAIL, "Metadata/region_lock was NULL"); // iterate the target metadata's region_lock_head (linked list) to search for queried region DL_FOREACH(res_meta->region_lock_head, elt) @@ -321,13 +298,10 @@ PDC_Server_region_lock_status(PDC_mapping_info_t *mapped_region, int *lock_statu PDC_region_transfer_t_to_list_t(&(mapped_region->remote_region), request_region); server_id = PDC_get_server_by_obj_id(mapped_region->remote_obj_id, pdc_server_size_g); - if (server_id == (uint32_t)pdc_server_rank_g) { + if (server_id == (uint32_t)pdc_server_rank_g) PDC_Server_local_region_lock_status(mapped_region, lock_status); - } - else { - LOG_INFO("lock is located in a different server, work not finished yet\n"); - fflush(stdout); - } + else + LOG_INFO("Lock is located in a different server, work not finished yet\n"); FUNC_LEAVE(ret_value); } @@ -416,9 +390,8 @@ PDC_Server_register_obj_region_by_pointer(data_server_region_t **new_obj_reg_ptr new_obj_reg->storage_location = (char *)PDC_malloc(sizeof(char) * ADDR_MAX); new_obj_reg->fd = server_open_storage(new_obj_reg->storage_location, obj_id); - if (new_obj_reg->fd < 0) { - goto done; - } + if (new_obj_reg->fd < 0) + PGOTO_DONE(ret_value); DL_APPEND(dataserver_region_g, new_obj_reg); } else { @@ -428,16 +401,15 @@ PDC_Server_register_obj_region_by_pointer(data_server_region_t **new_obj_reg_ptr if (new_obj_reg->fd < 0) { new_obj_reg->close_flag = close_flag; new_obj_reg->fd = open(new_obj_reg->storage_location, O_RDWR | O_CREAT, 0666); - if (new_obj_reg->fd < 0) { - goto done; - } + if (new_obj_reg->fd < 0) + PGOTO_DONE(ret_value); } } *new_obj_reg_ptr = new_obj_reg; done: FUNC_LEAVE(ret_value); -} // End PDC_Server_register_obj_region +} perr_t PDC_Server_unregister_obj_region_by_pointer(data_server_region_t *new_obj_reg, int close_flag) @@ -576,10 +548,6 @@ PDC_Data_Server_region_lock(region_lock_in_t *in, region_lock_out_t *out, hg_han out->ret = 1; done: - /* t = time(NULL); */ - /* tm = *localtime(&t); */ - - /* fflush(stdout); */ if (error == 1) { out->ret = 0; } @@ -604,7 +572,7 @@ PDC_Server_release_lock_request(uint64_t obj_id, struct pdc_region_info *region) new_obj_reg = PDC_Server_get_obj_region(obj_id); if (new_obj_reg == NULL) { - PGOTO_ERROR(FAIL, "===PDC Server: cannot locate data_server_region_t strcut for object ID"); + PGOTO_ERROR(FAIL, "Cannot locate data_server_region_t strcut for object ID"); } #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(&lock_request_mutex_g); @@ -625,7 +593,6 @@ PDC_Server_release_lock_request(uint64_t obj_id, struct pdc_region_info *region) request_region = (region_list_t *)PDC_free(request_region); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -656,12 +623,9 @@ PDC_Data_Server_region_release(region_lock_in_t *in, region_lock_out_t *out) PDC_copy_region_desc(in->region.count, request_region.count, ndim, ndim); obj_reg = PDC_Server_get_obj_region(in->obj_id); - if (obj_reg == NULL) { - ret_value = FAIL; - LOG_ERROR("==PDC_SERVER[%d]: requested release object does not exist\n", pdc_server_rank_g); - goto done; - } - // Find the lock region in the list and remove it + if (obj_reg == NULL) + PGOTO_ERROR(FAIL, "Requested release object does not exist"); + // Find the lock region in the list and remove it #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(&lock_list_mutex_g); #endif @@ -680,19 +644,11 @@ PDC_Data_Server_region_release(region_lock_in_t *in, region_lock_out_t *out) hg_thread_mutex_unlock(&lock_list_mutex_g); #endif // Request release lock region not found - if (found == 0) { - ret_value = FAIL; - LOG_ERROR("==PDC_SERVER[%d]: requested release region/object does not exist\n", pdc_server_rank_g); - goto done; - } + if (found == 0) + PGOTO_ERROR(FAIL, "Requested release region/object does not exist"); out->ret = 1; done: - /* t = time(NULL); */ - /* tm = *localtime(&t); */ - - /* fflush(stdout); */ - FUNC_LEAVE(ret_value); } @@ -743,7 +699,7 @@ region_list_path_offset_cmp(region_list_t *a, region_list_t *b) int ret_value; if (NULL == a || NULL == b) { - LOG_ERROR("NULL input!\n"); + LOG_ERROR("NULL input\n"); FUNC_LEAVE(-1); } @@ -787,8 +743,7 @@ PDC_Data_Server_buf_unmap(const struct hg_info *info, buf_unmap_in_t *in) target_obj = PDC_Server_get_obj_region(in->remote_obj_id); if (target_obj == NULL) { - PGOTO_ERROR(FAIL, - "===PDC_DATA_SERVER: PDC_Data_Server_buf_unmap() - requested object does not exist"); + PGOTO_ERROR(FAIL, "Requested object does not exist"); } #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(&data_buf_map_mutex_g); @@ -837,8 +792,7 @@ PDC_Data_Server_buf_unmap(const struct hg_info *info, buf_unmap_in_t *in) data_server_region_unmap_t *region = NULL; region = (data_server_region_unmap_t *)PDC_malloc(sizeof(struct data_server_region_unmap_t)); if (region == NULL) - PGOTO_ERROR(FAIL, - "===PDC_DATA_SERVER: PDC_Data_Server_buf_unmap() - cannot allocate region"); + PGOTO_ERROR(FAIL, "Cannot allocate region"); region->obj_id = in->remote_obj_id; region->unmap_region = in->remote_region; region->info = info; @@ -886,8 +840,7 @@ PDC_Data_Server_check_unmap() remote_obj_id = elt1->obj_id; target_obj = PDC_Server_get_obj_region(remote_obj_id); if (target_obj == NULL) { - PGOTO_ERROR( - FAIL, "===PDC_DATA_SERVER: PDC_Data_Server_check_unmap() - requested object does not exist"); + PGOTO_ERROR(FAIL, "Requested object does not exist"); } completed = 0; hg_thread_mutex_lock(&data_buf_map_mutex_g); @@ -951,9 +904,7 @@ server_send_buf_unmap_addr_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &out); if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: server_send_buf_unmap_addr_rpc_cb - error with HG_Get_output\n", - pdc_server_rank_g); - goto done; + PGOTO_ERROR(ret_value, "server_send_buf_unmap_addr_rpc_cb - error with HG_Get_output"); } done: @@ -992,9 +943,8 @@ buf_unmap_lookup_remote_server_cb(const struct hg_cb_info *callback_info) pdc_remote_server_info_g[server_id].addr_valid = 1; if (pdc_remote_server_info_g[server_id].addr == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: remote server addr is NULL\n", pdc_server_rank_g); error = 1; - goto done; + PGOTO_ERROR(FAIL, "Remote server addr is NULL\n"); } #ifdef ENABLE_MULTITHREAD hg_thread_mutex_unlock(&addr_valid_mutex_g); @@ -1008,8 +958,7 @@ buf_unmap_lookup_remote_server_cb(const struct hg_cb_info *callback_info) if (ret_value != HG_SUCCESS) { error = 1; HG_Destroy(server_send_buf_unmap_handle); - PGOTO_ERROR(ret_value, - "===PDC SERVER: buf_unmap_lookup_remote_server_cb() - Could not start HG_Forward()"); + PGOTO_ERROR(ret_value, "Could not start HG_Forward()"); } done: if (error == 1) { @@ -1018,6 +967,7 @@ buf_unmap_lookup_remote_server_cb(const struct hg_cb_info *callback_info) tranx_args = (struct transfer_buf_unmap *)PDC_free(tranx_args); } lookup_args = (struct buf_unmap_server_lookup_args_t *)PDC_free(lookup_args); + FUNC_LEAVE(ret_value); } @@ -1042,13 +992,10 @@ PDC_Server_buf_unmap_lookup_server_id(int remote_server_id, struct transfer_buf_ pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR( - FAIL, - "==PDC_SERVER: PDC_Server_buf_unmap_lookup_server_id() Connection to remote server FAILED!"); + PGOTO_ERROR(FAIL, "Connection to remote server failed"); } done: - fflush(stdout); if (error == 1) { HG_Free_input(handle, &(transfer_args->in)); HG_Destroy(handle); @@ -1073,10 +1020,8 @@ server_send_buf_unmap_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: server_send_buf_unmap_rpc_cb() - error with HG_Get_output\n", - pdc_server_rank_g); tranx_args->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Get_output"); } tranx_args->ret = output.ret; @@ -1110,7 +1055,7 @@ PDC_Meta_Server_buf_unmap(buf_unmap_in_t *in, hg_handle_t *handle) target_meta = find_metadata_by_id(in->remote_obj_id); if (target_meta == NULL) { error = 1; - PGOTO_ERROR(FAIL, "===PDC META SERVER: cannot retrieve object metadata"); + PGOTO_ERROR(FAIL, "Cannot retrieve object metadata"); } #ifdef ENABLE_MULTITHREAD hg_thread_mutex_lock(&meta_buf_map_mutex_g); @@ -1230,14 +1175,12 @@ PDC_Data_Server_buf_map(const struct hg_info *info, buf_map_in_t *in, region_lis PDC_Server_set_lustre_stripe(storage_location, stripe_count, stripe_size); if (is_debug_g == 1 && pdc_server_rank_g == 0) { - LOG_INFO("storage_location is %s\n", storage_location); + LOG_INFO("Storage_location is %s\n", storage_location); } #endif new_obj_reg->fd = open(storage_location, O_RDWR | O_CREAT, 0666); - if (new_obj_reg->fd == -1) { - LOG_ERROR("==PDC_SERVER[%d]: open %s failed\n", pdc_server_rank_g, storage_location); - goto done; - } + if (new_obj_reg->fd == -1) + PGOTO_ERROR(NULL, "open %s failed\n", storage_location); new_obj_reg->storage_location = strdup(storage_location); DL_APPEND(dataserver_region_g, new_obj_reg); } @@ -1306,14 +1249,14 @@ PDC_Server_maybe_allocate_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region_buf_map_t * tmp; if (dataserver_region_g == NULL) - PGOTO_ERROR(NULL, "===PDC SERVER: PDC_Server_get_region_buf_ptr() - object list is NULL"); + PGOTO_ERROR(NULL, "Object list is NULL"); DL_FOREACH(dataserver_region_g, elt) { if (obj_id == elt->obj_id) target_obj = elt; } if (target_obj == NULL) - PGOTO_ERROR(NULL, "===PDC SERVER: PDC_Server_get_region_buf_ptr() - cannot locate object"); + PGOTO_ERROR(NULL, "Cannot locate object"); DL_FOREACH(target_obj->region_buf_map_head, tmp) { @@ -1344,7 +1287,7 @@ PDC_Server_maybe_allocate_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t DL_APPEND(target_obj->region_buf_map_head, buf_map_ptr); } if (ret_value == NULL) - PGOTO_ERROR(NULL, "===PDC SERVER: PDC_Server_get_region_buf_ptr() - region data pointer is NULL"); + PGOTO_ERROR(NULL, "Region data pointer is NULL"); done: FUNC_LEAVE(ret_value); @@ -1360,14 +1303,14 @@ PDC_Server_get_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region) region_buf_map_t * tmp; if (dataserver_region_g == NULL) - PGOTO_ERROR(NULL, "===PDC SERVER: PDC_Server_get_region_buf_ptr() - object list is NULL"); + PGOTO_ERROR(NULL, "Object list is NULL"); DL_FOREACH(dataserver_region_g, elt) { if (obj_id == elt->obj_id) target_obj = elt; } if (target_obj == NULL) - PGOTO_ERROR(NULL, "===PDC SERVER: PDC_Server_get_region_buf_ptr() - cannot locate object"); + PGOTO_ERROR(NULL, "Cannot locate object"); DL_FOREACH(target_obj->region_buf_map_head, tmp) { @@ -1377,7 +1320,7 @@ PDC_Server_get_region_buf_ptr(pdcid_t obj_id, region_info_transfer_t region) } } if (ret_value == NULL) - PGOTO_ERROR(NULL, "===PDC SERVER: PDC_Server_get_region_buf_ptr() - region data pointer is NULL"); + PGOTO_ERROR(NULL, "Region data pointer is NULL"); done: FUNC_LEAVE(ret_value); @@ -1397,11 +1340,8 @@ server_send_buf_map_addr_rpc_cb(const struct hg_cb_info *callback_info) handle = callback_info->info.forward.handle; ret_value = HG_Get_output(handle, &out); - if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: server_send_buf_map_addr_rpc_cb - error with HG_Get_output\n", - pdc_server_rank_g); - goto done; - } + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); done: HG_Free_input(tranx_args->handle, &(tranx_args->in)); @@ -1438,10 +1378,10 @@ buf_map_lookup_remote_server_cb(const struct hg_cb_info *callback_info) pdc_remote_server_info_g[server_id].addr_valid = 1; if (pdc_remote_server_info_g[server_id].addr == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: remote server addr is NULL\n", pdc_server_rank_g); error = 1; - goto done; + PGOTO_ERROR(FAIL, "Remote server address was NULL"); } + #ifdef ENABLE_MULTITHREAD hg_thread_mutex_unlock(&addr_valid_mutex_g); #endif @@ -1454,8 +1394,7 @@ buf_map_lookup_remote_server_cb(const struct hg_cb_info *callback_info) if (ret_value != HG_SUCCESS) { error = 1; HG_Destroy(server_send_buf_map_handle); - PGOTO_ERROR(ret_value, - "===PDC SERVER: buf_map_lookup_remote_server_cb() - Could not start HG_Forward()"); + PGOTO_ERROR(ret_value, "Could not start HG_Forward()"); } done: @@ -1489,12 +1428,10 @@ PDC_Server_buf_map_lookup_server_id(int remote_server_id, struct transfer_buf_ma pdc_remote_server_info_g[remote_server_id].addr_string, HG_OP_ID_IGNORE); if (hg_ret != HG_SUCCESS) { error = 1; - PGOTO_ERROR( - FAIL, "==PDC_SERVER: PDC_Server_buf_map_lookup_server_id() Connection to remote server FAILED!"); + PGOTO_ERROR(FAIL, "Connection to remote server FAILED"); } done: - fflush(stdout); if (error == 1) { HG_Free_input(handle, &(transfer_args->in)); HG_Destroy(handle); @@ -1519,10 +1456,8 @@ server_send_buf_map_rpc_cb(const struct hg_cb_info *callback_info) ret_value = HG_Get_output(handle, &out); if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: server_send_buf_map_rpc_cb - error with HG_Get_output\n", - pdc_server_rank_g); tranx_args->ret = -1; - goto done; + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } done: @@ -1554,7 +1489,7 @@ PDC_Meta_Server_buf_map(buf_map_in_t *in, region_buf_map_t *new_buf_map_ptr, hg_ target_meta = find_metadata_by_id(in->remote_obj_id); if (target_meta == NULL) { error = 1; - PGOTO_ERROR(FAIL, "PDC_SERVER: PDC_Meta_Server_buf_map() find_metadata_by_id FAILED!"); + PGOTO_ERROR(FAIL, "PDC_SERVER: PDC_Meta_Server_buf_map() find_metadata_by_id FAILED"); } buf_map_ptr = (region_buf_map_t *)PDC_malloc(sizeof(region_buf_map_t)); @@ -1652,10 +1587,8 @@ PDC_Server_notify_region_update_cb(const struct hg_cb_info *callback_info) /* Get output from client */ ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_notify_region_update_cb - error with HG_Get_output\n", - pdc_server_rank_g); update_args->ret = -1; - goto done; + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } update_args->ret = output.ret; @@ -1675,34 +1608,25 @@ PDC_Server_notify_region_update_to_client(uint64_t obj_id, uint64_t reg_id, int3 hg_handle_t notify_region_update_handle; if (client_id >= pdc_client_num_g) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_SERVER_notify_region_update_to_client() - " - "client_id %d invalid)\n", - pdc_server_rank_g, client_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Client_id %d is invalid", client_id); } - if (pdc_client_info_g || pdc_client_info_g[client_id].addr_valid == 0) { + if (pdc_client_info_g == NULL) { + LOG_ERROR("pdc_client_info_g is NULL\n"); + FUNC_LEAVE(FAIL); + } + + if (pdc_client_info_g[client_id].addr_valid == 0) { ret_value = PDC_Server_lookup_client(client_id); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER: PDC_Server_notify_region_update_to_client() - \ - PDC_Server_lookup_client failed)\n"); - FUNC_LEAVE(FAIL); + PGOTO_ERROR(FAIL, "Error with PDC_Server_lookup_client"); } } - if (pdc_client_info_g == NULL) { - LOG_ERROR("==PDC_SERVER: pdc_client_info_g is NULL\n"); - FUNC_LEAVE(FAIL); - } - hg_ret = HG_Create(hg_context_g, pdc_client_info_g[client_id].addr, notify_region_update_register_id_g, ¬ify_region_update_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("PDC_Server_notify_region_update_to_client(): Could not HG_Create()\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); // Fill input structure notify_region_update_in_t in; @@ -1710,11 +1634,8 @@ PDC_Server_notify_region_update_to_client(uint64_t obj_id, uint64_t reg_id, int3 in.reg_id = reg_id; hg_ret = HG_Forward(notify_region_update_handle, PDC_Server_notify_region_update_cb, &update_args, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("PDC_Server_notify_region_update_to_client(): Could not start HG_Forward()\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not start HG_Forward"); done: HG_Destroy(notify_region_update_handle); @@ -1730,37 +1651,25 @@ PDC_Server_close_shm(region_list_t *region, int is_remove) perr_t ret_value = SUCCEED; if (region->is_shm_closed == 1) { - goto done; + PGOTO_DONE(ret_value); } - if (region == NULL || region->buf == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: NULL input\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region == NULL) + PGOTO_ERROR(FAIL, "Region was NULL"); + if (region->buf == NULL) + PGOTO_ERROR(FAIL, "region->buf was NULL"); /* remove the mapped memory segment from the address space of the process */ - if (munmap(region->buf, region->data_size) == -1) { - LOG_ERROR("==PDC_SERVER[%d]: unmap failed\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (munmap(region->buf, region->data_size) == -1) + PGOTO_ERROR(FAIL, "unmap failed\n"); /* close the shared memory segment as if it was a file */ - if (close(region->shm_fd) == -1) { - LOG_ERROR("==PDC_SERVER[%d]: close shm_fd failed\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (close(region->shm_fd) == -1) + PGOTO_ERROR(FAIL, "Cose shm_fd failed"); - if (is_remove == 1) { - /* remove the shared memory segment from the file system */ - if (shm_unlink(region->shm_addr) == -1) { - ret_value = FAIL; - goto done; - LOG_ERROR("==PDC_SERVER[%d]: Error removing %s\n", pdc_server_rank_g, region->shm_addr); - } - } + /* remove the shared memory segment from the file system */ + if (is_remove == 1 && shm_unlink(region->shm_addr) == -1) + PGOTO_ERROR(FAIL, "Error removing %s", region->shm_addr); region->buf = NULL; region->shm_fd = -1; @@ -1769,7 +1678,6 @@ PDC_Server_close_shm(region_list_t *region, int is_remove) total_mem_cache_size_mb_g -= (region->data_size / 1048576); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -1787,16 +1695,10 @@ PDC_Server_notify_client_multi_io_complete_cb(const struct hg_cb_info *callback_ args = (notify_multi_io_args_t *)callback_info->arg; ret_value = HG_Get_output(handle, &output); - if (ret_value != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: Error with HG_Get_output\n", pdc_server_rank_g); - goto done; - } - - if (output.ret != 1) { - LOG_ERROR("==PDC_SERVER[%d]: Return value [%d] is NOT expected\n", pdc_server_rank_g, output.ret); - } - - // TODO: Cache to BB if needed + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); + if (output.ret != 1) + PGOTO_ERROR(HG_OTHER_ERROR, "Return value [%d] is NOT expected", output.ret); done: if (args) { @@ -1826,27 +1728,19 @@ PDC_Server_notify_client_multi_io_complete(uint32_t client_id, int client_seq_id region_list_t * region_elt; notify_multi_io_args_t *bulk_args; - if (client_id >= (uint32_t)pdc_client_num_g) { - LOG_ERROR("==PDC_SERVER[%d]: client_id %d invalid\n", pdc_server_rank_g, client_id); - ret_value = FAIL; - goto done; - } + if (client_id >= (uint32_t)pdc_client_num_g) + PGOTO_ERROR(FAIL, "client_id %d invalid", client_id); while (pdc_client_info_g[client_id].addr_valid != 1) { ret_value = PDC_Server_lookup_client(client_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: lookup client failed!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(ret_value, "Lookup client failed\n"); } hg_ret = HG_Create(hg_context_g, pdc_client_info_g[client_id].addr, notify_client_multi_io_complete_rpc_register_id_g, &rpc_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create handle"); // Send the shm_addr + total data size to client buf_sizes = (hg_size_t *)PDC_calloc(sizeof(hg_size_t), n_completed * 2); @@ -1865,11 +1759,8 @@ PDC_Server_notify_client_multi_io_complete(uint32_t client_id, int client_seq_id /* Register memory */ hg_ret = HG_Bulk_create(hg_class_g, n_completed * 2, buf_ptrs, buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); /* Fill input structure */ bulk_rpc_in.cnt = n_completed; @@ -1885,14 +1776,10 @@ PDC_Server_notify_client_multi_io_complete(uint32_t client_id, int client_seq_id /* Forward call to remote addr */ hg_ret = HG_Forward(rpc_handle, PDC_Server_notify_client_multi_io_complete_cb, bulk_args, &bulk_rpc_in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not forward call\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not forward call"); done: - fflush(stdout); HG_Destroy(rpc_handle); FUNC_LEAVE(ret_value); @@ -1946,16 +1833,12 @@ PDC_Server_cache_region_to_BB(region_list_t *region) bb_data_path = "."; } sprintf(pdc_cache_file_path_g, "%s/PDCcacheBB.%d", bb_data_path, pdc_server_rank_g); - LOG_ERROR("==PDC_SERVER[%d]: No PDC_BB_LOC specified, use [%s]!\n", pdc_server_rank_g, - bb_data_path); + LOG_ERROR("No PDC_BB_LOC specified, use [%s]\n", bb_data_path); } pdc_cache_file_ptr_g = fopen(pdc_cache_file_path_g, "ab"); - if (NULL == pdc_cache_file_ptr_g) { - LOG_ERROR("==PDC_SERVER[%d]: fopen failed [%s]\n", pdc_server_rank_g, pdc_cache_file_path_g); - ret_value = FAIL; - goto done; - } + if (NULL == pdc_cache_file_ptr_g) + PGOTO_ERROR(FAIL, "fopen failed [%s]\n", pdc_cache_file_path_g); n_fopen_g++; } // End open cache file @@ -1963,13 +1846,11 @@ PDC_Server_cache_region_to_BB(region_list_t *region) offset = ftell(pdc_cache_file_ptr_g); // Actual write (append) - LOG_ERROR("==PDC_SERVER[%d]: appending %" PRIu64 " bytes to BB\n", pdc_server_rank_g, region->data_size); + LOG_INFO("Appending %" PRIu64 " bytes to BB\n", region->data_size); write_bytes = fwrite(region->buf, 1, region->data_size, pdc_cache_file_ptr_g); if (write_bytes != region->data_size) { - LOG_ERROR("==PDC_SERVER[%d]: fwrite to [%s] FAILED, size %" PRIu64 ", actual writeen %" PRIu64 "!\n", - pdc_server_rank_g, region->storage_location, region->data_size, write_bytes); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "fwrite to [%s] FAILED, size %" PRIu64 ", actual writeen %" PRIu64, + region->storage_location, region->data_size, write_bytes); } n_fwrite_g++; @@ -1978,8 +1859,7 @@ PDC_Server_cache_region_to_BB(region_list_t *region) double region_write_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); server_write_time_g += region_write_time; if (is_debug_g == 1) { - LOG_ERROR("==PDC_SERVER[%d]: fwrite %" PRIu64 " bytes, %.2fs\n", pdc_server_rank_g, write_bytes, - region_write_time); + LOG_ERROR("fwrite %" PRIu64 " bytes, %.2fs\n", write_bytes, region_write_time); } #endif @@ -1991,10 +1871,8 @@ PDC_Server_cache_region_to_BB(region_list_t *region) // Update storage meta ret_value = PDC_Server_update_region_storagelocation_offset(region, PDC_UPDATE_CACHE); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: failed to update region storage info!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(ret_value, "Failed to update region storage info"); // Close shm after writing to BB ret_value = PDC_Server_close_shm(region, 0); @@ -2002,7 +1880,6 @@ PDC_Server_cache_region_to_BB(region_list_t *region) region->is_io_done = 0; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2018,7 +1895,7 @@ PDC_cache_region_to_bb_cb(const struct hg_cb_info *callback_info) out = (server_read_check_out_t *)callback_info->arg; ret = PDC_Server_cache_region_to_BB(out->region); if (ret != SUCCEED) - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_cache_region_to_BB\n", pdc_server_rank_g); + LOG_ERROR("Error with PDC_Server_cache_region_to_BB\n"); if (out != NULL) out = (server_read_check_out_t *)PDC_free(out); @@ -2059,19 +1936,16 @@ PDC_Server_read_check(data_server_read_check_in_t *in, server_read_check_out_t * hg_thread_mutex_unlock(&data_read_list_mutex_g); #endif - if (NULL == io_target) { - LOG_ERROR("==PDC_SERVER[%d]: No existing io request with same obj_id %" PRIu64 " found!\n", - pdc_server_rank_g, meta.obj_id); + if (io_target == NULL) { out->ret = -1; - goto done; + PGOTO_ERROR(FAIL, "No existing io request with same obj_id %" PRIu64 " found", meta.obj_id); } if (is_debug_g) { - LOG_ERROR("==PDC_SERVER[%d]: Read check Obj [%s] id=%" PRIu64 " region: start(%" PRIu64 ", %" PRIu64 - ") " + LOG_ERROR("Read check Obj [%s] id=%" PRIu64 " region: start(%" PRIu64 ", %" PRIu64 ") " "size(%" PRIu64 ", %" PRIu64 ") \n", - pdc_server_rank_g, meta.obj_name, meta.obj_id, r_target.start[0], r_target.start[1], - r_target.count[0], r_target.count[1]); + meta.obj_name, meta.obj_id, r_target.start[0], r_target.start[1], r_target.count[0], + r_target.count[1]); } int found_region = 0; @@ -2086,7 +1960,7 @@ PDC_Server_read_check(data_server_read_check_in_t *in, server_read_check_out_t * if (region_elt->is_data_ready == 1) { out->shm_addr = PDC_calloc(sizeof(char), ADDR_MAX); if (strlen(region_elt->shm_addr) == 0) - LOG_ERROR("==PDC_SERVER[%d]: found shm_addr is NULL!\n", pdc_server_rank_g); + LOG_ERROR("Found shm_addr is NULL\n"); else strcpy(out->shm_addr, region_elt->shm_addr); out->region = region_elt; @@ -2095,20 +1969,18 @@ PDC_Server_read_check(data_server_read_check_in_t *in, server_read_check_out_t * strstr(region_elt->cache_location, "PDCcacheBB") == NULL) out->is_cache_to_bb = 1; } - ret_value = SUCCEED; - goto done; + PGOTO_DONE(SUCCEED); } } if (found_region == 0) { - LOG_ERROR("==PDC_SERVER[%d]: No io request with same region found!\n", pdc_server_rank_g); + LOG_ERROR("No io request with same region found\n"); PDC_print_region_list(&r_target); out->ret = -1; - goto done; + PGOTO_DONE(ret_value); } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2147,10 +2019,8 @@ PDC_Server_write_check(data_server_write_check_in_t *in, data_server_write_check // If not found, create and insert one to the list if (NULL == io_target) { - LOG_ERROR("==PDC_SERVER: No existing io request with same obj_id found!\n"); - out->ret = -1; - ret_value = SUCCEED; - goto done; + out->ret = -1; + PGOTO_ERROR(FAIL, "No existing io request with same obj_id found"); } DL_FOREACH_SAFE(io_target->region_list_head, region_elt, region_tmp) @@ -2165,21 +2035,17 @@ PDC_Server_write_check(data_server_write_check_in_t *in, data_server_write_check // is no longer needed. But this could be tricky, as we don't know if the client // want to read the data multliple times, so the best time is when the server recycles // the shm associated with this region. - - ret_value = SUCCEED; - goto done; + PGOTO_DONE(SUCCEED); } } if (found_region == 0) { - LOG_ERROR("==PDC_SERVER[%d]: No existing IO request of requested region found!\n", pdc_server_rank_g); - out->ret = -1; - ret_value = SUCCEED; - goto done; + LOG_WARNING("No existing IO request of requested region found"); + out->ret = -1; + PGOTO_DONE(SUCCEED); } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2196,7 +2062,7 @@ PDC_Server_data_read_to_shm(region_list_t *region_list_head) { FUNC_ENTER(NULL); - perr_t ret_value = FAIL; + perr_t ret_value = SUCCEED; is_server_direct_io_g = 0; // TODO: merge regions for aggregated read @@ -2207,15 +2073,10 @@ PDC_Server_data_read_to_shm(region_list_t *region_list_head) // POSIX read for now ret_value = PDC_Server_regions_io(region_list_head, PDC_POSIX); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error reading data from storage and create shared memory\n", - pdc_server_rank_g); - goto done; + PGOTO_ERROR(FAIL, "Error reading data from storage and create shared memory"); } - ret_value = SUCCEED; - done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2232,11 +2093,8 @@ PDC_Server_get_local_storage_location_of_region(uint64_t obj_id, region_list_t * // Find object metadata *n_loc = 0; target_meta = find_metadata_by_id(obj_id); - if (target_meta == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: find_metadata_by_id FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (target_meta == NULL) + PGOTO_ERROR(FAIL, "Error with find_metadata_by_id"); DL_FOREACH(target_meta->storage_region_list_head, region_elt) { if (PDC_is_contiguous_region_overlap(region_elt, region) == 1) { @@ -2244,18 +2102,14 @@ PDC_Server_get_local_storage_location_of_region(uint64_t obj_id, region_list_t * overlap_region_loc[*n_loc] = region_elt; *n_loc += 1; } - if (*n_loc > PDC_MAX_OVERLAP_REGION_NUM) { - LOG_ERROR("==PDC_SERVER[%d]: exceeding PDC_MAX_OVERLAP_REGION_NUM regions!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - } // DL_FOREACH + if (*n_loc > PDC_MAX_OVERLAP_REGION_NUM) + PGOTO_ERROR(FAIL, "Exceeding PDC_MAX_OVERLAP_REGION_NUM regions"); + } if (*n_loc == 0) { - LOG_ERROR("==PDC_SERVER[%d]: no overlapping storage region found\n", pdc_server_rank_g); + LOG_ERROR("No overlapping storage region found\n"); PDC_print_region_list(region); - ret_value = FAIL; - goto done; + PGOTO_DONE(FAIL); } done: @@ -2305,7 +2159,7 @@ PDC_Server_update_storage_meta(int *n_updated) { FUNC_ENTER(NULL); - perr_t ret_value; + perr_t ret_value = SUCCEED; update_storage_meta_list_t *meta_list_elt; // MPI Reduce implementation of metadata update @@ -2318,9 +2172,7 @@ PDC_Server_update_storage_meta(int *n_updated) meta_list_elt, n_updated); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: update storage info FAILED!\n", pdc_server_rank_g); - - goto done; + PGOTO_ERROR(FAIL, "Error with PDC_Server_update_region_storage_meta_bulk_with_cb"); } } @@ -2349,13 +2201,10 @@ PDC_Server_count_write_check_update_storage_meta_cb(const struct hg_cb_info *cal if (n_check_write_finish_returned_g >= pdc_buffered_bulk_update_total_g) { ret_value = PDC_Server_update_storage_meta(&n_updated); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: FAILED to update storage meta\n", pdc_server_rank_g); - goto done; - } - - } // end of if - } // end of if (write_ret->ret == 1) + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_update_storage_meta"); + } + } done: @@ -2367,7 +2216,6 @@ PDC_Server_count_write_check_update_storage_meta_cb(const struct hg_cb_info *cal if (write_ret) write_ret = (data_server_write_check_out_t *)PDC_free(write_ret); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2402,11 +2250,8 @@ PDC_Server_get_storage_location_of_region_mpi(region_list_t *regions_head) int * request_overlap_cnt = NULL; int nrequest_per_server = 0; - if (regions_head == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: NULL input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (regions_head == NULL) + PGOTO_ERROR(FAIL, "regions_head was NULL"); nrequest_per_server = 0; region_meta_prev = regions_head->meta; @@ -2416,25 +2261,17 @@ PDC_Server_get_storage_location_of_region_mpi(region_list_t *regions_head) region_meta = region_elt->meta; // All requests should point to the same metadata - if (region_meta == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: request region has NULL metadata!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - else if (region_meta->obj_id != region_meta_prev->obj_id) { - LOG_ERROR("==PDC_SERVER[%d]: request regions are of different object!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region_meta == NULL) + PGOTO_ERROR(FAIL, "Request region has NULL metadata"); + else if (region_meta->obj_id != region_meta_prev->obj_id) + PGOTO_ERROR(FAIL, "Request regions are of different object"); region_meta_prev = region_meta; // nrequest_per_server should be less than PDC_SERVER_MAX_PROC_PER_NODE // and should be the same across all servers. if (nrequest_per_server > PDC_SERVER_MAX_PROC_PER_NODE) { - LOG_ERROR("==PDC_SERVER[%d]: more requests than expected! " - "Increase PDC_SERVER_MAX_PROC_PER_NODE!\n", - pdc_server_rank_g); - fflush(stdout); + PGOTO_ERROR(FAIL, "More requests than expected! " + "Increase PDC_SERVER_MAX_PROC_PER_NODE\n"); } else { // After saninty check, add the current request to gather send buffer @@ -2487,27 +2324,19 @@ PDC_Server_get_storage_location_of_region_mpi(region_list_t *regions_head) for (i = 0; i < total_request_cnt; i++) { server_idx = i / nrequest_per_server; // server_idx should be [0, pdc_server_size_g) - if (server_idx < 0 || server_idx >= pdc_server_size_g) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with server idx count!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (server_idx < 0 || server_idx >= pdc_server_size_g) + PGOTO_ERROR(FAIL, "Error with server idx count"); memset(&req_region, 0, sizeof(region_list_t)); PDC_region_transfer_t_to_list_t(&all_requests[i], &req_region); ret_value = PDC_Server_get_local_storage_location_of_region(region_meta->obj_id, &req_region, &overlap_cnt, overlap_regions_2d); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: unable to get local storage location!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Unable to get local storage location"); if (overlap_cnt > PDC_MAX_OVERLAP_REGION_NUM) { - LOG_ERROR("==PDC_SERVER[%d]: found %d storage locations than PDC_MAX_OVERLAP_REGION_NUM!\n", - pdc_server_rank_g, overlap_cnt); + LOG_ERROR("Found %d storage locations than PDC_MAX_OVERLAP_REGION_NUM\n", overlap_cnt); overlap_cnt = PDC_MAX_OVERLAP_REGION_NUM; - - fflush(stdout); } // Record how many overlap regions for each request @@ -2603,7 +2432,6 @@ PDC_Server_get_storage_location_of_region_mpi(region_list_t *regions_head) if (request_overlap_cnt) request_overlap_cnt = (int *)PDC_free(request_overlap_cnt); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2622,20 +2450,15 @@ PDC_Server_regions_io(region_list_t *region_list_head, _pdc_io_plugin_t plugin) // If read, need to get locations from metadata server if (plugin == PDC_POSIX) { ret_value = PDC_Server_posix_one_file_io(region_list_head); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: %s-error with PDC_Server_posix_one_file_io\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_one_file_io"); } else if (plugin == PDC_DAOS) { - LOG_ERROR("DAOS plugin in under development, using POSIX.\n"); + LOG_WARNING("DAOS plugin in under development, using POSIX\n"); ret_value = PDC_Server_posix_one_file_io(region_list_head); } - else { - LOG_ERROR("==PDC_SERVER: unsupported IO plugin!\n"); - ret_value = FAIL; - goto done; - } + else + PGOTO_ERROR(FAIL, "Unsupported IO plugin"); #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); @@ -2643,8 +2466,6 @@ PDC_Server_regions_io(region_list_t *region_list_head, _pdc_io_plugin_t plugin) #endif done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -2686,29 +2507,20 @@ PDC_Server_data_write_from_shm(region_list_t *region_list_head) // Open shared memory and map to data buf region_elt->shm_fd = shm_open(region_elt->shm_addr, O_RDONLY, 0666); if (region_elt->shm_fd == -1) { - LOG_ERROR("==PDC_SERVER[%d]: Shared memory open failed [%s]!\n", pdc_server_rank_g, - region_elt->shm_addr); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Shared memory open failed [%s]", region_elt->shm_addr); } region_elt->buf = mmap(0, region_elt->data_size, PROT_READ, MAP_SHARED, region_elt->shm_fd, 0); - if (region_elt->buf == MAP_FAILED) { - // close and unlink? - ret_value = FAIL; - goto done; - } + if (region_elt->buf == MAP_FAILED) + PGOTO_DONE(FAIL); } // POSIX write ret_value = PDC_Server_regions_io(region_list_head, PDC_POSIX); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER: PDC_Server_regions_io ERROR!\n"); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_regions_io"); done: - fflush(stdout); // TODO: keep the shared memory for now and close them later? DL_FOREACH(region_list_head, region_elt) @@ -2717,7 +2529,6 @@ PDC_Server_data_write_from_shm(region_list_t *region_list_head) ret_value = PDC_Server_close_shm(region_elt, 1); } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -2759,12 +2570,8 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) buffer_read_request_total_g = io_info->nbuffer_request * io_info->nclient; buffer_read_request_num_g++; } - else { - LOG_ERROR("==PDC_SERVER: PDC_Server_data_io_via_shm - invalid IO type received from client!\n"); - ret_value = FAIL; - goto done; - } - fflush(stdout); + else + PGOTO_ERROR(FAIL, "Invalid IO type received from client"); #ifdef ENABLE_MULTITHREAD if (io_info->io_type == PDC_WRITE) @@ -2797,11 +2604,8 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) // pdc_data_server_io_list_t maintains the request list for one object id, // write and read are separate lists io_list_target = (pdc_data_server_io_list_t *)PDC_calloc(1, sizeof(pdc_data_server_io_list_t)); - if (NULL == io_list_target) { - LOG_ERROR("==PDC_SERVER: ERROR allocating pdc_data_server_io_list_t!\n"); - ret_value = FAIL; - goto done; - } + if (NULL == io_list_target) + PGOTO_ERROR(FAIL, "Error allocating pdc_data_server_io_list_t"); io_list_target->obj_id = io_info->meta.obj_id; io_list_target->total = io_info->nclient; io_list_target->count = 0; @@ -2841,12 +2645,9 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) } io_list_target->count++; - if (is_debug_g == 1) { - LOG_ERROR("==PDC_SERVER[%d]: received %d/%d data %s requests of [%s]\n", pdc_server_rank_g, - io_list_target->count, io_list_target->total, + if (is_debug_g == 1) + LOG_ERROR("Received %d/%d data %s requests of [%s]\n", io_list_target->count, io_list_target->total, io_info->io_type == PDC_READ ? "read" : "write", io_info->meta.obj_name); - fflush(stdout); - } int has_read_cache = 0; // Need to check if there is already one region in the list, and update accordingly @@ -2869,18 +2670,15 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) if (has_read_cache != 1) { // append current request region to the io list region_list_t *new_region = (region_list_t *)PDC_calloc(1, sizeof(region_list_t)); - if (new_region == NULL) { - LOG_ERROR("==PDC_SERVER: ERROR allocating new_region!\n"); - ret_value = FAIL; - goto done; - } + if (new_region == NULL) + PGOTO_ERROR(FAIL, "Error allocating new_region"); PDC_region_list_t_deep_cp(&(io_info->region), new_region); DL_APPEND(io_list_target->region_list_head, new_region); if (is_debug_g == 1) { DL_COUNT(io_list_target->region_list_head, region_elt, count); - LOG_DEBUG("==PDC_SERVER[%d]: Added 1 to IO request list, obj_id=%" PRIu64 ", %d total\n", - pdc_server_rank_g, new_region->meta->obj_id, count); + LOG_DEBUG("Added 1 to IO request list, obj_id=%" PRIu64 ", %d total\n", new_region->meta->obj_id, + count); PDC_print_region_list(new_region); } } @@ -2889,11 +2687,8 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) if (io_info->io_type == PDC_WRITE && buffer_write_request_num_g >= buffer_write_request_total_g && buffer_write_request_total_g != 0) { - if (is_debug_g) { - LOG_ERROR("==PDC_SERVER[%d]: received all %d requests, starts writing.\n", pdc_server_rank_g, - buffer_write_request_total_g); - fflush(stdout); - } + if (is_debug_g) + LOG_DEBUG("Received all %d requests, starts writing.\n", buffer_write_request_total_g); // Perform IO for all requests in each io_list (of unique obj_id) DL_FOREACH(pdc_data_server_write_list_head_g, io_list_elt) @@ -2919,8 +2714,7 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) // If BB is enabled, then overwrite with BB path with the right number of servers if (write_to_bb_percentage_g > 0) { if (strcmp(io_list_elt->bb_path, "") == 0 || io_list_elt->bb_path[0] == 0) { - LOG_ERROR("==PDC_SERVER[%d]: Error with BB path [%s]!\n", pdc_server_rank_g, - io_list_elt->bb_path); + LOG_ERROR("Error with BB path [%s]\n", io_list_elt->bb_path); } else { if (pdc_server_rank_g % 2 == 0) { @@ -2946,11 +2740,8 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) curr_cnt++; } ret_value = PDC_Server_data_write_from_shm(io_list_elt->region_list_head); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_data_write_from_shm FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_data_write_from_shm FAILED"); } // end for io_list buffer_write_request_num_g = 0; buffer_write_request_total_g = 0; @@ -2963,13 +2754,12 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) current_read_from_cache_cnt_g = 0; total_read_from_cache_cnt_g = buffer_read_request_total_g * cache_percentage_g / 100; if (pdc_server_rank_g == 0) { - LOG_ERROR("==PDC_SERVER[%d]: cache percentage %d%% read_from_cache %d/%d\n", pdc_server_rank_g, - cache_percentage_g, current_read_from_cache_cnt_g, total_read_from_cache_cnt_g); + LOG_INFO("Cache percentage %d%% read_from_cache %d/%d\n", cache_percentage_g, + current_read_from_cache_cnt_g, total_read_from_cache_cnt_g); } if (is_debug_g) { - LOG_ERROR("==PDC_SERVER[%d]: received all %d requests, starts reading.\n", pdc_server_rank_g, - buffer_read_request_total_g); + LOG_DEBUG("Received all %d requests, starts reading.\n", buffer_read_request_total_g); } DL_FOREACH(pdc_data_server_read_list_head_g, io_list_elt) { @@ -2989,10 +2779,8 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) } } ret_value = PDC_Server_data_read_to_shm(io_list_elt->region_list_head); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_data_read_to_shm FAILED!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_data_read_to_shm FAILED"); } buffer_read_request_num_g = 0; buffer_read_request_total_g = 0; @@ -3004,7 +2792,6 @@ PDC_Server_data_io_via_shm(const struct hg_cb_info *callback_info) #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3019,19 +2806,13 @@ PDC_Server_update_local_region_storage_loc(region_list_t *region, uint64_t obj_i region_list_t *region_elt = NULL, *new_region = NULL; int update_success = -1; - if (region == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: NULL input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region == NULL) + PGOTO_ERROR(FAIL, "region was NULL"); // Find object metadata target_meta = find_metadata_by_id(obj_id); - if (target_meta == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: FAIL to get storage metadata\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (target_meta == NULL) + PGOTO_ERROR(FAIL, "Failed to get storage metadata"); // Find if there is the same region already stored in the metadata and update it DL_FOREACH(target_meta->storage_region_list_head, region_elt) @@ -3049,7 +2830,7 @@ PDC_Server_update_local_region_storage_loc(region_list_t *region, uint64_t obj_i region_elt->region_hist = region->region_hist; } else { - LOG_ERROR("==PDC_SERVER[%d]: error with update type %d!\n", pdc_server_rank_g, type); + LOG_ERROR("Error with update type %d\n", type); break; } @@ -3067,11 +2848,8 @@ PDC_Server_update_local_region_storage_loc(region_list_t *region, uint64_t obj_i // Create the region list new_region = (region_list_t *)PDC_calloc(1, sizeof(region_list_t)); - if (PDC_region_list_t_deep_cp(region, new_region) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: deep copy FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (PDC_region_list_t_deep_cp(region, new_region) != SUCCEED) + PGOTO_ERROR(FAIL, "Deep copy FAILED"); new_region->meta = target_meta; new_region->region_hist = region->region_hist; @@ -3081,8 +2859,6 @@ PDC_Server_update_local_region_storage_loc(region_list_t *region, uint64_t obj_i } done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3109,9 +2885,8 @@ PDC_Server_update_region_loc_cb(const struct hg_cb_info *callback_info) /* Get output from server*/ ret_value = HG_Get_output(handle, &output); if (ret_value != HG_SUCCESS || output.ret != 20171031) { - LOG_ERROR("==PDC_SERVER[%d]: error HG_Get_output\n", pdc_server_rank_g); lookup_args->ret_int = -1; - goto done; + PGOTO_ERROR(ret_value, "Error with HG_Get_output"); } lookup_args->ret_int = output.ret; @@ -3136,24 +2911,14 @@ PDC_Server_update_region_storagelocation_offset(region_list_t *region, int type) update_region_loc_in_t in; server_lookup_args_t lookup_args; - if (region == NULL) { - LOG_ERROR("==PDC_SERVER[%d] NULL region!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - - if (region->storage_location[0] == 0) { - LOG_ERROR("==PDC_SERVER[%d]: NULL input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region == NULL) + PGOTO_ERROR(FAIL, "region was NULL"); + if (region->storage_location[0] == 0) + PGOTO_ERROR(FAIL, "region->storage_location was NULL"); region_meta = region->meta; - if (region_meta == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: region meta is NULL!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region_meta == NULL) + PGOTO_ERROR(FAIL, "Region meta was NULL"); server_id = PDC_get_server_by_obj_id(region_meta->obj_id, pdc_server_size_g); @@ -3161,33 +2926,22 @@ PDC_Server_update_region_storagelocation_offset(region_list_t *region, int type) // Metadata object is local, no need to send update RPC ret_value = PDC_Server_update_local_region_storage_loc(region, region_meta->obj_id, type); update_local_region_count_g++; - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: update_local_region_storage FAILED!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with update_local_region_storage"); } else { if (PDC_Server_lookup_server_id(server_id) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting remote server %d addr via lookup\n", pdc_server_rank_g, - server_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error getting remote server %d addr via lookup", server_id); } hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, update_region_loc_register_id_g, &update_region_loc_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Create FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); - if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: Sending updated region loc to server %d\n", pdc_server_rank_g, - server_id); - fflush(stdout); - } + if (is_debug_g == 1) + LOG_DEBUG("Sending updated region loc to server %d\n", server_id); in.obj_id = region->meta->obj_id; in.offset = region->offset; @@ -3203,24 +2957,19 @@ PDC_Server_update_region_storagelocation_offset(region_list_t *region, int type) } if (in.hist.nbin == 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR sending hist to server %d with 0 bins\n", pdc_server_rank_g, - server_id); + LOG_ERROR("Error sending hist to server %d with 0 bins\n", server_id); } lookup_args.rpc_handle = update_region_loc_handle; hg_ret = HG_Forward(update_region_loc_handle, PDC_Server_update_region_loc_cb, &lookup_args, &in); if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward() to server %d FAILED\n", pdc_server_rank_g, server_id); HG_Destroy(update_region_loc_handle); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Forward to server %d", server_id); } HG_Destroy(update_region_loc_handle); } done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3237,10 +2986,9 @@ PDC_Server_add_region_storage_meta_to_bulk_buf(region_list_t *region, bulk_xfer_ // Sanity check if (NULL == region || region->storage_location[0] == 0 || NULL == region->meta) { - LOG_ERROR("==PDC_SERVER[%d]: invalid region data!\n", pdc_server_rank_g); + LOG_ERROR("Invalid region data\n"); PDC_print_region_list(region); - ret_value = FAIL; - goto done; + PGOTO_DONE(FAIL); } // Alloc space and init if it's empty @@ -3251,11 +2999,8 @@ PDC_Server_add_region_storage_meta_to_bulk_buf(region_list_t *region, bulk_xfer_ sizeof(update_region_storage_meta_bulk_t), PDC_BULK_XFER_INIT_NALLOC); bulk_data->buf_sizes = (hg_size_t *)PDC_calloc(sizeof(hg_size_t), PDC_BULK_XFER_INIT_NALLOC); - if (NULL == buf_ptrs_1d || NULL == bulk_data->buf_sizes) { - LOG_ERROR("==PDC_SERVER[%d]: calloc FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (NULL == buf_ptrs_1d || NULL == bulk_data->buf_sizes) + PGOTO_ERROR(FAIL, "PDC_calloc FAILED"); // first element of bulk_buf is the obj_id bulk_data->buf_ptrs[0] = (void *)PDC_calloc(sizeof(uint64_t), 1); @@ -3274,30 +3019,19 @@ PDC_Server_add_region_storage_meta_to_bulk_buf(region_list_t *region, bulk_xfer_ // TODO: Need to expand the space when more than initial allocated int idx = bulk_data->idx; - if (idx >= bulk_data->n_alloc) { - LOG_ERROR("==PDC_SERVER[%d]: need to alloc larger!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (idx >= bulk_data->n_alloc) + PGOTO_ERROR(FAIL, "Need to alloc larger"); // get obj_id obj_id = region->meta->obj_id; - if (obj_id == 0) { - LOG_ERROR("==PDC_SERVER[%d]: invalid metadata from region!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (obj_id == 0) + PGOTO_ERROR(FAIL, "Invalid metadata from region"); obj_id_ptr = (uint64_t *)bulk_data->buf_ptrs[0]; // Check if current region has the same obj_id - if (0 != *obj_id_ptr) { - if (bulk_data->obj_id != obj_id) { - LOG_ERROR("==PDC_SERVER[%d]: region has a different obj id!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - } + if (0 != *obj_id_ptr && bulk_data->obj_id != obj_id) + PGOTO_ERROR(FAIL, "Region has a different obj id"); else { // obj_id and target_id only need to be init when the first data is added (when obj_id==0) *obj_id_ptr = obj_id; @@ -3329,21 +3063,20 @@ PDC_Server_update_region_storage_meta_bulk_local(update_region_storage_meta_bulk int update_success = 0, express_insert = 0; uint64_t obj_id; - if (NULL == bulk_ptrs || cnt == 0 || NULL == bulk_ptrs[0]) { - LOG_ERROR("==PDC_SERVER[%d]: invalid input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (bulk_ptrs == NULL) + PGOTO_ERROR(FAIL, "bulk_ptrs was NULL"); + if (cnt == 0) + PGOTO_ERROR(FAIL, "cnt was 0"); + if (bulk_ptrs[0] == NULL) + PGOTO_ERROR(FAIL, "bulk_ptrs[0] was NULL"); obj_id = *(uint64_t *)bulk_ptrs[0]; // First ptr in buf_ptrs is the obj_id for (i = 1; i < cnt; i++) { - bulk_ptr = (update_region_storage_meta_bulk_t *)(bulk_ptrs[i]); // Create a new region for each and copy the data from bulk data - new_region = (region_list_t *)PDC_calloc(1, sizeof(region_list_t)); PDC_region_transfer_t_to_list_t(&bulk_ptr->region_transfer, new_region); new_region->data_size = PDC_get_region_size(new_region); @@ -3352,12 +3085,8 @@ PDC_Server_update_region_storage_meta_bulk_local(update_region_storage_meta_bulk // The bulk data are regions of same obj_id, and the corresponding metadata must be local target_meta = find_metadata_by_id(obj_id); - if (target_meta == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: FAIL to get storage metadata\n", pdc_server_rank_g); - - ret_value = FAIL; - goto done; - } + if (target_meta == NULL) + PGOTO_ERROR(FAIL, "target_meta was NULL"); new_region->meta = target_meta; new_region->obj_id = target_meta->obj_id; @@ -3376,9 +3105,7 @@ PDC_Server_update_region_storage_meta_bulk_local(update_region_storage_meta_bulk region_elt->offset = new_region->offset; update_success = 1; - LOG_ERROR("==PDC_SERVER[%d]: overwrite existing region location/offset\n", - pdc_server_rank_g); - fflush(stdout); + LOG_INFO("Overwrite existing region location/offset\n"); new_region = (region_list_t *)PDC_free(new_region); break; } @@ -3401,42 +3128,33 @@ update_storage_meta_bulk_rpc_cb(const struct hg_cb_info *callback_info) hg_handle_t handle = callback_info->info.forward.handle; pdc_int_ret_t bulk_rpc_ret; - hg_return_t ret = HG_SUCCESS; + hg_return_t ret_value = HG_SUCCESS; update_region_storage_meta_bulk_args_t *cb_args = (update_region_storage_meta_bulk_args_t *)callback_info->arg; // Sent the bulk handle with rpc and get a response - ret = HG_Get_output(handle, &bulk_rpc_ret); - if (ret != HG_SUCCESS) { - LOG_ERROR("Could not get output\n"); - goto done; - } + ret_value = HG_Get_output(handle, &bulk_rpc_ret); + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Could not get output"); /* Get output parameters, 9999 corresponds to the one set in update_storage_meta_bulk_cb */ if (bulk_rpc_ret.ret != 9999) - LOG_ERROR("==PDC_SERVER[%d]: update storage meta bulk rpc returned value error!\n", - pdc_server_rank_g); - - fflush(stdout); + LOG_ERROR("Update storage meta bulk rpc returned value error\n"); - ret = HG_Free_output(handle, &bulk_rpc_ret); - if (ret != HG_SUCCESS) { - LOG_ERROR("Could not free output\n"); - goto done; - } + ret_value = HG_Free_output(handle, &bulk_rpc_ret); + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Could not free output"); if (cb_args->cb != NULL) cb_args->cb((update_storage_meta_list_t *)cb_args->meta_list_target, cb_args->n_updated); /* Free memory handle */ - ret = HG_Bulk_free(cb_args->bulk_handle); - if (ret != HG_SUCCESS) { - LOG_ERROR("Could not free bulk data handle\n"); - goto done; - } + ret_value = HG_Bulk_free(cb_args->bulk_handle); + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Could not free bulk data handle"); done: - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } perr_t @@ -3480,10 +3198,8 @@ PDC_Server_update_region_storage_meta_bulk_mpi(bulk_xfer_data_t *bulk_data) ret_value = PDC_Server_update_region_storage_meta_bulk_local( (update_region_storage_meta_bulk_t **)all_meta, all_meta_cnt + 1); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: update_region_storage_meta_bulk_local FAILED!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with update_region_storage_meta_bulk_local"); update_local_region_count_g += all_meta_cnt; } // end of if @@ -3493,9 +3209,8 @@ PDC_Server_update_region_storage_meta_bulk_mpi(bulk_xfer_data_t *bulk_data) all_meta = (void **)PDC_free(all_meta); } #else - LOG_ERROR("is not supposed to be called without MPI enabled!\n"); + LOG_ERROR("Not supposed to be called without MPI enabled\n"); #endif - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3525,10 +3240,8 @@ PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t * b ret_value = PDC_Server_update_region_storage_meta_bulk_local( (update_region_storage_meta_bulk_t **)bulk_data->buf_ptrs, bulk_data->idx); update_local_region_count_g++; - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: update_region_storage_meta_bulk_local FAILED!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with update_region_storage_meta_bulk_local"); meta_list_target->is_updated = 1; // Run callback function immediately @@ -3536,29 +3249,20 @@ PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t * b } // end of if else { if (PDC_Server_lookup_server_id(server_id) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting remote server %d addr via lookup\n", pdc_server_rank_g, - server_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error getting remote server %d addr via lookup", server_id); } // Send the bulk handle to the target with RPC hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, bulk_rpc_register_id_g, &rpc_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create handle"); /* Register memory */ hg_ret = HG_Bulk_create(hg_class_g, bulk_data->idx, bulk_data->buf_ptrs, bulk_data->buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); /* Fill input structure */ bulk_rpc_in.origin = pdc_server_rank_g; @@ -3574,18 +3278,13 @@ PDC_Server_update_region_storage_meta_bulk_with_cb(bulk_xfer_data_t * b /* Forward call to remote addr */ hg_ret = HG_Forward(rpc_handle, update_storage_meta_bulk_rpc_cb, cb_args, &bulk_rpc_in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not forward call\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not forward call"); meta_list_target->is_updated = 1; } // end of else done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3624,11 +3323,8 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re double n_contig_MB = 0.0; *total_read_bytes = 0; - if (ndim > 3 || ndim <= 0) { - LOG_ERROR("==PDC_SERVER[%d]: dim=%" PRIu32 " unsupported yet!", pdc_server_rank_g, ndim); - ret_value = FAIL; - goto done; - } + if (ndim > 3 || ndim <= 0) + PGOTO_ERROR(FAIL, "dim=%" PRIu32 " is unsupported", ndim); if (req_count && req_count[0] == 0) { is_all_selected = 1; @@ -3641,9 +3337,7 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re // Get the actual start and count of region in storage if (PDC_get_overlap_start_count(ndim, req_start, req_count, storage_start, storage_count, overlap_start, overlap_count) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_get_overlap_start_count FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error with PDC_get_overlap_start_count"); } total_bytes = 1; @@ -3691,8 +3385,8 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re } if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: read storage offset %" PRIu64 ", buf_offset %" PRIu64 "\n", - pdc_server_rank_g, storage_offset, buf_offset); + LOG_DEBUG("Read storage offset %" PRIu64 ", buf_offset %" PRIu64 "\n", storage_offset, + buf_offset); } read_bytes = fread(buf + buf_offset, 1, total_bytes, fp); @@ -3700,26 +3394,20 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end1, 0); double region_read_time1 = PDC_get_elapsed_time_double(&pdc_timer_start1, &pdc_timer_end1); - if (is_debug_g) { - LOG_ERROR("==PDC_SERVER[%d]: fseek + fread %" PRIu64 " bytes, %.2fs\n", pdc_server_rank_g, - read_bytes, region_read_time1); - fflush(stdout); - } + if (is_debug_g) + LOG_ERROR("seek + fread %" PRIu64 " bytes, %.2fs\n", read_bytes, region_read_time1); #endif n_contig_MB += read_bytes / 1048576.0; n_contig_read++; if (read_bytes != total_bytes) { - LOG_ERROR("==PDC_SERVER[%d]: read failed actual read bytes %" PRIu64 ", should be %" PRIu64 "\n", - pdc_server_rank_g, read_bytes, total_bytes); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Read failed actual read bytes %" PRIu64 ", should be %" PRIu64 "\n", + read_bytes, total_bytes); } *total_read_bytes += read_bytes; if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: Read entire storage region, size=%" PRIu64 "\n", pdc_server_rank_g, - read_bytes); + LOG_DEBUG("Read entire storage region, size=%" PRIu64 "\n", read_bytes); } } // end if else { @@ -3736,11 +3424,8 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re read_bytes = fread(buf + buf_offset + row_offset, 1, overlap_count[0], fp); n_contig_MB += read_bytes / 1048576.0; n_contig_read++; - if (read_bytes != overlap_count[0]) { - LOG_ERROR("==PDC_SERVER[%d]: fread failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (read_bytes != overlap_count[0]) + PGOTO_ERROR(FAIL, "fread failed"); *total_read_bytes += read_bytes; } // for each row } // ndim=2 @@ -3763,11 +3448,8 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re read_bytes = fread(buf + buf_serialize_offset, 1, overlap_count[0], fp); n_contig_MB += read_bytes / 1048576.0; n_contig_read++; - if (read_bytes != overlap_count[0]) { - LOG_ERROR("==PDC_SERVER[%d]: fread failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (read_bytes != overlap_count[0]) + PGOTO_ERROR(FAIL, "fread failed\n"); *total_read_bytes += read_bytes; if (is_debug_g == 1) { LOG_DEBUG("z: %" PRIu64 ", j: %" PRIu64 ", Read data size=%" PRIu64 ": [%.*s]\n", j, @@ -3782,15 +3464,10 @@ PDC_Server_read_overlap_regions(uint32_t ndim, uint64_t *req_start, uint64_t *re n_fread_g += n_contig_read; fread_total_MB += n_contig_MB; - if (total_bytes != *total_read_bytes) { - LOG_ERROR("==PDC_SERVER[%d]: read size error!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (total_bytes != *total_read_bytes) + PGOTO_ERROR(FAIL, "Read size error"); done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -3800,7 +3477,7 @@ PDC_init_bulk_xfer_data_t(bulk_xfer_data_t *a) FUNC_ENTER(NULL); if (NULL == a) { - LOG_ERROR("NULL input!\n"); + LOG_ERROR("NULL input\n"); return; } a->buf_ptrs = NULL; @@ -3841,19 +3518,16 @@ PDC_Server_read_one_region(region_list_t *read_region) if (read_region->access_type != PDC_READ || read_region->n_overlap_storage_region == 0 || read_region->overlap_storage_regions == NULL) { - - LOG_ERROR("==PDC_SERVER[%d]: Error with input\n", pdc_server_rank_g); + LOG_ERROR("Error with input\n"); PDC_print_region_list(read_region); - goto done; + PGOTO_DONE(FAIL); } // Create the shm segment to read data into snprintf(read_region->shm_addr, ADDR_MAX, "/PDC%d_%d", pdc_server_rank_g, rand()); ret_value = PDC_create_shm_segment(read_region); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with shared memory creation\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with shared memory creation"); is_shm_created = 1; total_mem_cache_size_mb_g += (read_region->data_size / 1048576); @@ -3862,14 +3536,12 @@ PDC_Server_read_one_region(region_list_t *read_region) DL_FOREACH(read_region->overlap_storage_regions, region_elt) { if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: Found overlapping storage regions %d\n", pdc_server_rank_g, - n_storage_regions); + LOG_DEBUG("Found overlapping storage regions %d\n", n_storage_regions); } if (region_elt->storage_location[0] == 0) { - LOG_DEBUG("==PDC_SERVER[%d]: empty overlapping storage location \n", pdc_server_rank_g); + LOG_DEBUG("Empty overlapping storage location\n"); PDC_print_storage_region_list(region_elt); - fflush(stdout); continue; } @@ -3888,8 +3560,7 @@ PDC_Server_read_one_region(region_list_t *read_region) fp_read = fopen(region_elt->storage_location, "rb"); if (fp_read == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: fopen failed [%s]\n", pdc_server_rank_g, - read_region->storage_location); + LOG_ERROR("fopen failed [%s]\n", read_region->storage_location); continue; } n_fopen_g++; @@ -3908,7 +3579,7 @@ PDC_Server_read_one_region(region_list_t *read_region) region_elt->offset, read_region->buf, &read_bytes); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_read_overlap_regions\n", pdc_server_rank_g); + LOG_ERROR("Error with PDC_Server_read_overlap_regions\n"); fclose(fp_read); fp_read = NULL; continue; @@ -3920,11 +3591,8 @@ PDC_Server_read_one_region(region_list_t *read_region) } // end of for all overlapping storage regions for one request region #ifdef ENABLE_TIMING - if (is_debug_g == 1) { - LOG_ERROR("==PDC_SERVER[%d]: Read data total size %" PRIu64 ", fopen time: %.3f\n", pdc_server_rank_g, - total_read_bytes, fopen_time); - fflush(stdout); - } + if (is_debug_g == 1) + LOG_ERROR("Read data total size %" PRIu64 ", fopen time: %.3f\n", total_read_bytes, fopen_time); #endif read_region->is_data_ready = 1; @@ -3937,7 +3605,6 @@ PDC_Server_read_one_region(region_list_t *read_region) read_region->is_data_ready = 0; read_region->is_io_done = 0; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -3945,21 +3612,7 @@ PDC_Server_read_one_region(region_list_t *read_region) /* * Read with POSIX within one file, based on the region list * after the server has accumulated requests from all node local clients - - - - - - - - - - - - * - - * \param region_list_head[IN] Region info of IO request * * \return Non-negative on success/Negative on failure @@ -3981,11 +3634,8 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) int stripe_count, stripe_size; #endif - if (NULL == region_list_head) { - LOG_ERROR("==PDC_SERVER[%d]: NULL input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (NULL == region_list_head) + PGOTO_ERROR(FAIL, "region_list_head was NULL"); // For read requests, it's better to aggregate read requests from all node-local clients // and query once, rather than query one by one, so we aggregate at the beginning @@ -4002,9 +3652,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) continue; ret_value = PDC_Server_get_storage_location_of_region_mpi(region_elt); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_get_storage_location_of_region failed!\n", - pdc_server_rank_g); - goto done; + PGOTO_ERROR(FAIL, "Error with PDC_Server_get_storage_location_of_region"); } } } @@ -4020,7 +3668,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) { if (region_elt->access_type == PDC_READ) { if (region_elt->is_io_done == 1 && region_elt->is_shm_closed != 1) { - LOG_ERROR("==PDC_SERVER[%d]: found cached data!\n", pdc_server_rank_g); + LOG_ERROR("Found cached data\n"); if (region_elt->access_type == PDC_READ && current_read_from_cache_cnt_g < total_read_from_cache_cnt_g) @@ -4033,7 +3681,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) snprintf(region_elt->shm_addr, ADDR_MAX, "/PDC%d_%d", pdc_server_rank_g, rand()); ret_value = PDC_create_shm_segment(region_elt); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with shared memory creation\n", pdc_server_rank_g); + LOG_ERROR("Error with shared memory creation\n"); continue; } @@ -4049,8 +3697,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) fclose(fp_read); fp_read = fopen(region_elt->cache_location, "rb"); if (fp_read == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: unable to open file [%s]\n", pdc_server_rank_g, - region_elt->cache_location); + LOG_ERROR("Unable to open file [%s]\n", region_elt->cache_location); } n_fopen_g++; } @@ -4061,13 +3708,13 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) fseek(fp_read, region_elt->cache_offset, SEEK_SET); if (region_elt->data_size == 0) { - LOG_ERROR("==PDC_SERVER[%d]: region data_size is 0\n", pdc_server_rank_g); + LOG_ERROR("Region data_size is 0\n"); continue; } read_bytes = fread(region_elt->buf, 1, region_elt->data_size, fp_read); if (read_bytes != region_elt->data_size) { - LOG_ERROR("==PDC_SERVER[%d]: read size %zu is not expected %" PRIu64 "\n", - pdc_server_rank_g, read_bytes, region_elt->data_size); + LOG_ERROR("Read size %zu is not expected %" PRIu64 "\n", read_bytes, + region_elt->data_size); continue; } #ifdef ENABLE_TIMING @@ -4101,7 +3748,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) n_fopen_g++; } else { - LOG_ERROR("==PDC_SERVER[%d]: NULL storage location\n", pdc_server_rank_g); + LOG_ERROR("NULL storage location\n"); fp_read = NULL; } @@ -4112,10 +3759,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) #endif if (fp_read == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: fopen failed [%s]\n", pdc_server_rank_g, - region_elt->storage_location); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "fopen failed [%s]", region_elt->storage_location); } } @@ -4128,30 +3772,22 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) region_elt->overlap_storage_regions[i].offset, region_elt->buf, &read_bytes); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_read_overlap_regions\n", - pdc_server_rank_g); fclose(fp_read); fp_read = NULL; - goto done; + PGOTO_ERROR(FAIL, "Error with PDC_Server_read_overlap_regions"); } total_read_bytes += read_bytes; prev_path = region_elt->overlap_storage_regions[i].storage_location; } // end of for all overlapping storage regions for one request region - if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: Read data total size %zu\n", pdc_server_rank_g, - total_read_bytes); - fflush(stdout); - } + if (is_debug_g == 1) + LOG_DEBUG("Read data total size %zu\n", total_read_bytes); offset += total_read_bytes; } // end else read from storage - if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: Read data total size %zu\n", pdc_server_rank_g, - total_read_bytes); - fflush(stdout); - } + if (is_debug_g == 1) + LOG_DEBUG("Read data total size %zu\n", total_read_bytes); region_elt->is_data_ready = 1; region_elt->is_io_done = 1; @@ -4162,9 +3798,8 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) // Assumes all regions are written to one file if (region_elt->storage_location[0] == 0) { - ret_value = FAIL; region_elt->is_data_ready = -1; - goto done; + PGOTO_DONE(FAIL); } // Open file if needed: @@ -4213,10 +3848,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) #endif if (NULL == fp_write) { - LOG_ERROR("==PDC_SERVER[%d]: fopen failed [%s]\n", pdc_server_rank_g, - region_elt->storage_location); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "fopen failed [%s]", region_elt->storage_location); } } // End open file @@ -4231,13 +3863,10 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) // Actual write (append) write_bytes = fwrite(region_elt->buf, 1, region_elt->data_size, fp_write); if (write_bytes != region_elt->data_size) { - LOG_ERROR("==PDC_SERVER[%d]: fwrite to [%s] FAILED, region off %" PRIu64 ", size %" PRIu64 - ", " - "actual writeen %zu!\n", - pdc_server_rank_g, region_elt->storage_location, offset, region_elt->data_size, - write_bytes); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, + "fwrite to [%s] FAILED, region off %" PRIu64 ", size %" PRIu64 ", " + "actual writeen %zu\n", + region_elt->storage_location, offset, region_elt->data_size, write_bytes); } n_fwrite_g++; fwrite_total_MB += write_bytes / 1048576.0; @@ -4247,8 +3876,7 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) double region_write_time = PDC_get_elapsed_time_double(&pdc_timer_start5, &pdc_timer_end5); server_write_time_g += region_write_time; if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: fwrite %" PRIu64 " bytes, %.2fs\n", pdc_server_rank_g, - write_bytes, region_write_time); + LOG_DEBUG("fwrite %" PRIu64 " bytes, %.2fs\n", write_bytes, region_write_time); } #endif @@ -4266,21 +3894,15 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) region_elt->offset = offset; ret_value = PDC_Server_update_region_storagelocation_offset(region_elt, PDC_UPDATE_STORAGE); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: failed to update region storage info!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Failed to update region storage info"); previous_region = region_elt; region_elt->is_io_done = 1; - - } // end of WRITE - else { - LOG_ERROR("==PDC_SERVER[%d]: unsupported access type\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; } - } // end DL_FOREACH region IO request (region) + else + PGOTO_ERROR(FAIL, "Unsupported access type"); + } done: if (fp_write != NULL) { @@ -4296,7 +3918,6 @@ PDC_Server_posix_one_file_io(region_list_t *region_list_head) if (ret_value != SUCCEED) region_elt->is_data_ready = -1; - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4361,7 +3982,6 @@ PDC_Server_data_io_direct(pdc_access_t io_type, uint64_t obj_id, struct pdc_regi // Need to get the metadata ret_value = PDC_Server_get_metadata_by_id_with_cb(obj_id, PDC_Server_regions_io, io_region); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -4378,10 +3998,8 @@ PDC_Server_posix_write(int fd, void *buf, uint64_t write_size) while (write_size > max_write_size) { ret = write(fd, buf, max_write_size); if (ret < 0 || ret != (ssize_t)max_write_size) { - LOG_ERROR("==PDC_SERVER[%d]: in-loop: write %d failed, ret = %ld, max_write_size = %llu\n", - pdc_server_rank_g, fd, ret, max_write_size); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "In-loop: write %d failed, ret = %ld, max_write_size = %llu", fd, ret, + max_write_size); } write_bytes += ret; buf += max_write_size; @@ -4390,10 +4008,7 @@ PDC_Server_posix_write(int fd, void *buf, uint64_t write_size) ret = write(fd, buf, write_size); if (ret < 0 || ret != (ssize_t)write_size) { - LOG_ERROR("==PDC_SERVER[%d]: write %d failed, not all data written %llu/%llu\n", pdc_server_rank_g, - fd, write_bytes, write_size); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "write %d failed, not all data written %llu/%llu", fd, write_bytes, write_size); } done: @@ -4414,7 +4029,7 @@ _setup_zfp(struct pdc_region_info *region_info, zfp_stream **zfp) else if (region_info->unit == 4) type = zfp_type_int32; else - LOG_ERROR("==PDC_SERVER[%d]: unit has size %u not expected!\n", pdc_server_rank_g, region_info->unit); + LOG_ERROR("Unit has size %u not expected\n", region_info->unit); if (region_info->ndim == 1) field = zfp_field_1d(region_info->buf, type, region_info->size[0]); @@ -4489,27 +4104,16 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, &overlap_size); if (overlap_offset) { - // is_overlap = 1; if (!is_contained && detect_region_contained(region_info->offset, region_info->size, overlap_region->start, overlap_region->count, region_info->ndim)) { is_contained = 1; } -#if 0 - local_write_size = overlap_region->count[0]; - for ( i = 1; i < (unsigned) region_info->ndim; ++i ) { - local_write_size *= overlap_region->count[i]; - } - total_write_size += local_write_size; -#endif if (region_info->ndim == 1) { // 1D can overwrite data in region directly pos = (overlap_offset[0] - overlap_region->start[0]) * unit; if (pos > write_size) { - LOG_ERROR("==PDC_SERVER[%d]: Error with buf pos calculation %llu / %llu!\n", - pdc_server_rank_g, pos, write_size); - ret_value = -1; - goto done; + PGOTO_ERROR(FAIL, "Error with buf pos calculation %llu / %llu", pos, write_size); } lseek(region->fd, overlap_region->offset + pos, SEEK_SET); @@ -4522,12 +4126,8 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_posix_write FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - // No need to update metadata + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_write"); } else { // data_sieving_g = 1 by default, export PDC_DATA_SIEVING=0 to change @@ -4539,7 +4139,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, #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); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; @@ -4558,11 +4158,8 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_posix_write FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_write"); tmp_buf = (char *)PDC_free(tmp_buf); } else { @@ -4605,10 +4202,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, tmp_buf = (char *)PDC_free(tmp_buf); } if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_posix_write FAILED!\n", - pdc_server_rank_g); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_write"); } } else { @@ -4634,10 +4228,7 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_posix_write FAILED!\n", - pdc_server_rank_g); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_write"); } } } @@ -4734,22 +4325,22 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, field = _setup_zfp(region_info, &zfp); if (field == NULL) - LOG_ERROR("==PDC_SERVER[%d]: _setup_zfp failed!\n", pdc_server_rank_g); + LOG_ERROR("_setup_zfp failed\n"); else { bufsize = zfp_stream_maximum_size(zfp, field); if (bufsize == 0) - LOG_ERROR("==PDC_SERVER[%d]: zfp_stream_maximum_size returned 0!\n", pdc_server_rank_g); + LOG_ERROR("zfp_stream_maximum_size returned 0\n"); buffer = PDC_malloc(bufsize); if (buffer == 0) - LOG_ERROR("==PDC_SERVER[%d]: malloc failed!\n", pdc_server_rank_g); + LOG_ERROR("malloc failed\n"); else { stream = stream_open(buffer, bufsize); zfp_stream_set_bit_stream(zfp, stream); // Compress the data and overwrite the write_size for the following posix write size_t compress_size = zfp_compress(zfp, field); - LOG_ERROR("==PDC_SERVER[%d]: zfp compressed size %lu / %llu CR=%.2lf\n", pdc_server_rank_g, - compress_size, write_size, (double)write_size / compress_size); + LOG_ERROR("zfp compressed size %lu / %llu CR=%.2lf\n", compress_size, write_size, + (double)write_size / compress_size); buf = buffer; write_size = compress_size; } @@ -4766,11 +4357,8 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_write_posix += MPI_Wtime() - start_posix; #endif - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_posix_write FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_write"); // Store storage information request_region->data_size = write_size; @@ -4785,16 +4373,13 @@ PDC_Server_data_write_out(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); write_total_sec = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - LOG_ERROR("==PDC_SERVER[%d]: write region time: %.4f, %llu bytes\n", pdc_server_rank_g, write_total_sec, - write_size); - fflush(stdout); + LOG_INFO("Write region time: %.4f, %llu bytes\n", write_total_sec, write_size); #endif #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_write_out += MPI_Wtime() - start; #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } // End PDC_Server_data_write_out @@ -4815,12 +4400,6 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, double start = MPI_Wtime(), start_posix; #endif region = PDC_Server_get_obj_region(obj_id); - /* - if (region == NULL) { - LOG_ERROR("cannot locate file handle\n"); - goto done; - } - */ // Was opened previously and closed. // The location string is cached, so we utilize // that to reopen the file. @@ -4854,16 +4433,13 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, if (pread(region->fd, buf + (overlap_offset[0] - region_info->offset[0]) * unit, overlap_size[0] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[0] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; #endif - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_posix_read FAILED!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_posix_read"); // No need to update metadata } else { @@ -4883,8 +4459,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, while (leftover > 0) { if (pread(region->fd, tmp_buf + buf_off, read_size, reg_off) != read_size) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes %llu\n", - pdc_server_rank_g, read_size); + LOG_ERROR("pread failed to read enough bytes %llu\n", read_size); } reg_off += read_size; buf_off += read_size; @@ -4896,8 +4471,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, else { 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); + LOG_ERROR("pread failed to read enough bytes\n"); } } #ifdef PDC_TIMING @@ -4913,9 +4487,8 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, field = _setup_zfp(region_info, &zfp); if (field == NULL) - LOG_ERROR("==PDC_SERVER[%d]: _setup_zfp failed!\n", pdc_server_rank_g); + LOG_ERROR("_setup_zfp failed\n"); else { - if (region_info->ndim >= 1) decompress_size = region_info->unit * region_info->size[0]; if (region_info->ndim >= 2) @@ -4923,19 +4496,18 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, if (region_info->ndim >= 3) decompress_size *= region_info->size[2]; if (decompress_size == 0) - LOG_ERROR("==PDC_SERVER[%d]: zfp_stream_maximum_size returned 0!\n", - pdc_server_rank_g); + LOG_ERROR("zfp_stream_maximum_size returned 0\n"); void *decompress_buffer = PDC_malloc(decompress_size); if (decompress_buffer == 0) - LOG_ERROR("==PDC_SERVER[%d]: malloc failed!\n", pdc_server_rank_g); + LOG_ERROR("malloc failed\n"); else { stream = stream_open(decompress_buffer, decompress_size); zfp_stream_set_bit_stream(zfp, stream); // Decompress the data decompress_size = zfp_decompress(zfp, field); if (decompress_size == 0) - LOG_ERROR("==PDC_SERVER[%d]: zfp_decompress failed!\n", pdc_server_rank_g); + LOG_ERROR("zfp_decompress failed\n"); tmp_buf = (char *)PDC_free(tmp_buf); tmp_buf = decompress_buffer; } @@ -4970,8 +4542,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, overlap_size[0] * overlap_size[1] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[0] * overlap_size[1] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", - pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; @@ -4985,8 +4556,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, if (pread(region->fd, tmp_buf, overlap_size[0] * overlap_size[1] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[0] * overlap_size[1] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", - pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; @@ -5013,8 +4583,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, unit, overlap_size[1] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[1] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", - pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; @@ -5042,8 +4611,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, overlap_size[0] * overlap_size[1] * overlap_size[2] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[0] * overlap_size[1] * overlap_size[2] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", - pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; @@ -5059,8 +4627,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, overlap_size[0] * overlap_size[1] * overlap_size[2] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[0] * overlap_size[1] * overlap_size[2] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", - pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += MPI_Wtime() - start_posix; @@ -5092,8 +4659,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, unit, overlap_size[2] * unit, overlap_region->offset + pos) != (ssize_t)(overlap_size[2] * unit)) { - LOG_ERROR("==PDC_SERVER[%d]: pread failed to read enough bytes\n", - pdc_server_rank_g); + LOG_ERROR("pread failed to read enough bytes\n"); } #ifdef PDC_TIMING pdc_server_timings->PDCdata_server_read_posix += @@ -5112,9 +4678,7 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); read_total_sec = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - LOG_INFO("==PDC_SERVER[%d]: read region time: %.4f, %llu bytes\n", pdc_server_rank_g, read_total_sec, - total_read_bytes); - fflush(stdout); + LOG_INFO("Read region time: %.4f, %llu bytes\n", read_total_sec, total_read_bytes); #endif #ifdef PDC_TIMING @@ -5122,7 +4686,6 @@ PDC_Server_data_read_from(uint64_t obj_id, struct pdc_region_info *region_info, #endif done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5134,15 +4697,10 @@ PDC_Server_data_write_direct(uint64_t obj_id, struct pdc_region_info *region_inf perr_t ret_value = SUCCEED; ret_value = PDC_Server_data_io_direct(PDC_WRITE, obj_id, region_info, buf); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_data_write_direct() " - "error with PDC_Server_data_io_direct()\n", - pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_data_io_direct"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5154,15 +4712,10 @@ PDC_Server_data_read_direct(uint64_t obj_id, struct pdc_region_info *region_info perr_t ret_value = SUCCEED; ret_value = PDC_Server_data_io_direct(PDC_READ, obj_id, region_info, buf); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_data_read_direct() " - "error with PDC_Server_data_io_direct()\n", - pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_data_io_direct"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5179,9 +4732,8 @@ PDC_Server_get_local_storage_meta_with_one_name(storage_meta_query_one_name_args // FIXME: currently use timestep value of 0 PDC_Server_search_with_name_timestep(args->name, PDC_get_hash_by_name(args->name), 0, &meta); - if (meta == NULL) { - goto done; - } + if (meta == NULL) + PGOTO_DONE(ret_value); region_head = meta->storage_region_list_head; @@ -5195,10 +4747,7 @@ PDC_Server_get_local_storage_meta_with_one_name(storage_meta_query_one_name_args DL_FOREACH(region_head, region_elt) { if (i >= region_count) { - LOG_ERROR("==PDC_SERVER[%d] More regions %d than allocated %d\n", pdc_server_rank_g, i, - region_count); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "More regions %d than allocated %d", i, region_count); } PDC_region_list_t_deep_cp(region_elt, &res_region_list[i]); res_region_list[i].prev = NULL; @@ -5208,7 +4757,6 @@ PDC_Server_get_local_storage_meta_with_one_name(storage_meta_query_one_name_args } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5236,10 +4784,8 @@ PDC_Server_get_all_storage_meta_with_one_name(storage_meta_query_one_name_args_t // Metadata object is local, no need to send update RPC // Fill in with storage meta (region_list_t **regions, int n_res) ret_value = PDC_Server_get_local_storage_meta_with_one_name(args); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: get local storage location ERROR!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Failed to get local storage location"); // Execute callback function immediately // cb: PDC_Server_accumulate_storage_meta_then_read @@ -5250,17 +4796,11 @@ PDC_Server_get_all_storage_meta_with_one_name(storage_meta_query_one_name_args_t else { // send the name to target server server_id = PDC_get_server_by_name(args->name, pdc_server_size_g); - if (is_debug_g == 1) { - LOG_DEBUG("==PDC_SERVER[%d]: will get storage meta from remote server %d\n", pdc_server_rank_g, - server_id); - fflush(stdout); - } + if (is_debug_g == 1) + LOG_DEBUG("Will get storage meta from remote server %d\n", server_id); if (PDC_Server_lookup_server_id(server_id) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting remote server %d addr via lookup\n", pdc_server_rank_g, - server_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error getting remote server %d addr via lookup", server_id); } n_get_remote_storage_meta_g++; @@ -5277,17 +4817,13 @@ PDC_Server_get_all_storage_meta_with_one_name(storage_meta_query_one_name_args_t hg_ret = HG_Forward(rpc_handle, PDC_check_int_ret_cb, NULL, &in); if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: Could not start HG_Forward to server %u\n", pdc_server_rank_g, - server_id); HG_Destroy(rpc_handle); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Could not start HG_Forward to server %u", server_id); } HG_Destroy(rpc_handle); - } // end else + } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5361,7 +4897,7 @@ PDC_Server_accumulate_storage_meta_then_read(storage_meta_query_one_name_args_t // Read data to shm ret_value = PDC_Server_read_one_region(region_elt); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error with PDC_Server_read_one_region\n", pdc_server_rank_g); + LOG_ERROR("Error with PDC_Server_read_one_region\n"); } } @@ -5370,10 +4906,8 @@ PDC_Server_accumulate_storage_meta_then_read(storage_meta_query_one_name_args_t #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); read_total_sec = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - LOG_INFO("==PDC_SERVER[%d]: read %d objects time: %.4f, n_fread: %d, n_fopen: %d, is_sort_read: %d\n", - pdc_server_rank_g, accu_meta->n_accumulated, read_total_sec, n_fread_g, n_fopen_g, - is_sort_read); - fflush(stdout); + LOG_INFO("Read %d objects time: %.4f, n_fread: %d, n_fopen: %d, is_sort_read: %d\n", + accu_meta->n_accumulated, read_total_sec, n_fread_g, n_fopen_g, is_sort_read); #endif // send all shm info to client @@ -5382,7 +4916,6 @@ PDC_Server_accumulate_storage_meta_then_read(storage_meta_query_one_name_args_t } // End if // TODO free many things - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5430,7 +4963,6 @@ PDC_Server_query_read_names(query_read_names_args_t *query_read_args) // When all storage metadata have been collected, the read operation will be triggered // in PDC_Server_accumulate_storage_meta_then_read(). - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5449,25 +4981,21 @@ PDC_Server_storage_meta_name_query_bulk_respond_cb(const struct hg_cb_info *call { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; - hg_handle_t handle = callback_info->info.forward.handle; + hg_return_t ret_value = HG_SUCCESS; + hg_handle_t handle = callback_info->info.forward.handle; pdc_int_ret_t bulk_rpc_ret; // Sent the bulk handle with rpc and get a response - ret = HG_Get_output(handle, &bulk_rpc_ret); - if (ret != HG_SUCCESS) { - LOG_ERROR("Could not get output\n"); - goto done; - } + ret_value = HG_Get_output(handle, &bulk_rpc_ret); + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Could not get output"); - ret = HG_Free_output(handle, &bulk_rpc_ret); - if (ret != HG_SUCCESS) { - LOG_ERROR("Could not free output\n"); - goto done; - } + ret_value = HG_Free_output(handle, &bulk_rpc_ret); + if (ret_value != HG_SUCCESS) + PGOTO_ERROR(ret_value, "Could not free output"); done: - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } // Get all storage meta of the one requested object name and bulk xfer to original requested server @@ -5498,28 +5026,20 @@ PDC_Server_storage_meta_name_query_bulk_respond(const struct hg_cb_info *callbac ret_value = PDC_Server_get_local_storage_meta_with_one_name(query_args); if (ret_value != SUCCEED) { - - LOG_ERROR("==PDC_SERVER[%d]: get local storage location ERROR!\n", pdc_server_rank_g); - goto done; + PGOTO_ERROR(FAIL, "Error with geting local storage location"); } // Now the storage meta is stored in query_args->regions; server_id = args->origin_id; if (PDC_Server_lookup_server_id(server_id) != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting remote server %d addr via lookup\n", pdc_server_rank_g, - server_id); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error getting remote server %d addr via lookup", server_id); } // bulk transfer to args->origin_id hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, get_storage_meta_name_query_bulk_result_rpc_register_id_g, &rpc_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create handle"); int nbuf = 3 * query_args->n_res + 1; buf_sizes = (hg_size_t *)PDC_calloc(sizeof(hg_size_t), nbuf); @@ -5557,31 +5077,20 @@ PDC_Server_storage_meta_name_query_bulk_respond(const struct hg_cb_info *callbac /* Register memory */ hg_ret = HG_Bulk_create(hg_class_g, nbuf, buf_ptrs, buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); /* Fill input structure */ bulk_rpc_in.cnt = query_args->n_res; bulk_rpc_in.origin = pdc_server_rank_g; bulk_rpc_in.bulk_handle = bulk_handle; - // TODO: put ptrs that need to be freed into cb_args - /* cb_args.bulk_handle = bulk_handle; */ - /* cb_args.rpc_handle = rpc_handle; */ - /* Forward call to remote addr */ hg_ret = HG_Forward(rpc_handle, PDC_Server_storage_meta_name_query_bulk_respond_cb, NULL, &bulk_rpc_in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not forward call\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not forward call"); done: - fflush(stdout); FUNC_LEAVE(hg_ret); } @@ -5601,11 +5110,8 @@ PDC_Server_proc_storage_meta_bulk(int task_id, int n_regions, region_list_t *reg pdc_task_list_t *task = PDC_find_task_from_list(&pdc_server_s2s_task_head_g, task_id, &pdc_server_task_mutex_g); - if (task == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Error getting task %d\n", pdc_server_rank_g, task_id); - ret_value = FAIL; - goto done; - } + if (task == NULL) + PGOTO_ERROR(FAIL, "Error getting task %d", task_id); // Add the result storage regions to accumulate_storage_meta query_args = (storage_meta_query_one_name_args_t *)task->cb_args; @@ -5619,8 +5125,6 @@ PDC_Server_proc_storage_meta_bulk(int task_id, int n_regions, region_list_t *reg PDC_del_task_from_list(&pdc_server_s2s_task_head_g, task, &pdc_server_task_mutex_g); done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -5672,31 +5176,23 @@ PDC_Server_add_client_shm_to_cache(int cnt, void *buf_cp) // Open shared memory and map to data buf new_region->shm_fd = shm_open(new_region->shm_addr, O_RDONLY, 0666); - if (new_region->shm_fd == -1) { - LOG_ERROR("==PDC_SERVER[%d]: Shared memory open failed [%s]!\n", pdc_server_rank_g, - new_region->shm_addr); - ret_value = FAIL; - goto done; - } + if (new_region->shm_fd == -1) + PGOTO_ERROR(FAIL, "Shared memory open failed [%s]", new_region->shm_addr); new_region->buf = mmap(0, new_region->data_size, PROT_READ, MAP_SHARED, new_region->shm_fd, new_region->offset); - if (new_region->buf == MAP_FAILED) { - ret_value = FAIL; - goto done; - } + if (new_region->buf == MAP_FAILED) + PGOTO_DONE(FAIL); new_region->is_data_ready = 1; new_region->is_io_done = 1; DL_PREPEND(io_list_target->region_list_head, new_region); - - } // End for each cache entry + } done: #ifdef ENABLE_MULTITHREAD hg_thread_mutex_unlock(&data_read_list_mutex_g); #endif - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -5758,11 +5254,8 @@ PDC_Server_data_read_to_buf_1_region(region_list_t *region) FUNC_LEAVE(SUCCEED); fp_read = fopen(region->storage_location, "rb"); - if (NULL == fp_read) { - LOG_ERROR("==PDC_SERVER[%d]: fopen failed [%s]\n", pdc_server_rank_g, region->storage_location); - ret_value = FAIL; - goto done; - } + if (NULL == fp_read) + PGOTO_ERROR(FAIL, "fopen failed [%s]", region->storage_location); n_fopen_g++; offset = ftell(fp_read); @@ -5771,20 +5264,14 @@ PDC_Server_data_read_to_buf_1_region(region_list_t *region) else fseek(fp_read, region->offset, SEEK_SET); - if (region->data_size == 0) { - LOG_ERROR("==PDC_SERVER[%d]: region data_size is 0\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region->data_size == 0) + PGOTO_ERROR(FAIL, "Region data_size was 0"); region->buf = PDC_malloc(region->data_size); read_bytes = fread(region->buf, 1, region->data_size, fp_read); if (read_bytes != region->data_size) { - LOG_ERROR("==PDC_SERVER[%d]: read size %" PRIu64 " is not expected %" PRIu64 "\n", pdc_server_rank_g, - read_bytes, region->data_size); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Read size %" PRIu64 " is not expected %" PRIu64, read_bytes, region->data_size); } region->is_data_ready = 1; @@ -5826,8 +5313,7 @@ PDC_Server_data_read_to_buf(region_list_t *region_list_head) fclose(fp_read); fp_read = fopen(region_elt->storage_location, "rb"); if (NULL == fp_read) { - LOG_ERROR("==PDC_SERVER[%d]: fopen failed [%s]\n", pdc_server_rank_g, - region_elt->storage_location); + LOG_ERROR("fopen failed [%s]\n", region_elt->storage_location); } n_fopen_g++; } @@ -5839,7 +5325,7 @@ PDC_Server_data_read_to_buf(region_list_t *region_list_head) fseek(fp_read, region_elt->offset, SEEK_SET); if (region_elt->data_size == 0) { - LOG_ERROR("==PDC_SERVER[%d]: region data_size is 0\n", pdc_server_rank_g); + LOG_ERROR("Region data_size is 0\n"); continue; } @@ -5847,8 +5333,8 @@ PDC_Server_data_read_to_buf(region_list_t *region_list_head) read_bytes = fread(region_elt->buf, 1, region_elt->data_size, fp_read); if (read_bytes != region_elt->data_size) { - LOG_ERROR("==PDC_SERVER[%d]: read size %" PRIu64 " is not expected %" PRIu64 "\n", - pdc_server_rank_g, read_bytes, region_elt->data_size); + LOG_ERROR("Read size %" PRIu64 " is not expected %" PRIu64 "\n", read_bytes, + region_elt->data_size); continue; } read_count++; @@ -5865,15 +5351,12 @@ PDC_Server_data_read_to_buf(region_list_t *region_list_head) double read_time = PDC_get_elapsed_time_double(&pdc_timer_start1, &pdc_timer_end1); server_read_time_g += read_time; if (region_list_head != NULL) { - LOG_INFO("==PDC_SERVER[%d]: finished reading obj %" PRIu64 " of %d regions, %.2f seconds!\n", - pdc_server_rank_g, region_list_head->obj_id, read_count, read_time); + LOG_INFO("Finished reading obj %" PRIu64 " of %d regions, %.2f seconds\n", region_list_head->obj_id, + read_count, read_time); } else - LOG_INFO("==PDC_SERVER[%d]: no regions have been read!\n", pdc_server_rank_g); + LOG_INFO("No regions have been read\n"); #endif - - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -5886,7 +5369,7 @@ PDC_region_has_hits_from_hist(pdc_query_constraint_t *constraint, pdc_histogram_ double value, value2; if (constraint == NULL || region_hist == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: NULL input!\n", pdc_server_rank_g); + LOG_ERROR("NULL input\n"); FUNC_LEAVE(-1); } @@ -5917,8 +5400,9 @@ PDC_region_has_hits_from_hist(pdc_query_constraint_t *constraint, pdc_histogram_ value2 = (double)constraint->value2; break; default: - LOG_ERROR("==PDC_SERVER[%d]: error with operator type!\n", pdc_server_rank_g); + LOG_ERROR("Error with operator type\n"); FUNC_LEAVE(-1); + break; } lop = constraint->op; @@ -5959,10 +5443,10 @@ PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_com pdc_query_constraint_t *constraint = query->constraint; storage_region_list_head = constraint->storage_region_list_head; - if (NULL == constraint || NULL == storage_region_list_head) { - LOG_ERROR("==PDC_SERVER[%d]: NULL query constraint/storage region!\n", pdc_server_rank_g); - goto done; - } + if (constraint == NULL) + PGOTO_ERROR(FAIL, "constraint was NULL"); + if (storage_region_list_head == NULL) + PGOTO_ERROR(FAIL, "storage_region_list_head was NULL"); obj_id = constraint->obj_id; @@ -5984,11 +5468,8 @@ PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_com // pdc_data_server_io_list_t maintains the request list for one object id, // write and read are separate lists io_list_target = (pdc_data_server_io_list_t *)PDC_calloc(1, sizeof(pdc_data_server_io_list_t)); - if (NULL == io_list_target) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR allocating pdc_data_server_io_list_t!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (NULL == io_list_target) + PGOTO_ERROR(FAIL, "Error with allocating pdc_data_server_io_list_t"); io_list_target->obj_id = obj_id; io_list_target->total = 0; // not used yet io_list_target->count = 0; @@ -6033,10 +5514,8 @@ PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_com // use histogram to see if we need to read this region if (gen_hist_g == 1) { - if (req_region->region_hist->nbin == 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR histogram is empty!\n", pdc_server_rank_g); - fflush(stdout); - } + if (req_region->region_hist->nbin == 0) + LOG_ERROR("Error histogram is empty\n"); if (PDC_region_has_hits_from_hist(constraint, req_region->region_hist) == 0) { if (task->invalid_region_ids == NULL) @@ -6068,11 +5547,8 @@ PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_com if (1 != is_same_region) { // append current request region to the io list region_list_t *new_region = (region_list_t *)PDC_calloc(1, sizeof(region_list_t)); - if (new_region == NULL) { - LOG_ERROR("==PDC_SERVER: ERROR allocating new_region!\n"); - ret_value = FAIL; - goto done; - } + if (new_region == NULL) + PGOTO_ERROR(FAIL, "Error with allocating new_region"); req_region->io_cache_region = new_region; PDC_region_list_t_deep_cp(req_region, new_region); new_region->is_data_ready = 0; @@ -6084,18 +5560,14 @@ PDC_Server_load_query_data(query_task_t *task, pdc_query_t *query, pdc_query_com DL_APPEND(io_list_target->region_list_head, new_region); } - } // Ened DL_FOREACH + } // Currently reads all regions of a query constraint together - // TODO: potential optimization: aggregate all I/O requests ret_value = PDC_Server_data_read_to_buf(io_list_target->region_list_head); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_data_read_to_shm FAILED!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_data_read_to_buf"); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -6105,12 +5577,11 @@ region_index_to_coord(int ndim, uint64_t idx, uint64_t *sizes, uint64_t *coord) FUNC_ENTER(NULL); if (sizes == NULL || coord == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: input NULL!\n", pdc_server_rank_g); + LOG_ERROR("Input NULL\n"); FUNC_LEAVE(FAIL); } - if (ndim > 3) { - LOG_ERROR("==PDC_SERVER[%d]: dimension > 3 not supported!\n", pdc_server_rank_g); + LOG_ERROR("Dimension > 3 not supported\n"); FUNC_LEAVE(FAIL); } @@ -6135,12 +5606,11 @@ coord_to_region_index(size_t ndim, uint64_t *coord, region_list_t *region, int u uint64_t off = 0; if (ndim == 0 || coord == NULL || region == NULL || region->start[0] == 0 || region->count[0] == 0) { - LOG_ERROR("==PDC_SERVER[%d]: input NULL!\n", pdc_server_rank_g); + LOG_ERROR("Input NULL\n"); FUNC_LEAVE(0); } - if (ndim > 3) { - LOG_ERROR("==PDC_SERVER[%d]: cannot handle dim > 3!\n", pdc_server_rank_g); + LOG_ERROR("Cannot handle dim > 3\n"); FUNC_LEAVE(0); } @@ -6239,9 +5709,7 @@ compare_coords_3d(const void *a, const void *b) _ndim = (_region)->ndim; \ istart = (_sel)->nhits * _ndim; \ if (_ndim > 3) { \ - LOG_ERROR("==PDC_SERVER[%d]: dimension > 3 not supported!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Dimension > 3 not supported"); \ } \ if ((_combine_op) == PDC_QUERY_NONE || (_combine_op) == PDC_QUERY_OR) { \ for (iii = 0; iii < (_n); iii++) { \ @@ -6271,9 +5739,7 @@ compare_coords_3d(const void *a, const void *b) is_good = 1; \ break; \ default: \ - LOG_ERROR("==PDC_SERVER[%d]: error with operator type!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Error with operator type"); \ } \ if (is_good == 1) { \ if ((istart + cur_count + 1) * _ndim > ((_sel)->coords_alloc)) { \ @@ -6281,9 +5747,7 @@ compare_coords_3d(const void *a, const void *b) ((_sel)->coords) = (uint64_t *)PDC_realloc(((_sel)->coords), \ (_sel)->coords_alloc * sizeof(uint64_t)); \ if (NULL == ((_sel)->coords)) { \ - LOG_ERROR("==PDC_SERVER[%d]: error with malloc!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Error with PDC_realloc"); \ } \ } \ ttt = iii; \ @@ -6342,9 +5806,7 @@ compare_coords_3d(const void *a, const void *b) is_good = 1; \ break; \ default: \ - LOG_ERROR("==PDC_SERVER[%d]: error with operator type!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Error with operator type"); \ } \ if (is_good != 1) { \ /* Invalidate the coord by setting it to max value */ \ @@ -6367,8 +5829,7 @@ compare_coords_3d(const void *a, const void *b) jjj++; \ } \ if (iii > (_sel)->nhits) \ - LOG_ERROR("==PDC_SERVER[%d]: Error! invalidated more elements than total\n", \ - pdc_server_rank_g); \ + LOG_ERROR("Error invalidated more elements than total\n"); \ else \ ((_sel)->nhits) -= iii; \ } \ @@ -6384,9 +5845,7 @@ compare_coords_3d(const void *a, const void *b) _ndim = (_region)->ndim; \ istart = (_sel)->nhits * _ndim; \ if (_ndim > 3) { \ - LOG_ERROR("==PDC_SERVER[%d]: dimension > 3 not supported!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Dimension > 3 not supported"); \ } \ if ((_combine_op) == PDC_QUERY_NONE || (_combine_op) == PDC_QUERY_OR) { \ for (iii = 0; iii < (_n); iii++) { \ @@ -6411,9 +5870,7 @@ compare_coords_3d(const void *a, const void *b) is_good = 1; \ } \ else { \ - LOG_ERROR("==PDC_SERVER[%d]: error with range op! \n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Error with range op"); \ } \ if (is_good == 1) { \ if ((istart + cur_count + 1) * _ndim > ((_sel)->coords_alloc)) { \ @@ -6421,9 +5878,7 @@ compare_coords_3d(const void *a, const void *b) ((_sel)->coords) = (uint64_t *)PDC_realloc(((_sel)->coords), \ (_sel)->coords_alloc * sizeof(uint64_t)); \ if (NULL == ((_sel)->coords)) { \ - LOG_ERROR("==PDC_SERVER[%d]: error with malloc!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Error with malloc"); \ } \ } \ ttt = iii; \ @@ -6477,9 +5932,7 @@ compare_coords_3d(const void *a, const void *b) is_good = 1; \ } \ else { \ - LOG_ERROR("==PDC_SERVER[%d]: - error with range op!\n", pdc_server_rank_g); \ - ret_value = FAIL; \ - goto done; \ + PGOTO_ERROR(FAIL, "Error with range op"); \ } \ if (is_good != 1) { \ /* Invalidate the coord by setting it to max value */ \ @@ -6502,8 +5955,7 @@ compare_coords_3d(const void *a, const void *b) jjj++; \ } \ if (iii > (_sel)->nhits) \ - LOG_ERROR("==PDC_SERVER[%d]: Error! invalidated more elements than total\n", \ - pdc_server_rank_g); \ + LOG_ERROR("Error invalidated more elements than total\n"); \ else \ ((_sel)->nhits) -= iii; \ } \ @@ -6557,25 +6009,16 @@ generate_write_fastbit_idx(uint64_t obj_id, void *data, uint64_t dataCount, Fast PDC_gen_fastbit_idx_name(offName, "off", obj_id, timestep, ndim, start, count); fastbitErr = fastbit_iapi_register_array(bmsName, ft, data, dataCount); - if (fastbitErr < 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with fastbit_iapi_register_array\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (fastbitErr < 0) + PGOTO_ERROR(FAIL, "Error with fastbit_iapi_register_array"); fastbitErr = fastbit_iapi_build_index(bmsName, (const char *)gBinningOption); - if (fastbitErr < 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with fastbit_iapi_build_index\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (fastbitErr < 0) + PGOTO_ERROR(FAIL, "Error with fastbit_iapi_build_index"); fastbitErr = fastbit_iapi_deconstruct_index(bmsName, &keys, &nk, &offsets, &no, &bms, &nb); - if (fastbitErr < 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with fastbit_iapi_deconstruct_index\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (fastbitErr < 0) + PGOTO_ERROR(FAIL, "Error with fastbit_iapi_deconstruct_index"); // Need to write out bms, key, and offset char storage_location[256]; @@ -6594,28 +6037,22 @@ generate_write_fastbit_idx(uint64_t obj_id, void *data, uint64_t dataCount, Fast sprintf(out_name, "%s/%s", storage_location, bmsName); fp = fopen(out_name, "w"); - if (fp == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: unable to open file [%s]\n", pdc_server_rank_g, out_name); - goto done; - } + if (fp == NULL) + PGOTO_ERROR(FAIL, "Unable to open file [%s]", out_name); fwrite(bms, nb, sizeof(uint32_t), fp); fclose(fp); sprintf(out_name, "%s/%s", storage_location, keyName); fp = fopen(out_name, "w"); - if (fp == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: unable to open file [%s]\n", pdc_server_rank_g, out_name); - goto done; - } + if (fp == NULL) + PGOTO_ERROR(FAIL, "Unable to open file [%s]", out_name); fwrite(keys, nk, sizeof(double), fp); fclose(fp); sprintf(out_name, "%s/%s", storage_location, offName); fp = fopen(out_name, "w"); - if (fp == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: unable to open file [%s]\n", pdc_server_rank_g, out_name); - goto done; - } + if (fp == NULL) + PGOTO_ERROR(FAIL, "Unable to open file [%s]", out_name); fwrite(offsets, no, sizeof(int64_t), fp); fclose(fp); @@ -6712,7 +6149,7 @@ PDC_load_fastbit_index(char *idx_name, uint64_t obj_id, FastBitDataType dtype, i sprintf(out_name, "%s/%s", storage_location, bmsName); fp = fopen(out_name, "r"); if (fp == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR opening file [%s]!\n", pdc_server_rank_g, out_name); + LOG_ERROR("Error opening file [%s]\n", out_name); FUNC_LEAVE(-1); } fseek(fp, 0, SEEK_END); @@ -6726,10 +6163,9 @@ PDC_load_fastbit_index(char *idx_name, uint64_t obj_id, FastBitDataType dtype, i sprintf(out_name, "%s/%s", storage_location, keyName); fp = fopen(out_name, "r"); if (fp == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR opening file [%s]!\n", pdc_server_rank_g, out_name); + LOG_ERROR("Error opening file [%s]\n", out_name); FUNC_LEAVE(-1); } - fseek(fp, 0, SEEK_END); size = ftell(fp); nk = size / sizeof(double); @@ -6741,7 +6177,7 @@ PDC_load_fastbit_index(char *idx_name, uint64_t obj_id, FastBitDataType dtype, i sprintf(out_name, "%s/%s", storage_location, offName); fp = fopen(out_name, "r"); if (fp == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR opening file [%s]!\n", pdc_server_rank_g, out_name); + LOG_ERROR("Error opening file [%s]\n", out_name); FUNC_LEAVE(-1); } fseek(fp, 0, SEEK_END); @@ -6776,11 +6212,8 @@ PDC_query_fastbit_idx(region_list_t *region, pdc_query_constraint_t *constraint, uint64_t start[DIM_MAX], count[DIM_MAX]; pdc_var_type_t dtype; - if (region == NULL || constraint == NULL || coords == NULL || nhit == NULL) { - LOG_ERROR("==PDC_SERVER[%d]:ERROR with input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region == NULL || constraint == NULL || coords == NULL || nhit == NULL) + PGOTO_ERROR(FAIL, "Error with input"); dtype = constraint->type; if (PDC_INT == dtype) @@ -6838,10 +6271,7 @@ PDC_query_fastbit_idx(region_list_t *region, pdc_query_constraint_t *constraint, v2 = (double)(*((uint64_t *)&constraint->value2)); break; default: - LOG_ERROR("==PDC_SERVER[%d]: error with operator type!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - + PGOTO_ERROR(FAIL, "Error with operator type"); } // End switch if (constraint->op == PDC_GT) @@ -6902,11 +6332,8 @@ PDC_gen_fastbit_idx(region_list_t *region, pdc_var_type_t dtype) FastBitDataType ft; uint64_t dataCount, start[DIM_MAX], count[DIM_MAX], type_size; - if (region == NULL || region->buf == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (region == NULL || region->buf == NULL) + PGOTO_ERROR(FAIL, "Error with input"); if (PDC_INT == dtype) ft = FastBitDataTypeInt; @@ -6962,8 +6389,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ 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); - fflush(stdout); + LOG_INFO("Start query evaluation\n"); #ifdef ENABLE_TIMING struct timeval pdc_timer_start, pdc_timer_end; @@ -6972,29 +6398,21 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ #endif // query is guarenteed to be non-leaf nodes - if (query == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: input query NULL!\n", pdc_server_rank_g); - goto done; - } + if (query == NULL) + PGOTO_ERROR(FAIL, "Input query NULL"); // Need to go through each region for query evaluation, so get region head region_list_head = (region_list_t *)query->constraint->storage_region_list_head; - if (NULL == region_list_head) { - LOG_ERROR("==PDC_SERVER[%d]: error with storage_region_list_head!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (NULL == region_list_head) + PGOTO_ERROR(FAIL, "Error with storage_region_list_head"); unit_size = PDC_get_var_type_size(query->constraint->type); if (task->ndim <= 0 || task->ndim > 3) task->ndim = region_list_head->ndim; ndim = task->ndim; - if (ndim <= 0 || ndim > 3) { - LOG_ERROR("==PDC_SERVER[%d]: error with ndim = %d!\n", pdc_server_rank_g, ndim); - ret_value = FAIL; - goto done; - } + if (ndim <= 0 || ndim > 3) + PGOTO_ERROR(FAIL, "Error with ndim = %d", ndim); // Calculate total number of elements of all regions if (task->total_elem == 0) { @@ -7006,10 +6424,10 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ // No need to evaluate a query if a previous one has selected all and combining with OR if (sel->nhits == task->total_elem && combine_op == PDC_QUERY_OR) { - goto done; + PGOTO_DONE(ret_value); } else if (sel->nhits == 0 && combine_op == PDC_QUERY_AND) { - goto done; + PGOTO_DONE(ret_value); } // Set up region constraint if the query has one @@ -7053,10 +6471,8 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ ui64hi = (uint64_t)query->constraint->value2; break; default: - LOG_ERROR("==PDC_SERVER[%d]: error with operator type!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } // End switch + PGOTO_ERROR(FAIL, "Error with operator type"); + } lop = query->constraint->op; rop = query->constraint->op2; @@ -7117,8 +6533,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ uint64_t idx_nhits = 0, *idx_coords = NULL, tmp_coord[DIM_MAX]; PDC_query_fastbit_idx(region_elt, query->constraint, &idx_nhits, &idx_coords); if (idx_nhits > region_elt->data_size / unit_size) { - LOG_WARNING("==PDC_SERVER[%d]: idx_nhits = %" PRIu64 " may be too large!\n", - pdc_server_rank_g, idx_nhits); + LOG_WARNING("idx_nhits = %" PRIu64 " may be too large\n", idx_nhits); } if (idx_nhits > 0) { @@ -7137,8 +6552,8 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ for (j = 0; j < ndim; j++) { tmp = (sel->nhits + iter) * ndim + j; if (tmp > sel->coords_alloc) { - LOG_ERROR("==PDC_SERVER[%d]: - coord array overflow %" PRIu64 "/ %" PRIu64 "!\n", - pdc_server_rank_g, tmp, sel->coords_alloc); + LOG_ERROR("Coord array overflow %" PRIu64 "/ %" PRIu64 "\n", tmp, + sel->coords_alloc); } else sel->coords[tmp] = tmp_coord[j] + region_elt->start[j] / unit_size; @@ -7156,8 +6571,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ } // End if use fastbit else { // Load data - LOG_INFO("==PDC_SERVER[%d]: start loading data!\n", pdc_server_rank_g); - fflush(stdout); + LOG_INFO("Start loading data\n"); PDC_Server_load_query_data(task, query, combine_op); region_iter = -1; @@ -7293,9 +6707,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ } break; default: - LOG_ERROR("==PDC_SERVER[%d]: error with operator type!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error with operator type"); } // End switch n_eval_region++; @@ -7345,7 +6757,7 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ if (pdc_server_rank_g == 0 || pdc_server_rank_g == 1) { gettimeofday(&pdc_timer_end1, 0); double rm_dup_time = PDC_get_elapsed_time_double(&pdc_timer_start1, &pdc_timer_end1); - LOG_INFO("==PDC_SERVER[%d]: remove duplicate time %.4fs\n", pdc_server_rank_g, rm_dup_time); + LOG_INFO("Remove duplicates time %.4fs\n", rm_dup_time); } #endif @@ -7353,13 +6765,9 @@ PDC_Server_query_evaluate_merge_opt(pdc_query_t *query, query_task_t *task, pdc_ #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); double query_eval_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - LOG_INFO("==PDC_SERVER[%d]: evaluated %d regions of %" PRIu64 ": %" PRIu64 "/ %" PRIu64 - " hits, time %.4fs\n", - pdc_server_rank_g, n_eval_region, query->constraint->obj_id, sel->nhits, task->total_elem, - query_eval_time); + LOG_INFO("Evaluated %d regions of %" PRIu64 ": %" PRIu64 "/ %" PRIu64 " hits, time %.4fs\n", + n_eval_region, query->constraint->obj_id, sel->nhits, task->total_elem, query_eval_time); #endif - - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -7439,7 +6847,7 @@ attach_cache_storage_region_to_query(pdc_query_t *query) cache_storage_region_t *cache_region_elt; if (NULL == query->constraint) { - LOG_ERROR("==PDC_SERVER[%d]: query->constraint is NULL!\n", pdc_server_rank_g); + LOG_ERROR("query->constraint is NULL\n"); FUNC_LEAVE(FAIL); } @@ -7474,13 +6882,13 @@ attach_local_storage_region_to_query(pdc_query_t *query) pdc_data_server_io_list_t *obj_reg; if (NULL == query->constraint) { - LOG_ERROR("==PDC_SERVER[%d]: query->constraint is NULL!\n", pdc_server_rank_g); + LOG_ERROR("query->constraint was NULL\n"); FUNC_LEAVE(FAIL); } obj_reg = PDC_Server_get_obj_region_query(query->constraint->obj_id); if (obj_reg == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: cannot find region from object!\n", pdc_server_rank_g); + LOG_ERROR("Cannot find region from object\n"); } else query->constraint->storage_region_list_head = obj_reg->region_list_head; @@ -7500,44 +6908,29 @@ PDC_Server_send_nhits_to_server(query_task_t *task) int server_id; server_id = task->manager; - if (server_id >= pdc_server_size_g) { - LOG_ERROR("==PDC_SERVER[%d]: server_id %d invalid!\n", pdc_server_rank_g, server_id); - ret_value = FAIL; - goto done; - } + if (server_id >= pdc_server_size_g) + PGOTO_ERROR(FAIL, "server_id %d invalid", server_id); - if (pdc_remote_server_info_g == NULL) { - - LOG_ERROR("==PDC_SERVER[%d]: pdc_remote_server_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (pdc_remote_server_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_remote_server_info_g was NULL"); if (pdc_remote_server_info_g[server_id].addr_valid == 0) { ret_value = PDC_Server_lookup_server_id(server_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup failed"); } hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, send_nhits_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); in.query_id = task->query_id; in.nhits = task->query->sel->nhits; hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: HG_Destroy(handle); @@ -7558,47 +6951,31 @@ PDC_Server_send_nhits_to_client(query_task_t *task) int client_id; client_id = task->client_id; - if (client_id >= pdc_client_num_g) { - LOG_ERROR("==PDC_SERVER[%d]: client_id %d invalid!\n", pdc_server_rank_g, client_id); - ret_value = FAIL; - goto done; - } + if (client_id >= pdc_client_num_g) + PGOTO_ERROR(FAIL, "client_id %d invalid", client_id); - if (pdc_client_info_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: pdc_client_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (pdc_client_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_client_info_g was NULL"); if (pdc_client_info_g[client_id].addr_valid == 0) { ret_value = PDC_Server_lookup_client(client_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup_client failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup_client failed"); } hg_ret = HG_Create(hg_context_g, pdc_client_info_g[client_id].addr, send_nhits_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); // Fill input structure in.nhits = task->nhits; in.query_id = task->query_id; - LOG_INFO("==PDC_SERVER[%d]: sending %" PRIu64 " nhits to client!\n", pdc_server_rank_g, in.nhits); - - fflush(stdout); + LOG_INFO("Sending %" PRIu64 " nhits to client\n", in.nhits); hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: HG_Destroy(handle); @@ -7625,7 +7002,7 @@ PDC_recv_nhits(const struct hg_cb_info *callback_info) } if (task_elt == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Invalid task ID!\n", pdc_server_rank_g); + LOG_ERROR("Invalid task ID\n"); task_elt = query_task_list_head_g; } @@ -7653,25 +7030,16 @@ PDC_Server_send_coords_to_client(query_task_t *task) int client_id; client_id = task->client_id; - if (client_id >= pdc_client_num_g) { - LOG_ERROR("==PDC_SERVER[%d]: client_id %d invalid!\n", pdc_server_rank_g, client_id); - ret_value = FAIL; - goto done; - } + if (client_id >= pdc_client_num_g) + PGOTO_ERROR(FAIL, "client_id %d invalid", client_id); - if (pdc_client_info_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: pdc_client_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (pdc_client_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_client_info_g was NULL"); if (pdc_client_info_g[client_id].addr_valid == 0) { ret_value = PDC_Server_lookup_client(client_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup_client failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup_client failed"); } if (pdc_server_size_g == 1) { @@ -7689,11 +7057,8 @@ PDC_Server_send_coords_to_client(query_task_t *task) if (in.cnt > 0) { hg_ret = HG_Bulk_create(hg_class_g, 1, &buf, &buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); } in.seq_id = task->query_id; @@ -7702,17 +7067,12 @@ PDC_Server_send_coords_to_client(query_task_t *task) in.bulk_handle = bulk_handle; hg_ret = HG_Create(hg_context_g, pdc_client_info_g[client_id].addr, send_bulk_rpc_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: HG_Destroy(handle); @@ -7735,37 +7095,23 @@ PDC_Server_send_coords_to_server(query_task_t *task) int server_id; server_id = task->manager; - if (server_id >= pdc_server_size_g) { - LOG_ERROR("==PDC_SERVER[%d]: server_id %d invalid!\n", pdc_server_rank_g, server_id); - ret_value = FAIL; - goto done; - } - - if (pdc_remote_server_info_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: pdc_server_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - - goto done; - } + if (server_id >= pdc_server_size_g) + PGOTO_ERROR(FAIL, "server_id %d invalid", server_id); + if (pdc_remote_server_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_server_info_g was NULL"); if (pdc_remote_server_info_g[server_id].addr_valid == 0) { ret_value = PDC_Server_lookup_server_id(server_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup_server_id failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup_server_id failed"); } if (task->query->sel->nhits > 0) { buf = task->query->sel->coords; buf_sizes = task->query->sel->nhits * sizeof(uint64_t) * task->ndim; hg_ret = HG_Bulk_create(hg_class_g, 1, &buf, &buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); } // Fill input structure @@ -7779,16 +7125,12 @@ PDC_Server_send_coords_to_server(query_task_t *task) hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, send_bulk_rpc_register_id_g, &handle); if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "Error with HG_Create"); } hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: HG_Destroy(handle); @@ -7826,12 +7168,11 @@ coord_to_offset(size_t ndim, uint64_t *coord, uint64_t *start, uint64_t *count, uint64_t off = 0; if (ndim == 0 || coord == NULL || start == NULL || count == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: input NULL!\n", pdc_server_rank_g); + LOG_ERROR("Input NULL\n"); FUNC_LEAVE(-1); } - if (ndim > 3) { - LOG_ERROR("==PDC_SERVER[%d]: cannot handle dim > 3!\n", pdc_server_rank_g); + LOG_ERROR("Cannot handle dim > 3\n"); FUNC_LEAVE(0); } @@ -7852,7 +7193,7 @@ is_coord_in_region(int ndim, uint64_t *coord, size_t unit_size, region_list_t *r int i; if (ndim == 0 || coord == NULL || region == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: input NULL!\n", pdc_server_rank_g); + LOG_ERROR("Input NULL"); FUNC_LEAVE(-1); } @@ -7879,36 +7220,23 @@ PDC_send_data_to_client(int client_id, void *buf, size_t ndim, size_t unit_size, bulk_rpc_in_t in; hg_size_t buf_sizes; - if (client_id >= pdc_client_num_g) { - LOG_ERROR("==PDC_SERVER[%d]: client_id %d invalid!\n", pdc_server_rank_g, client_id); - ret_value = FAIL; - goto done; - } - - if (pdc_client_info_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: pdc_client_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (client_id >= pdc_client_num_g) + PGOTO_ERROR(FAIL, "client_id %d invalid", client_id); + if (pdc_client_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_client_info_g was NULL"); if (pdc_client_info_g[client_id].addr_valid == 0) { ret_value = PDC_Server_lookup_client(client_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup_client failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup_client failed"); } buf_sizes = count * unit_size; if (buf != NULL && buf_sizes != 0) { hg_ret = HG_Bulk_create(hg_class_g, 1, &buf, &buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); } in.ndim = ndim; @@ -7920,17 +7248,12 @@ PDC_send_data_to_client(int client_id, void *buf, size_t ndim, size_t unit_size, in.bulk_handle = bulk_handle; hg_ret = HG_Create(hg_context_g, pdc_client_info_g[client_id].addr, send_bulk_rpc_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: HG_Destroy(handle); @@ -7944,8 +7267,8 @@ PDC_Server_read_coords(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; - query_task_t * task = (query_task_t *)callback_info->arg; + hg_return_t ret_value = HG_SUCCESS; + 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; size_t ndim, unit_size; @@ -7961,9 +7284,8 @@ PDC_Server_read_coords(const struct hg_cb_info *callback_info) task->my_data = PDC_malloc(my_size); if (NULL == task->my_data) { - LOG_ERROR("==PDC_SERVER[%d]: error allocating %" PRIu64 " bytes for data read!\n", - pdc_server_rank_g, task->my_nread_coords * unit_size); - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Eror allocating %" PRIu64 " bytes for data read", + task->my_nread_coords * unit_size); } data_off = 0; @@ -7980,13 +7302,12 @@ PDC_Server_read_coords(const struct hg_cb_info *callback_info) if (cache_region->is_io_done != 1) { PDC_Server_data_read_to_buf_1_region(cache_region); } - /* float *tmp = cache_region->buf + buf_off; */ memcpy(task->my_data + data_off, cache_region->buf + buf_off, unit_size); data_off += unit_size; break; } } - } // End for + } PDC_send_data_to_client(task->client_id, task->my_data, ndim, unit_size, task->my_nread_coords, task->query_id, task->client_seq_id); @@ -7994,15 +7315,11 @@ PDC_Server_read_coords(const struct hg_cb_info *callback_info) else { // Requested object is not part of query, need to find their storage data and then read from // storage - - LOG_INFO("==PDC_SERVER[%d]: Requested object is not here, need to find its storage data!\n", - pdc_server_rank_g); - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Requested object is not here, need to find its storage data"); } done: - fflush(stdout); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } // Receive coords from other servers @@ -8011,7 +7328,7 @@ PDC_recv_read_coords(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; + 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; query_task_t * task_elt = NULL; @@ -8024,10 +7341,8 @@ PDC_recv_read_coords(const struct hg_cb_info *callback_info) out.ret = 1; if (callback_info->ret != HG_SUCCESS) { - // HG_LOG_ERROR("Error in callback"); - ret = HG_PROTOCOL_ERROR; out.ret = -1; - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Error with callback_info->ret"); } else { nhits = bulk_args->cnt; @@ -8037,17 +7352,15 @@ PDC_recv_read_coords(const struct hg_cb_info *callback_info) origin = bulk_args->origin; obj_id = bulk_args->obj_id; - if (nhits == 0) { - LOG_ERROR("==PDC_SERVER[%d]: received 0 read coords!\n", pdc_server_rank_g); - goto done; - } + if (nhits == 0) + PGOTO_ERROR(HG_OTHER_ERROR, "Received 0 read coords"); if (nhits * ndim * sizeof(uint64_t) != bulk_args->nbytes) { - LOG_ERROR("==PDC_SERVER[%d]: receive buf size not expected %" PRIu64 " / %zu!\n", - pdc_server_rank_g, nhits * ndim * sizeof(uint64_t), bulk_args->nbytes); + PGOTO_ERROR(HG_OTHER_ERROR, "Receive buf size not expected %" PRIu64 " / %zu", + nhits * ndim * sizeof(uint64_t), bulk_args->nbytes); } - ret = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, (void **)&buf, - NULL, NULL); + ret_value = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, + (void **)&buf, NULL, NULL); DL_FOREACH(query_task_list_head_g, task_elt) { @@ -8064,28 +7377,25 @@ PDC_recv_read_coords(const struct hg_cb_info *callback_info) } } - if (task_elt == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Invalid task ID %d!\n", pdc_server_rank_g, query_id); - goto done; - } - LOG_ERROR("==PDC_SERVER[%d]: received read coords from server %d!\n", pdc_server_rank_g, origin); - } // End else + if (task_elt == NULL) + PGOTO_ERROR(HG_OTHER_ERROR, "Invalid task ID %d", query_id); + } done: - ret = HG_Bulk_free(local_bulk_handle); - if (ret != HG_SUCCESS) { + ret_value = HG_Bulk_free(local_bulk_handle); + if (ret_value != HG_SUCCESS) { LOG_ERROR("Could not free HG bulk handle\n"); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } - ret = HG_Respond(bulk_args->handle, PDC_Server_read_coords, task_elt, &out); - if (ret != HG_SUCCESS) + ret_value = HG_Respond(bulk_args->handle, PDC_Server_read_coords, task_elt, &out); + if (ret_value != HG_SUCCESS) LOG_ERROR("Could not respond\n"); - ret = HG_Destroy(bulk_args->handle); - if (ret != HG_SUCCESS) + ret_value = HG_Destroy(bulk_args->handle); + if (ret_value != HG_SUCCESS) LOG_ERROR("Could not destroy handle\n"); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } // Receive coords from other servers @@ -8094,7 +7404,7 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; + 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; query_task_t * task_elt; @@ -8108,10 +7418,8 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) out.ret = 1; if (callback_info->ret != HG_SUCCESS) { - // HG_LOG_ERROR("Error in callback"); - ret = HG_PROTOCOL_ERROR; out.ret = -1; - goto done; + PGOTO_ERROR(HG_PROTOCOL_ERROR, "Error with callback_info->ret"); } else { nhits = bulk_args->cnt; @@ -8122,12 +7430,12 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) if (nhits > 0) { if (nhits * unit_size * ndim != bulk_args->nbytes) { - LOG_ERROR("==PDC_SERVER[%d]: receive size is unexpected %" PRIu64 " / %" PRIu64 "!\n", - pdc_server_rank_g, (uint64_t)nhits * unit_size * ndim, (uint64_t)bulk_args->nbytes); + LOG_ERROR("Received size is unexpected %" PRIu64 " / %" PRIu64 "\n", + (uint64_t)nhits * unit_size * ndim, (uint64_t)bulk_args->nbytes); } - ret = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, (void **)&buf, - NULL, NULL); + ret_value = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, + (void **)&buf, NULL, NULL); } found_task = 0; @@ -8181,31 +7489,31 @@ PDC_recv_coords(const struct hg_cb_info *callback_info) task_elt->coords_arr = NULL; } - LOG_INFO("==PDC_SERVER[%d]: received all %d query results, send to client!\n", pdc_server_rank_g, - task_elt->n_recv); + LOG_INFO("Received all %d query results, send to client\n", task_elt->n_recv); PDC_Server_send_coords_to_client(task_elt); } } // End else done: - fflush(stdout); if (nhits > 0) { - ret = HG_Bulk_free(local_bulk_handle); - if (ret != HG_SUCCESS) { + ret_value = HG_Bulk_free(local_bulk_handle); + if (ret_value != HG_SUCCESS) { LOG_ERROR("Could not free HG bulk handle\n"); - FUNC_LEAVE(ret); + return ret_value; } } - ret = HG_Respond(bulk_args->handle, NULL, NULL, &out); - if (ret != HG_SUCCESS) + + ret_value = HG_Respond(bulk_args->handle, NULL, NULL, &out); + if (ret_value != HG_SUCCESS) LOG_ERROR("Could not respond\n"); - ret = HG_Destroy(bulk_args->handle); - if (ret != HG_SUCCESS) + + ret_value = HG_Destroy(bulk_args->handle); + if (ret_value != HG_SUCCESS) LOG_ERROR("Could not destroy handle\n"); bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } static perr_t @@ -8223,16 +7531,11 @@ PDC_Server_send_query_result_to_client(query_task_t *task) } else if (task->get_op == PDC_QUERY_GET_DATA) { } - else { - LOG_ERROR("==PDC_SERVER[%d]: Invalid get_op type!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + else + PGOTO_ERROR(FAIL, "Invalid get_op type"); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: error sending query result to client!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error sending query result to client"); done: FUNC_LEAVE(ret_value); @@ -8247,30 +7550,20 @@ PDC_Server_send_query_result_to_manager(query_task_t *task) if (task->get_op == PDC_QUERY_GET_NHITS) { ret_value = PDC_Server_send_nhits_to_server(task); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: error with PDC_Server_send_nhits_to_server!\n", pdc_server_rank_g); - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_send_nhits_to_server"); } else if (task->get_op == PDC_QUERY_GET_SEL) { ret_value = PDC_Server_send_coords_to_server(task); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: error with PDC_Server_send_coords_to_server!\n", pdc_server_rank_g); - goto done; - } - } - else { - LOG_ERROR("==PDC_SERVER[%d]: Invalid get_op type!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "Error with PDC_Server_send_coords_to_server"); } + else + PGOTO_ERROR(FAIL, "Invalid get_op type"); - // TODO: free the task_list at close time + LOG_INFO("Sent query results to manager %d\n", task->manager); - LOG_ERROR("==PDC_SERVER[%d]: sent query results to manager %d!\n", pdc_server_rank_g, task->manager); done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -8281,9 +7574,8 @@ PDC_Server_do_query(query_task_t *task) perr_t ret_value = SUCCEED; - if (task == NULL || task->is_done == 1) { - goto done; - } + if (task == NULL || task->is_done == 1) + PGOTO_DONE(ret_value); #ifdef ENABLE_TIMING struct timeval pdc_timer_start, pdc_timer_end; @@ -8306,7 +7598,7 @@ PDC_Server_do_query(query_task_t *task) #ifdef ENABLE_TIMING gettimeofday(&pdc_timer_end, 0); double query_process_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - LOG_INFO("==PDC_SERVER[%d]: query processing time %.4fs\n", pdc_server_rank_g, query_process_time); + LOG_INFO("Query processing time %.4fs\n", query_process_time); #endif task->is_done = 1; @@ -8326,8 +7618,7 @@ add_storage_region_to_buf(void **in_buf, uint64_t *buf_alloc, uint64_t *buf_off, if (in_buf == NULL || *in_buf == NULL || region == NULL || buf_alloc == NULL || buf_off == NULL || region->storage_location[0] == '\0') { - LOG_ERROR("==PDC_SERVER[%d]: ERROR! NULL input!\n", pdc_server_rank_g); - goto done; + PGOTO_ERROR(FAIL, "Error with input paramters"); } my_size = 4 + strlen(region->storage_location) + 1 + sizeof(region_info_transfer_t) + 20; @@ -8433,59 +7724,37 @@ PDC_send_query_metadata_bulk(bulk_rpc_in_t *in, void *buf, uint64_t buf_sizes, i hg_handle_t handle = NULL; hg_bulk_t bulk_handle = NULL; - if (buf == NULL || buf_sizes == 0 || server_id < 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR with input!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (buf == NULL || buf_sizes == 0 || server_id < 0) + PGOTO_ERROR(FAIL, "Error with input"); - if (server_id >= (int32_t)pdc_server_size_g) { - LOG_ERROR("==PDC_SERVER[%d]: server_id %d invalid!\n", pdc_server_rank_g, server_id); - ret_value = FAIL; - goto done; - } + if (server_id >= (int32_t)pdc_server_size_g) + PGOTO_ERROR(FAIL, "server_id %d invalid", server_id); - if (pdc_remote_server_info_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: pdc_server_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (pdc_remote_server_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_server_info_g is NULL"); if (pdc_remote_server_info_g[server_id].addr_valid == 0) { ret_value = PDC_Server_lookup_server_id(server_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup_server_id failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup_server_id failed"); } hg_ret = HG_Bulk_create(hg_class_g, 1, &buf, &buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); in->bulk_handle = bulk_handle; hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, send_bulk_rpc_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_DONE(FAIL); - LOG_INFO("==PDC_SERVER[%d]: sending %" PRIu64 " meta to server %d!\n", pdc_server_rank_g, in->cnt, - server_id); - fflush(stdout); + LOG_INFO("Sending %" PRIu64 " meta to server %d\n", in->cnt, server_id); hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: if (handle) @@ -8533,7 +7802,7 @@ PDC_Server_distribute_query_storage_info(query_task_t *task, uint64_t obj_id, in // there can be multiple pass to the same object, we only need to send it once for (i = 0; i < *obj_idx; i++) { if (obj_id == obj_ids[i]) { - goto done; + PGOTO_DONE_VOID; } } @@ -8553,10 +7822,9 @@ PDC_Server_distribute_query_storage_info(query_task_t *task, uint64_t obj_id, in } if (meta->all_storage_region_distributed == 1) - goto done; + PGOTO_DONE_VOID; - LOG_INFO("==PDC_SERVER[%d]: found metadata for %" PRIu64 ", %d regions!\n", pdc_server_rank_g, obj_id, - count); + LOG_INFO("Found metadata for %" PRIu64 ", %d regions\n", obj_id, count); // Need to distribute storage metadata to other servers avg_count = ceil((1.0 * count) / task->n_sent_server); @@ -8588,11 +7856,8 @@ PDC_Server_distribute_query_storage_info(query_task_t *task, uint64_t obj_id, in server_id %= pdc_server_size_g; } - if (nsent > count) { - LOG_ERROR("==PDC_SERVER[%d]: Error sending more storage meta (%d) than expected (%d)!\n", - pdc_server_rank_g, nsent, count); - fflush(stdout); - } + if (nsent > count) + LOG_ERROR("Error sending more storage meta (%d) than expected (%d)\n", nsent, count); if (server_id == pdc_server_rank_g) { // If needs to send to self, make a copy of the storage metadata @@ -8632,15 +7897,12 @@ PDC_Server_distribute_query_storage_info(query_task_t *task, uint64_t obj_id, in } } // End DL_FOREACH - LOG_INFO("==PDC_SERVER[%d]: distributed all storage meta of %" PRIu64 "!\n", pdc_server_rank_g, - obj_id); - fflush(stdout); + LOG_INFO("Distributed all storage meta of %" PRIu64 "\n", obj_id); meta->all_storage_region_distributed = 1; } // end if (NULL != meta) done: - fflush(stdout); FUNC_LEAVE_VOID(); } @@ -8668,7 +7930,7 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; + 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; void * buf; @@ -8684,36 +7946,28 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) pdc_int_ret_t out; out.ret = 1; - LOG_INFO("==PDC_SERVER[%d]: received %d query metadata from %d!\n", pdc_server_rank_g, bulk_args->cnt, - bulk_args->origin); - fflush(stdout); + LOG_INFO("Received %d query metadata from %d\n", bulk_args->cnt, bulk_args->origin); // TODO: test if (callback_info->ret != HG_SUCCESS) { - // HG_LOG_ERROR("Error in callback"); - ret = HG_PROTOCOL_ERROR; out.ret = -1; - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Error with callback_info->ret"); } else { nregion = bulk_args->cnt; - if (nregion <= 0) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR! 0 query metadata received!\n", pdc_server_rank_g); - goto done; - } - ret = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, (void **)&buf, - NULL, NULL); + if (nregion <= 0) + PGOTO_ERROR(HG_OTHER_ERROR, "0 query metadata received"); + ret_value = HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, + (void **)&buf, NULL, NULL); regions = (region_list_t *)PDC_calloc(nregion, sizeof(region_list_t)); buf_off = 0; for (i = 0; i < nregion; i++) { - if (buf_off > bulk_args->nbytes) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR! buf overflow %d! 1\n", pdc_server_rank_g, i); - fflush(stdout); - } + if (buf_off > bulk_args->nbytes) + LOG_ERROR("buf overflow %d\n", i); loc_len_ptr = (int *)(buf + buf_off); buf_off += sizeof(int); @@ -8736,10 +7990,8 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) has_hist_ptr = (int *)(buf + buf_off); buf_off += sizeof(int); - if (buf_off > bulk_args->nbytes) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR! buf overflow %d!2\n", pdc_server_rank_g, i); - fflush(stdout); - } + if (buf_off > bulk_args->nbytes) + LOG_ERROR("buf overflow %d!2\n", i); if (*has_hist_ptr == 1) { hist_ptr = (pdc_histogram_t *)(buf + buf_off); @@ -8753,23 +8005,19 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) PDC_copy_hist(regions[i].region_hist, hist_ptr); if (regions[i].region_hist->nbin == 0 || regions[i].region_hist->nbin > 1000) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR received hist nbin=%d\n", pdc_server_rank_g, - regions[i].region_hist->nbin); + LOG_ERROR("Received hist nbin=%d", regions[i].region_hist->nbin); } } - if (buf_off > bulk_args->nbytes) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR! buf overflow %d! 3\n", pdc_server_rank_g, i); - fflush(stdout); - } + if (buf_off > bulk_args->nbytes) + LOG_ERROR("buf overflow %d\n", i); + regions[i].obj_id = bulk_args->obj_id; regions[i].ndim = bulk_args->ndim; } - if (buf_off > bulk_args->nbytes) { - LOG_ERROR("==PDC_SERVER[%d]: ERROR! buf overflow after!\n", pdc_server_rank_g); - fflush(stdout); - } + if (buf_off > bulk_args->nbytes) + LOG_ERROR("buf overflow after\n"); found_task = 0; DL_FOREACH(query_task_list_head_g, task_elt) @@ -8797,26 +8045,26 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) add_to_cache_storage_region(bulk_args->obj_id, ®ions[i]); if (bulk_args->op == PDC_RECV_REGION_DO_READ) { - goto done; + PGOTO_DONE(ret_value); } attach_storage_region_to_query(query, ®ions[nregion - 1]); } // End else done: - ret = HG_Bulk_free(local_bulk_handle); - if (ret != HG_SUCCESS) { + ret_value = HG_Bulk_free(local_bulk_handle); + if (ret_value != HG_SUCCESS) { LOG_ERROR("Could not free HG bulk handle\n"); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } - ret = HG_Respond(bulk_args->handle, NULL, NULL, &out); - if (ret != HG_SUCCESS) + ret_value = HG_Respond(bulk_args->handle, NULL, NULL, &out); + if (ret_value != HG_SUCCESS) LOG_ERROR("Could not respond\n"); - ret = HG_Destroy(bulk_args->handle); - if (ret != HG_SUCCESS) + ret_value = HG_Destroy(bulk_args->handle); + if (ret_value != HG_SUCCESS) LOG_ERROR("Could not destroy handle\n"); if (bulk_args->op == PDC_RECV_REGION_DO_READ) - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); if (bulk_args->origin == task_elt->prev_server_id || task_elt->prev_server_id == -1) { uint64_t *obj_ids = (uint64_t *)PDC_calloc(pdc_server_size_g, sizeof(uint64_t)); int obj_idx = 0; @@ -8835,7 +8083,7 @@ PDC_recv_query_metadata_bulk(const struct hg_cb_info *callback_info) } bulk_args = (struct bulk_args_t *)PDC_free(bulk_args); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } hg_return_t @@ -8843,7 +8091,7 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; + hg_return_t ret_value = HG_SUCCESS; pdc_query_xfer_t *query_xfer = (pdc_query_xfer_t *)callback_info->arg; int obj_idx = 0; uint64_t * obj_ids; @@ -8852,19 +8100,15 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) pdc_query_t * query; query = PDC_deserialize_query(query_xfer); - if (NULL == query) { - LOG_ERROR("==PDC_SERVER[%d]: deserialize query FAILED!\n", pdc_server_rank_g); - goto done; - } + if (NULL == query) + PGOTO_ERROR(HG_OTHER_ERROR, "Deserialize query FAILED"); query->sel = (pdc_selection_t *)PDC_calloc(1, sizeof(pdc_selection_t)); query->sel->nhits = 0; query->sel->coords_alloc = 8192; query->sel->coords = (uint64_t *)PDC_calloc(query->sel->coords_alloc, sizeof(uint64_t)); - if (NULL == query->sel->coords) { - LOG_ERROR("==PDC_SERVER[%d]: error with calloc!\n", pdc_server_rank_g); - goto done; - } + if (NULL == query->sel->coords) + PGOTO_ERROR(HG_OTHER_ERROR, "Error with PDC_calloc"); // Attach the query sel to all query nodes PDC_query_visit_all_with_cb_arg(query, attach_sel_to_query, query->sel); @@ -8875,8 +8119,7 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) if (task_elt->query_id == query_xfer->query_id) { query_id_exist = 1; new_task = task_elt; - LOG_WARNING("==PDC_SERVER[%d]: query id already exist!\n", pdc_server_rank_g); - fflush(stdout); + LOG_WARNING("Query id already exist\n"); break; } } @@ -8898,8 +8141,7 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) new_task->prev_server_id = query_xfer->prev_server_id; if (is_debug_g == 1) { - LOG_INFO("==PDC_SERVER[%d]: appended new query task %d to list head\n", pdc_server_rank_g, - new_task->query_id); + LOG_INFO("Appended new query task %d to list head\n", new_task->query_id); } // find metadata of all queried objects and distribute to other servers @@ -8923,7 +8165,7 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) PDC_Server_distribute_query_workload(new_task, query, &obj_idx, obj_ids, PDC_RECV_REGION_DO_QUERY); obj_ids = (uint64_t *)PDC_free(obj_ids); - goto done; + PGOTO_DONE(ret_value); } int has_more = 0; @@ -8931,7 +8173,6 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) if (has_more == 0) { // Process query PDC_Server_do_query(new_task); - // Send the result to manager PDC_Server_send_query_result_to_manager(new_task); } @@ -8940,9 +8181,8 @@ PDC_Server_recv_data_query(const struct hg_cb_info *callback_info) done: if (query_xfer) PDC_query_xfer_free(query_xfer); - fflush(stdout); - FUNC_LEAVE(ret); + FUNC_LEAVE(ret_value); } perr_t @@ -8959,35 +8199,21 @@ PDC_Server_send_read_coords_to_server(int server_id, uint64_t *coord, uint64_t n hg_size_t buf_sizes; void * buf; - if (server_id >= pdc_server_size_g) { - LOG_ERROR("==PDC_SERVER[%d]: server_id %d invalid!\n", pdc_server_rank_g, server_id); - ret_value = FAIL; - goto done; - } - - if (pdc_remote_server_info_g == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: pdc_server_info_g is NULL\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } - + if (server_id >= pdc_server_size_g) + PGOTO_ERROR(FAIL, "server_id %d invalid", server_id); + if (pdc_remote_server_info_g == NULL) + PGOTO_ERROR(FAIL, "pdc_server_info_g was NULL"); if (pdc_remote_server_info_g[server_id].addr_valid == 0) { ret_value = PDC_Server_lookup_server_id(server_id); - if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_SERVER[%d]: PDC_Server_lookup_server_id failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (ret_value != SUCCEED) + PGOTO_ERROR(FAIL, "PDC_Server_lookup_server_id failed"); } buf = coord; buf_sizes = ncoords * ndim * sizeof(uint64_t); hg_ret = HG_Bulk_create(hg_class_g, 1, &buf, &buf_sizes, HG_BULK_READ_ONLY, &bulk_handle); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("Could not create bulk data handle\n"); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Could not create bulk data handle"); // Fill input structure in.ndim = ndim; @@ -9002,17 +8228,12 @@ PDC_Server_send_read_coords_to_server(int server_id, uint64_t *coord, uint64_t n hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[server_id].addr, send_bulk_rpc_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); hg_ret = HG_Forward(handle, PDC_check_int_ret_cb, NULL, &in); - if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "HG_Forward failed"); done: HG_Destroy(handle); @@ -9042,25 +8263,19 @@ PDC_Server_send_query_obj_read_to_all_server(query_task_t *task, uint64_t obj_id hg_ret = HG_Create(hg_context_g, pdc_remote_server_info_g[i].addr, send_read_sel_obj_id_rpc_register_id_g, &handle); - if (hg_ret != HG_SUCCESS) { - ret_value = FAIL; - goto done; - } + if (hg_ret != HG_SUCCESS) + PGOTO_ERROR(FAIL, "Error with HG_Create"); hg_ret = HG_Forward(handle, NULL, NULL, &in); if (hg_ret != HG_SUCCESS) { - LOG_ERROR("==PDC_SERVER[%d]: HG_Forward failed!\n", pdc_server_rank_g); HG_Destroy(handle); - ret_value = FAIL; - goto done; + PGOTO_ERROR(FAIL, "HG_Forward failed"); } hg_ret = HG_Destroy(handle); } done: - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -9069,8 +8284,8 @@ PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; - get_sel_data_rpc_in_t * in = (get_sel_data_rpc_in_t *)callback_info->arg; + hg_return_t ret_value = 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; uint64_t nhits, *coord, *coords = NULL, obj_id, buf_off, my_size, data_off, i; size_t ndim, unit_size; @@ -9088,19 +8303,16 @@ PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) } if (NULL == task) { - LOG_ERROR("==PDC_SERVER[%d]: cannot find task id = %d, obj = %" PRIu64 "\n", pdc_server_rank_g, - in->query_id, in->obj_id); - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Cannot find task id = %d, obj = %" PRIu64, in->query_id, in->obj_id); } coords = task->query->sel->coords; nhits = task->query->sel->nhits; ndim = task->ndim; obj_id = in->obj_id; - // If I have not participated in previous query, just skip - if (NULL == coords) { - goto done; - } + // If we have not participated in previous query, just skip + if (NULL == coords) + PGOTO_DONE(ret_value); // Get storage region DL_FOREACH(cache_storage_region_head_g, cache_region_elt) @@ -9113,9 +8325,8 @@ PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) } if (NULL == storage_region_head) { - LOG_ERROR("==PDC_SERVER[%d]: cannot find cached storage region query_id=%d, obj_id=%" PRIu64 "\n", - pdc_server_rank_g, in->query_id, in->obj_id); - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Cannot find cached storage region query_id=%d, obj_id=%" PRIu64, + in->query_id, in->obj_id); } ndim = storage_region_head->ndim; @@ -9123,9 +8334,7 @@ PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) my_size = nhits * unit_size; task->my_data = PDC_malloc(my_size); if (NULL == task->my_data) { - LOG_ERROR("==PDC_SERVER[%d]: error allocating %" PRIu64 " bytes for data read!\n", pdc_server_rank_g, - nhits * unit_size); - goto done; + PGOTO_ERROR(HG_OTHER_ERROR, "Error allocating %" PRIu64 " bytes for data read", nhits * unit_size); } // We will read task->coords, from obj_id @@ -9152,10 +8361,9 @@ PDC_Server_recv_read_sel_obj_data(const struct hg_cb_info *callback_info) // Send read data back to client PDC_send_data_to_client(task->client_id, task->my_data, ndim, unit_size, nhits, task->query_id, pdc_server_rank_g); -done: - fflush(stdout); - FUNC_LEAVE(ret); +done: + FUNC_LEAVE(ret_value); } hg_return_t @@ -9163,8 +8371,8 @@ PDC_Server_recv_get_sel_data(const struct hg_cb_info *callback_info) { FUNC_ENTER(NULL); - hg_return_t ret = HG_SUCCESS; - get_sel_data_rpc_in_t *in = (get_sel_data_rpc_in_t *)callback_info->arg; + hg_return_t ret_value = 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; struct hg_cb_info fake_callback_info = {0}; @@ -9178,18 +8386,13 @@ PDC_Server_recv_get_sel_data(const struct hg_cb_info *callback_info) } } - if (NULL == task) { - LOG_ERROR("==PDC_SERVER[%d]: cannot find query task id=%d\n", pdc_server_rank_g, in->query_id); - goto done; - } + if (NULL == task) + PGOTO_ERROR(HG_OTHER_ERROR, "Cannot find query task id=%d\n", in->query_id); // Find metadata object meta = PDC_Server_get_obj_metadata(in->obj_id); - if (NULL == meta) { - LOG_ERROR("==PDC_SERVER[%d]: cannot find metadata object id=%" PRIu64 "\n", pdc_server_rank_g, - in->obj_id); - goto done; - } + if (NULL == meta) + PGOTO_ERROR(HG_OTHER_ERROR, "Cannot find metadata object id=%" PRIu64 "\n", in->obj_id); if (pdc_server_size_g != 1) { if (meta->all_storage_region_distributed != 1) { @@ -9218,5 +8421,6 @@ PDC_Server_recv_get_sel_data(const struct hg_cb_info *callback_info) done: if (in) in = (get_sel_data_rpc_in_t *)PDC_free(in); - FUNC_LEAVE(ret); + + FUNC_LEAVE(ret_value); } diff --git a/src/server/pdc_server_region/pdc_server_region_cache.c b/src/server/pdc_server_region/pdc_server_region_cache.c index 55a44e484..8344a1914 100644 --- a/src/server/pdc_server_region/pdc_server_region_cache.c +++ b/src/server/pdc_server_region/pdc_server_region_cache.c @@ -3,7 +3,6 @@ #include "pdc_timing.h" #include "pdc_logger.h" -/* #define TANG_DEBUG 1 */ #ifdef PDC_SERVER_CACHE #ifdef PDC_SERVER_CACHE_MAX_GB @@ -74,7 +73,7 @@ PDC_region_server_cache_init() MPI_Comm_rank(MPI_COMM_WORLD, &server_rank); #endif if (server_rank == 0) - LOG_INFO("==PDC_SERVER[%d]: max cache size: %llu\n", server_rank, maximum_cache_size); + LOG_INFO("Max cache size: %llu\n", maximum_cache_size); obj_cache_list = NULL; obj_cache_list_end = NULL; @@ -448,12 +447,6 @@ PDC_region_cache_register(uint64_t obj_id, int obj_ndim, const uint64_t *obj_dim FUNC_LEAVE(FAIL); } -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: for %llu\n", cur_time, PDC_get_rank(), obj_id); -#endif - pthread_mutex_lock(&pdc_obj_cache_list_mutex); obj_cache_iter = obj_cache_list; @@ -527,8 +520,8 @@ PDC_region_cache_register(uint64_t obj_id, int obj_ndim, const uint64_t *obj_dim gettimeofday(&(obj_cache->timestamp), NULL); if (total_cache_size > maximum_cache_size) { - LOG_INFO("==PDC_SERVER[%d]: server cache full %.1f / %.1f MB, will flush to storage\n", - PDC_get_rank(), total_cache_size / 1048576.0, maximum_cache_size / 1048576.0); + LOG_INFO("Server cache full %.1f / %.1f MB, will flush to storage\n", total_cache_size / 1048576.0, + maximum_cache_size / 1048576.0); PDC_region_cache_flush_all(); } @@ -586,11 +579,6 @@ PDC_transfer_request_data_write_out(uint64_t obj_id, int obj_ndim, const uint64_ if (region_info->ndim >= 3) write_size *= region_info->size[2]; -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_INFO("%s ==PDC_SERVER[%d]: enter for %llu\n", cur_time, PDC_get_rank(), obj_id); -#endif - pthread_mutex_lock(&pdc_obj_cache_list_mutex); obj_cache = NULL; @@ -626,40 +614,20 @@ PDC_transfer_request_data_write_out(uint64_t obj_id, int obj_ndim, const uint64_ break; } } - /* - else { - merge_status = PDC_region_merge(buf, region_cache_iter->region_cache_info->buf, - region_info->offset, region_info->size, region_cache_iter->region_cache_info->offset, - region_cache_iter->region_cache_info->size, &buf_merged, &offset_merged, &size_merged, ndim, - unit); if ( merge_status == PDC_MERGE_SUCCESS ) { - - } - } - */ region_cache_iter = region_cache_iter->next; } } pthread_mutex_unlock(&pdc_obj_cache_list_mutex); - /* PDC_get_time_str(cur_time); */ - if (!flag) { PDC_region_cache_register(obj_id, obj_ndim, obj_dims, buf, write_size, region_info->offset, region_info->size, region_info->ndim, unit); } - // PDC_Server_data_write_out2(obj_id, region_info, buf, unit); #ifdef PDC_TIMING pdc_server_timings->PDCcache_write += MPI_Wtime() - start; #endif -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_INFO("%s ==PDC_SERVER[%d]: leaving\n", cur_time, PDC_get_rank()); -#endif - - // done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -758,12 +726,10 @@ PDC_region_cache_flush_by_pointer(uint64_t obj_id, pdc_obj_cache *obj_cache, int #endif env_char = getenv("PDC_SERVER_CACHE_NO_FLUSH"); if (env_char && atoi(env_char) != 0) { - LOG_ERROR("==PDC_SERVER[%d]: flushed disabled\n", PDC_get_rank()); + LOG_ERROR("Flushed disabled\n"); FUNC_LEAVE(0); } - /* PDC_get_time_str(cur_time); */ - // For 1D case, we can merge regions to minimize the number of POSIX calls. if (obj_cache->ndim == 1 && obj_cache->region_cache_size) { start = (uint64_t *)PDC_malloc(sizeof(uint64_t) * obj_cache->region_cache_size * 2); @@ -844,8 +810,8 @@ PDC_region_cache_flush_by_pointer(uint64_t obj_id, pdc_obj_cache *obj_cache, int if (write_size > 0) { PDC_get_time_str(cur_time); - LOG_INFO("%s ==PDC_SERVER[%d.%d]: server flushed %.1f / %.1f MB to storage\n", cur_time, - PDC_get_rank(), flag, write_size / 1048576.0, total_cache_size / 1048576.0); + LOG_INFO("Server flushed %.1f / %.1f MB to storage\n", write_size / 1048576.0, + total_cache_size / 1048576.0); } total_cache_size -= write_size; @@ -891,12 +857,6 @@ PDC_region_cache_flush(uint64_t obj_id) FUNC_LEAVE(1); } -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_INFO("%s ==PDC_SERVER[%d]: going to flush\n", cur_time, PDC_get_rank()); -#endif - PDC_region_cache_flush_by_pointer(obj_id, obj_cache, 0); FUNC_LEAVE(0); } @@ -969,8 +929,7 @@ PDC_region_cache_clock_cycle(void *ptr) if (nflush > 0) { PDC_get_time_str(cur_time); - LOG_INFO("%s ==PDC_SERVER[%d.1]: flushed %d regions to storage, took %.4fs\n", - cur_time, PDC_get_rank(), nflush, elapsed_time); + LOG_INFO("Flushed %d regions to storage, took %.4fs\n", nflush, elapsed_time); } } else { @@ -1009,7 +968,7 @@ PDC_transfer_request_data_read_from(uint64_t obj_id, int obj_ndim, const uint64_ #ifdef PDC_TIMING double start = MPI_Wtime(); #endif - // PDC_Server_data_read_from2(obj_id, region_info, buf, unit); + pthread_mutex_lock(&pdc_obj_cache_list_mutex); PDC_region_fetch(obj_id, obj_ndim, obj_dims, region_info, buf, unit); pthread_mutex_unlock(&pdc_obj_cache_list_mutex); @@ -1017,8 +976,7 @@ PDC_transfer_request_data_read_from(uint64_t obj_id, int obj_ndim, const uint64_ #ifdef PDC_TIMING pdc_server_timings->PDCcache_read += MPI_Wtime() - start; #endif - // done: - fflush(stdout); + FUNC_LEAVE(ret_value); } @@ -1072,12 +1030,6 @@ PDC_region_fetch(uint64_t obj_id, int obj_ndim, const uint64_t *obj_dims, struct } if (!flag) { if (obj_cache != NULL) { -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: going to flush\n", cur_time, PDC_get_rank()); -#endif - PDC_region_cache_flush_by_pointer(obj_id, obj_cache, 0); } PDC_Server_transfer_request_io(obj_id, obj_ndim, obj_dims, region_info, buf, unit, 0); 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 a91292c19..e16e921a5 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 @@ -175,11 +175,6 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) int i; char cur_time[64]; -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: enter\n", cur_time, PDC_get_rank()); -#endif - gettimeofday(&last_cache_activity_timeval_g, NULL); #ifdef PDC_TIMING @@ -204,11 +199,6 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) } #endif -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: before (cache) writing\n", cur_time, PDC_get_rank()); -#endif - for (i = 0; i < request_data.n_objs; ++i) { remote_reg_info->ndim = request_data.remote_ndim[i]; remote_reg_info->offset = request_data.remote_offset[i]; @@ -236,11 +226,6 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) pthread_mutex_unlock(&transfer_request_status_mutex); } -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: after (cache) writing\n", cur_time, PDC_get_rank()); -#endif - #ifndef PDC_SERVER_CACHE for (i = 0; i < request_data.n_objs; ++i) { PDC_Server_unregister_obj_region_by_pointer(temp_ptrs[i], 1); @@ -266,11 +251,6 @@ transfer_request_all_bulk_transfer_write_cb(const struct hg_cb_info *info) pdc_timestamp_register(pdc_transfer_request_inner_write_all_bulk_timestamps, start, end); #endif -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: leaving\n", cur_time, PDC_get_rank()); -#endif - FUNC_LEAVE(ret); } @@ -343,12 +323,6 @@ transfer_request_bulk_transfer_write_cb(const struct hg_cb_info *info) struct pdc_region_info * remote_reg_info; uint64_t obj_dims[3]; -#ifdef TANG_DEBUG - char cur_time[64]; - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: enter\n", cur_time, PDC_get_rank()); -#endif - gettimeofday(&last_cache_activity_timeval_g, NULL); #ifdef PDC_TIMING @@ -454,7 +428,6 @@ HG_TEST_RPC_CB(transfer_request_status, handle) HG_Free_input(handle, &in); HG_Destroy(handle); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -508,7 +481,6 @@ HG_TEST_RPC_CB(transfer_request_wait, handle) } #endif - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -547,7 +519,6 @@ HG_TEST_RPC_CB(transfer_request_wait_all, handle) local_bulk_args->in.total_buf_size, HG_OP_ID_IGNORE); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -571,11 +542,6 @@ HG_TEST_RPC_CB(transfer_request_all, handle) HG_Get_input(handle, &in); -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: enter process CLIENT[%d]\n", cur_time, PDC_get_rank(), in.client_id); -#endif - gettimeofday(&last_cache_activity_timeval_g, NULL); info = HG_Get_info(handle); @@ -613,20 +579,10 @@ HG_TEST_RPC_CB(transfer_request_all, handle) &(local_bulk_args->in.total_buf_size), HG_BULK_READWRITE, &(local_bulk_args->bulk_handle)); -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[x]: start bulk \n", cur_time); -#endif - ret_value = HG_Bulk_transfer(info->context, transfer_request_all_bulk_transfer_write_cb, local_bulk_args, HG_BULK_PULL, info->addr, in.local_bulk_handle, 0, local_bulk_args->bulk_handle, 0, local_bulk_args->in.total_buf_size, HG_OP_ID_IGNORE); - -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[x]: done bulk\n", cur_time); -#endif } else { // Read operation has to receive region metadata first. There will be another bulk transfer triggered @@ -655,12 +611,6 @@ HG_TEST_RPC_CB(transfer_request_all, handle) } #endif -#ifdef TANG_DEBUG - PDC_get_time_str(cur_time); - LOG_DEBUG("%s ==PDC_SERVER[%d]: leaving responded CLIENT[%d]\n", cur_time, PDC_get_rank(), in.client_id); -#endif - - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -720,8 +670,6 @@ HG_TEST_RPC_CB(transfer_request_metadata_query, handle) HG_Free_input(handle, &in); - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -781,8 +729,6 @@ HG_TEST_RPC_CB(transfer_request_metadata_query2, handle) HG_Free_input(handle, &in); - fflush(stdout); - FUNC_LEAVE(ret_value); } @@ -902,7 +848,6 @@ HG_TEST_RPC_CB(transfer_request, handle) } #endif - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/server/pdc_server_region/pdc_server_region_transfer.c b/src/server/pdc_server_region/pdc_server_region_transfer.c index fe5000bec..97950aaef 100644 --- a/src/server/pdc_server_region/pdc_server_region_transfer.c +++ b/src/server/pdc_server_region/pdc_server_region_transfer.c @@ -69,7 +69,6 @@ PDC_commit_request(uint64_t transfer_request_id) transfer_request_status_list_end = ptr->next; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -138,7 +137,6 @@ PDC_finish_request(uint64_t transfer_request_id) ptr = ptr->next; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -191,7 +189,6 @@ PDC_check_request(uint64_t transfer_request_id) ptr = ptr->next; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -220,7 +217,6 @@ PDC_try_finish_request(uint64_t transfer_request_id, hg_handle_t handle, int *ha ptr = ptr->next; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -242,7 +238,6 @@ PDC_transfer_request_id_register() ret_value = transfer_request_id_g; transfer_request_id_g++; - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -285,13 +280,10 @@ PDC_Server_transfer_request_io(uint64_t obj_id, int obj_ndim, const uint64_t *ob else { PDC_Server_data_read_from(obj_id, region_info, buf, unit); } - // PDC_Server_unregister_obj_region(obj_id); - goto done; - } - if (obj_ndim != (int)region_info->ndim) { - LOG_ERROR("Server I/O error: Obj dim does not match obj dim\n"); - goto done; + PGOTO_DONE(ret_value); } + if (obj_ndim != (int)region_info->ndim) + PGOTO_ERROR(FAIL, "Obj dim does not match obj dim\n"); user_specified_data_path = getenv("PDC_DATA_LOC"); if (user_specified_data_path != NULL) { @@ -307,9 +299,6 @@ PDC_Server_transfer_request_io(uint64_t obj_id, int obj_ndim, const uint64_t *ob PDC_get_rank(), PDC_get_rank()); PDC_mkdir(storage_location); - /* LOG_ERROR("Rank %d, write to offset %llu, size %llu\n", server_rank, region_info->offset[0], - * region_info->size[0]); */ - fd = open(storage_location, O_RDWR | O_CREAT, 0666); if (region_info->ndim == 1) { lseek(fd, region_info->offset[0] * unit, SEEK_SET); @@ -374,9 +363,6 @@ PDC_Server_transfer_request_io(uint64_t obj_id, int obj_ndim, const uint64_t *ob close(fd); done: - /* PDC_get_time_str(cur_time); */ - - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/server/pdc_server_region/pdc_server_region_transfer_metadata_query.c b/src/server/pdc_server_region/pdc_server_region_transfer_metadata_query.c index 8194d869a..c66ecd905 100644 --- a/src/server/pdc_server_region/pdc_server_region_transfer_metadata_query.c +++ b/src/server/pdc_server_region/pdc_server_region_transfer_metadata_query.c @@ -132,7 +132,6 @@ transfer_request_metadata_query_init(int pdc_server_size_input, char *checkpoint } } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -165,7 +164,6 @@ transfer_request_metadata_query_finalize() pthread_mutex_destroy(&metadata_query_mutex); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -241,7 +239,6 @@ transfer_request_metadata_query_checkpoint(char **checkpoint, uint64_t *checkpoi } pthread_mutex_unlock(&metadata_query_mutex); - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -391,7 +388,7 @@ transfer_request_metadata_query_lookup_query_buf(uint64_t query_id, char **buf_p metadata_query_buf_end = previous; } metadata_query = (pdc_metadata_query_buf *)PDC_free(metadata_query); - goto done; + PGOTO_DONE(ret_value); } i++; previous = metadata_query; @@ -399,8 +396,6 @@ transfer_request_metadata_query_lookup_query_buf(uint64_t query_id, char **buf_p } *buf_ptr = NULL; done: - /* pthread_mutex_unlock(&metadata_query_mutex); */ - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -448,7 +443,6 @@ transfer_request_metadata_query_parse(int32_t n_objs, char *buf, uint8_t is_writ } query_id = metadata_query_buf_create(region_metadata, n_objs, total_buf_size_ptr); region_metadata = (pdc_obj_region_metadata *)PDC_free(region_metadata); - fflush(stdout); FUNC_LEAVE(query_id); } @@ -495,7 +489,6 @@ transfer_request_metadata_reg_append(pdc_region_metadata_pkg *regions, int ndim, regions->data_server_id = data_server_id; } - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -552,6 +545,5 @@ transfer_request_metadata_query_append(uint64_t obj_id, int ndim, uint64_t *reg_ } transfer_request_metadata_reg_append(temp_region_metadata, ndim, reg_offset, reg_size, unit, data_server_id, region_partition); - fflush(stdout); FUNC_LEAVE(temp->regions_end->data_server_id); } diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt index 40dad5073..bf9935c84 100644 --- a/src/tests/CMakeLists.txt +++ b/src/tests/CMakeLists.txt @@ -43,15 +43,9 @@ include_directories(${TEST_EXT_INCLUDE_DIRS}) set(PROGRAMS misc/pdc_init - #prop/create_prop - #region/create_region - #obj/create_obj_coll - #propset_prop prop/dup_prop obj/read_obj obj/read_obj_shared - #cont/create_cont - #cont/create_cont_coll cont/open_cont cont/cont_life cont/cont_iter @@ -67,7 +61,6 @@ set(PROGRAMS obj/obj_del obj/obj_iter obj/obj_life - #obj/obj_dim obj/obj_buf obj/obj_tags obj/obj_put_data @@ -83,28 +76,20 @@ set(PROGRAMS region/region_transfer_merge obj/obj_round_robin_io obj/obj_round_robin_io_all - #misc/close_server - #obj/stat_obj obj/delete_obj misc/vpicio misc/vpicio_mts misc/bdcats deprecated/vpicio_old deprecated/bdcats_old - #cont/cont_add_del - #misc/data_server_meta_test tags/kvtag_add_get - #tags/kvtag_get tags/kvtag_query - #deprecated/obj_transformation region/region_transfer_query region/region_transfer region/region_transfer_status region/region_transfer_skewed region/region_transfer_2D - #region/region_transfer_2D_skewed region/region_transfer_3D - #region/region_transfer_3D_skewed region/region_transfer_write_only region/region_transfer_read_only region/region_transfer_write_read @@ -118,19 +103,6 @@ set(PROGRAMS region/region_transfer_set_dims region/region_transfer_set_dims_2D region/region_transfer_set_dims_3D - #query/query_vpic_create_data - #query/query_vpic - #query/query_vpic_multi - #query/query_vpic_multi_preload - #query/query_vpic_multi_nopreload - #query/query_vpic_bin_sds_preload - #query/query_vpic_bin_sds_nopreload - #query/query_vpic_bin_sds1_preload - #query/query_vpic_bin_sds1_nopreload - #query/query_vpic_multi_nopreload1 - #misc/gen_fastbit_idx - #query/query_vpic_exyz_nopreload - #query/query_vpic_exyz_preload query/query_data misc/producer_waitall ) @@ -151,7 +123,10 @@ foreach(program ${PROGRAMS}) if(EXISTS ${SOURCE_FILE}) add_executable(${program_name} ${SOURCE_FILE}) - target_include_directories(${program_name} PRIVATE "${CMAKE_SOURCE_DIR}/include") + target_include_directories(${program_name} PRIVATE + ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/src/tests/include + ) target_link_libraries(${program_name} pdc pdc_commons ${TEST_EXT_LIB}) else() message(WARNING "Source file ${SOURCE_FILE} not found, skipping ${program_name}.") @@ -180,7 +155,9 @@ if(BUILD_MPI_TESTING) target_compile_options(${program_name} PRIVATE ${SUPPRESSED_LIST}) endif() target_link_libraries(${program_name} pdc pdc_commons ${TEST_EXT_LIB}) - target_include_directories(${program_name} PRIVATE ${TEST_EXT_INCLUDE_DIRS}) + target_include_directories(${program_name} PRIVATE + ${TEST_EXT_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/src/tests/include) else() message(WARNING "Source file ${SOURCE_FILE} not found, skipping ${program_name}.") endif() @@ -268,10 +245,7 @@ add_library(pdcanalysis ${PDC_ANALYSIS_SRCS}) target_link_libraries(pdcanalysis pdc) add_test(NAME pdc_init WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./pdc_init ) -#add_test(NAME create_prop WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./create_prop ) -#add_test(NAME set_prop WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./set_prop ) add_test(NAME dup_prop WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./dup_prop ) -#add_test(NAME create_cont WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./create_cont ) add_test(NAME open_cont WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./open_cont ) add_test(NAME cont_life WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./cont_life ) add_test(NAME cont_iter WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./cont_iter ) @@ -279,12 +253,10 @@ add_test(NAME cont_info WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTO add_test(NAME cont_getid WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./cont_getid ) add_test(NAME cont_tags WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./cont_tags ) add_test(NAME cont_del WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./cont_del ) -#add_test(NAME create_obj WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./create_obj ) add_test(NAME obj_del WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_del ) add_test(NAME open_obj WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./open_obj ) add_test(NAME obj_iter WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_iter ) add_test(NAME obj_life WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_life ) -#add_test(NAME obj_dim WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_dim ) add_test(NAME obj_buf WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_buf ) add_test(NAME obj_tags WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_tags ) add_test(NAME kvtag_add_get WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./kvtag_add_get) @@ -293,14 +265,11 @@ add_test(NAME idioms_ci_test WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECT add_test(NAME obj_info WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_info ) add_test(NAME obj_put_data WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_put_data ) add_test(NAME obj_get_data WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./obj_get_data ) -#add_test(NAME create_region WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./create_region ) add_test(NAME region_transfer WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer ) add_test(NAME region_transfer_status WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_status ) add_test(NAME region_transfer_2D WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_2D ) add_test(NAME region_transfer_3D WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_3D ) add_test(NAME region_transfer_skewed WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_skewed ) -# add_test(NAME region_transfer_2D_skewed WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_2D_skewed ) -# add_test(NAME region_transfer_3D_skewed WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_3D_skewed ) add_test(NAME region_transfer_partial WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_partial ) add_test(NAME region_transfer_2D_partial WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_2D_partial ) add_test(NAME region_transfer_3D_partial WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./region_transfer_3D_partial ) @@ -343,102 +312,77 @@ add_test(NAME read_obj_int64 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTOR add_test(NAME read_obj_uint64 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./read_obj o 1 uint64) add_test(NAME read_obj_int16 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./read_obj o 1 int16) add_test(NAME read_obj_int8 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./read_obj o 1 int8) -# add_test(NAME query_data WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_test.sh ./query_data o 1) -#add_test(NAME region_transfer_write_read2 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_checkpoint_restart_test.sh ./region_transfer_write_only ./region_transfer_read_only) -#add_test(NAME vpicio_bdcats WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio_old ./bdcats_old) add_test(NAME vpicio_bdcats_transfer_request WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./bdcats) -set_tests_properties(pdc_init PROPERTIES LABELS serial ) -#set_tests_properties(create_prop PROPERTIES LABELS serial ) -#set_tests_properties(set_prop PROPERTIES LABELS serial ) -set_tests_properties(dup_prop PROPERTIES LABELS serial ) -#set_tests_properties(create_cont PROPERTIES LABELS serial ) -set_tests_properties(open_cont PROPERTIES LABELS serial ) -set_tests_properties(cont_life PROPERTIES LABELS serial ) -set_tests_properties(cont_iter PROPERTIES LABELS serial ) -set_tests_properties(cont_info PROPERTIES LABELS serial ) -set_tests_properties(cont_getid PROPERTIES LABELS serial ) -set_tests_properties(cont_tags PROPERTIES LABELS serial ) -set_tests_properties(cont_del PROPERTIES LABELS serial ) -#set_tests_properties(create_obj PROPERTIES LABELS serial ) -set_tests_properties(obj_del PROPERTIES LABELS serial ) -set_tests_properties(open_obj PROPERTIES LABELS serial ) -set_tests_properties(obj_iter PROPERTIES LABELS serial ) -set_tests_properties(obj_life PROPERTIES LABELS serial ) -#set_tests_properties(obj_dim PROPERTIES LABELS serial ) -set_tests_properties(obj_buf PROPERTIES LABELS serial ) -set_tests_properties(obj_tags PROPERTIES LABELS serial ) -set_tests_properties(kvtag_add_get PROPERTIES LABELS serial ) -set_tests_properties(kvtag_query PROPERTIES LABELS serial ) -set_tests_properties(idioms_ci_test PROPERTIES LABELS serial ) -set_tests_properties(obj_info PROPERTIES LABELS serial ) -set_tests_properties(obj_put_data PROPERTIES LABELS serial ) -set_tests_properties(obj_get_data PROPERTIES LABELS serial ) -#set_tests_properties(create_region PROPERTIES LABELS serial ) -set_tests_properties(region_transfer PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_status PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_skewed PROPERTIES LABELS serial ) -# set_tests_properties(region_transfer_2D_skewed PROPERTIES LABELS serial ) -# set_tests_properties(region_transfer_3D_skewed PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_partial PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_2D_partial PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_3D_partial PROPERTIES LABELS serial ) - -set_tests_properties(region_transfer_overlap PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_overlap_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_overlap_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_write_read PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all2 PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all2_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all2_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append2 PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append2_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append2_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all3 PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all3_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all3_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append3 PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append3_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append3_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all4 PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all4_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all4_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append4 PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append4_2D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_append4_3D PROPERTIES LABELS serial ) -set_tests_properties(region_transfer_all_split_wait PROPERTIES LABELS serial ) -set_tests_properties(read_obj_int PROPERTIES LABELS serial ) -set_tests_properties(read_obj_float PROPERTIES LABELS serial ) -set_tests_properties(read_obj_double PROPERTIES LABELS serial ) -set_tests_properties(read_obj_char PROPERTIES LABELS serial ) -set_tests_properties(read_obj_uint PROPERTIES LABELS serial ) -set_tests_properties(read_obj_int64 PROPERTIES LABELS serial ) -set_tests_properties(read_obj_uint64 PROPERTIES LABELS serial ) -set_tests_properties(read_obj_int16 PROPERTIES LABELS serial ) -set_tests_properties(read_obj_int8 PROPERTIES LABELS serial ) -# set_tests_properties(query_data PROPERTIES LABELS serial ) -#set_tests_properties(vpicio_bdcats PROPERTIES LABELS serial ) -set_tests_properties(vpicio_bdcats_transfer_request PROPERTIES LABELS serial ) -#set_tests_properties(region_transfer_write_read2 PROPERTIES LABELS serial ) -#add_test(NAME vpicio_query_vpic WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic ) -#add_test(NAME vpicio_query_vpic_multi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_multi ) -#add_test(NAME vpicio_query_vpic_multi_preload WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_multi_preload ) -#add_test(NAME vpicio_query_vpic_multi_nopreload1 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_multi_nopreload1 ) -#add_test(NAME vpicio_query_vpic_create_data WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_create_data ) -#add_test(NAME vpicio_query_vpic_bin_sds1_nopreload WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_bin_sds1_nopreload ) -#add_test(NAME vpicio_query_vpic_bin_sds1_preload WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_bin_sds1_preload ) -#add_test(NAME vpicio_query_vpic_exyz_preload WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_exyz_preload ) -#add_test(NAME vpicio_query_vpic_exyz_nopreload WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND run_multiple_test.sh ./vpicio ./query_vpic_exyz_nopreload ) - +set_tests_properties(pdc_init PROPERTIES LABELS serial) +set_tests_properties(dup_prop PROPERTIES LABELS serial) +set_tests_properties(open_cont PROPERTIES LABELS serial) +set_tests_properties(cont_life PROPERTIES LABELS serial) +set_tests_properties(cont_iter PROPERTIES LABELS serial) +set_tests_properties(cont_info PROPERTIES LABELS serial) +set_tests_properties(cont_getid PROPERTIES LABELS serial) +set_tests_properties(cont_tags PROPERTIES LABELS serial) +set_tests_properties(cont_del PROPERTIES LABELS serial) +set_tests_properties(obj_del PROPERTIES LABELS serial) +set_tests_properties(open_obj PROPERTIES LABELS serial) +set_tests_properties(obj_iter PROPERTIES LABELS serial) +set_tests_properties(obj_life PROPERTIES LABELS serial) +set_tests_properties(obj_buf PROPERTIES LABELS serial) +set_tests_properties(obj_tags PROPERTIES LABELS serial) +set_tests_properties(kvtag_add_get PROPERTIES LABELS serial) +set_tests_properties(kvtag_query PROPERTIES LABELS serial) +set_tests_properties(idioms_ci_test PROPERTIES LABELS serial) +set_tests_properties(obj_info PROPERTIES LABELS serial) +set_tests_properties(obj_put_data PROPERTIES LABELS serial) +set_tests_properties(obj_get_data PROPERTIES LABELS serial) +set_tests_properties(region_transfer PROPERTIES LABELS serial) +set_tests_properties(region_transfer_status PROPERTIES LABELS serial) +set_tests_properties(region_transfer_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_skewed PROPERTIES LABELS serial) +set_tests_properties(region_transfer_partial PROPERTIES LABELS serial) +set_tests_properties(region_transfer_2D_partial PROPERTIES LABELS serial) +set_tests_properties(region_transfer_3D_partial PROPERTIES LABELS serial) +set_tests_properties(region_transfer_overlap PROPERTIES LABELS serial) +set_tests_properties(region_transfer_overlap_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_overlap_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_write_read PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all2 PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all2_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all2_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append2 PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append2_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append2_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all3 PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all3_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all3_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append3 PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append3_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append3_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all4 PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all4_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all4_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append4 PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append4_2D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_append4_3D PROPERTIES LABELS serial) +set_tests_properties(region_transfer_all_split_wait PROPERTIES LABELS serial) +set_tests_properties(read_obj_int PROPERTIES LABELS serial) +set_tests_properties(read_obj_float PROPERTIES LABELS serial) +set_tests_properties(read_obj_double PROPERTIES LABELS serial) +set_tests_properties(read_obj_char PROPERTIES LABELS serial) +set_tests_properties(read_obj_uint PROPERTIES LABELS serial) +set_tests_properties(read_obj_int64 PROPERTIES LABELS serial) +set_tests_properties(read_obj_uint64 PROPERTIES LABELS serial) +set_tests_properties(read_obj_int16 PROPERTIES LABELS serial) +set_tests_properties(read_obj_int8 PROPERTIES LABELS serial) +set_tests_properties(vpicio_bdcats_transfer_request PROPERTIES LABELS serial) if(BUILD_MPI_TESTING) add_test(NAME read_obj_shared_int WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./read_obj_shared ${MPI_RUN_CMD} 4 6 o 1 int) @@ -450,15 +394,10 @@ if(BUILD_MPI_TESTING) add_test(NAME read_obj_shared_uint64 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./read_obj_shared ${MPI_RUN_CMD} 4 6 o 1 uint64) add_test(NAME read_obj_shared_int16 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./read_obj_shared ${MPI_RUN_CMD} 4 6 o 1 int16) add_test(NAME read_obj_shared_int8 WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./read_obj_shared ${MPI_RUN_CMD} 4 6 o 1 int8) -# add_test(NAME create_obj_coll WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./create_obj_coll ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME create_cont_coll WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./create_cont_coll ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME region_transfer_status_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_status ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_2D_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_2D ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_3D_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_3D ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_skewed_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_skewed ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME region_transfer_2D_skewed_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_2D_skewed ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME region_transfer_3D_skewed_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_3D_skewed ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_partial_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_partial ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_2D_partial_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_2D_partial ${MPI_RUN_CMD} 4 6 ) add_test(NAME region_transfer_3D_partial_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./region_transfer_3D_partial ${MPI_RUN_CMD} 4 6 ) @@ -498,10 +437,7 @@ if(BUILD_MPI_TESTING) add_test(NAME obj_round_robin_io_all_2D WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_round_robin_io ${MPI_RUN_CMD} 4 4 int 2 ) add_test(NAME obj_round_robin_io_all_3D WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_round_robin_io ${MPI_RUN_CMD} 4 4 int 3 ) add_test(NAME pdc_init_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./pdc_init ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME create_prop_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./create_prop ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME set_prop_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./set_prop ${MPI_RUN_CMD} 4 6 ) add_test(NAME dup_prop_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./dup_prop ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME create_cont_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./create_cont ${MPI_RUN_CMD} 4 6 ) add_test(NAME open_cont_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./open_cont ${MPI_RUN_CMD} 4 6 ) add_test(NAME cont_life_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./cont_life ${MPI_RUN_CMD} 4 6 ) add_test(NAME cont_iter_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./cont_iter ${MPI_RUN_CMD} 4 6 ) @@ -509,11 +445,9 @@ if(BUILD_MPI_TESTING) add_test(NAME cont_getid_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./cont_getid ${MPI_RUN_CMD} 4 6 ) add_test(NAME cont_tags_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./cont_tags ${MPI_RUN_CMD} 4 6 ) add_test(NAME consistency_semantics WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./consistency_semantics ${MPI_RUN_CMD} 2 4 ) -# add_test(NAME create_obj_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./create_obj ${MPI_RUN_CMD} 4 6 ) add_test(NAME open_obj_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./open_obj ${MPI_RUN_CMD} 4 6 ) add_test(NAME obj_iter_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_iter ${MPI_RUN_CMD} 4 6 ) add_test(NAME obj_life_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_life ${MPI_RUN_CMD} 4 6 ) -# add_test(NAME obj_dim_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_dim ${MPI_RUN_CMD} 4 6 ) add_test(NAME obj_buf_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_buf ${MPI_RUN_CMD} 4 6 ) add_test(NAME obj_tags_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_tags ${MPI_RUN_CMD} 4 6 ) add_test(NAME obj_info_mpi WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND mpi_test.sh ./obj_info ${MPI_RUN_CMD} 4 6 ) @@ -531,8 +465,6 @@ if(BUILD_MPI_TESTING) set_tests_properties(read_obj_shared_uint64 PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(read_obj_shared_int16 PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(read_obj_shared_int8 PROPERTIES LABELS "parallel;parallel_obj" ) -# set_tests_properties(create_obj_coll PROPERTIES LABELS "parallel;parallel_obj" ) -# set_tests_properties(create_cont_coll PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(consistency_semantics PROPERTIES LABELS "parallel;parallel_consistency") set_tests_properties(region_transfer_partial_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_2D_partial_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) @@ -541,12 +473,9 @@ if(BUILD_MPI_TESTING) set_tests_properties(region_transfer_overlap_2D_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_overlap_3D_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) -# set_tests_properties(region_transfer_status_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_2D_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_3D_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_skewed_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) -# set_tests_properties(region_transfer_2D_skewed_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) -# set_tests_properties(region_transfer_3D_skewed_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(region_transfer_write_read_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(vpicio_bdcats_mpi PROPERTIES LABELS "parallel;parallel_region_transfer" ) set_tests_properties(vpicio_mpi_small_cache PROPERTIES LABELS "parallel;parallel_region_transfer" ) @@ -582,21 +511,16 @@ if(BUILD_MPI_TESTING) set_tests_properties(obj_round_robin_io_all_2D PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(obj_round_robin_io_all_3D PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(pdc_init_mpi PROPERTIES LABELS "parallel;parallel_pdc" ) -# set_tests_properties(create_prop_mpi PROPERTIES LABELS "parallel;parallel_prop" ) -# set_tests_properties(set_prop_mpi PROPERTIES LABELS "parallel;parallel_prop" ) set_tests_properties(dup_prop_mpi PROPERTIES LABELS "parallel;parallel_prop" ) -# set_tests_properties(create_cont_mpi PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(open_cont_mpi PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(cont_life_mpi PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(cont_iter_mpi PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(cont_info_mpi PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(cont_getid_mpi PROPERTIES LABELS "parallel;parallel_cont" ) set_tests_properties(cont_tags_mpi PROPERTIES LABELS "parallel;parallel_cont" ) -# set_tests_properties(create_obj_mpi PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(open_obj_mpi PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(obj_iter_mpi PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(obj_life_mpi PROPERTIES LABELS "parallel;parallel_obj" ) -# set_tests_properties(obj_dim_mpi PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(obj_buf_mpi PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(obj_tags_mpi PROPERTIES LABELS "parallel;parallel_obj" ) set_tests_properties(obj_info_mpi PROPERTIES LABELS "parallel;parallel_obj" ) diff --git a/src/tests/cont/cont_add_del.c b/src/tests/cont/cont_add_del.c index a0bb80043..65bc70748 100644 --- a/src/tests/cont/cont_add_del.c +++ b/src/tests/cont/cont_add_del.c @@ -31,7 +31,7 @@ #include #include #include "pdc.h" -#include "pdc_client_connect.h" +#include "test_helper.h" #define NCONT 10 @@ -54,7 +54,7 @@ rand_string(char *str, size_t size) void print_usage() { - LOG_JUST_PRINT("Usage: srun -n ./creat_obj -r num_of_obj_per_rank\n"); + LOG_JUST_PRINT("Usage: srun -n ./cont_add_del -r num_of_obj_per_rank\n"); } int @@ -65,9 +65,10 @@ main(int argc, char **argv) int i; pdcid_t pdc, cont_prop, cont[NCONT], obj_prop; char cont_name[128]; - uint64_t dims[3] = {100, 200, 700}; - pdcid_t *obj_ids = NULL; - int use_name = -1; + uint64_t dims[3] = {100, 200, 700}; + pdcid_t *obj_ids = NULL; + int use_name = -1; + int ret_value = TSUCCEED; struct timeval ht_total_start; struct timeval ht_total_end; @@ -102,12 +103,12 @@ main(int argc, char **argv) return 1; default: print_usage(); - exit(-1); + TGOTO_DONE(TFAIL); } if (count == -1) { print_usage(); - exit(-1); + TGOTO_DONE(TFAIL); } count /= size; @@ -116,31 +117,28 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Creating %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc - pdc = PDCinit("pdc"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop <= 0) - LOG_ERROR("Failed to create container property"); + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create NCONT container for (i = 0; i < NCONT; i++) { sprintf(cont_name, "Cont%d", i); - cont[i] = PDCcont_create(cont_name, cont_prop); - if (cont[i] <= 0) - LOG_ERROR("Failed to create container"); + TASSERT((cont[i] = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); } // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop <= 0) - LOG_ERROR("Failed to create object property"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - PDCprop_set_obj_type(obj_prop, PDC_INT); - PDCprop_set_obj_dims(obj_prop, 3, dims); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); env_str = getenv("PDC_OBJ_NAME"); if (env_str != NULL) { @@ -160,35 +158,41 @@ main(int argc, char **argv) gettimeofday(&ht_total_start, 0); for (i = 0; i < count; i++) { - if (use_name == -1) { sprintf(obj_name, "%s", rand_string(tmp_str, 16)); - PDCprop_set_obj_time_step(obj_prop, rank); + TASSERT(PDCprop_set_obj_time_step(obj_prop, rank) >= 0, + "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); } else if (use_name == 1) { sprintf(obj_name, "%s", obj_prefix[0]); - PDCprop_set_obj_time_step(obj_prop, i + rank * count); + TASSERT(PDCprop_set_obj_time_step(obj_prop, i + rank * count) >= 0, + "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); } else if (use_name == 4) { sprintf(obj_name, "%s", obj_prefix[i % 4]); - PDCprop_set_obj_time_step(obj_prop, i / 4 + rank * count); + TASSERT(PDCprop_set_obj_time_step(obj_prop, i / 4 + rank * count) >= 0, + "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); } - else { - LOG_ERROR("Unsupported name choice\n"); - goto done; - } - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_app_name(obj_prop, "test_app"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); - - if (count < 20) { + else + PGOTO_ERROR(TFAIL, "Unsupported name choice"); + + TASSERT(PDCprop_set_obj_time_step(obj_prop, rank) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "test_app") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); + + if (count < 20) LOG_INFO("[%d] create obj with name %s\n", rank, obj_name); - } - obj_ids[i] = PDCobj_create(cont[i % NCONT], obj_name, obj_prop); - if (obj_ids[i] <= 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", obj_name); - exit(-1); - } + + TASSERT((obj_ids[i] = PDCobj_create(cont[i % NCONT], obj_name, obj_prop)) != 0, + "Call to PDCobj_create succeeded", "Call to PDCobj_create failed"); // Print progress int progress_factor = count < 10 ? 1 : 10; @@ -197,10 +201,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("%10d created ... %.5e s\n", i * size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif @@ -214,34 +216,33 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to create %d obj/rank with %d ranks: %.5e\n", count, size, ht_total_sec); - fflush(stdout); - } // Add object to container - PDC_Client_add_objects_to_container(count, obj_ids, cont[0]); + TASSERT(PDC_Client_add_objects_to_container(count, obj_ids, cont[0]) >= 0, + "Call to PDC_Client_del_objects_to_container succeeded", + "Call to PDC_Client_del_objects_to_container failed"); // Delete object to container - PDC_Client_del_objects_to_container(count, obj_ids, cont[0]); + TASSERT(PDC_Client_del_objects_to_container(count, obj_ids, cont[0]) >= 0, + "Call to PDC_Client_del_objects_to_container succeeded", + "Call to PDC_Client_del_objects_to_container failed"); -done: // close all container for (i = 0; i < NCONT; i++) { - if (PDCcont_close(cont[i]) < 0) - LOG_ERROR("Failed to close container c1\n"); + TASSERT(PDCcont_close(cont[i]) >= 0, "Call to PDCcont_close succeeded", + "Call to PDCcont_close failed"); } - // close a container property - if (PDCprop_close(cont_prop) < 0) - LOG_ERROR("Failed to close property"); - - if (PDCclose(pdc) < 0) - LOG_ERROR("Failed to close PDC\n"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/cont/cont_del.c b/src/tests/cont/cont_del.c index 987be51fe..8ee19939d 100644 --- a/src/tests/cont/cont_del.c +++ b/src/tests/cont/cont_del.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -34,7 +35,7 @@ main(int argc, char **argv) int rank = 0, size = 1; perr_t ret; - int ret_value = 0; + int ret_value = TSUCCEED; char cont_name[128]; #ifdef ENABLE_MPI @@ -44,59 +45,29 @@ main(int argc, char **argv) #endif sprintf(cont_name, "c%d", rank); // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - create_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (create_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((create_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create(cont_name, create_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } - ret = PDCcont_del(cont); - if (ret != SUCCEED) { - LOG_ERROR("Failed to delete container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, create_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); + TASSERT(PDCcont_del(cont) >= 0, "Call to PDCcont_del succeeded", "Call to PDCcont_del failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); LOG_INFO("Trying to open a deleted container, should fail\n"); - cont = PDCcont_open(cont_name, pdc); - if (cont > 0) - LOG_ERROR("Error: opened a container that was just deleted"); + + TASSERT(PDCcont_open(cont_name, pdc) == 0, "Call to PDCcont_open failed as expected", + "Call to PDCcont_open didn't fail as expected"); // close a container property - if (PDCprop_close(create_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(create_prop) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/cont/cont_getid.c b/src/tests/cont/cont_getid.c index 9a6abadaf..8c9240568 100644 --- a/src/tests/cont/cont_getid.c +++ b/src/tests/cont/cont_getid.c @@ -28,13 +28,14 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { int rank = 0, size = 1; pdcid_t pdc_id, cont_prop, cont_id, cont_id2, cont_id3; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -43,7 +44,7 @@ main(int argc, char **argv) #endif // create a pdc - pdc_id = PDCinit("pdc"); + TASSERT((pdc_id = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id); @@ -51,48 +52,33 @@ main(int argc, char **argv) LOG_ERROR("Failed to create container property"); ret_value = 1; } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont_id = PDCcont_create_col("c1", cont_prop); - if (cont_id <= 0) { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont_id = PDCcont_create_col("c1", cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); + #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - - cont_id2 = PDCcont_open("c1", pdc_id); - if (cont_id2 == 0) { - LOG_ERROR("Failed to open container"); - ret_value = 1; - } + TASSERT((cont_id2 = PDCcont_open("c1", pdc_id)) > 0, "Call to PDCcont_open succeeded", + "Call to PDCcont_open failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - cont_id3 = PDCcont_get_id("c1", pdc_id); - if (PDCcont_close(cont_id3) < 0) { - LOG_ERROR("Failed to close container cont_id3\n"); - ret_value = 1; - } - // close a container - if (PDCcont_close(cont_id) < 0) { - LOG_ERROR("Failed to close container cont_id1\n"); - ret_value = 1; - } - if (PDCcont_close(cont_id2) < 0) { - LOG_ERROR("Failed to close container cont_id2\n"); - ret_value = 1; - } + TASSERT((cont_id3 = PDCcont_get_id("c1", pdc_id)) > 0, "Call to PDCcont_get_id succeeded", + "Call to PDCcont_get_id failed"); + // close containers + TASSERT(PDCcont_close(cont_id3) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCcont_close(cont_id) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCcont_close(cont_id2) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - if (PDCclose(pdc_id) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc_id) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/cont/cont_info.c b/src/tests/cont/cont_info.c index 9315ecb61..4669a4899 100644 --- a/src/tests/cont/cont_info.c +++ b/src/tests/cont/cont_info.c @@ -28,6 +28,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -35,6 +36,7 @@ main(int argc, char **argv) int rank = 0, size = 1; pdcid_t pdc_id, cont_prop, cont_id, cont_id2; struct pdc_cont_info *cont_info; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -43,52 +45,42 @@ main(int argc, char **argv) #endif // create a pdc - pdc_id = PDCinit("pdc"); - + TASSERT((pdc_id = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id); - if (cont_prop <= 0) - LOG_ERROR("Failed to create container property"); - + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont_id = PDCcont_create_col("c1", cont_prop); - if (cont_id <= 0) - LOG_ERROR("Failed to create container"); + TASSERT((cont_id = PDCcont_create("c1", cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - cont_id2 = PDCcont_open("c1", pdc_id); - if (cont_id2 == 0) - LOG_ERROR("Failed to open container"); + TASSERT((cont_id2 = PDCcont_open("c1", pdc_id)) > 0, "Call to PDCcont_open succeeded", + "Call to PDCcont_open failed"); + #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - cont_info = PDCcont_get_info("c1"); - if (strcmp(cont_info->name, "c1")) { - LOG_ERROR("container get info with wrong name\n"); - return 1; - } + TASSERT((cont_info = PDCcont_get_info("c1")) != NULL, "Call to PDCcont_get_info succeeded", + "Call to PDCcont_get_info failed"); + TASSERT(strcmp(cont_info->name, "c1") == 0, "Container c1 had correct name", + "Container c1 had incorrect name"); // close a container - if (PDCcont_close(cont_id) < 0) - LOG_ERROR("Failed to close container cont_id1\n"); - - if (PDCcont_close(cont_id2) < 0) - LOG_ERROR("Failed to close container cont_id2\n"); - + TASSERT(PDCcont_close(cont_id) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCcont_close(cont_id2) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) - LOG_ERROR("Failed to close property"); - - if (PDCclose(pdc_id) < 0) - LOG_ERROR("Failed to close PDC\n"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc_id) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/cont/cont_iter.c b/src/tests/cont/cont_iter.c index e9d3ba973..6216dfde3 100644 --- a/src/tests/cont/cont_iter.c +++ b/src/tests/cont/cont_iter.c @@ -27,6 +27,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -34,7 +35,7 @@ main(int argc, char **argv) pdcid_t pdc, create_prop, cont1, cont2, cont3; cont_handle *ch; int rank = 0, size = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -42,92 +43,45 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - create_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (create_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((create_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont1 = PDCcont_create("c1", create_prop); - if (cont1 > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont1 = PDCcont_create("c1", create_prop)) != 0, "Call to PDCcont_create succeeded for c1", + "Call to PDCcont_create failed for c1"); // create second container - cont2 = PDCcont_create("c2", create_prop); - if (cont2 > 0) { - LOG_INFO("Create a container c2\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont2 = PDCcont_create("c2", create_prop)) != 0, "Call to PDCcont_create succeeded for c2", + "Call to PDCcont_create failed for c2"); // create third container - cont3 = PDCcont_create("c3", create_prop); - if (cont3 > 0) { - LOG_INFO("Create a container c3\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont3 = PDCcont_create("c3", create_prop)) != 0, "Call to PDCcont_create succeeded for c3", + "Call to PDCcont_create failed for c3"); + // start container iteration ch = PDCcont_iter_start(pdc); - while (!PDCcont_iter_null(ch)) { PDCcont_iter_get_info(ch); - LOG_INFO("container property id is"); - + LOG_INFO("Container property id is %d\n", ch); ch = PDCcont_iter_next(ch); } // close cont1 - if (PDCcont_close(cont1) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont1) >= 0, "Call to PDCcont_close succeeded for c1", + "Call to PDCcont_close failed for c1"); // close cont2 - if (PDCcont_close(cont2) < 0) { - LOG_ERROR("Failed to close container c2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c2\n"); - } + TASSERT(PDCcont_close(cont2) >= 0, "Call to PDCcont_close succeeded for c2", + "Call to PDCcont_close failed for c2"); // close cont3 - if (PDCcont_close(cont3) < 0) { - LOG_ERROR("Failed to close container c3\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c3\n"); - } + TASSERT(PDCcont_close(cont3) >= 0, "Call to PDCcont_close succeeded for c3", + "Call to PDCcont_close failed for c3"); // close a container property - if (PDCprop_close(create_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(create_prop) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/cont/cont_iter_mt.c b/src/tests/cont/cont_iter_mt.c index 8238a27b1..e0adcd8bf 100644 --- a/src/tests/cont/cont_iter_mt.c +++ b/src/tests/cont/cont_iter_mt.c @@ -51,7 +51,7 @@ TestThread(void *ThreadArgs) if (create_prop > 0) LOG_INFO("[%d] Create a container property, id is %llx\n", args->ThreadRank, create_prop); else - LOG_ERROR("[%d] Fail to create container property!\n", args->ThreadRank); + LOG_ERROR("[%d] Fail to create container property\n", args->ThreadRank); // create a container pdcid_t cont1 = PDCcont_create("c1", create_prop); diff --git a/src/tests/cont/cont_life.c b/src/tests/cont/cont_life.c index 7db836807..416a7705a 100644 --- a/src/tests/cont/cont_life.c +++ b/src/tests/cont/cont_life.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -33,7 +34,7 @@ main(int argc, char **argv) pdcid_t pdc, create_prop, cont; // struct _pdc_cont_prop *prop; int rank = 0, size = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -41,62 +42,36 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - create_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (create_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } - // print default container lifetime (persistent) - // prop = PDCcont_prop_get_info(create_prop); - PDCcont_prop_get_info(create_prop); + TASSERT((create_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCcont_prop_get_info(create_prop) != NULL, "Call to PDCcont_prop_get_info succeeded", + "Call to PDCcont_prop_get_info failed"); // create a container - cont = PDCcont_create("c1", create_prop); - if (cont > 0) { - LOG_INFO("Create a container, c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create("c1", create_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // set container lifetime to transient - PDCprop_set_cont_lifetime(create_prop, PDC_TRANSIENT); - // prop = PDCcont_prop_get_info(create_prop); - PDCcont_prop_get_info(create_prop); - + TASSERT(PDCprop_set_cont_lifetime(cont, PDC_TRANSIENT) >= 0, + "Call to PDCprop_set_cont_lifetime succeeded", "Call to PDCprop_set_cont_lifetime failed"); + TASSERT(PDCcont_prop_get_info(create_prop) != NULL, "Call to PDCcont_prop_get_info succeeded", + "Call to PDCcont_prop_get_info failed"); // set container lifetime to persistent - PDCcont_persist(cont); - // prop = PDCcont_prop_get_info(create_prop); - PDCcont_prop_get_info(create_prop); - + TASSERT(PDCcont_persist(cont) >= 0, "Call to PDCcont_persist succeeded", + "Call to PDCcont_persist failed"); + TASSERT(PDCcont_prop_get_info(create_prop) != NULL, "Call to PDCcont_prop_get_info succeeded", + "Call to PDCcont_prop_get_info failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(create_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(create_prop) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/cont/cont_life_mt.c b/src/tests/cont/cont_life_mt.c index 3c13b7dc2..7cb7c7e77 100644 --- a/src/tests/cont/cont_life_mt.c +++ b/src/tests/cont/cont_life_mt.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" #include "mercury.h" #include "mercury_thread_pool.h" #include "mercury_atomic.h" @@ -51,10 +52,10 @@ TestThread(void *ThreadArgs) if (create_prop > 0) LOG_INFO("[%d] Create a container property, id is %llx\n", args->ThreadRank, create_prop); else - LOG_ERROR("[%d] Fail to create container property!\n", args->ThreadRank); + LOG_ERROR("[%d] Fail to create container property\n", args->ThreadRank); // print default container lifetime (persistent) - struct PDC_cont_prop *prop = PDCcont_prop_get_info(create_prop); + struct _pdc_cont_prop *prop = PDCcont_prop_get_info(create_prop); if (prop->cont_life == PDC_PERSIST) LOG_INFO("[%d] container property (id: %lld) default lifetime is persistent\n", args->ThreadRank, create_prop); @@ -67,7 +68,7 @@ TestThread(void *ThreadArgs) if (cont > 0) LOG_INFO("[%d] Create a container, id is %lld\n", args->ThreadRank, cont); else - LOG_ERROR("[%d] Failed to create container!\n", args->ThreadRank); + LOG_ERROR("[%d] Failed to create container\n", args->ThreadRank); // set container lifetime to transient PDCprop_set_cont_lifetime(create_prop, PDC_TRANSIENT); @@ -111,6 +112,7 @@ main(int argc, char **argv) int status = 0; thread_args_t *args; int rank = 0, size = 1; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -124,7 +126,7 @@ main(int argc, char **argv) // create a pdc pdcid_t create_prop; - pdcid_t pdc = PDC_init("pdc"); + pdcid_t pdc = PDCinit("pdc"); LOG_INFO("[MAIN] created a new pdc, pdc id is: %lld\n", pdc); /*Create nThreads threads in each process*/ @@ -141,7 +143,7 @@ main(int argc, char **argv) } // close pdc - if (PDC_close(pdc) < 0) + if (PDCclose(pdc) < 0) LOG_ERROR("Failed to close PDC\n"); else LOG_INFO("PDC is closed\n"); @@ -154,7 +156,7 @@ main(int argc, char **argv) LOG_INFO("No errors reported\n"); } -#ifdef ENABLE_MPI +#ifdef ENABLE_MPIz MPI_Finalize(); #endif return 0; diff --git a/src/tests/cont/cont_tags.c b/src/tests/cont/cont_tags.c index 5afa5dd04..fc6b2834a 100644 --- a/src/tests/cont/cont_tags.c +++ b/src/tests/cont/cont_tags.c @@ -26,12 +26,13 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { pdcid_t pdc, cont_prop, cont, cont2; - perr_t ret; + int ret_value = TSUCCEED; int rank = 0, size = 1; @@ -47,163 +48,91 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - return -1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create("c1", cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - return -1; - } - - cont2 = PDCcont_create("c2", cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c2\n"); - } - else { - LOG_ERROR("Failed to create container"); - return -1; - } - - ret = PDCcont_put_tag(cont, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1); - - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at container 1\n"); - return -1; - } - ret = PDCcont_put_tag(cont, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at container 1\n"); - return -1; - } - - ret = PDCcont_put_tag(cont2, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at container 2\n"); - return -1; - } - - ret = PDCcont_put_tag(cont2, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at container 2\n"); - return -1; - } - - ret = PDCcont_get_tag(cont, "some tag", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at container 1\n"); - return -1; - } - if (strcmp(tag_value, tag_value_ret) != 0) { - LOG_ERROR("Wrong tag value at container 1, expected = [%s], get [%s]\n", tag_value, tag_value_ret); - return -1; - } - - ret = PDCcont_get_tag(cont, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at container 1\n"); - return -1; - } - - if (strcmp(tag_value2, tag_value_ret) != 0) { - LOG_ERROR("Wrong tag value at container 1, expected = [%s], get [%s]\n", tag_value2, tag_value_ret); - return -1; - } - - ret = PDCcont_get_tag(cont2, "some tag", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at container 2\n"); - return -1; - } - - if (strcmp(tag_value, tag_value_ret) != 0) { - LOG_ERROR("Wrong tag value at container 2, expected = [%s], get [%s]\n", tag_value, tag_value_ret); - return -1; - } - - ret = PDCcont_get_tag(cont2, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at container 2\n"); - return -1; - } + TASSERT((cont = PDCcont_create("c1", cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); + TASSERT((cont2 = PDCcont_create("c2", cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); + + TASSERT(PDCcont_put_tag(cont, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1) >= 0, + "Call to PDCcont_put_tag succeeded for container 1", + "Call to PDCcont_put_tag failed for container 1"); + TASSERT(PDCcont_put_tag(cont, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1) >= 0, + "Call to PDCcont_put_tag succeeded for container 2", + "Call to PDCcont_put_tag failed for container 1"); + + TASSERT(PDCcont_put_tag(cont2, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1) >= 0, + "Call to PDCcont_put_tag succeeded for container 1", + "Call to PDCcont_put_tag failed for container 2"); + TASSERT(PDCcont_put_tag(cont2, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1) >= 0, + "Call to PDCcont_put_tag succeeded for container 2", + "Call to PDCcont_put_tag failed for container 2"); + TASSERT(PDCcont_get_tag(cont, "some tag", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCcont_get_tag succeeded for container 1", + "Call to PDCcont_get_tag failed for container 1"); + + if (strcmp(tag_value, tag_value_ret) != 0) + TGOTO_ERROR(TFAIL, "Wrong tag value at container 1, expected = [%s], get [%s]", tag_value, + tag_value_ret); + + TASSERT(PDCcont_get_tag(cont, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCcont_get_tag succeeded for container 1", + "Call to PDCcont_get_tag failed for container 1"); + + if (strcmp(tag_value2, tag_value_ret) != 0) + TGOTO_ERROR(TFAIL, "Wrong tag value at container 1, expected = [%s], get [%s]", tag_value2, + tag_value_ret); + + TASSERT(PDCcont_get_tag(cont2, "some tag", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCcont_get_tag succeeded for container 2", + "Call to PDCcont_get_tag failed for container 2"); + + if (strcmp(tag_value, tag_value_ret) != 0) + TGOTO_ERROR(TFAIL, "Wrong tag value at container 2, expected = [%s], get [%s]", tag_value, + tag_value_ret); + + TASSERT(PDCcont_get_tag(cont2, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCcont_get_tag succeeded for container 2", + "Call to PDCcont_get_tag failed for container 2"); if (strcmp(tag_value2, tag_value_ret) != 0) { LOG_ERROR("Wrong tag value at container 2, expected = [%s], get [%s]\n", tag_value2, tag_value_ret); return -1; } - - ret = PDCcont_del_tag(cont2, "some tag 2"); - if (ret != SUCCEED) { - LOG_ERROR("Delete tag failed at container 2\n"); - return -1; - } - else { - LOG_INFO("successfully deleted a tag from container c2\n"); - } + TASSERT(PDCcont_del_tag(cont2, "some tag 2") >= 0, "Call to PDCcont_del_tag succeeded for container 2", + "Call to PDCcont_del_tag failed for container 2"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - ret = PDCcont_get_tag(cont2, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at container 2\n"); - return -1; - } + TASSERT(PDCcont_get_tag(cont2, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCcont_get_tag succeeded for container 2", + "Call to PDCcont_get_tag failed for container 2"); - if (tag_value_ret != NULL || value_size != 0) { - LOG_ERROR("Error: got non-empty tag after deletion\n"); - return -1; - } - else { - LOG_INFO("verified the tag has been deleted successfully\n"); - } + if (tag_value_ret != NULL || value_size != 0) + TGOTO_ERROR(TFAIL, "Error: got non-empty tag after deletion"); + else + LOG_INFO("Verified the tag has been deleted successfully\n"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - return -1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container - if (PDCcont_close(cont2) < 0) { - LOG_ERROR("Failed to close container c1\n"); - return -1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont2) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - return -1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - return -1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/cont/create_cont.c b/src/tests/cont/create_cont.c index 03fe603c2..bf3efb6f7 100644 --- a/src/tests/cont/create_cont.c +++ b/src/tests/cont/create_cont.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -33,7 +34,7 @@ main(int argc, char **argv) pdcid_t pdc, create_prop, cont; int rank = 0, size = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -42,48 +43,22 @@ main(int argc, char **argv) #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - create_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (create_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((create_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create("c1", create_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create("c1", create_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(create_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(create_prop) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/cont/create_cont_coll.c b/src/tests/cont/create_cont_coll.c index a8bb04d8e..6dd48327c 100644 --- a/src/tests/cont/create_cont_coll.c +++ b/src/tests/cont/create_cont_coll.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -33,7 +34,7 @@ main(int argc, char **argv) pdcid_t pdc, create_prop, cont; int rank = 0, size = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -42,48 +43,23 @@ main(int argc, char **argv) #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - create_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (create_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((create_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create_col("c1", create_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create_col("c1", create_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(create_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(create_prop) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/cont/open_cont.c b/src/tests/cont/open_cont.c index 5aaf2b2e7..7fdcd0a72 100644 --- a/src/tests/cont/open_cont.c +++ b/src/tests/cont/open_cont.c @@ -28,6 +28,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -35,7 +36,7 @@ main(int argc, char **argv) int rank = 0, size = 1; pdcid_t pdc_id, cont_prop, cont_id, cont_id2; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -44,51 +45,33 @@ main(int argc, char **argv) #endif // create a pdc - pdc_id = PDCinit("pdc"); + TASSERT((pdc_id = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id); - if (cont_prop <= 0) { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont_id = PDCcont_create_col("c1", cont_prop); - if (cont_id <= 0) { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont_id = PDCcont_create_col("c1", cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - cont_id2 = PDCcont_open("c1", pdc_id); - if (cont_id2 == 0) { - LOG_ERROR("Failed to open container"); - ret_value = 1; - } + TASSERT((cont_id2 = PDCcont_open("c1", pdc_id)) > 0, "Call to PDCcont_open succeeded", + "Call to PDCcont_open failed"); + #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif // close a container - if (PDCcont_close(cont_id) < 0) { - LOG_ERROR("Failed to close container cont_id1\n"); - ret_value = 1; - } - if (PDCcont_close(cont_id2) < 0) { - LOG_ERROR("Failed to close container cont_id2\n"); - ret_value = 1; - } + TASSERT(PDCcont_close(cont_id) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCcont_close(cont_id2) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - if (PDCclose(pdc_id) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCclose(pdc_id) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/dart/dart_algo_sim.c b/src/tests/dart/dart_algo_sim.c index e3514da27..2586765a0 100644 --- a/src/tests/dart/dart_algo_sim.c +++ b/src/tests/dart/dart_algo_sim.c @@ -9,6 +9,7 @@ #include "string_utils.h" #include "timer_utils.h" #include "dart_core.h" +#include "pdc.h" #define HASH_MD5 0 #define HASH_MURMUR 1 @@ -35,94 +36,6 @@ virtual_dart_retrieve_server_info_cb(dart_server *server_ptr) server_ptr->request_count = server_ptr->request_count + 1; } -// void -// md5_keyword_insert(char *key, int prefix_len) -// { -// if (key == NULL) -// return; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = md5_hash(len, key); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].indexed_word_count = all_servers[server_id].indexed_word_count + 1; -// } - -// int -// md5_keyword_search(char *key, int prefix_len) -// { -// if (key == NULL) -// return 0; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = md5_hash(len, key); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].request_count = all_servers[server_id].request_count + 1; -// } - -// void -// murmurhash_keyword_insert(char *key, int prefix_len) -// { -// if (key == NULL) -// return; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = murmur3_32(key, len, 1); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].indexed_word_count = all_servers[server_id].indexed_word_count + 1; -// } - -// int -// murmurhash_keyword_search(char *key, int prefix_len) -// { -// if (key == NULL) -// return 0; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = murmur3_32(key, len, 1); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].request_count = all_servers[server_id].request_count + 1; -// } - -// int -// djb2_hash_keyword_insert(char *key, int prefix_len) -// { -// if (key == NULL) -// return; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = djb2_hash(key, len); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].indexed_word_count = all_servers[server_id].indexed_word_count + 1; -// } - -// int -// djb2_hash_keyword_search(char *key, int prefix_len) -// { -// if (key == NULL) -// return 0; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = djb2_hash(key, len); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].request_count = all_servers[server_id].request_count + 1; -// } - -// int -// djb2_hash_keyword_insert_full(char *key, int prefix_len) -// { -// if (key == NULL) -// return; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = djb2_hash(key, strlen(key)); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].indexed_word_count = all_servers[server_id].indexed_word_count + 1; -// } - -// int -// djb2_hash_keyword_search_full(char *key, int prefix_len) -// { -// if (key == NULL) -// return 0; -// int len = prefix_len == 0 ? strlen(key) : prefix_len; -// uint32_t hashVal = djb2_hash(key, strlen(key)); -// uint32_t server_id = hashVal % dart_g.num_server; -// all_servers[server_id].request_count = all_servers[server_id].request_count + 1; -// } - void DHT_INITIAL_keyword_insert(char *key, int prefix_len) { @@ -224,8 +137,8 @@ get_key_distribution(int num_server, char *algo) if (max < num_indexed_word) { max = num_indexed_word; } - println("[%s Key Distribution] The total number of indexed keys on server %d = %.0f", algo, srv_cnt, - num_indexed_word); + LOG_JUST_PRINT("[%s Key Distribution] The total number of indexed keys on server %d = %.0f\n", algo, + srv_cnt, num_indexed_word); sum += (double)num_indexed_word; sqrt_sum += (double)((double)num_indexed_word * (double)num_indexed_word); } @@ -234,8 +147,9 @@ get_key_distribution(int num_server, char *algo) double variance = sqrt_sum / num_server - mean * mean; double stddev = sqrt(variance); - println("[%s Key Distribution] STDDEV = %.3f and CV = %.3f for %d servers and %.0f keys in total.", algo, - stddev, stddev / mean, num_server, sum); + LOG_JUST_PRINT( + "[%s Key Distribution] STDDEV = %.3f and CV = %.3f for %d servers and %.0f keys in total\n", algo, + stddev, stddev / mean, num_server, sum); } void @@ -248,16 +162,16 @@ get_request_distribution(int num_server, char *algo) for (srv_cnt = 0; srv_cnt < num_server; srv_cnt++) { dart_server server_abstract = all_servers[srv_cnt]; double request_count = (double)server_abstract.request_count; - println("[%s Load Balance All] The total number of query requests on server %d = %.0f", algo, srv_cnt, - request_count); + LOG_INFO("[%s Load Balance All] The total number of query requests on server %d = %.0f\n", algo, + srv_cnt, request_count); sum += (double)request_count; sqrt_sum += (double)((double)request_count * (double)request_count); } double mean = sum / (double)num_server; double variance = sqrt_sum / num_server - mean * mean; double stddev = sqrt(variance); - println("[%s Load Balance All] STDDEV = %.3f and CV = %.3f for %d servers and %.0f request in total.", - algo, stddev, stddev / mean, num_server, sum); + LOG_INFO("[%s Load Balance All] STDDEV = %.3f and CV = %.3f for %d servers and %.0f request in total\n", + algo, stddev, stddev / mean, num_server, sum); } void @@ -332,7 +246,7 @@ read_words_from_text(const char *fileName, int *word_count, int **req_count, int FILE *file = fopen(fileName, "r"); /* should check the result */ if (file == NULL) { - println("File not available\n"); + LOG_ERROR("File not available\n"); exit(4); } int lines_allocated = 128; @@ -378,8 +292,8 @@ read_words_from_text(const char *fileName, int *word_count, int **req_count, int void print_usage() { - println("dart_sim.exe " - " "); + LOG_JUST_PRINT("dart_sim.exe " + " \n"); } int @@ -427,7 +341,7 @@ main(int argc, char **argv) algo_name = "DART"; } - println("HASH = %s", algo_name); + LOG_INFO("HASH = %s\n", algo_name); void (*keyword_insert[])(char *, int) = {DHT_INITIAL_keyword_insert, DHT_FULL_keyword_insert, dart_keyword_insert}; diff --git a/src/tests/dart/dart_attr_dist_test.c b/src/tests/dart/dart_attr_dist_test.c index a619d36c8..bb0c48997 100644 --- a/src/tests/dart/dart_attr_dist_test.c +++ b/src/tests/dart/dart_attr_dist_test.c @@ -76,7 +76,6 @@ main(int argc, char *argv[]) int rank = 0, size = 1; #ifdef ENABLE_MPI - fflush(stdout); MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); @@ -214,7 +213,7 @@ main(int argc, char *argv[]) int num_obj_per_attr = attr_2_obj_array[i]; sprintf(key, "k%ld", i + 12345); sprintf(value, "v%ld", val); - println("attaching attribute #%d [%s:%s] to %d objects", i, key, value, num_obj_per_attr); + LOG_INFO("Attaching attribute #%d [%s:%s] to %d objects\n", i, key, value, num_obj_per_attr); for (j = 0; j < num_obj_per_attr; j++) { // each attribute is attached to a specific number of objects, and this is how we make up // different selectivity. @@ -311,8 +310,8 @@ main(int argc, char *argv[]) } timer_pause(&timer_obj); duration_obj_ms += timer_delta_ms(&timer_obj); - println("[Client_Side_Exact] Search '%s' for %d times and get %d results, obj time: %.4f ms\n", - key, q_repeat_count, rest_count1, duration_obj_ms); + LOG_INFO("[Client_Side_Exact] Search '%s' for %d times and get %d results, obj time: %.4f ms\n", + key, q_repeat_count, rest_count1, duration_obj_ms); } } @@ -344,9 +343,9 @@ main(int argc, char *argv[]) } timer_pause(&timer_dart); duration_dart_ms += timer_delta_ms(&timer_dart); - println("[Client_Side_Exact] Search '%s' for %d times and get %d results, dart " - "time: %.4f ms\n", - key, q_repeat_count, rest_count1, duration_dart_ms); + LOG_INFO("[Client_Side_Exact] Search '%s' for %d times and get %d results, dart " + "time: %.4f ms\n", + key, q_repeat_count, rest_count1, duration_dart_ms); } } diff --git a/src/tests/dart/dart_func_test.c b/src/tests/dart/dart_func_test.c index e4b34313a..ff5317a82 100644 --- a/src/tests/dart/dart_func_test.c +++ b/src/tests/dart/dart_func_test.c @@ -26,8 +26,6 @@ main(int argc, char **argv) int rank = 0, size = 1; #ifdef ENABLE_MPI - // println("MPI enabled!\n"); - fflush(stdout); MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); @@ -55,7 +53,7 @@ main(int argc, char **argv) uint64_t data = 12341234; // if (rank == 0) { PDC_Client_insert_obj_ref_into_dart(hash_algo, key, value, strlen(value), PDC_STRING, ref_type, data); - println("[Client_Side_Insert] Insert '%s=%s' for ref %llu", key, value, data); + LOG_INFO("[Client_Side_Insert] Insert '%s=%s' for ref %llu\n", key, value, data); // This is for testing exact search char * exact_query = "abcd=1234"; @@ -63,7 +61,8 @@ main(int argc, char **argv) int rest_count1 = 0; PDC_Client_search_obj_ref_through_dart(hash_algo, exact_query, ref_type, &rest_count1, &out1); - println("[Client_Side_Exact] Search '%s' and get %d results : %llu", exact_query, rest_count1, out1[0]); + LOG_INFO("[Client_Side_Exact] Search '%s' and get %d results : %llu\n", exact_query, rest_count1, + out1[0]); // This function test is for testing the prefix search char * prefix_query = "ab*=12*"; @@ -71,7 +70,8 @@ main(int argc, char **argv) int rest_count2 = 0; PDC_Client_search_obj_ref_through_dart(hash_algo, prefix_query, ref_type, &rest_count2, &out2); - println("[Client_Side_Prefix] Search '%s' and get %d results : %llu", prefix_query, rest_count2, out2[0]); + LOG_INFO("[Client_Side_Prefix] Search '%s' and get %d results : %llu\n", prefix_query, rest_count2, + out2[0]); // This function test is for testing the suffix search. char * suffix_query = "*cd=*34"; @@ -79,7 +79,8 @@ main(int argc, char **argv) int rest_count3 = 0; PDC_Client_search_obj_ref_through_dart(hash_algo, suffix_query, ref_type, &rest_count3, &out3); - println("[Client_Side_Suffix] Search '%s' and get %d results : %llu", suffix_query, rest_count3, out3[0]); + LOG_INFO("[Client_Side_Suffix] Search '%s' and get %d results : %llu\n", suffix_query, rest_count3, + out3[0]); // This is for testing infix search. char * infix_query = "*bc*=*23*"; @@ -87,11 +88,8 @@ main(int argc, char **argv) int rest_count4 = 0; PDC_Client_search_obj_ref_through_dart(hash_algo, infix_query, ref_type, &rest_count4, &out4); - println("[Client_Side_Infix] Search '%s' and get %d results : %llu", infix_query, rest_count4, out4[0]); - - // } - - // done: + LOG_INFO("[Client_Side_Infix] Search '%s' and get %d results : %llu\n", infix_query, rest_count4, + out4[0]); if (PDCcont_close(cont) < 0) LOG_ERROR("Failed to close container %lld\n", cont); diff --git a/src/tests/dart/dart_test.c b/src/tests/dart/dart_test.c index 2f6b9bef5..4bbf49e6f 100644 --- a/src/tests/dart/dart_test.c +++ b/src/tests/dart/dart_test.c @@ -26,14 +26,15 @@ const int INPUT_WIKI_KEYWORD = 3; void print_usage() { - println("Usage: srun -n ./dart_test " - " /path/to/txtfile \n" - "alphabet_size: 26 for random string, 37 for uuid, 29 for dictionary, 129 for wiki keyword\n" - "replication_factor: 1-5\n" - "word_count: The number of words you would like to generate. For txt files, it doesn't matter.\n" - "txtfile: /path/to/txtfile, for random string and uuid, just provide random/uuid.\n" - "index_type: 1 for full hashing, 2 for initial hashing, 3 for DART\n" - "Example: srun -n 4 ./dart_test 0 26 2 2048 random 3\n"); + LOG_JUST_PRINT( + "Usage: srun -n ./dart_test " + " /path/to/txtfile \n" + "alphabet_size: 26 for random string, 37 for uuid, 29 for dictionary, 129 for wiki keyword\n" + "replication_factor: 1-5\n" + "word_count: The number of words you would like to generate. For txt files, it doesn't matter.\n" + "txtfile: /path/to/txtfile, for random string and uuid, just provide random/uuid.\n" + "index_type: 1 for full hashing, 2 for initial hashing, 3 for DART\n" + "Example: srun -n 4 ./dart_test 0 26 2 2048 random 3\n"); } char ** @@ -56,7 +57,7 @@ read_words_from_text(const char *fileName, int *word_count, int *total_word_coun FILE *file = fopen(fileName, "r"); /* should check the result */ if (file == NULL) { - println("File not available\n"); + LOG_ERROR("File not available\n"); exit(4); } int lines_allocated = 128; @@ -118,10 +119,9 @@ main(int argc, char **argv) { int rank = 0, size = 1; + int ret_value = SUCCEED; #ifdef ENABLE_MPI - // println("MPI enabled!\n"); - fflush(stdout); MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); @@ -168,20 +168,18 @@ main(int argc, char **argv) else { input_word_list = read_words_from_text(dict_filename, &word_count, &total_word_count, rank); alphabet_size = 29; - if (indexOfStr(dict_filename, "wiki") != -1) { + if (indexOfStr(dict_filename, "wiki") != -1) alphabet_size = 129; - } } - if (rank == 0) { - println("word_count = %d", word_count); - } + if (rank == 0) + LOG_INFO("word_count = %d\n", word_count); pdcid_t pdc = PDCinit("pdc"); pdcid_t cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop <= 0) - LOG_ERROR("Failed to create container property"); + PGOTO_ERROR(FAIL, "Failed to create container property"); pdcid_t cont = PDCcont_create("c1", cont_prop); if (cont <= 0) @@ -237,9 +235,10 @@ main(int argc, char **argv) (uint64_t)data); timer_pause(&detailed_timer); if (round == 1) - println("[Client_Side_Insert] Time to insert key %s for both prefix index and suffix index = " - "%d microseconds", - input_word_list[i], timer_delta_us(&detailed_timer)); + LOG_INFO( + "[Client_Side_Insert] Time to insert key %s for both prefix index and suffix index = " + "%d microseconds\n", + input_word_list[i], timer_delta_us(&detailed_timer)); } #ifdef ENABLE_MPI @@ -252,24 +251,7 @@ main(int argc, char **argv) insert_throughput = (double)((double)(total_word_count) / (double)timer_delta_ms(&timer)); if (round == 1) - println("[Client_Side_Insert_Throughput] %.3f ops/ms", insert_throughput); - - // int srv_cnt = 0; - // double sqrt_sum = 0; - // double sum = 0; - - // for (srv_cnt = 0; srv_cnt < dart_g->num_server; srv_cnt++){ - // dart_server server_abstract = dart_retrieve_server_info_cb((uint32_t)srv_cnt); - // int64_t num_indexed_word = server_abstract.indexed_word_count/2; - // println("[DART Key Distribution] Server %d has %d words indexed", srv_cnt, - // num_indexed_word); sum += (double)num_indexed_word; sqrt_sum += - // (double)((double)num_indexed_word * (double)num_indexed_word); - // } - // double mean = sum/(double)dart_g->num_server; - // double variance = sqrt_sum/dart_g->num_server - mean * mean; - // double stddev = sqrt(variance); - // println("[DART Key Distribution] STDDEV = %.3f for %d servers and %d keys in total.", stddev, - // dart_g->num_server, word_count * size); + LOG_INFO("[Client_Side_Insert_Throughput] %.3f ops/ms\n", insert_throughput); } // /* =============== Exact Query testing ======================= */ @@ -296,9 +278,9 @@ main(int argc, char **argv) PDC_Client_search_obj_ref_through_dart(hash_algo, query_str, ref_type, &rest_count, &out); timer_pause(&detailed_timer); if (round == 1) - println("[Client_Side_Exact] Time to search '%s' and get %d results = %d microseconds for " - "rank %d", - query_str, rest_count, timer_delta_us(&detailed_timer), rank); + LOG_INFO("[Client_Side_Exact] Time to search '%s' and get %d results = %d microseconds for " + "rank %d\n", + query_str, rest_count, timer_delta_us(&detailed_timer), rank); } #ifdef ENABLE_MPI @@ -310,7 +292,7 @@ main(int argc, char **argv) if (rank == 0) { query_throughput = (double)((double)(total_word_count) / (double)timer_delta_ms(&timer)); if (round == 1) - println("[Client_Side_Exact_Throughput] %.3f ops/ms", query_throughput); + LOG_INFO("[Client_Side_Exact_Throughput] %.3f ops/ms\n", query_throughput); int srv_cnt = 0; for (srv_cnt = 0; srv_cnt < dart_g->num_server; srv_cnt++) { @@ -318,8 +300,8 @@ main(int argc, char **argv) server_abstract.id = srv_cnt; dart_retrieve_server_info_cb(&server_abstract); if (round == 1) - println("[DART Load Balance 1] Server %d has query requests = %d", srv_cnt, - server_abstract.request_count); + LOG_INFO("[DART Load Balance 1] Server %d has query requests = %d\n", srv_cnt, + server_abstract.request_count); } } @@ -349,9 +331,9 @@ main(int argc, char **argv) PDC_Client_search_obj_ref_through_dart(hash_algo, query_str, ref_type, &rest_count, &out); timer_pause(&detailed_timer); if (round == 1) - println("[Client_Side_Prefix] Time to search '%s' and get %d results = %d microseconds for " - "rank %d", - query_str, rest_count, timer_delta_us(&detailed_timer), rank); + LOG_INFO("[Client_Side_Prefix] Time to search '%s' and get %d results = %d microseconds for " + "rank %d\n", + query_str, rest_count, timer_delta_us(&detailed_timer), rank); } #ifdef ENABLE_MPI @@ -363,7 +345,7 @@ main(int argc, char **argv) if (rank == 0) { query_throughput = (double)((double)(total_word_count) / (double)timer_delta_ms(&timer)); if (round == 1) - println("[Client_Side_Prefix_Throughput] %.3f ops/ms", query_throughput); + LOG_INFO("[Client_Side_Prefix_Throughput] %.3f ops/ms\n", query_throughput); int srv_cnt = 0; for (srv_cnt = 0; srv_cnt < dart_g->num_server; srv_cnt++) { @@ -371,8 +353,8 @@ main(int argc, char **argv) server_abstract.id = srv_cnt; dart_retrieve_server_info_cb(&server_abstract); if (round == 1) - println("[DART Load Balance 2] Server %d has query requests = %d", srv_cnt, - server_abstract.request_count); + LOG_INFO("[DART Load Balance 2] Server %d has query requests = %d\n", srv_cnt, + server_abstract.request_count); } } @@ -402,9 +384,9 @@ main(int argc, char **argv) PDC_Client_search_obj_ref_through_dart(hash_algo, query_str, ref_type, &rest_count, &out); timer_pause(&detailed_timer); if (round == 1) - println("[Client_Side_Suffix] Time to search '%s' and get %d results = %d microseconds for " - "rank %d", - query_str, rest_count, timer_delta_us(&detailed_timer), rank); + LOG_INFO("[Client_Side_Suffix] Time to search '%s' and get %d results = %d microseconds for " + "rank %d\n", + query_str, rest_count, timer_delta_us(&detailed_timer), rank); } #ifdef ENABLE_MPI @@ -416,7 +398,7 @@ main(int argc, char **argv) if (rank == 0) { query_throughput = (double)((double)(total_word_count) / (double)timer_delta_ms(&timer)); if (round == 1) - println("[Client_Side_Suffix_Throughput] %.3f ops/ms", query_throughput); + LOG_INFO("[Client_Side_Suffix_Throughput] %.3f ops/ms\n", query_throughput); int srv_cnt = 0; for (srv_cnt = 0; srv_cnt < dart_g->num_server; srv_cnt++) { @@ -424,8 +406,8 @@ main(int argc, char **argv) server_abstract.id = srv_cnt; dart_retrieve_server_info_cb(&server_abstract); if (round == 1) - println("[DART Load Balance 3] Server %d has query requests = %d", srv_cnt, - server_abstract.request_count); + LOG_INFO("[DART Load Balance 3] Server %d has query requests = %d\n", srv_cnt, + server_abstract.request_count); } } @@ -458,9 +440,9 @@ main(int argc, char **argv) PDC_Client_search_obj_ref_through_dart(hash_algo, query_str, ref_type, &rest_count, &out); timer_pause(&detailed_timer); if (round == 1) - println("[Client_Side_Infix] Time to search '%s' and get %d results = %d microseconds for " - "rank %d", - query_str, rest_count, timer_delta_us(&detailed_timer), rank); + LOG_INFO("[Client_Side_Infix] Time to search '%s' and get %d results = %d microseconds for " + "rank %d\n", + query_str, rest_count, timer_delta_us(&detailed_timer), rank); } #ifdef ENABLE_MPI @@ -472,7 +454,7 @@ main(int argc, char **argv) if (rank == 0) { query_throughput = (double)((double)(total_word_count) / (double)timer_delta_ms(&timer)); if (round == 1) - println("[Client_Side_Infix_Throughput] %.3f ops/ms", query_throughput); + LOG_INFO("[Client_Side_Infix_Throughput] %.3f ops/ms\n", query_throughput); int srv_cnt = 0; for (srv_cnt = 0; srv_cnt < dart_g->num_server; srv_cnt++) { @@ -480,8 +462,8 @@ main(int argc, char **argv) server_abstract.id = srv_cnt; dart_retrieve_server_info_cb(&server_abstract); if (round == 1) - println("[DART Load Balance 4] Server %d has query requests = %d", srv_cnt, - server_abstract.request_count); + LOG_INFO("[DART Load Balance 4] Server %d has query requests = %d\n", srv_cnt, + server_abstract.request_count); } } @@ -499,8 +481,8 @@ main(int argc, char **argv) dart_retrieve_server_info_cb(&server_abstract); int64_t num_request = server_abstract.request_count; if (round == 1) - println("[DART Load Balance All] The total number of query requests on server %d = %d", - srv_cnt, num_request); + LOG_INFO("[DART Load Balance All] The total number of query requests on server %d = %d\n", + srv_cnt, num_request); sum += (double)num_request; sqrt_sum += (double)((double)num_request * (double)num_request); } @@ -508,14 +490,9 @@ main(int argc, char **argv) double variance = sqrt_sum / dart_g->num_server - mean * mean; double stddev = sqrt(variance); - // double normalSum = (sum - (mean*(double)dart_g->num_server))/stddev; - // double normalSqrtSum = sqrt_sum-2*sum*mean+((sum*sum)/(double)dart_g->num_server); - // double normalMean = normalSum / (double)dart_g->num_server; - // double normalVariance = normalSqrtSum/dart_g->num_server - normalMean * normalMean; - // double normalStdDev = sqrt(normalVariance); if (round == 1) - println( - "[DART DART Load Balance All] STDDEV = %.3f for %d servers and %.1f request in total.", + LOG_INFO( + "[DART DART Load Balance All] STDDEV = %.3f for %d servers and %.1f request in total\n", stddev, dart_g->num_server, sum); srv_cnt = 0; @@ -528,8 +505,8 @@ main(int argc, char **argv) dart_retrieve_server_info_cb(&server_abstract); int64_t num_indexed_word = server_abstract.indexed_word_count / 2; if (round == 1) - println("[DART Key Distribution] Server %d has %d words indexed", srv_cnt, - num_indexed_word); + LOG_INFO("[DART Key Distribution] Server %d has %d words indexed\n", srv_cnt, + num_indexed_word); sum += (double)num_indexed_word; sqrt_sum += (double)((double)num_indexed_word * (double)num_indexed_word); } @@ -537,15 +514,9 @@ main(int argc, char **argv) variance = sqrt_sum / dart_g->num_server - mean * mean; stddev = sqrt(variance); - // normalSum = (sum - (mean*(double)dart_g->num_server))/stddev; - // normalSqrtSum = sqrt_sum-2*sum*mean+((sum*sum)/(double)dart_g->num_server); - // normalMean = normalSum / (double)dart_g->num_server; - // normalVariance = normalSqrtSum/dart_g->num_server - normalMean * normalMean; - // normalStdDev = sqrt(normalVariance); - if (round == 1) - println("[DART Key Distribution] STDDEV = %.3f for %d servers and %d keys in total.", stddev, - dart_g->num_server, word_count * size); + LOG_INFO("[DART Key Distribution] STDDEV = %.3f for %d servers and %d keys in total\n", + stddev, dart_g->num_server, word_count * size); } /* =========================== Delete From Index ========================= */ @@ -562,9 +533,10 @@ main(int argc, char **argv) (uint64_t)data); timer_pause(&detailed_timer); if (round == 1) - println("[Client_Side_Delete] Time to delete key %s for both prefix index and suffix index = " - "%d microseconds", - input_word_list[i], timer_delta_us(&detailed_timer)); + LOG_INFO( + "[Client_Side_Delete] Time to delete key %s for both prefix index and suffix index = " + "%d microseconds\n", + input_word_list[i], timer_delta_us(&detailed_timer)); } #ifdef ENABLE_MPI @@ -577,7 +549,7 @@ main(int argc, char **argv) delete_throughput = (double)((double)(total_word_count) / (double)timer_delta_ms(&timer)); if (round == 1) - println("[Client_Side_Delete_Throughput] %.3f ops/ms", delete_throughput); + LOG_INFO("[Client_Side_Delete_Throughput] %.3f ops/ms\n", delete_throughput); } } // end round loop @@ -593,9 +565,10 @@ main(int argc, char **argv) if (PDCclose(pdc) < 0) LOG_ERROR("Failed to close PDC\n"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/data_server/data_server_meta.c b/src/tests/data_server/data_server_meta.c index 844383e5d..dba79f21c 100644 --- a/src/tests/data_server/data_server_meta.c +++ b/src/tests/data_server/data_server_meta.c @@ -85,7 +85,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Creating %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc pdc = PDC_init("pdc"); diff --git a/src/tests/data_server/data_server_meta_test.c b/src/tests/data_server/data_server_meta_test.c index ed9b4cb48..96ff92c88 100644 --- a/src/tests/data_server/data_server_meta_test.c +++ b/src/tests/data_server/data_server_meta_test.c @@ -13,7 +13,7 @@ void print_usage() { - LOG_JUST_PRINT("Should run with more than 1 processes!\n"); + LOG_JUST_PRINT("Should run with more than 1 processes\n"); } int @@ -98,7 +98,7 @@ main(int argc, char **argv) for (i = 0; i < NOBJ; i++) { PDC_Client_query_metadata_name_timestep(obj_names[i], 0, &metadata[i]); if (metadata[i]->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); goto done; } @@ -107,8 +107,7 @@ main(int argc, char **argv) PDC_Client_write(metadata[i], &write_region, write_data); } - LOG_INFO("%d - Finished writing %d regions. \n", rank, NOBJ); - fflush(stdout); + LOG_INFO("%d - Finished writing %d regions\n", rank, NOBJ); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -133,7 +132,6 @@ main(int argc, char **argv) for (i = 0; i < my_read_obj; i++) { LOG_INFO("Proc %d - [%s]: [%c] ... [%c], size %" PRId64 "\n", rank, obj_names[i], ((char **)out_buf)[i][0], ((char **)out_buf)[i][out_buf_sizes[i] - 1], out_buf_sizes[i]); - fflush(stdout); } #ifdef ENABLE_MPI diff --git a/src/tests/data_server/data_server_read.c b/src/tests/data_server/data_server_read.c index 4bd096aff..70468abcd 100644 --- a/src/tests/data_server/data_server_read.c +++ b/src/tests/data_server/data_server_read.c @@ -87,10 +87,8 @@ main(int argc, char **argv) ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to read data with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); diff --git a/src/tests/data_server/data_server_read_multi.c b/src/tests/data_server/data_server_read_multi.c index 798325105..078862679 100644 --- a/src/tests/data_server/data_server_read_multi.c +++ b/src/tests/data_server/data_server_read_multi.c @@ -111,11 +111,11 @@ main(int argc, char **argv) // Query the created object if (rank == 0) - LOG_INFO("%d: Start to query object just created ...", rank); + LOG_INFO("%d: Start to query object just created...", rank); PDC_Client_query_metadata_name_timestep_agg(obj_name, ts, &metadata); if (metadata == NULL || metadata->obj_id == 0) { - LOG_ERROR("[%d]: Error with metadata!\n", rank); + LOG_ERROR("[%d]: Error with metadata\n", rank); exit(-1); } #ifdef ENABLE_MPI @@ -129,10 +129,8 @@ main(int argc, char **argv) (meta_end.tv_sec - meta_start.tv_sec) * 1000000LL + meta_end.tv_usec - meta_start.tv_usec; total_meta_sec += meta_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Sleep %.2f seconds.\n", sleepseconds); - fflush(stdout); - } // Fake computation usleep(microseconds); @@ -142,7 +140,7 @@ main(int argc, char **argv) // Wait for previous read completion before reading current timestep ret_value = PDC_Client_wait(&request, 60000, 100); if (ret_value != SUCCEED) { - LOG_ERROR("==PDC_CLIENT: PDC_Client_read - PDC_Client_wait error\n"); + LOG_ERROR("PDC_Client_read - PDC_Client_wait error\n"); goto done; } @@ -157,13 +155,12 @@ main(int argc, char **argv) total_wait_sec += wait_elapsed / 1000000.0; LOG_INFO("Timestep %d read, metadata %.2f s, wait %.2f s.\n", ts, meta_elapsed / 1000000.0, wait_elapsed / 1000000.0); - fflush(stdout); } } ret_value = PDC_Client_iread(metadata, ®ion, &request, mydata); if (ret_value != SUCCEED) { - LOG_ERROR("[%d] Error with PDC_Client_iread!\n", rank); + LOG_ERROR("[%d] Error with PDC_Client_iread\n", rank); goto done; } @@ -178,13 +175,11 @@ main(int argc, char **argv) total_elapsed = (total_end.tv_sec - total_start.tv_sec) * 1000000LL + total_end.tv_usec - total_start.tv_usec; - if (rank == 0) { + if (rank == 0) printf( "Total time read %d ts data each %luMB with %d ranks: %.5e, meta %.2f, wait %.2f, sleep %.2f\n", ntimestep, size_MB, size, total_elapsed / 1000000.0, total_meta_sec, total_wait_sec, sleepseconds * ntimestep); - fflush(stdout); - } done: // close a container diff --git a/src/tests/data_server/data_server_read_vpic.c b/src/tests/data_server/data_server_read_vpic.c index b0103c2be..7d74b8171 100644 --- a/src/tests/data_server/data_server_read_vpic.c +++ b/src/tests/data_server/data_server_read_vpic.c @@ -119,7 +119,7 @@ main(int argc, char **argv) ret = PDC_Client_query_metadata_name_timestep(obj_names[i], 0, &obj_metas[i]); #endif if (ret != SUCCEED || obj_metas[i] == NULL || obj_metas[i]->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); exit(-1); } @@ -157,7 +157,7 @@ main(int argc, char **argv) request[i].n_update = read_var; ret = PDC_Client_iread(obj_metas[i], &obj_regions[i], &request[i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iread!\n"); + LOG_ERROR("Error with PDC_Client_iread\n"); goto done; } @@ -176,7 +176,7 @@ main(int argc, char **argv) for (i = 0; i < read_var; i++) { ret = PDC_Client_wait(&request[i], 200000, 100); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_wait!\n"); + LOG_ERROR("Error with PDC_Client_wait\n"); goto done; } } @@ -195,19 +195,18 @@ main(int argc, char **argv) LOG_INFO("Read %.2f MB data with %d ranks\nTotal read time: %.2f\nSent %.2f, wait %.2f, Throughput " "%.2f MB/s\n", total_size, size, read_time, sent_time_total, wait_time_total, total_size / read_time); - fflush(stdout); } int verify = 1; if (rank == 0) - LOG_INFO("Verifying data correctness ..."); + LOG_INFO("Verifying data correctness..."); // Data verification for (i = 0; i < NPARTICLES; i++) { if (((int *)mydata[7])[i] != i * 2 || ((int *)mydata[6])[i] != i || ((float *)mydata[5])[i] != (i * 2.0 / NPARTICLES) * ZDIM || ((float *)mydata[2])[i] != (i * 1.0 / NPARTICLES) * ZDIM) { - LOG_ERROR("\nERROR on rank %d at element %d. [%d %d %.2f %.2f]/[%d %d %.2f %.2f]\n", rank, i, + LOG_ERROR("\nError on rank %d at element %d. [%d %d %.2f %.2f]/[%d %d %.2f %.2f]\n", rank, i, ((int *)mydata[7])[i], ((int *)mydata[6])[i], ((float *)mydata[5])[i], ((float *)mydata[2])[i], i * 2, i, (i * 2.0 / NPARTICLES) * ZDIM, (i * 1.0 / NPARTICLES) * ZDIM); @@ -221,8 +220,6 @@ main(int argc, char **argv) } done: - fflush(stdout); - if (PDCcont_close(cont_id) < 0) LOG_ERROR("Failed to close container\n"); diff --git a/src/tests/data_server/data_server_read_vpic_multits.c b/src/tests/data_server/data_server_read_vpic_multits.c index f17735434..ba55d9d6b 100644 --- a/src/tests/data_server/data_server_read_vpic_multits.c +++ b/src/tests/data_server/data_server_read_vpic_multits.c @@ -120,11 +120,9 @@ main(int argc, char **argv) if (sleep_time < 0) sleep_time = 15; - if (rank == 0) { + if (rank == 0) LOG_INFO("read %d variables, each %dMB per proc, %d timesteps, %.1f compute time\n", n_var, size_per_proc_var_MB, n_ts, sleep_time); - fflush(stdout); - } // In VPIC-IO, each client reads 32MB per variable, 8 var per client, so 256MB per client n_particles = size_per_proc_var_MB * 262144; // Convert to number of particles @@ -199,10 +197,8 @@ main(int argc, char **argv) query_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end_1); query_time_total += query_time; - if (rank == 0) { - LOG_INFO("Query done!\n"); - fflush(stdout); - } + if (rank == 0) + LOG_INFO("Query done\n"); for (ts = 0; ts < n_ts; ts++) { /* @@ -214,7 +210,6 @@ main(int argc, char **argv) if (ts == 0) { if (rank == 0) LOG_INFO("Timestep %d: sync read start\n", ts); - fflush(stdout); // Timing gettimeofday(&pdc_timer_start_1, 0); @@ -222,7 +217,7 @@ main(int argc, char **argv) for (i = 0; i < n_var; i++) { ret = PDC_Client_read(obj_metas[ts][i], &obj_regions[ts][i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_read!\n"); + LOG_ERROR("Error with PDC_Client_read\n"); goto done; } } // end of for @@ -235,10 +230,8 @@ main(int argc, char **argv) wait_time = read_time; wait_time_total += wait_time; - if (rank == 0) { - LOG_INFO("sync read done\n"); - fflush(stdout); - } + if (rank == 0) + LOG_INFO("Sync read done\n"); } else { /* @@ -250,16 +243,14 @@ main(int argc, char **argv) #endif gettimeofday(&pdc_timer_start_1, 0); - if (rank == 0) { + if (rank == 0) LOG_INFO("Timestep %d: Wait for prefetch.\n", ts); - fflush(stdout); - } // wait for read to finish before reading next timestep for (i = 0; i < n_var; i++) { ret = PDC_Client_wait(&request[ts][i], 90000, 100); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_wait!\n"); + LOG_ERROR("Error with PDC_Client_wait\n"); goto done; } } @@ -270,10 +261,8 @@ main(int argc, char **argv) wait_time = PDC_get_elapsed_time_double(&pdc_timer_start_1, &pdc_timer_end_1); wait_time_total += wait_time; - if (rank == 0) { + if (rank == 0) LOG_INFO("Timestep %d: prefetch finished.\n", ts); - fflush(stdout); - } } // Prefetch next ts except the last read @@ -286,7 +275,7 @@ main(int argc, char **argv) ret = PDC_Client_iread(obj_metas[ts + 1][i], &obj_regions[ts + 1][i], &request[ts + 1][i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iread!\n"); + LOG_ERROR("Error with PDC_Client_iread\n"); goto done; } } // end of for @@ -306,10 +295,8 @@ main(int argc, char **argv) if (true_sleep_time < 0) true_sleep_time = 0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Compute for %d seconds.\n", (int)(true_sleep_time)); - fflush(stdout); - } // Sleep to fake compute time PDC_msleep((unsigned long)(true_sleep_time * 1000)); @@ -329,13 +316,11 @@ main(int argc, char **argv) gettimeofday(&pdc_timer_end, 0); total_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); total_size = n_particles * 4.0 * 8 * size / 1024.0 / 1024.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("read %d ts each of %.0fMB data with %d ranks: total %.2f\n" "query %.2f, read %.2f, wait %.2f, compute %.2f\n", n_ts, total_size, size, total_time, query_time_total, read_time_total, wait_time_total, compute_total); - fflush(stdout); - } // Free allocated space for (i = 0; i < n_var; i++) { diff --git a/src/tests/data_server/data_server_read_vpic_spatial.c b/src/tests/data_server/data_server_read_vpic_spatial.c index 9a68cf512..3e20f6b79 100644 --- a/src/tests/data_server/data_server_read_vpic_spatial.c +++ b/src/tests/data_server/data_server_read_vpic_spatial.c @@ -142,7 +142,7 @@ main(int argc, char **argv) ret = PDC_Client_query_metadata_name_timestep(obj_names[i], 0, &obj_metas[i]); #endif if (ret != SUCCEED || obj_metas[i] == NULL || obj_metas[i]->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); exit(-1); } @@ -172,7 +172,7 @@ main(int argc, char **argv) request[i].n_update = 1; ret = PDC_Client_iread(obj_metas[i], &obj_regions[i], &request[i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iread!\n"); + LOG_ERROR("Error with PDC_Client_iread\n"); goto done; } @@ -188,7 +188,7 @@ main(int argc, char **argv) ret = PDC_Client_wait(&request[i], 60000, 100); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_wait!\n"); + LOG_ERROR("Error with PDC_Client_wait\n"); goto done; } @@ -207,16 +207,12 @@ main(int argc, char **argv) gettimeofday(&pdc_timer_end, 0); read_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); total_size = NPARTICLES * selectivity * 4.0 * 8.0 * size / 1024.0 / 1024.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Read %.2f MB data with %d ranks\nTotal read time: %.2f\nSent %.2f, wait %.2f, Throughput " "%.2f MB/s\n", total_size, size, read_time, sent_time_total, wait_time_total, total_size / read_time); - fflush(stdout); - } done: - fflush(stdout); - if (PDCcont_close(cont_id) < 0) LOG_ERROR("Failed to close container\n"); diff --git a/src/tests/data_server/data_server_read_vpic_spatial_multits.c b/src/tests/data_server/data_server_read_vpic_spatial_multits.c index a10c2ad29..bbd882d1b 100644 --- a/src/tests/data_server/data_server_read_vpic_spatial_multits.c +++ b/src/tests/data_server/data_server_read_vpic_spatial_multits.c @@ -130,11 +130,9 @@ main(int argc, char **argv) selectivity = 1.0; } - if (rank == 0) { + if (rank == 0) LOG_INFO("read %d variables, each %dMB per proc, %d timesteps, %.1f compute time, %.2f selectivity\n", n_var, size_per_proc_var_MB, n_ts, sleep_time, selectivity); - fflush(stdout); - } // create a pdc pdc_id = PDCinit("pdc"); @@ -206,8 +204,7 @@ main(int argc, char **argv) query_time_total += query_time; if (rank == 0) - LOG_INFO("Query done!\n"); - fflush(stdout); + LOG_INFO("Query done\n"); for (ts = 0; ts < n_ts; ts++) { /* @@ -219,7 +216,6 @@ main(int argc, char **argv) if (ts == 0) { if (rank == 0) LOG_INFO("Timestep %d: sync read start\n", ts); - fflush(stdout); // Timing gettimeofday(&pdc_timer_start_1, 0); @@ -227,7 +223,7 @@ main(int argc, char **argv) for (i = 0; i < n_var; i++) { ret = PDC_Client_read(obj_metas[ts][i], &obj_regions[ts][i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_read!\n"); + LOG_ERROR("Error with PDC_Client_read\n"); goto done; } } // end of for @@ -241,8 +237,7 @@ main(int argc, char **argv) wait_time_total += wait_time; if (rank == 0) - LOG_INFO("sync read done\n"); - fflush(stdout); + LOG_INFO("Sync read done\n"); } else { /* @@ -254,16 +249,14 @@ main(int argc, char **argv) #endif gettimeofday(&pdc_timer_start_1, 0); - if (rank == 0) { + if (rank == 0) LOG_INFO("Timestep %d: Wait for prefetch.\n", ts); - fflush(stdout); - } // wait for read to finish before reading next timestep for (i = 0; i < n_var; i++) { ret = PDC_Client_wait(&request[ts][i], 90000, 100); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_wait!\n"); + LOG_ERROR("Error with PDC_Client_wait\n"); goto done; } } @@ -274,10 +267,8 @@ main(int argc, char **argv) wait_time = PDC_get_elapsed_time_double(&pdc_timer_start_1, &pdc_timer_end_1); wait_time_total += wait_time; - if (rank == 0) { + if (rank == 0) LOG_INFO("Timestep %d: prefetch finished.\n", ts); - fflush(stdout); - } } /* @@ -293,7 +284,7 @@ main(int argc, char **argv) ret = PDC_Client_iread(obj_metas[ts + 1][i], &obj_regions[ts + 1][i], &request[ts + 1][i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iread!\n"); + LOG_ERROR("Error with PDC_Client_iread\n"); goto done; } } // end of for @@ -313,10 +304,8 @@ main(int argc, char **argv) if (true_sleep_time < 0) true_sleep_time = 0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Compute for %d seconds.\n", (int)(true_sleep_time)); - fflush(stdout); - } // Sleep to fake compute time PDC_msleep((unsigned long)(true_sleep_time * 1000)); @@ -336,13 +325,11 @@ main(int argc, char **argv) gettimeofday(&pdc_timer_end, 0); total_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); total_size = n_particles * selectivity * 4.0 * 8 * size / 1024.0 / 1024.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("read %d ts each of %.0fMB data with %d ranks: total %.2f\n" "query %.2f, read %.2f, wait %.2f, compute %.2f\n", n_ts, total_size, size, total_time, query_time_total, read_time_total, wait_time_total, compute_total); - fflush(stdout); - } // Free allocated space for (i = 0; i < n_var; i++) { diff --git a/src/tests/data_server/data_server_write.c b/src/tests/data_server/data_server_write.c index aa26d0ab9..1459edf39 100644 --- a/src/tests/data_server/data_server_write.c +++ b/src/tests/data_server/data_server_write.c @@ -96,7 +96,7 @@ main(int argc, char **argv) // Query the created object PDC_Client_query_metadata_name_timestep(obj_name, 0, &metadata); if (metadata == NULL || metadata->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); } region.ndim = ndim; @@ -123,10 +123,8 @@ main(int argc, char **argv) ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to write data with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } // close a container if (PDCcont_close(cont) < 0) diff --git a/src/tests/data_server/data_server_write_multi.c b/src/tests/data_server/data_server_write_multi.c index c796534d2..b5c597ea5 100644 --- a/src/tests/data_server/data_server_write_multi.c +++ b/src/tests/data_server/data_server_write_multi.c @@ -122,7 +122,6 @@ main(int argc, char **argv) // Create a object with only rank 0 if (rank == 0) { LOG_INFO("Creating an object with name [%s], timestep %u\n", obj_name, ts); - /* fflush(stdout); */ test_obj = PDCobj_create(cont, obj_name, obj_prop); if (test_obj <= 0) { LOG_ERROR("Error getting an object id of %s from server, exit...\n", "DataServerTestBin"); @@ -136,11 +135,11 @@ main(int argc, char **argv) // Query the created object if (rank == 0) - LOG_INFO("%d: Start to query object just created ...", rank); + LOG_INFO("%d: Start to query object just created...", rank); PDC_Client_query_metadata_name_timestep_agg(obj_name, ts, &metadata); if (metadata == NULL || metadata->obj_id == 0) { - LOG_ERROR("[%d]: Error with metadata!\n", rank); + LOG_ERROR("[%d]: Error with metadata\n", rank); exit(-1); } #ifdef ENABLE_MPI @@ -154,10 +153,8 @@ main(int argc, char **argv) (meta_end.tv_sec - meta_start.tv_sec) * 1000000LL + meta_end.tv_usec - meta_start.tv_usec; total_meta_sec += meta_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Sleep %.2f seconds.\n", sleepseconds); - fflush(stdout); - } // Fake computation usleep(microseconds); @@ -167,7 +164,7 @@ main(int argc, char **argv) // Wait for previous write completion before writting current timestep ret_value = PDC_Client_wait(&request, 60000, 100); if (ret_value != SUCCEED) { - LOG_INFO("==PDC_CLIENT: PDC_Client_write - PDC_Client_wait error\n"); + LOG_INFO("PDC_Client_write - PDC_Client_wait error\n"); goto done; } @@ -183,14 +180,13 @@ main(int argc, char **argv) total_wait_sec += wait_elapsed / 1000000.0; LOG_INFO("Timestep %d written, metadata %.2f s, wait %.2f s.\n", ts, meta_elapsed / 1000000.0, wait_elapsed / 1000000.0); - fflush(stdout); } } // (pdc_metadata_t *meta, struct PDC_region_info *region, PDC_Request_t *request, void *buf) ret_value = PDC_Client_iwrite(metadata, ®ion, &request, mydata); if (ret_value != SUCCEED) { - LOG_ERROR("[%d] Error with PDC_Client_iwrite!\n", rank); + LOG_ERROR("[%d] Error with PDC_Client_iwrite\n", rank); goto done; } @@ -205,13 +201,11 @@ main(int argc, char **argv) total_elapsed = (total_end.tv_sec - total_start.tv_sec) * 1000000LL + total_end.tv_usec - total_start.tv_usec; - if (rank == 0) { + if (rank == 0) LOG_INFO( "Total time write %d ts data each %luMB with %d ranks: %.5e, meta %.2f, wait %.2f, sleep %.2f\n", ntimestep, size_MB, size, total_elapsed / 1000000.0, total_meta_sec, total_wait_sec, sleepseconds * ntimestep); - fflush(stdout); - } done: // close a container diff --git a/src/tests/data_server/data_server_write_vpic.c b/src/tests/data_server/data_server_write_vpic.c index 3dc142952..719c4caca 100644 --- a/src/tests/data_server/data_server_write_vpic.c +++ b/src/tests/data_server/data_server_write_vpic.c @@ -61,8 +61,7 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #else - LOG_INFO("MPI NOT Enabled!\n"); - fflush(stdout); + LOG_INFO("MPI NOT Enabled\n"); #endif char *obj_names[] = {"x", "y", "z", "px", "py", "pz", "id1", "id2"}; @@ -181,7 +180,7 @@ main(int argc, char **argv) ret = PDC_Client_query_metadata_name_timestep(obj_names[i], 0, &obj_metas[i]); #endif if (ret != SUCCEED || obj_metas[i] == NULL || obj_metas[i]->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); exit(-1); } } @@ -215,7 +214,7 @@ main(int argc, char **argv) request[i].n_update = write_var; ret = PDC_Client_iwrite(obj_metas[i], &obj_regions[i], &request[i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iwrite!\n"); + LOG_ERROR("Error with PDC_Client_iwrite\n"); goto done; } @@ -232,7 +231,7 @@ main(int argc, char **argv) for (i = 0; i < write_var; i++) { ret = PDC_Client_wait(&request[i], 200000, 500); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_wait!\n"); + LOG_ERROR("Error with PDC_Client_wait\n"); goto done; } } @@ -251,7 +250,6 @@ main(int argc, char **argv) LOG_INFO("Write %f MB data with %d ranks\nTotal write time: %.2f\nSent %.2f, wait %.2f, Throughput " "%.2f MB/s\n", total_size, size, write_time, sent_time_total, wait_time_total, total_size / write_time); - fflush(stdout); } done: diff --git a/src/tests/data_server/data_server_write_vpic_multits.c b/src/tests/data_server/data_server_write_vpic_multits.c index 025095641..a4405751d 100644 --- a/src/tests/data_server/data_server_write_vpic_multits.c +++ b/src/tests/data_server/data_server_write_vpic_multits.c @@ -130,11 +130,9 @@ main(int argc, char **argv) if (sleep_time < 0) sleep_time = 15; - if (rank == 0) { + if (rank == 0) LOG_INFO("Write %d variables, each %dMB per proc, %d timesteps, %.1f compute time\n", n_var, size_per_proc_var_MB, n_ts, sleep_time); - fflush(stdout); - } // create a pdc pdc_id = PDCinit("pdc"); @@ -212,10 +210,8 @@ main(int argc, char **argv) true_sleep_time = sleep_time - gen_time; } - if (rank == 0) { + if (rank == 0) LOG_INFO("Compute for %.2f seconds\n", gen_time + true_sleep_time); - } - fflush(stdout); // Sleep to fake compute time PDC_msleep((unsigned long)(true_sleep_time * 1000)); @@ -225,10 +221,8 @@ main(int argc, char **argv) MPI_Barrier(MPI_COMM_WORLD); #endif - if (rank == 0) { + if (rank == 0) LOG_INFO("Compute done\n"); - fflush(stdout); - } gettimeofday(&pdc_timer_start_1, 0); // Create obj and region one by one @@ -271,10 +265,8 @@ main(int argc, char **argv) create_time = PDC_get_elapsed_time_double(&pdc_timer_start_1, &pdc_timer_end_1); create_time_total += create_time; - if (rank == 0) { + if (rank == 0) LOG_INFO("%d: start querying objects\n", rank); - fflush(stdout); - } for (i = 0; i < n_var; i++) { ret = PDC_Client_query_metadata_name_timestep_agg(obj_names[i], ts, &obj_metas[ts][i]); @@ -291,10 +283,8 @@ main(int argc, char **argv) #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - if (rank == 0) { + if (rank == 0) LOG_INFO("%d: querying done\n", rank); - fflush(stdout); - } // Wait for the previous request to finish if (ts > 0 && ts != n_ts - 1) { @@ -304,7 +294,7 @@ main(int argc, char **argv) for (i = 0; i < n_var; i++) { ret = PDC_Client_wait(&request[ts - 1][i], 30000, 100); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_wait!\n"); + LOG_ERROR("Error with PDC_Client_wait\n"); goto done; } } @@ -318,7 +308,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Timestep %d: start to write.\n", ts); - fflush(stdout); // Last ts is sync IO if (ts != n_ts - 1) { @@ -332,7 +321,7 @@ main(int argc, char **argv) request[ts][i].n_update = n_var; ret = PDC_Client_iwrite(obj_metas[ts][i], &obj_regions[ts][i], &request[ts][i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iwrite!\n"); + LOG_ERROR("Error with PDC_Client_iwrite\n"); goto done; } } // end of for @@ -360,7 +349,7 @@ main(int argc, char **argv) for (i = 0; i < n_var; i++) { ret = PDC_Client_write(obj_metas[n_ts - 1][i], &obj_regions[n_ts - 1][i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iwrite!\n"); + LOG_ERROR("Error with PDC_Client_iwrite\n"); goto done; } } // end of for @@ -385,7 +374,6 @@ main(int argc, char **argv) "create %.2f, query %.2f, write %.2f, wait %.2f, compute %.2f\n", n_ts, total_size, size, total_time, create_time_total, query_time_total, write_time_total, wait_time_total, compute_total); - fflush(stdout); } // Free allocated space diff --git a/src/tests/deprecated/bdcats_v2.c b/src/tests/deprecated/bdcats_v2.c index e945cdeaf..02e80c709 100644 --- a/src/tests/deprecated/bdcats_v2.c +++ b/src/tests/deprecated/bdcats_v2.c @@ -225,10 +225,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to map with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -274,10 +272,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to lock with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -323,10 +319,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to relese lock with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -371,10 +365,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to read data with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } if (PDCobj_close(obj_xx) < 0) LOG_ERROR("Failed to close obj_xx\n"); diff --git a/src/tests/deprecated/blocked_lock.c b/src/tests/deprecated/blocked_lock.c index d821b088f..3d1381471 100644 --- a/src/tests/deprecated/blocked_lock.c +++ b/src/tests/deprecated/blocked_lock.c @@ -103,8 +103,7 @@ main(int argc, char **argv) mysize[0] = numparticles; // create a region - r1 = PDCregion_create(1, offset, mysize); - // LOG_ERROR("First region id: %lld\n", r1); + r1 = PDCregion_create(1, offset, mysize); r2 = PDCregion_create(1, offset_remote, mysize); ret = PDCbuf_obj_map(&x[0], PDC_FLOAT, r1, obj2, r2); if (ret < 0) { @@ -122,7 +121,6 @@ main(int argc, char **argv) for (int i = 0; i < numparticles; i++) { x[i] = uniform_random_number() * x_dim; - // fflush(stdout); } ret = PDCreg_release_lock(obj2, r2, WRITE); @@ -131,20 +129,15 @@ main(int argc, char **argv) MPI_Barrier(MPI_COMM_WORLD); LOG_INFO("done with region release\n"); - fflush(stdout); - if (rank == 0) { + if (rank == 0) LOG_INFO("request another lock\n"); - fflush(stdout); - } ret = PDCreg_obtain_lock(obj2, r2, WRITE, BLOCK); if (ret != SUCCEED) LOG_ERROR("Failed to obtain lock for r2\n"); - if (rank == 0) { + if (rank == 0) LOG_INFO("lock is granted\n"); - fflush(stdout); - } ret = PDCbuf_obj_unmap(obj2, r2); if (ret != SUCCEED) diff --git a/src/tests/deprecated/obj_transformation.c b/src/tests/deprecated/obj_transformation.c index d6f8b2791..ebba0f16d 100644 --- a/src/tests/deprecated/obj_transformation.c +++ b/src/tests/deprecated/obj_transformation.c @@ -271,10 +271,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to map with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -320,10 +318,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to lock with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } for (i = 0; i < numparticles; i++) { id1[i] = i; @@ -383,10 +379,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to update data with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif diff --git a/src/tests/deprecated/region_obj_map.c b/src/tests/deprecated/region_obj_map.c index 1f0ab783c..952e8f455 100644 --- a/src/tests/deprecated/region_obj_map.c +++ b/src/tests/deprecated/region_obj_map.c @@ -76,7 +76,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -86,7 +86,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -95,7 +95,7 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } @@ -118,7 +118,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object diff --git a/src/tests/deprecated/region_obj_map_3D.c b/src/tests/deprecated/region_obj_map_3D.c index 24d0a2fa4..6dd819f11 100644 --- a/src/tests/deprecated/region_obj_map_3D.c +++ b/src/tests/deprecated/region_obj_map_3D.c @@ -198,7 +198,7 @@ main(int argc, char **argv) ret = PDCreg_obtain_lock(obj1, reg_global, PDC_READ, PDC_BLOCK); if (ret != SUCCEED) { - priLOG_ERRORntf("PDCreg_obtain_lock failed\n"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); ret_value = 1; } diff --git a/src/tests/deprecated/region_obj_map_merge.c b/src/tests/deprecated/region_obj_map_merge.c index 308c26fb9..6de785c94 100644 --- a/src/tests/deprecated/region_obj_map_merge.c +++ b/src/tests/deprecated/region_obj_map_merge.c @@ -73,35 +73,35 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_buf(obj_prop, obj_data); @@ -115,20 +115,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -142,34 +142,34 @@ main(int argc, char **argv) } ret = PDCbuf_obj_map(data, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 2; @@ -178,40 +178,40 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data + offset[0], PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -225,97 +225,97 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data_read, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_READ, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); ret_value = 1; } ret = PDCreg_release_lock(obj1, reg_global, PDC_READ); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } for (i = 0; i < BUF_LEN; ++i) { if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d!\n", data_read[i], i); + LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); ret_value = 1; break; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); free(obj_data); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/deprecated/region_obj_map_overlap.c b/src/tests/deprecated/region_obj_map_overlap.c index 98391ef11..9cac4eab8 100644 --- a/src/tests/deprecated/region_obj_map_overlap.c +++ b/src/tests/deprecated/region_obj_map_overlap.c @@ -73,35 +73,35 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_buf(obj_prop, obj_data); @@ -115,20 +115,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -142,34 +142,34 @@ main(int argc, char **argv) } ret = PDCbuf_obj_map(data, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 2; @@ -178,40 +178,40 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data + offset[0], PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -225,50 +225,50 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data_read, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_READ, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); ret_value = 1; } ret = PDCreg_release_lock(obj1, reg_global, PDC_READ); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i + BUF_LEN / 4) { - LOG_ERROR("wrong value %d!=%d!\n", data_read[i], i + BUF_LEN / 4); + LOG_ERROR("wrong value %d!=%d\n", data_read[i], i + BUF_LEN / 4); ret_value = 1; break; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Write the same object again. This time we test writing a region contained in the previously written @@ -285,42 +285,42 @@ main(int argc, char **argv) } ret = PDCbuf_obj_map(data + BUF_LEN / 8, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Read the whole object for checking purpose offset[0] = BUF_LEN / 8; @@ -334,96 +334,96 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data_read, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_READ, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); ret_value = 1; } ret = PDCreg_release_lock(obj1, reg_global, PDC_READ); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i + BUF_LEN / 8 + BUF_LEN) { - LOG_ERROR("wrong value %d!=%d!\n", data_read[i], i + BUF_LEN / 8 + BUF_LEN); + LOG_ERROR("wrong value %d!=%d\n", data_read[i], i + BUF_LEN / 8 + BUF_LEN); ret_value = 1; break; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); free(obj_data); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/deprecated/region_obj_map_overlap_2D.c b/src/tests/deprecated/region_obj_map_overlap_2D.c index cef21ed67..b569a6736 100644 --- a/src/tests/deprecated/region_obj_map_overlap_2D.c +++ b/src/tests/deprecated/region_obj_map_overlap_2D.c @@ -74,35 +74,35 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_buf(obj_prop, obj_data); @@ -116,20 +116,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -145,34 +145,34 @@ main(int argc, char **argv) } ret = PDCbuf_obj_map(data, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 8; @@ -183,40 +183,40 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data + BUF_LEN / 2, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -234,31 +234,31 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data_read, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_READ, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); ret_value = 1; } ret = PDCreg_release_lock(obj1, reg_global, PDC_READ); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i + BUF_LEN / 4) { - LOG_ERROR("i = %d, wrong value %d!=%d!\n", i, data_read[i], i + BUF_LEN / 4); + LOG_ERROR("i = %d, wrong value %d!=%d\n", i, data_read[i], i + BUF_LEN / 4); ret_value = 1; break; } @@ -268,19 +268,19 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Partial write for a region that has been written before offset[0] = 0; @@ -300,40 +300,40 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data + BUF_LEN / 8, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_WRITE, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); exit(-1); } ret = PDCreg_release_lock(obj1, reg_global, PDC_WRITE); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local regio\nn"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 32; @@ -351,31 +351,31 @@ main(int argc, char **argv) ret = PDCbuf_obj_map(data_read, PDC_INT, reg, obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_map failed"); + LOG_ERROR("PDCbuf_obj_map failed\n"); ret_value = 1; } ret = PDCreg_obtain_lock(obj1, reg_global, PDC_READ, PDC_BLOCK); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_obtain_lock failed"); + LOG_ERROR("PDCreg_obtain_lock failed\n"); ret_value = 1; } ret = PDCreg_release_lock(obj1, reg_global, PDC_READ); if (ret != SUCCEED) { - LOG_ERROR("PDCreg_release_lock failed"); + LOG_ERROR("PDCreg_release_lock failed\n"); ret_value = 1; } ret = PDCbuf_obj_unmap(obj1, reg_global); if (ret != SUCCEED) { - LOG_ERROR("PDCbuf_obj_unmap failed"); + LOG_ERROR("PDCbuf_obj_unmap failed\n"); ret_value = 1; } for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i + BUF_LEN + BUF_LEN / 8) { - LOG_ERROR("i = %d, wrong value %d!=%d!\n", i, data_read[i], i + BUF_LEN + BUF_LEN / 8); + LOG_ERROR("i = %d, wrong value %d!=%d\n", i, data_read[i], i + BUF_LEN + BUF_LEN / 8); ret_value = 1; break; } @@ -385,65 +385,65 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); free(obj_data); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/deprecated/region_obj_map_partial.c b/src/tests/deprecated/region_obj_map_partial.c index 401322fcb..70f039e20 100644 --- a/src/tests/deprecated/region_obj_map_partial.c +++ b/src/tests/deprecated/region_obj_map_partial.c @@ -75,7 +75,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -85,7 +85,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -94,13 +94,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_buf(obj_prop, obj_data); @@ -117,7 +117,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object @@ -127,7 +127,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -269,7 +269,7 @@ main(int argc, char **argv) } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { diff --git a/src/tests/deprecated/vpicio_v2.c b/src/tests/deprecated/vpicio_v2.c index ff0347fbc..d540a881f 100644 --- a/src/tests/deprecated/vpicio_v2.c +++ b/src/tests/deprecated/vpicio_v2.c @@ -298,10 +298,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to map with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -347,10 +345,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to lock with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } for (i = 0; i < numparticles; i++) { id1[i] = i; @@ -407,10 +403,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to update data with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); diff --git a/src/tests/helper/julia_helper_loader.c b/src/tests/helper/julia_helper_loader.c index 56d255688..3634897f4 100644 --- a/src/tests/helper/julia_helper_loader.c +++ b/src/tests/helper/julia_helper_loader.c @@ -8,13 +8,13 @@ jl_load_module(const char *mod_name) const char *julia_module_dir = getenv("PDC_JULIA_MODULE_DIR"); if (julia_module_dir == NULL || strlen(julia_module_dir) == 0) { // try to get it from PWD - LOG_WARNING("[PDC_JL_HELPER] Warning: PDC_JULIA_MODULE_DIR is not set, fallback to PWD!\n"); + LOG_WARNING("[PDC_JL_HELPER] Warning: PDC_JULIA_MODULE_DIR is not set, fallback to PWD\n"); julia_module_dir = getenv("PWD"); } if (julia_module_dir == NULL || strlen(julia_module_dir) == 0) { // No way to find julia module directory - LOG_ERROR("[PDC_JL_HELPER] Error: Not able to find Julia module directory!\n"); + LOG_ERROR("[PDC_JL_HELPER] Error: Not able to find Julia module directory\n"); exit(-1); } LOG_INFO("[PDC_JL_HELPER] Julia module directory: %s\n", julia_module_dir); diff --git a/src/tests/include/test_helper.h b/src/tests/include/test_helper.h new file mode 100644 index 000000000..da7883e8d --- /dev/null +++ b/src/tests/include/test_helper.h @@ -0,0 +1,68 @@ +#ifndef TEST_HELPER_H +#define TEST_HELPER_H + +#include "pdc.h" + +#define TSUCCEED 0 +#define TFAIL 1 + +/* + * TGOTO_DONE macro. The argument is the return value which is + * assigned to the `ret_value' variable. Control branches to + * the `done' label. + */ +#define TGOTO_DONE(ret_val) \ + do { \ + ret_value = ret_val; \ + goto done; \ + } while (0) + +#define TGOTO_DONE_VOID \ + do { \ + goto done; \ + } while (0) + +/* + * TGOTO_ERROR macro. The arguments are the return value and an + * error string. The return value is assigned to a variable `ret_value' and + * control branches to the `done' label. + */ +#define TGOTO_ERROR(ret_val, ...) \ + do { \ + LOG_ERROR(__VA_ARGS__); \ + LOG_JUST_PRINT("\n"); \ + TGOTO_DONE(ret_val); \ + } while (0) + +#define TGOTO_ERROR_VOID(...) \ + do { \ + LOG_ERROR(__VA_ARGS__); \ + LOG_JUST_PRINT("\n"); \ + TGOTO_DONE_VOID; \ + } while (0) + +#ifdef ENABLE_MPI +#define TASSERT(status, success_message, fail_message) \ + do { \ + if (!(status)) { \ + TGOTO_ERROR(TFAIL, "%s", fail_message); \ + } \ + else { \ + LOG_INFO("%s\n", success_message); \ + } \ + } while (0) + +#else + +#define TASSERT(status, success_message, fail_message) \ + do { \ + if (!(status)) { \ + TGOTO_ERROR(TFAIL, "%s", fail_message); \ + } \ + else { \ + LOG_INFO("%s\n", success_message); \ + } \ + } while (0) +#endif + +#endif \ No newline at end of file diff --git a/src/tests/misc/bdcats.c b/src/tests/misc/bdcats.c index 228aa1b2e..3f9e814b6 100644 --- a/src/tests/misc/bdcats.c +++ b/src/tests/misc/bdcats.c @@ -32,6 +32,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" #define NPARTICLES 8388608 @@ -55,7 +56,7 @@ main(int argc, char **argv) pdcid_t obj_xx, obj_yy, obj_zz, obj_pxx, obj_pyy, obj_pzz, obj_id11, obj_id22; pdcid_t region_x, region_y, region_z, region_px, region_py, region_pz, region_id1, region_id2; pdcid_t region_xx, region_yy, region_zz, region_pxx, region_pyy, region_pzz, region_id11, region_id22; - perr_t ret; + int ret_value = TSUCCEED; float * x, *y, *z; float * px, *py, *pz; @@ -94,54 +95,27 @@ main(int argc, char **argv) id2 = (int *)malloc(numparticles * sizeof(int)); // create a pdc - pdc_id = PDCinit("pdc"); - + TASSERT((pdc_id = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // open a container - cont_id = PDCcont_open("c1", pdc_id); - if (cont_id == 0) - LOG_ERROR("Failed to create container"); - + TASSERT((cont_id = PDCcont_open("c1", pdc_id)) > 0, "Call to PDCcont_open succeeded", + "Call to PDCcont_open failed"); // open objects - obj_xx = PDCobj_open("obj-var-xx", pdc_id); - if (obj_xx == 0) { - LOG_ERROR("Error when open object %s\n", "obj-var-xx"); - exit(-1); - } - obj_yy = PDCobj_open("obj-var-yy", pdc_id); - if (obj_yy == 0) { - LOG_ERROR("Error when open object %s\n", "obj-var-yy"); - exit(-1); - } - obj_zz = PDCobj_open("obj-var-zz", pdc_id); - if (obj_zz == 0) { - LOG_ERROR("Error when open object %s\n", "obj-var-zz"); - exit(-1); - } - obj_pxx = PDCobj_open("obj-var-pxx", pdc_id); - if (obj_pxx == 0) { - LOG_ERROR("Error when open object %s\n", "obj-var-pxx"); - exit(-1); - } - obj_pyy = PDCobj_open("obj-var-pyy", pdc_id); - if (obj_pyy == 0) { - LOG_ERROR("Error when open object %s\n", "obj-var-pyy"); - exit(-1); - } - obj_pzz = PDCobj_open("obj-var-pzz", pdc_id); - if (obj_pzz == 0) { - LOG_ERROR("Error when open object %s\n", "obj-var-pzz"); - exit(-1); - } - obj_id11 = PDCobj_open("id11", pdc_id); - if (obj_id11 == 0) { - LOG_ERROR("Error when open object %s\n", "id11"); - exit(-1); - } - obj_id22 = PDCobj_open("id22", pdc_id); - if (obj_id22 == 0) { - LOG_ERROR("Error when open object %s\n", "id22"); - exit(-1); - } + TASSERT((obj_xx = PDCobj_open("obj-var-xx", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_yy = PDCobj_open("obj-var-yy", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_zz = PDCobj_open("obj-var-zz", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_pxx = PDCobj_open("obj-var-pxx", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_pyy = PDCobj_open("obj-var-pyy", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_pzz = PDCobj_open("obj-var-pyy", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_id11 = PDCobj_open("obj-var-pyy", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((obj_id22 = PDCobj_open("id22", pdc_id)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); offset = (uint64_t *)malloc(sizeof(uint64_t) * ndim); offset_remote = (uint64_t *)malloc(sizeof(uint64_t) * ndim); @@ -150,275 +124,170 @@ main(int argc, char **argv) offset_remote[0] = rank * numparticles; mysize[0] = numparticles; - // create a region - region_x = PDCregion_create(ndim, offset, mysize); - region_y = PDCregion_create(ndim, offset, mysize); - region_z = PDCregion_create(ndim, offset, mysize); - region_px = PDCregion_create(ndim, offset, mysize); - region_py = PDCregion_create(ndim, offset, mysize); - region_pz = PDCregion_create(ndim, offset, mysize); - region_id1 = PDCregion_create(ndim, offset, mysize); - region_id2 = PDCregion_create(ndim, offset, mysize); - - region_xx = PDCregion_create(ndim, offset_remote, mysize); - region_yy = PDCregion_create(ndim, offset_remote, mysize); - region_zz = PDCregion_create(ndim, offset_remote, mysize); - region_pxx = PDCregion_create(ndim, offset_remote, mysize); - region_pyy = PDCregion_create(ndim, offset_remote, mysize); - region_pzz = PDCregion_create(ndim, offset_remote, mysize); - region_id11 = PDCregion_create(ndim, offset_remote, mysize); - region_id22 = PDCregion_create(ndim, offset_remote, mysize); + // create regions + TASSERT((region_x = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_y = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_z = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_px = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_py = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pz = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id1 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id2 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + + TASSERT((region_xx = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_yy = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_zz = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pxx = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pyy = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pzz = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id11 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id22 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - transfer_request_x = PDCregion_transfer_create(&x[0], PDC_READ, obj_xx, region_x, region_xx); - if (transfer_request_x == 0) { - LOG_ERROR("Array x transfer request creation failed\n"); - return 1; - } - - transfer_request_y = PDCregion_transfer_create(&y[0], PDC_READ, obj_yy, region_y, region_yy); - if (transfer_request_y == 0) { - LOG_ERROR("Array y transfer request creation failed\n"); - return 1; - } - transfer_request_z = PDCregion_transfer_create(&z[0], PDC_READ, obj_zz, region_z, region_zz); - if (transfer_request_z == 0) { - LOG_ERROR("Array z transfer request creation failed\n"); - return 1; - } - transfer_request_px = PDCregion_transfer_create(&px[0], PDC_READ, obj_pxx, region_px, region_pxx); - if (transfer_request_px == 0) { - LOG_ERROR("Array px transfer request creation failed\n"); - return 1; - } - transfer_request_py = PDCregion_transfer_create(&py[0], PDC_READ, obj_pyy, region_py, region_pyy); - if (transfer_request_py == 0) { - LOG_ERROR("Array py transfer request creation failed\n"); - return 1; - } - transfer_request_pz = PDCregion_transfer_create(&pz[0], PDC_READ, obj_pzz, region_pz, region_pzz); - if (transfer_request_pz == 0) { - LOG_ERROR("Array pz transfer request creation failed\n"); - return 1; - } - transfer_request_id1 = PDCregion_transfer_create(&id1[0], PDC_READ, obj_id11, region_id1, region_id11); - if (transfer_request_id1 == 0) { - LOG_ERROR("Array id1 transfer request creation failed\n"); - return 1; - } - transfer_request_id2 = PDCregion_transfer_create(&id2[0], PDC_READ, obj_id22, region_id2, region_id22); - if (transfer_request_id2 == 0) { - LOG_ERROR("Array id2 transfer request creation failed\n"); - return 1; - } - - ret = PDCregion_transfer_start(transfer_request_x); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_xx\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_y); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_yy\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_z); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_zz\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_px); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_pxx\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_py); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_pyy\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_pz); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_pzz\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_id1); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_id11\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_id2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to start transfer for region_id22\n"); - return 1; - } - - ret = PDCregion_transfer_wait(transfer_request_x); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_xx\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_y); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_yy\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_z); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_zz\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_px); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_pxx\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_py); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_pyy\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_pz); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_pzz\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_id1); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_id11\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_id2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to transfer wait for region_id22\n"); - return 1; - } - - ret = PDCregion_transfer_close(transfer_request_x); - if (ret != SUCCEED) { - LOG_ERROR("region xx transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_y); - if (ret != SUCCEED) { - LOG_ERROR("region yy transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_z); - if (ret != SUCCEED) { - LOG_ERROR("region zz transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_px); - if (ret != SUCCEED) { - LOG_ERROR("region pxx transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_py); - if (ret != SUCCEED) { - LOG_ERROR("region pyy transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_pz); - if (ret != SUCCEED) { - LOG_ERROR("region pzz transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_id1); - if (ret != SUCCEED) { - LOG_ERROR("region id11 transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_id2); - if (ret != SUCCEED) { - LOG_ERROR("region id22 transfer close failed\n"); - return 1; - } + TASSERT((transfer_request_x = PDCregion_transfer_create(&x[0], PDC_READ, obj_xx, region_x, region_xx)) != + 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_y = PDCregion_transfer_create(&y[0], PDC_READ, obj_yy, region_y, region_yy)) != + 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_z = PDCregion_transfer_create(&z[0], PDC_READ, obj_zz, region_z, region_zz)) != + 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_px = + PDCregion_transfer_create(&px[0], PDC_READ, obj_pxx, region_px, region_pxx)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_py = + PDCregion_transfer_create(&py[0], PDC_READ, obj_pyy, region_py, region_pyy)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_pz = + PDCregion_transfer_create(&pz[0], PDC_READ, obj_pzz, region_pz, region_pzz)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_id1 = + PDCregion_transfer_create(&id1[0], PDC_READ, obj_id11, region_id1, region_id11)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_id2 = + PDCregion_transfer_create(&id2[0], PDC_READ, obj_id22, region_id2, region_id22)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + + TASSERT(PDCregion_transfer_start(transfer_request_x) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_y) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_z) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_px) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_py) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_pz) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_id1) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_id2) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCregion_transfer_wait(transfer_request_x) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_y) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_z) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_px) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_py) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_pz) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_id1) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_id2) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCregion_transfer_close(transfer_request_x) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_y) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_z) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_px) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_py) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_pz) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_id1) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_id2) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); PDC_timing_report("read"); - if (PDCobj_close(obj_xx) < 0) - LOG_ERROR("Failed to close obj_xx\n"); - - if (PDCobj_close(obj_yy) < 0) - LOG_ERROR("Failed to close object obj_yy\n"); - - if (PDCobj_close(obj_zz) < 0) - LOG_ERROR("Failed to close object obj_zz\n"); - - if (PDCobj_close(obj_pxx) < 0) - LOG_ERROR("Failed to close object obj_pxx\n"); - - if (PDCobj_close(obj_pyy) < 0) - LOG_ERROR("Failed to close object obj_pyy\n"); - - if (PDCobj_close(obj_pzz) < 0) - LOG_ERROR("Failed to close object obj_pzz\n"); - - if (PDCobj_close(obj_id11) < 0) - LOG_ERROR("Failed to close object obj_id11\n"); - - if (PDCobj_close(obj_id22) < 0) - LOG_ERROR("Failed to close object obj_id22\n"); - - if (PDCregion_close(region_x) < 0) - LOG_ERROR("Failed to close region region_x\n"); - - if (PDCregion_close(region_y) < 0) - LOG_ERROR("Failed to close region region_y\n"); - - if (PDCregion_close(region_z) < 0) - LOG_ERROR("Failed to close region region_z\n"); - - if (PDCregion_close(region_px) < 0) - LOG_ERROR("Failed to close region region_px\n"); - - if (PDCregion_close(region_py) < 0) - LOG_ERROR("Failed to close region region_py\n"); - - if (PDCobj_close(region_pz) < 0) - LOG_ERROR("Failed to close region region_pz\n"); - - if (PDCobj_close(region_id1) < 0) - LOG_ERROR("Failed to close region region_id1\n"); - - if (PDCobj_close(region_id2) < 0) - LOG_ERROR("Failed to close region region_id2\n"); - - if (PDCregion_close(region_xx) < 0) - LOG_ERROR("Failed to close region region_xx\n"); - - if (PDCregion_close(region_yy) < 0) - LOG_ERROR("Failed to close region region_yy\n"); - - if (PDCregion_close(region_zz) < 0) - LOG_ERROR("Failed to close region region_zz\n"); - - if (PDCregion_close(region_pxx) < 0) - LOG_ERROR("Failed to close region region_pxx\n"); - - if (PDCregion_close(region_pyy) < 0) - LOG_ERROR("Failed to close region region_pyy\n"); - - if (PDCregion_close(region_pzz) < 0) - LOG_ERROR("Failed to close region region_pzz\n"); - - if (PDCobj_close(region_id11) < 0) - LOG_ERROR("Failed to close region region_id11\n"); - - if (PDCobj_close(region_id22) < 0) - LOG_ERROR("Failed to close region region_id22\n"); - + TASSERT(PDCobj_close(obj_xx) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_yy) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_zz) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_pxx) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_pyy) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_pzz) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_id11) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_id22) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCregion_close(region_x) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_y) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_z) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_px) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_py) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pz) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id1) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id2) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_xx) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_yy) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_zz) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pxx) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pyy) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pzz) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id11) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id22) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close a container - if (PDCcont_close(cont_id) < 0) - LOG_ERROR("Failed to close container c1\n"); - - if (PDCclose(pdc_id) < 0) - LOG_ERROR("Failed to close PDC\n"); + TASSERT(PDCcont_close(cont_id) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCclose(pdc_id) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(offset); + free(offset_remote); + free(mysize); free(x); free(y); free(z); @@ -427,13 +296,11 @@ main(int argc, char **argv) free(pz); free(id1); free(id2); - free(offset); - free(offset_remote); - free(mysize); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/misc/client_server.c b/src/tests/misc/client_server.c index a510d004b..a4efe8ac1 100644 --- a/src/tests/misc/client_server.c +++ b/src/tests/misc/client_server.c @@ -102,7 +102,7 @@ client_lookup_cb(const struct hg_cb_info *callback_info) hg_ret = HG_Forward(handle, client_rpc_cb, client_lookup_args, &in); if (hg_ret != HG_SUCCESS) { - LOG_ERROR("client_lookup_cb(): Could not start HG_Forward()\n"); + LOG_ERROR("Could not start HG_Forward()\n"); return EXIT_FAILURE; } return HG_SUCCESS; diff --git a/src/tests/misc/consistency_semantics.c b/src/tests/misc/consistency_semantics.c index 9f0583d1c..c0db6bbc7 100644 --- a/src/tests/misc/consistency_semantics.c +++ b/src/tests/misc/consistency_semantics.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -58,197 +60,118 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + // create a pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 2, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "consistency_semantics_test"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); - PDCprop_set_obj_consistency_semantics(obj_prop, PDC_CONSISTENCY_POSIX); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "consistency_semantics_test") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); + TASSERT(PDCprop_set_obj_consistency_semantics(obj_prop, PDC_CONSISTENCY_POSIX) >= 0, + "Call to PDCprop_set_obj_consistency_semantics succeeded", + "Call to PDCprop_set_obj_consistency_semantics failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = BUF_LEN / 4; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); // When use POSIX consistency, we do not need to explicitly call wait() // PDCregion_transfer_wait(transfer_request); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = BUF_LEN / 4; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); // When use POSIX consistency, we do not need to explicitly call wait() // PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[i], i); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/misc/data_rw_test.c b/src/tests/misc/data_rw_test.c index e79517170..ae264c1b4 100644 --- a/src/tests/misc/data_rw_test.c +++ b/src/tests/misc/data_rw_test.c @@ -163,7 +163,7 @@ test1d(char *obj_name) // Query the created object PDC_Client_query_metadata_name_timestep(obj_name, 0, &metadata); if (metadata == NULL) { - LOG_ERROR("Error getting metadata from server!\n"); + LOG_ERROR("Error getting metadata from server\n"); exit(-1); } @@ -232,7 +232,7 @@ test1d(char *obj_name) is_correct = data_verify(ndim, data_start, read_region.size, read_data, data_offset_real, data); if (is_correct != 1) - LOG_ERROR("proc %d: verification failed!\n", rank); + LOG_ERROR("proc %d: verification failed\n", rank); is_all_correct = is_correct; #ifdef ENABLE_MPI @@ -241,11 +241,11 @@ test1d(char *obj_name) #endif if (rank == 0) { - LOG_INFO("1D data verfication ..."); + LOG_INFO("1D data verfication..."); if (is_all_correct != size) - LOG_ERROR("FAILED!\n"); + LOG_ERROR("FAILED\n"); else - LOG_INFO("succeED!\n"); + LOG_INFO("succeED\n"); } free(data); @@ -287,7 +287,7 @@ test2d(char *obj_name) // Query the created object PDC_Client_query_metadata_name_timestep(obj_name, 0, &metadata); if (metadata == NULL) { - LOG_ERROR("Error getting metadata from server!\n"); + LOG_ERROR("Error getting metadata from server\n"); exit(-1); } @@ -410,7 +410,7 @@ test2d(char *obj_name) is_correct = data_verify(ndim, data_start, read_region.size, read_data_2d, data_offset_real, data_2d); if (is_correct != 1) - LOG_ERROR("proc %d: verification failed!\n", rank); + LOG_ERROR("proc %d: verification failed\n", rank); is_all_correct = is_correct; #ifdef ENABLE_MPI @@ -419,11 +419,11 @@ test2d(char *obj_name) #endif if (rank == 0) { - LOG_INFO("2D data verfication ..."); + LOG_INFO("2D data verfication..."); if (is_all_correct != size) - LOG_ERROR("FAILED!\n"); + LOG_ERROR("FAILED\n"); else - LOG_INFO("succeED!\n"); + LOG_INFO("succeED\n"); } free(data); @@ -484,7 +484,7 @@ test3d(char *obj_name) // Query the created object PDC_Client_query_metadata_name_timestep(obj_name, 0, &metadata); if (metadata == NULL) { - LOG_ERROR("Error getting metadata from server!\n"); + LOG_ERROR("Error getting metadata from server\n"); exit(-1); } @@ -745,7 +745,7 @@ test3d(char *obj_name) is_correct = data_verify(ndim, data_start, read_region.size, read_data_3d, data_offset_real, data_3d); if (is_correct != 1) - LOG_ERROR("proc %d: verification failed!\n", rank); + LOG_ERROR("proc %d: verification failed\n", rank); is_all_correct = is_correct; @@ -755,11 +755,11 @@ test3d(char *obj_name) #endif if (rank == 0) { - LOG_INFO("3D data verfication ..."); + LOG_INFO("3D data verfication..."); if (is_all_correct != size) - LOG_ERROR("FAILED!\n"); + LOG_ERROR("FAILED\n"); else - LOG_INFO("succeED!\n"); + LOG_INFO("succeED\n"); } free(data); diff --git a/src/tests/misc/gen_fastbit_idx.c b/src/tests/misc/gen_fastbit_idx.c index 9e07151cd..3868d7602 100644 --- a/src/tests/misc/gen_fastbit_idx.c +++ b/src/tests/misc/gen_fastbit_idx.c @@ -19,10 +19,9 @@ main(int argc, char **argv) pdcid_t pdc, id; float preload_value = -2000000000.0; - if (argc < 2) { - LOG_ERROR("Please enter var name as input!\n"); - fflush(stdout); - } + if (argc < 2) + LOG_ERROR("Please enter var name as input\n"); + var_name = argv[1]; pdc = PDCinit("pdc"); @@ -30,7 +29,7 @@ main(int argc, char **argv) // Query the created object PDC_Client_query_metadata_name_timestep(var_name, 0, &meta); if (meta == NULL || meta->obj_id == 0) { - LOG_ERROR("Error with [%s] metadata!\n", var_name); + LOG_ERROR("Error with [%s] metadata\n", var_name); goto done; } id = meta->obj_id; diff --git a/src/tests/misc/hash_table.c b/src/tests/misc/hash_table.c index 1e856c487..f8465da8b 100644 --- a/src/tests/misc/hash_table.c +++ b/src/tests/misc/hash_table.c @@ -83,7 +83,6 @@ main(int argc, char *argv[]) hash_value_metadata_t *lookup_value = NULL; int lookup_key; - /* int *value1, *value2; */ int ret = EXIT_SUCCESS; (void)argc; @@ -95,9 +94,6 @@ main(int argc, char *argv[]) key1 = (int *)malloc(sizeof(int)); key2 = (int *)malloc(sizeof(int)); - /* value1 = (int *) malloc(sizeof(int)); */ - /* value2 = (int *) malloc(sizeof(int)); */ - value1 = (hash_value_metadata_t *)malloc(sizeof(hash_value_metadata_t)); value2 = (hash_value_metadata_t *)malloc(sizeof(hash_value_metadata_t)); @@ -130,17 +126,17 @@ main(int argc, char *argv[]) lookup_value->test = "World"; } else { - LOG_INFO("Object with lookup_key=%d not found!\n", lookup_key); + LOG_INFO("Object with lookup_key=%d not found\n", lookup_key); } - LOG_INFO("New value after change!\n"); + LOG_INFO("New value after change\n"); lookup_value = hg_hash_table_lookup(hash_table, &lookup_key); if (lookup_value != NULL) { LOG_INFO("Found in hash table with obj_id=%d, obj_name=%s, test=%s\n", lookup_value->obj_id, lookup_value->obj_name, lookup_value->test); } else { - LOG_INFO("Object with lookup_key=%d not found!\n", lookup_key); + LOG_INFO("Object with lookup_key=%d not found\n", lookup_key); } hg_hash_table_free(hash_table); diff --git a/src/tests/misc/idioms_ci_test.c b/src/tests/misc/idioms_ci_test.c index cd8d63ba3..1826d3f7c 100644 --- a/src/tests/misc/idioms_ci_test.c +++ b/src/tests/misc/idioms_ci_test.c @@ -30,8 +30,7 @@ #include #include #include "pdc.h" -#include "pdc_client_connect.h" -#include "string_utils.h" +#include "test_helper.h" dart_object_ref_type_t ref_type = REF_PRIMARY_ID; dart_hash_algo_t hash_algo = DART_HASH; @@ -56,31 +55,21 @@ print_usage(char *name) perr_t prepare_container(pdcid_t *pdc, pdcid_t *cont_prop, pdcid_t *cont, pdcid_t *obj_prop, int world_rank) { - perr_t ret_value = FAIL; + perr_t ret_value = SUCCEED; + int rank = world_rank; // create a pdc - *pdc = PDCinit("pdc"); - + TASSERT((*pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - *cont_prop = PDCprop_create(PDC_CONT_CREATE, *pdc); - if (*cont_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create container property!\n", world_rank); - goto done; - } + TASSERT((*cont_prop = PDCprop_create(PDC_CONT_CREATE, *pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - *cont = PDCcont_create("c1", *cont_prop); - if (*cont <= 0) { - LOG_ERROR("[Client %d] Fail to create container!\n", world_rank); - goto done; - } + TASSERT((*cont = PDCcont_create("c1", *cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - *obj_prop = PDCprop_create(PDC_OBJ_CREATE, *pdc); - if (*obj_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create object property!\n", world_rank); - goto done; - } + TASSERT((*obj_prop = PDCprop_create(PDC_OBJ_CREATE, *pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - ret_value = SUCCEED; done: return ret_value; } @@ -302,14 +291,6 @@ search_through_index(int world_rank, int world_size, int (*validator)(int r, int step_failed = 2; } break; - // case 3: - // // infix string query - // if (PDC_Client_search_obj_ref_through_dart(hash_algo, "*09*=\"*09*\"", ref_type, &nres, - // &pdc_ids) < 0) { - // LOG_ERROR("Failed to query kvtag [%s] with rank %d\n", "*09*=*09*", world_rank); - // step_failed = 3; - // } - // break; case 4: // exact integer query if (PDC_Client_search_obj_ref_through_dart(hash_algo, "intkey=109", ref_type, &nres, &pdc_ids) < @@ -341,6 +322,7 @@ main(int argc, char *argv[]) pdcid_t pdc, cont_prop, cont, obj_prop; int world_size, world_rank, i; double stime, total_time; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -348,18 +330,16 @@ main(int argc, char *argv[]) MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); #endif - // prepare container - if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, world_rank) < 0) { - println("Failed to prepare container"); - goto done; - } + int rank = world_rank; - if (world_rank == 0) { - println("Initialization Done!"); - } + // prepare container + if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, world_rank) < 0) + PGOTO_ERROR(FAIL, "Failed to prepare container"); - // No need to create any object for testing only the index. + if (world_rank == 0) + LOG_INFO("Initialization Done\n"); + // No need to create any object for testing only the index. #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); stime = MPI_Wtime(); @@ -383,11 +363,9 @@ main(int argc, char *argv[]) // perform the same query, there should be no result. // we are performing 1000 insertion operations for string value and 1000 times for numerical values. - perr_t ret_value = insert_index_records(world_rank, world_size); - if (ret_value == FAIL) { - LOG_ERROR("CLIENT %d failed to insert index records\n", world_rank); - } - assert(ret_value == SUCCEED); + ret_value = insert_index_records(world_rank, world_size); + if (ret_value == FAIL) + PGOTO_ERROR(FAIL, "CLIENT %d failed to insert index records\n", world_rank); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -462,47 +440,19 @@ main(int argc, char *argv[]) 1000.0 * world_size / total_time); } -done: // close a container - if (PDCcont_close(cont) < 0) { - if (world_rank == 0) { - LOG_ERROR("Failed to close container c1\n"); - } - } - else { - if (world_rank == 0) - LOG_INFO("Successfully closed container c1\n"); - } - + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close an object property - if (PDCprop_close(obj_prop) < 0) { - if (world_rank == 0) - LOG_ERROR("Failed to close property"); - } - else { - if (world_rank == 0) - LOG_INFO("Successfully closed object property\n"); - } - + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - if (world_rank == 0) - LOG_ERROR("Failed to close property"); - } - else { - if (world_rank == 0) - LOG_INFO("Successfully closed container property\n"); - } - + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - if (world_rank == 0) - LOG_ERROR("Failed to close PDC\n"); - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/misc/import_vpic.c b/src/tests/misc/import_vpic.c index efa6f25ac..2746f96cb 100644 --- a/src/tests/misc/import_vpic.c +++ b/src/tests/misc/import_vpic.c @@ -63,21 +63,21 @@ main(int argc, char *argv[]) file_id = H5Fopen(file_name, H5F_ACC_RDONLY, fapl); if (file_id < 0) { - LOG_ERROR("Error opening file [%s]!\n", file_name); + LOG_ERROR("Error opening file [%s]\n", file_name); goto done; } group_name = "Step#0"; group_id = H5Gopen(file_id, group_name, H5P_DEFAULT); if (group_id < 0) { - LOG_ERROR("Error opening group [%s]!\n", group_name); + LOG_ERROR("Error opening group [%s]\n", group_name); goto done; } for (i = 0; i < NVAR; i++) { dset_ids[i] = H5Dopen(group_id, dset_names[i], H5P_DEFAULT); if (dset_ids[i] < 0) { - LOG_ERROR("Error opening dataset [%s]!\n", dset_names[i]); + LOG_ERROR("Error opening dataset [%s]\n", dset_names[i]); goto done; } } @@ -130,7 +130,7 @@ main(int argc, char *argv[]) ret = PDC_Client_query_metadata_name_timestep(dset_names[i], 0, &obj_meta); #endif if (ret != SUCCEED || obj_meta == NULL || obj_meta->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); exit(-1); } @@ -143,7 +143,7 @@ main(int argc, char *argv[]) memspace = H5Screate_simple(1, &elem_count, NULL); H5Sselect_hyperslab(filespace, H5S_SELECT_SET, &elem_offset, NULL, &elem_count, NULL); if (elem_offset + elem_count > dims[0]) { - LOG_ERROR("%d ERROR - off %llu count %llu\n", my_rank, elem_offset, elem_count); + LOG_ERROR("%d error - off %llu count %llu\n", my_rank, elem_offset, elem_count); } hg_ret = H5Dread(dset_ids[i], H5T_NATIVE_FLOAT, memspace, filespace, H5P_DEFAULT, data); H5Sclose(memspace); @@ -153,7 +153,7 @@ main(int argc, char *argv[]) ret = PDC_Client_write(obj_meta, &obj_region, data); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_write!\n"); + LOG_ERROR("Error with PDC_Client_write\n"); exit(-1); } @@ -169,7 +169,6 @@ main(int argc, char *argv[]) if (my_rank == 0) LOG_INFO("\n\nFinished import object %s\n\n", dset_names[i]); - fflush(stdout); } // End for i H5Pclose(fapl); diff --git a/src/tests/misc/init_only.c b/src/tests/misc/init_only.c index 691b57f35..a1e2cea62 100644 --- a/src/tests/misc/init_only.c +++ b/src/tests/misc/init_only.c @@ -36,7 +36,7 @@ main(int argc, char **argv) if (cont <= 0) LOG_ERROR("Failed to create container"); - LOG_INFO("PROC[%d] FINISHED!\n", rank); + LOG_INFO("PROC[%d] FINISHED\n", rank); // close a container if (PDCcont_close(cont) < 0) diff --git a/src/tests/misc/list_all.c b/src/tests/misc/list_all.c index 5532153e5..1ba23e454 100644 --- a/src/tests/misc/list_all.c +++ b/src/tests/misc/list_all.c @@ -112,7 +112,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Creating %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc pdc = PDCinit("pdc"); @@ -186,10 +185,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to create %d obj/rank with %d ranks: %.5e\n", count, size, ht_total_sec); - fflush(stdout); - } LOG_INFO("Listing all objects\n"); PDC_Client_list_all(&n_obj, &out); diff --git a/src/tests/misc/llsm_idioms_bench.c b/src/tests/misc/llsm_idioms_bench.c index d3177118d..8fb8dff18 100644 --- a/src/tests/misc/llsm_idioms_bench.c +++ b/src/tests/misc/llsm_idioms_bench.c @@ -17,7 +17,7 @@ int assign_work_to_rank(int rank, int size, int nwork, int *my_count, int *my_start) { if (rank > size || my_count == NULL || my_start == NULL) { - LOG_ERROR("assign_work_to_rank(): Error with input!\n"); + LOG_ERROR("assign_work_to_rank(): Error with input\n"); return -1; } if (nwork < size) { @@ -84,7 +84,7 @@ prepare_container(pdcid_t *pdc, pdcid_t *cont_prop, pdcid_t *cont, pdcid_t *obj_ // create an object property *obj_prop = PDCprop_create(PDC_OBJ_CREATE, *pdc); if (*obj_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create object property!\n", my_rank); + LOG_ERROR("[Client %d] Fail to create object property\n", my_rank); goto done; } @@ -111,7 +111,7 @@ create_objects(pdcid_t **obj_ids, int my_csv_rows, int csv_expand_factor, pdcid_ (*obj_ids)[obj_created] = obj_id; if ((*obj_ids)[obj_created] <= 0) { - LOG_ERROR("[Client %d] Fail to create object!\n", my_rank); + LOG_ERROR("[Client %d] Fail to create object\n", my_rank); goto done; } @@ -405,6 +405,7 @@ main(int argc, char *argv[]) int nres, ntotal; int * my_cnt_round; int * total_cnt_round; + int ret_value = SUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -415,7 +416,7 @@ main(int argc, char *argv[]) if (argc < 8) { if (my_rank == 0) print_usage(argv[0]); - goto done; + PGOTO_DONE(FAIL); } n_obj = atoi(argv[1]); round = atoi(argv[2]); @@ -430,10 +431,8 @@ main(int argc, char *argv[]) int bypass_query = query_type == -1 ? 1 : 0; // prepare container - if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, my_rank) < 0) { - println("Failed to prepare container"); - goto done; - } + if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, my_rank) < 0) + PGOTO_ERROR(FAIL, "Failed to prepare container"); // ********************** Read and Broadcast first few rows of CSV file ********************** char * data = NULL; @@ -482,13 +481,11 @@ main(int argc, char *argv[]) total_time = MPI_Wtime() - stime; #endif - if (my_rank == 0) { - println("[Object Creation] Rank %d/%d: Created %d objects, time: %.5f ms", my_rank, proc_num, - obj_created, total_time * 1000.0); - } - - // ********************** Add tags to objects ********************** + if (my_rank == 0) + LOG_INFO("[Object Creation] Rank %d/%d: Created %d objects, time: %.5f ms\n", my_rank, proc_num, + obj_created, total_time * 1000.0); + // ********************** Add tags to objects ********************** #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); stime = MPI_Wtime(); @@ -503,13 +500,13 @@ main(int argc, char *argv[]) #endif if (my_rank == 0) { - println("[Tag Creation] Rank %d/%d: Added %d tags for %d objects, time: %.5f ms", my_rank, proc_num, - tags_added, obj_created, total_time * 1000.0); + LOG_INFO("[Tag Creation] Rank %d/%d: Added %d tags for %d objects, time: %.5f ms\n", my_rank, + proc_num, tags_added, obj_created, total_time * 1000.0); } if (bypass_query) { if (my_rank == 0) { - println("Rank %d: All queries are bypassed.", my_rank); + LOG_INFO("Rank %d: All queries are bypassed\n", my_rank); report_avg_server_profiling_rst(); } goto done; @@ -523,8 +520,7 @@ main(int argc, char *argv[]) for (comm_type = 1; comm_type >= 0; comm_type--) { for (query_type = 0; query_type < 4; query_type++) { - perr_t ret_value; - int round_total = 0; + int round_total = 0; for (iter = -1; iter < iter_round; iter++) { // -1 is for warm up #ifdef ENABLE_MPI if (iter == 0) { @@ -549,16 +545,16 @@ main(int argc, char *argv[]) query_type_str = "SUFFIX"; else if (query_type == 3) query_type_str = "INFIX"; - println("[%s Client %s Query with%sINDEX] %d rounds (%d) within %.5f ms", - comm_type == 0 ? "Single" : "Multi", query_type_str, - is_using_dart == 0 ? " NO " : " DART ", round, round_total, total_time * 1000.0); + LOG_INFO("[%s Client %s Query with%sINDEX] %d rounds (%d) within %.5f ms\n", + comm_type == 0 ? "Single" : "Multi", query_type_str, + is_using_dart == 0 ? " NO " : " DART ", round, round_total, total_time * 1000.0); } #endif } // end query type } // end comm type if (my_rank == 0) { - println("Rank %d: All queries are done.", my_rank); + LOG_INFO("Rank %d: All queries are done\n", my_rank); report_avg_server_profiling_rst(); } @@ -578,11 +574,10 @@ main(int argc, char *argv[]) #endif if (my_rank == 0) { - println("[TAG Deletion] Rank %d/%d: Deleted %d kvtag from %d objects, time: %.5f ms", my_rank, - proc_num, tags_deleted, obj_created, total_time * 1000.0); + LOG_INFO("[TAG Deletion] Rank %d/%d: Deleted %d kvtag from %d objects, time: %.5f ms\n", my_rank, + proc_num, tags_deleted, obj_created, total_time * 1000.0); } -done: // close a container if (PDCcont_close(cont) < 0) { if (my_rank == 0) { @@ -620,9 +615,10 @@ main(int argc, char *argv[]) LOG_ERROR("Failed to close PDC\n"); } +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } \ No newline at end of file diff --git a/src/tests/misc/pdc_init.c b/src/tests/misc/pdc_init.c index 4403516f3..c5f15825b 100644 --- a/src/tests/misc/pdc_init.c +++ b/src/tests/misc/pdc_init.c @@ -26,13 +26,14 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { pdcid_t pdc; int rank = 0, size = 1; - int ret_value = 0; + int ret_value = TSUCCEED; // create a pdc #ifdef ENABLE_MPI @@ -41,14 +42,12 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - pdc = PDCinit("pdc"); - LOG_INFO("generated new pdc\n"); - + // create pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/misc/vpicio.c b/src/tests/misc/vpicio.c index f0bf64f92..58c59caa7 100644 --- a/src/tests/misc/vpicio.c +++ b/src/tests/misc/vpicio.c @@ -32,6 +32,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" #define NPARTICLES 8388608 @@ -57,7 +58,7 @@ main(int argc, char **argv) pdcid_t obj_xx, obj_yy, obj_zz, obj_pxx, obj_pyy, obj_pzz, obj_id11, obj_id22; pdcid_t region_x, region_y, region_z, region_px, region_py, region_pz, region_id1, region_id2; pdcid_t region_xx, region_yy, region_zz, region_pxx, region_pyy, region_pzz, region_id11, region_id22; - perr_t ret; + perr_t ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Comm comm; #else @@ -108,51 +109,67 @@ main(int argc, char **argv) id2 = (int *)malloc(numparticles * sizeof(int)); // create a pdc - pdc_id = PDCinit("pdc"); - + TASSERT((pdc_id = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id); - if (cont_prop <= 0) { - LOG_ERROR("Failed to create container property"); - return 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc_id)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont_id = PDCcont_create_col("c1", cont_prop); - if (cont_id <= 0) { - LOG_ERROR("Failed to create container"); - return 1; - } + TASSERT((cont_id = PDCcont_create_col("c1", cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // create an object property - obj_prop_xx = PDCprop_create(PDC_OBJ_CREATE, pdc_id); - - PDCprop_set_obj_transfer_region_type(obj_prop_xx, PDC_REGION_LOCAL); - PDCprop_set_obj_dims(obj_prop_xx, 1, dims); - PDCprop_set_obj_type(obj_prop_xx, PDC_FLOAT); - PDCprop_set_obj_time_step(obj_prop_xx, 0); - PDCprop_set_obj_user_id(obj_prop_xx, getuid()); - PDCprop_set_obj_app_name(obj_prop_xx, "VPICIO"); - PDCprop_set_obj_tags(obj_prop_xx, "tag0=1"); - - obj_prop_yy = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_yy, PDC_FLOAT); - - obj_prop_zz = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_zz, PDC_FLOAT); - - obj_prop_pxx = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_pxx, PDC_FLOAT); - - obj_prop_pyy = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_pyy, PDC_FLOAT); - - obj_prop_pzz = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_pzz, PDC_FLOAT); - - obj_prop_id11 = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_id11, PDC_INT); - - obj_prop_id22 = PDCprop_obj_dup(obj_prop_xx); - PDCprop_set_obj_type(obj_prop_id22, PDC_INT); + TASSERT((obj_prop_xx = PDCprop_create(PDC_OBJ_CREATE, pdc_id)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop_xx, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_xx, PDC_FLOAT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop_xx, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop_xx, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop_xx, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop_xx, "VPICIO") >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop_xx, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); + + TASSERT((obj_prop_yy = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_yy, PDC_FLOAT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT((obj_prop_zz = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_zz, PDC_FLOAT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT((obj_prop_pxx = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_pxx, PDC_FLOAT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT((obj_prop_pyy = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_pyy, PDC_FLOAT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT((obj_prop_pzz = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_pzz, PDC_FLOAT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT((obj_prop_id11 = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_id11, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT((obj_prop_id22 = PDCprop_obj_dup(obj_prop_xx)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); + TASSERT(PDCprop_set_obj_type(obj_prop_id22, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); for (i = 0; i < numparticles; i++) { id1[i] = i; @@ -172,420 +189,231 @@ main(int argc, char **argv) offset_remote[0] = rank * numparticles; mysize[0] = numparticles; - // create a region - region_x = PDCregion_create(ndim, offset, mysize); - region_y = PDCregion_create(ndim, offset, mysize); - region_z = PDCregion_create(ndim, offset, mysize); - region_px = PDCregion_create(ndim, offset, mysize); - region_py = PDCregion_create(ndim, offset, mysize); - region_pz = PDCregion_create(ndim, offset, mysize); - region_id1 = PDCregion_create(ndim, offset, mysize); - region_id2 = PDCregion_create(ndim, offset, mysize); - - region_xx = PDCregion_create(ndim, offset_remote, mysize); - region_yy = PDCregion_create(ndim, offset_remote, mysize); - region_zz = PDCregion_create(ndim, offset_remote, mysize); - region_pxx = PDCregion_create(ndim, offset_remote, mysize); - region_pyy = PDCregion_create(ndim, offset_remote, mysize); - region_pzz = PDCregion_create(ndim, offset_remote, mysize); - region_id11 = PDCregion_create(ndim, offset_remote, mysize); - region_id22 = PDCregion_create(ndim, offset_remote, mysize); + // create regions + TASSERT((region_x = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_y = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_z = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_px = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_py = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pz = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id1 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id2 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + + TASSERT((region_xx = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_yy = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_zz = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pxx = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pyy = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_pzz = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id11 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((region_id22 = PDCregion_create(ndim, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); t0 = MPI_Wtime(); #endif - obj_xx = PDCobj_create_mpi(cont_id, "obj-var-xx", obj_prop_xx, 0, comm); - if (obj_xx == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj-var-xx"); - exit(-1); - } - obj_yy = PDCobj_create_mpi(cont_id, "obj-var-yy", obj_prop_yy, 0, comm); - if (obj_yy == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj-var-yy"); - exit(-1); - } - obj_zz = PDCobj_create_mpi(cont_id, "obj-var-zz", obj_prop_zz, 0, comm); - if (obj_zz == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj-var-zz"); - exit(-1); - } - obj_pxx = PDCobj_create_mpi(cont_id, "obj-var-pxx", obj_prop_pxx, 0, comm); - if (obj_pxx == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj-var-pxx"); - exit(-1); - } - obj_pyy = PDCobj_create_mpi(cont_id, "obj-var-pyy", obj_prop_pyy, 0, comm); - if (obj_pyy == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj-var-pyy"); - exit(-1); - } - obj_pzz = PDCobj_create_mpi(cont_id, "obj-var-pzz", obj_prop_pzz, 0, comm); - if (obj_pzz == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj-var-pzz"); - exit(-1); - } - - obj_id11 = PDCobj_create_mpi(cont_id, "id11", obj_prop_id11, 0, comm); - if (obj_id11 == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj_id11"); - exit(-1); - } - obj_id22 = PDCobj_create_mpi(cont_id, "id22", obj_prop_id22, 0, comm); - if (obj_id22 == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", "obj_id22"); - exit(-1); - } + TASSERT((obj_xx = PDCobj_create_mpi(cont_id, "obj-var-xx", obj_prop_xx, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_yy = PDCobj_create_mpi(cont_id, "obj-var-yy", obj_prop_yy, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_zz = PDCobj_create_mpi(cont_id, "obj-var-zz", obj_prop_zz, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_pxx = PDCobj_create_mpi(cont_id, "obj-var-pxx", obj_prop_pxx, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_pyy = PDCobj_create_mpi(cont_id, "obj-var-pyy", obj_prop_pyy, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_pzz = PDCobj_create_mpi(cont_id, "obj-var-pzz", obj_prop_pzz, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_id11 = PDCobj_create_mpi(cont_id, "id11", obj_prop_id11, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); + TASSERT((obj_id22 = PDCobj_create_mpi(cont_id, "id22", obj_prop_id22, 0, comm)) != 0, + "Call to PDCobj_create_mpi succeeded", "Call to PDCobj_create_mpi failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); t1 = MPI_Wtime(); - if (rank == 0) { + if (rank == 0) LOG_INFO("Obj create time: %.5e\n", t1 - t0); - } #endif - transfer_request_x = PDCregion_transfer_create(&x[0], PDC_WRITE, obj_xx, region_x, region_xx); - if (transfer_request_x == 0) { - LOG_ERROR("Array x transfer request creation failed\n"); - return 1; - } - transfer_request_y = PDCregion_transfer_create(&y[0], PDC_WRITE, obj_yy, region_y, region_yy); - if (transfer_request_y == 0) { - LOG_ERROR("Array y transfer request creation failed\n"); - return 1; - } - transfer_request_z = PDCregion_transfer_create(&z[0], PDC_WRITE, obj_zz, region_z, region_zz); - if (transfer_request_z == 0) { - LOG_ERROR("Array z transfer request creation failed\n"); - return 1; - } - transfer_request_px = PDCregion_transfer_create(&px[0], PDC_WRITE, obj_pxx, region_px, region_pxx); - if (transfer_request_px == 0) { - LOG_ERROR("Array px transfer request creation failed\n"); - return 1; - } - transfer_request_py = PDCregion_transfer_create(&py[0], PDC_WRITE, obj_pyy, region_py, region_pyy); - if (transfer_request_py == 0) { - LOG_ERROR("Array py transfer request creation failed\n"); - return 1; - } - transfer_request_pz = PDCregion_transfer_create(&pz[0], PDC_WRITE, obj_pzz, region_pz, region_pzz); - if (transfer_request_pz == 0) { - LOG_ERROR("Array pz transfer request creation failed\n"); - return 1; - } - transfer_request_id1 = PDCregion_transfer_create(&id1[0], PDC_WRITE, obj_id11, region_id1, region_id11); - if (transfer_request_id1 == 0) { - LOG_ERROR("Array id1 transfer request creation failed\n"); - return 1; - } - transfer_request_id2 = PDCregion_transfer_create(&id2[0], PDC_WRITE, obj_id22, region_id2, region_id22); - if (transfer_request_id2 == 0) { - LOG_ERROR("Array id2 transfer request creation failed\n"); - return 1; - } + TASSERT((transfer_request_x = PDCregion_transfer_create(&x[0], PDC_WRITE, obj_xx, region_x, region_xx)) != + 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_y = PDCregion_transfer_create(&y[0], PDC_WRITE, obj_yy, region_y, region_yy)) != + 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_z = PDCregion_transfer_create(&z[0], PDC_WRITE, obj_zz, region_z, region_zz)) != + 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_px = + PDCregion_transfer_create(&px[0], PDC_WRITE, obj_pxx, region_px, region_pxx)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_py = + PDCregion_transfer_create(&py[0], PDC_WRITE, obj_pyy, region_py, region_pyy)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_pz = + PDCregion_transfer_create(&pz[0], PDC_WRITE, obj_pzz, region_pz, region_pzz)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_id1 = + PDCregion_transfer_create(&id1[0], PDC_WRITE, obj_id11, region_id1, region_id11)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT((transfer_request_id2 = + PDCregion_transfer_create(&id2[0], PDC_WRITE, obj_id22, region_id2, region_id22)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); t0 = MPI_Wtime(); - if (rank == 0) { + if (rank == 0) LOG_INFO("Transfer create time: %.5e\n", t0 - t1); - } #endif - ret = PDCregion_transfer_start(transfer_request_x); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_xx\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_y); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_yy\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_z); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_zz\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_px); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_pxx\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_py); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_pyy\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_pz); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_pzz\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_id1); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_id11\n"); - return 1; - } - ret = PDCregion_transfer_start(transfer_request_id2); - if (ret != SUCCEED) { - LOG_ERROR("failed to start transfer for region_id22\n"); - return 1; - } + TASSERT(PDCregion_transfer_start(transfer_request_x) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_y) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_z) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_px) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_py) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_pz) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_id1) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_start(transfer_request_id2) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); t1 = MPI_Wtime(); - if (rank == 0) { + if (rank == 0) LOG_INFO("Transfer start time: %.5e\n", t1 - t0); - } #endif - ret = PDCregion_transfer_wait(transfer_request_x); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_xx\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_y); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_yy\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_z); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_zz\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_px); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_pxx\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_py); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_pyy\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_pz); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_pzz\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_id1); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_id11\n"); - return 1; - } - ret = PDCregion_transfer_wait(transfer_request_id2); - if (ret != SUCCEED) { - LOG_ERROR("failed to transfer wait for region_id22\n"); - return 1; - } + TASSERT(PDCregion_transfer_wait(transfer_request_x) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_y) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_z) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_px) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_py) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_pz) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_id1) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_wait(transfer_request_id2) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); t0 = MPI_Wtime(); - if (rank == 0) { - LOG_ERROR("Transfer wait time: %.5e\n", t0 - t1); - } + if (rank == 0) + LOG_INFO("Transfer wait time: %.5e\n", t0 - t1); #endif - ret = PDCregion_transfer_close(transfer_request_x); - if (ret != SUCCEED) { - LOG_ERROR("region xx transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_y); - if (ret != SUCCEED) { - LOG_ERROR("region yy transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_z); - if (ret != SUCCEED) { - LOG_ERROR("region zz transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_px); - if (ret != SUCCEED) { - LOG_ERROR("region pxx transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_py); - if (ret != SUCCEED) { - LOG_ERROR("region pyy transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_pz); - if (ret != SUCCEED) { - LOG_ERROR("region pzz transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_id1); - if (ret != SUCCEED) { - LOG_ERROR("region id11 transfer close failed\n"); - return 1; - } - ret = PDCregion_transfer_close(transfer_request_id2); - if (ret != SUCCEED) { - LOG_ERROR("region id22 transfer close failed\n"); - return 1; - } + TASSERT(PDCregion_transfer_close(transfer_request_x) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_y) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_z) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_px) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_py) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_pz) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_id1) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request_id2) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); PDC_timing_report("write"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); t1 = MPI_Wtime(); - if (rank == 0) { - LOG_ERROR("Transfer close time: %.5e\n", t1 - t0); - } + if (rank == 0) + LOG_INFO("Transfer close time: %.5e\n", t1 - t0); #endif - if (PDCobj_close(obj_xx) < 0) { - LOG_ERROR("Failed to close obj_xx\n"); - return 1; - } - - if (PDCobj_close(obj_yy) < 0) { - LOG_ERROR("Failed to close object obj_yy\n"); - return 1; - } - if (PDCobj_close(obj_zz) < 0) { - LOG_ERROR("Failed to close object obj_zz\n"); - return 1; - } - if (PDCobj_close(obj_pxx) < 0) { - LOG_ERROR("Failed to close object obj_pxx\n"); - return 1; - } - if (PDCobj_close(obj_pyy) < 0) { - LOG_ERROR("Failed to close object obj_pyy\n"); - return 1; - } - if (PDCobj_close(obj_pzz) < 0) { - LOG_ERROR("Failed to close object obj_pzz\n"); - return 1; - } - if (PDCobj_close(obj_id11) < 0) { - LOG_ERROR("Failed to close object obj_id11\n"); - return 1; - } - if (PDCobj_close(obj_id22) < 0) { - LOG_ERROR("Failed to close object obj_id22\n"); - return 1; - } - if (PDCprop_close(obj_prop_xx) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_xx\n"); - return 1; - } - if (PDCprop_close(obj_prop_yy) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_yy\n"); - return 1; - } - if (PDCprop_close(obj_prop_zz) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_zz\n"); - return 1; - } - if (PDCprop_close(obj_prop_pxx) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_pxx\n"); - return 1; - } - if (PDCprop_close(obj_prop_pyy) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_pyy\n"); - return 1; - } - if (PDCprop_close(obj_prop_pzz) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_pzz\n"); - return 1; - } - if (PDCprop_close(obj_prop_id11) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_id11\n"); - return 1; - } - if (PDCprop_close(obj_prop_id22) < 0) { - LOG_ERROR("Failed to close obj property obj_prop_id22\n"); - return 1; - } - if (PDCregion_close(region_x) < 0) { - LOG_ERROR("Failed to close region region_x\n"); - return 1; - } - if (PDCregion_close(region_y) < 0) { - LOG_ERROR("Failed to close region region_y\n"); - return 1; - } - if (PDCregion_close(region_z) < 0) { - LOG_ERROR("Failed to close region region_z\n"); - return 1; - } - if (PDCregion_close(region_px) < 0) { - LOG_ERROR("Failed to close region region_px\n"); - return 1; - } - if (PDCregion_close(region_py) < 0) { - LOG_ERROR("Failed to close region region_py\n"); - return 1; - } - if (PDCobj_close(region_pz) < 0) { - LOG_ERROR("Failed to close region region_pz\n"); - return 1; - } - if (PDCobj_close(region_id1) < 0) { - LOG_ERROR("Failed to close region region_id1\n"); - return 1; - } - if (PDCobj_close(region_id2) < 0) { - LOG_ERROR("Failed to close region region_id2\n"); - return 1; - } - if (PDCregion_close(region_xx) < 0) { - LOG_ERROR("Failed to close region region_xx\n"); - return 1; - } - if (PDCregion_close(region_yy) < 0) { - LOG_ERROR("Failed to close region region_yy\n"); - return 1; - } - if (PDCregion_close(region_zz) < 0) { - LOG_ERROR("Failed to close region region_zz\n"); - return 1; - } - if (PDCregion_close(region_pxx) < 0) { - LOG_ERROR("Failed to close region region_pxx\n"); - return 1; - } - if (PDCregion_close(region_pyy) < 0) { - LOG_ERROR("Failed to close region region_pyy\n"); - return 1; - } - if (PDCregion_close(region_pzz) < 0) { - LOG_ERROR("Failed to close region region_pzz\n"); - return 1; - } - if (PDCobj_close(region_id11) < 0) { - LOG_ERROR("Failed to close region region_id11\n"); - return 1; - } - if (PDCobj_close(region_id22) < 0) { - LOG_ERROR("Failed to close region region_id22\n"); - return 1; - } + TASSERT(PDCobj_close(obj_xx) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_yy) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_zz) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_pxx) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_pyy) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_pzz) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_id11) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_id22) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_xx) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_yy) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_zz) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_pxx) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_pyy) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_pzz) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_id11) >= 0, "Call to PDCobj_close succeeded", + "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj_prop_id22) >= 0, "Call to PDCobj_close succeeded", + "Call to PDCobj_close failed"); + TASSERT(PDCregion_close(region_x) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_y) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_z) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_px) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_py) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pz) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id1) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id2) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_xx) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_yy) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_zz) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pxx) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pyy) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_pzz) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id11) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(region_id22) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close a container - if (PDCcont_close(cont_id) < 0) { - LOG_ERROR("Failed to close container c1\n"); - return 1; - } + TASSERT(PDCcont_close(cont_id) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - return 1; - } - if (PDCclose(pdc_id) < 0) { - LOG_ERROR("Failed to close PDC\n"); - return 1; - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCclose(pdc_id) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(offset); free(offset_remote); free(mysize); @@ -597,9 +425,10 @@ main(int argc, char **argv) free(pz); free(id1); free(id2); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - - return 0; + return ret_value; } diff --git a/src/tests/obj/create_obj.c b/src/tests/obj/create_obj.c index 350819200..8de720ced 100644 --- a/src/tests/obj/create_obj.c +++ b/src/tests/obj/create_obj.c @@ -28,14 +28,16 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { pdcid_t pdc, cont_prop, cont, obj_prop, obj1, obj2; - int ret_value = 0; - int rank = 0; + int rank = 0; char cont_name[128], obj_name1[128], obj_name2[128]; + int ret_value = TSUCCEED; + // create a pdc #ifdef ENABLE_MPI int size; @@ -44,94 +46,39 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); + // close first object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close second object - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/create_obj_coll.c b/src/tests/obj/create_obj_coll.c index 2e1cb916e..cdcf8cbb4 100644 --- a/src/tests/obj/create_obj_coll.c +++ b/src/tests/obj/create_obj_coll.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -33,8 +34,8 @@ main(int argc, char **argv) pdcid_t pdc, cont_prop, cont, obj_prop; pdcid_t obj1, obj2, open11, open12, open21; int rank = 0, size = 1; - int ret_value = 0; char cont_name[128], obj_name1[128], obj_name2[128]; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -42,158 +43,65 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Rank %d Create a container property\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create container property!\n", rank); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Rank %d Create a container c1\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create container!\n", rank); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Rank %d Create an object property\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create object property!\n", rank); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create first object sprintf(obj_name1, "o1"); #ifdef ENABLE_MPI - obj1 = PDCobj_create_mpi(cont, obj_name1, obj_prop, 0, MPI_COMM_WORLD); + TASSERT((obj1 = PDCobj_create_mpi(cont, obj_name1, obj_prop, 0, MPI_COMM_WORLD)) != 0, + "Call to PDCobj_create succeeded", "Call to PDCobj_create failed"); #else - obj1 = PDCobj_create(cont, obj_name1, obj_prop); + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); #endif - if (obj1 > 0) { - LOG_INFO("Rank %d Create an object o1\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create object!\n", rank); - ret_value = 1; - } - LOG_INFO("checkpoint 1 rank %d\n", rank); + LOG_INFO("Checkpoint 1 rank %d\n", rank); // create second object sprintf(obj_name2, "o2"); #ifdef ENABLE_MPI - obj2 = PDCobj_create_mpi(cont, obj_name2, obj_prop, 0, MPI_COMM_WORLD); + TASSERT((obj2 = PDCobj_create_mpi(cont, obj_name2, obj_prop, 0, MPI_COMM_WORLD)) != 0, + "Call to PDCobj_create succeeded", "Call to PDCobj_create failed"); #else - obj2 = PDCobj_create(cont, obj_name2, obj_prop); + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); #endif - if (obj2 > 0) { - LOG_INFO("Rank %d Create an object o2\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create object!\n", rank); - ret_value = 1; - } - LOG_INFO("checkpoint 2 rank %d\n", rank); + LOG_INFO("Checkpoint 2 rank %d\n", rank); // open first object twice - open11 = PDCobj_open(obj_name1, pdc); - if (open11 == 0) { - LOG_ERROR("Rank %d Fail to open object o1\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Open object o1\n", rank); - } - open12 = PDCobj_open(obj_name1, pdc); - if (open12 == 0) { - LOG_ERROR("Rank %d Fail to open object o1\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Open object o1\n", rank); - } + TASSERT((open11 = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((open12 = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); // open second object once - open21 = PDCobj_open(obj_name2, pdc); - if (open21 == 0) { - LOG_ERROR("Rank %d Fail to open object o2\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Open object o2\n", rank); - } + TASSERT((open21 = PDCobj_open(obj_name2, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + // open second object twice + TASSERT((open21 = PDCobj_open(obj_name2, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Rank %d Fail to close object o1\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object o1\n", rank); - } - if (PDCobj_close(open11) < 0) { - LOG_ERROR("Rank %d Fail to close object open11\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object open11\n", rank); - } - if (PDCobj_close(open12) < 0) { - LOG_ERROR("Rank %d Fail to close object open12\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object open12\n", rank); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Rank %d Fail to close object o2\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object o2\n", rank); - } - if (PDCobj_close(open21) < 0) { - LOG_ERROR("Rank %d Fail to close object open21\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object open21\n", rank); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(open11) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(open12) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(open21) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Rank %d Fail to close container c1\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed container c1\n", rank); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Rank %d Fail to close property\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object property\n", rank); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Rank %d Fail to close property\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed container property\n", rank); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Rank %d Fail to close PDC\n", rank); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/create_obj_scale.c b/src/tests/obj/create_obj_scale.c index f618fae3e..131d84a94 100644 --- a/src/tests/obj/create_obj_scale.c +++ b/src/tests/obj/create_obj_scale.c @@ -32,6 +32,7 @@ #include #include "pdc.h" #include "pdc_client_connect.h" +#include "test_helper.h" static char * rand_string(char *str, size_t size) @@ -62,9 +63,11 @@ main(int argc, char **argv) int count = -1; int i; pdcid_t pdc, cont_prop, cont, obj_prop; - uint64_t dims[3] = {100, 200, 700}; - pdcid_t test_obj = -1; - int use_name = -1; + uint64_t dims[3] = {100, 200, 700}; + pdcid_t test_obj = -1; + int use_name = -1; + int ret_value = TSUCCEED; + perr_t err; struct timeval ht_total_start; struct timeval ht_total_end; @@ -96,60 +99,52 @@ main(int argc, char **argv) LOG_ERROR("Unknown option `-%c'.\n", i); else LOG_ERROR("Unknown option character `\\x%x'.\n", i); - return 1; + TGOTO_DONE(FAIL); + break; default: print_usage(); -#ifdef ENABLE_MPI - MPI_Finalize(); - return 1; -#endif + TGOTO_DONE(TFAIL); + break; } if (count == -1) { print_usage(); -#ifdef ENABLE_MPI - MPI_Finalize(); - return 1; -#endif + TGOTO_DONE(TFAIL); } count /= size; if (rank == 0) LOG_INFO("Creating %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc - pdc = PDCinit("pdc"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop <= 0) - LOG_ERROR("Failed to create container property"); - + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create_col("c1", cont_prop); - if (cont <= 0) - LOG_ERROR("Failed to create container"); + TASSERT((cont = PDCcont_create_col("c1", cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); char *cont_tags = "cont_tags0=123"; if (rank == 0) { - PDC_Client_add_tags_to_container(cont, cont_tags); + TASSERT(PDC_Client_add_tags_to_container(cont, cont_tags) >= 0, + "Call to PDC_Client_add_tags_to_container succeeded", + "Call to PDC_Client_add_tags_to_container failed"); } // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop <= 0) - LOG_ERROR("Failed to create object property"); - - PDCprop_set_obj_type(obj_prop, PDC_INT); - PDCprop_set_obj_dims(obj_prop, 3, dims); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); env_str = getenv("PDC_OBJ_NAME"); if (env_str != NULL) { use_name = atoi(env_str); } - if (rank == 0) { LOG_INFO("Using %s\n", name_mode[use_name + 1]); } @@ -166,32 +161,37 @@ main(int argc, char **argv) if (use_name == -1) { sprintf(obj_name, "%s", rand_string(tmp_str, 16)); - PDCprop_set_obj_time_step(obj_prop, rank); + TASSERT(PDCprop_set_obj_time_step(obj_prop, rank) >= 0, + "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); } else if (use_name == 1) { sprintf(obj_name, "%s", obj_prefix[0]); - PDCprop_set_obj_time_step(obj_prop, i + rank * count); + TASSERT(PDCprop_set_obj_time_step(obj_prop, i + rank * count) >= 0, + "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); } else if (use_name == 4) { sprintf(obj_name, "%s", obj_prefix[i % 4]); - PDCprop_set_obj_time_step(obj_prop, i / 4 + rank * count); + TASSERT(PDCprop_set_obj_time_step(obj_prop, i / 4 + rank * count) >= 0, + "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); } - else { - LOG_ERROR("Unsupported name choice\n"); - goto done; - } - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_app_name(obj_prop, "test_app"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + else + TGOTO_ERROR(TFAIL, "Unsupported name choice"); + + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "test_app") >= 0, + "Call to PDCprop_set_obj_app_name succeeded", "Call to PDCprop_set_obj_app_name failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); if (count < 20) { LOG_INFO("[%d] create obj with name %s\n", rank, obj_name); } - test_obj = PDCobj_create(cont, obj_name, obj_prop); - if (test_obj == 0) { - LOG_ERROR("Error getting an object id of %s from server, exit...\n", obj_name); - exit(-1); - } + TASSERT((test_obj = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // Print progress int progress_factor = count < 10 ? 1 : 10; @@ -200,10 +200,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("%10d created ... %.5e s\n", i * size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif @@ -217,26 +215,21 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to create %d obj/rank with %d ranks: %.5e\n", count, size, ht_total_sec); - fflush(stdout); - } -done: + // close object + TASSERT(PDCobj_close(test_obj) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) - LOG_ERROR("Failed to close container c1\n"); - + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) - LOG_ERROR("Failed to close property"); - - if (PDCclose(pdc) < 0) - LOG_ERROR("Failed to close PDC\n"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/obj/delete_obj.c b/src/tests/obj/delete_obj.c index 235b44bf1..7410ba716 100644 --- a/src/tests/obj/delete_obj.c +++ b/src/tests/obj/delete_obj.c @@ -104,7 +104,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Delete %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc pdc = PDCinit("pdc"); @@ -131,10 +130,8 @@ main(int argc, char **argv) use_name = atoi(env_str); } - if (rank == 0) { + if (rank == 0) LOG_INFO("Using %s\n", name_mode[use_name + 1]); - fflush(stdout); - } srand(rank + 1); diff --git a/src/tests/obj/delete_obj_scale.c b/src/tests/obj/delete_obj_scale.c index 6cdb54eb3..abec7c9e0 100644 --- a/src/tests/obj/delete_obj_scale.c +++ b/src/tests/obj/delete_obj_scale.c @@ -30,8 +30,6 @@ #include #include #include "pdc.h" -#include "pdc_client_server_common.h" -#include "pdc_client_connect.h" static char * rand_string(char *str, size_t size) @@ -107,7 +105,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Creating %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc pdc = PDCinit("pdc"); @@ -179,7 +176,6 @@ main(int argc, char **argv) ht_total_sec = ht_total_elapsed / 1000000.0; LOG_INFO("%10d deleted ... %.2fs\n", i * size, ht_total_sec); - fflush(stdout); } } #ifdef ENABLE_MPI @@ -190,10 +186,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to create %d obj/rank with %d ranks: %.5e\n", count, size, ht_total_sec); - fflush(stdout); - } done: // close a container diff --git a/src/tests/obj/obj_buf.c b/src/tests/obj/obj_buf.c index f342f70e1..04a1d0589 100644 --- a/src/tests/obj/obj_buf.c +++ b/src/tests/obj/obj_buf.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -34,7 +35,7 @@ main(int argc, char **argv) int rank = 0, size = 1; int myArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; void ** rbuf; - int ret_value = 0; + int ret_value = TSUCCEED; char cont_name[128], obj_name1[128]; #ifdef ENABLE_MPI @@ -44,91 +45,41 @@ main(int argc, char **argv) #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - PDCprop_set_obj_buf(obj_prop, myArray); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCprop_set_obj_buf(obj_prop, myArray) >= 0, "Call to PDCprop_set_obj_buf succeeded", + "Call to PDCprop_set_obj_buf failed"); // create object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj1", "Call to PDCobj_create failed for obj1"); // set and retrieve the object buffer - - rbuf = PDCobj_buf_retrieve(obj1); - LOG_ERROR("First number to retrieve is: %d\n", *((int *)*rbuf)); + TASSERT((rbuf = PDCobj_buf_retrieve(obj1)) != NULL, "Call to PDCobj_buf_retrieve succeeded", + "Call to PDCobj_buf_retrieve failed"); + LOG_INFO("First number to retrieve is: %d\n", *((int *)*rbuf)); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property\n"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_del.c b/src/tests/obj/obj_del.c index 7b544847d..e8e13120e 100644 --- a/src/tests/obj/obj_del.c +++ b/src/tests/obj/obj_del.c @@ -28,12 +28,13 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { pdcid_t pdc, cont_prop, cont, obj_prop, obj1, obj2; - int ret_value = 0; + int ret_value = TSUCCEED; int rank = 0; char cont_name[128], obj_name1[128], obj_name2[128]; // create a pdc @@ -44,103 +45,47 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj1", "Call to PDCobj_create failed for obj1"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj2", "Call to PDCobj_create failed for obj2"); - if (PDCobj_del(obj1) != SUCCEED) { - LOG_ERROR("Failed to delete object"); - } - - if (PDCobj_del(obj2) != SUCCEED) { - LOG_ERROR("Failed to delete object"); - } + // delete objects + TASSERT(PDCobj_del(obj1) >= 0, "Call to PDCobj_del succeeded for obj1", + "Call to PDCobj_del failed for obj1"); + TASSERT(PDCobj_del(obj2) >= 0, "Call to PDCobj_del succeeded for obj2", + "Call to PDCobj_del failed for obj2"); // close first object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded for obj1", + "Call to PDCobj_close failed for obj1"); // close second object - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded for obj2", + "Call to PDCobj_close failed for obj2"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_get_data.c b/src/tests/obj/obj_get_data.c index 92195194e..506e19360 100644 --- a/src/tests/obj/obj_get_data.c +++ b/src/tests/obj/obj_get_data.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" #define BUF_LEN 16 @@ -49,70 +50,39 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Rank %d Create a container %s\n", rank, cont_name); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); memset(data, 1, BUF_LEN * sizeof(double)); sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_put_data(obj_name1, (void *)data, BUF_LEN * sizeof(double), cont); - if (obj1 > 0) { - LOG_INFO("Rank %d Put data to %s\n", rank, obj_name1); - } - else { - LOG_ERROR("Failed to put data into object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_put_data(obj_name1, (void *)data, BUF_LEN * sizeof(double), cont)) > 0, + "Call to DCobj_put_data succeeded", "Call to DCobj_put_data failed"); memset(data, 2, BUF_LEN * sizeof(double)); sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_put_data(obj_name2, (void *)data, BUF_LEN * sizeof(double), cont); - if (obj2 > 0) { - LOG_INFO("Rank %d Put data to %s\n", rank, obj_name2); - } - else { - LOG_ERROR("Failed to put data into object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_put_data(obj_name2, (void *)data, BUF_LEN * sizeof(double), cont)) > 0, + "Call to DCobj_put_data succeeded", "Call to DCobj_put_data failed"); memset(data, 0, BUF_LEN * sizeof(double)); - error_code = PDCobj_get_data(obj1, (void *)(data), BUF_LEN * sizeof(double)); - if (error_code != SUCCEED) { - LOG_ERROR("Failed to get obj 1 data\n"); - ret_value = 1; - } + TASSERT(PDCobj_get_data(obj1, (void *)(data), BUF_LEN * sizeof(double)) >= 0, + "Call to PDCobj_get_data succeeded", "Call to PDCobj_get_data failed"); + for (i = 0; i < BUF_LEN * sizeof(double); ++i) { if (data[i] != 1) { - LOG_ERROR("wrong value at obj 1\n"); + LOG_ERROR("Wrong value at obj 1\n"); ret_value = 1; break; } } memset(data, 0, BUF_LEN * sizeof(double)); - error_code = PDCobj_get_data(obj2, (void *)(data), BUF_LEN * sizeof(double)); - if (error_code != SUCCEED) { - LOG_ERROR("Failed to get obj 1 data\n"); - ret_value = 1; - } + TASSERT(PDCobj_get_data(obj2, (void *)(data), BUF_LEN * sizeof(double)) >= 0, + "Call to PDCobj_get_data succeeded", "Call to PDCobj_get_data failed"); for (i = 0; i < BUF_LEN * sizeof(double); ++i) { if (data[i] != 2) { LOG_ERROR("wrong value at obj 2\n"); @@ -122,42 +92,16 @@ main(int argc, char **argv) } // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } - + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_info.c b/src/tests/obj/obj_info.c index e2a6e8bfa..ecbeeb7ed 100644 --- a/src/tests/obj/obj_info.c +++ b/src/tests/obj/obj_info.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -51,168 +52,81 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - ret = PDCprop_set_obj_dims(obj_prop, ndim, dims); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } - ret = PDCprop_set_obj_type(obj_prop, PDC_DOUBLE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, ndim, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_DOUBLE) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } - obj1_info = PDCobj_get_info(obj1); - obj2_info = PDCobj_get_info(obj2); - if (strcmp(obj1_info->name, obj_name1) != 0) { - LOG_ERROR("Object 1 name is wrong\n"); - ret_value = 1; - } - - if (obj1_info->obj_pt->type != PDC_DOUBLE) { - LOG_ERROR("Type is not properly inherited from object property.\n"); - ret_value = 1; - } - - if (obj1_info->obj_pt->ndim != ndim) { - LOG_ERROR("Number of dimensions is not properly inherited from object property.\n"); - ret_value = 1; - } - if (obj1_info->obj_pt->dims[0] != dims[0]) { - LOG_ERROR("First dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - if (obj1_info->obj_pt->dims[1] != dims[1]) { - LOG_ERROR("Second dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - if (obj1_info->obj_pt->dims[2] != dims[2]) { - LOG_ERROR("Third dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - - if (strcmp(obj2_info->name, obj_name2) != 0) { - LOG_ERROR("Object 2 name is wrong\n"); - ret_value = 1; - } - - if (obj2_info->obj_pt->type != PDC_DOUBLE) { - LOG_ERROR("Type is not properly inherited from object property.\n"); - ret_value = 1; - } - - if (obj2_info->obj_pt->ndim != ndim) { - LOG_ERROR("Number of dimensions is not properly inherited from object property.\n"); - ret_value = 1; - } - if (obj2_info->obj_pt->dims[0] != dims[0]) { - LOG_ERROR("First dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - if (obj2_info->obj_pt->dims[1] != dims[1]) { - LOG_ERROR("Second dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - if (obj2_info->obj_pt->dims[2] != dims[2]) { - LOG_ERROR("Third dimension is not properly inherited from object property.\n"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); + TASSERT((obj1_info = PDCobj_get_info(obj1)) != NULL, "Call to PDCobj_get_info succeeded", + "Call to PDCobj_get_info failed"); + TASSERT((obj2_info = PDCobj_get_info(obj2)) != NULL, "Call to PDCobj_get_info succeeded", + "Call to PDCobj_get_info failed"); + TASSERT(strcmp(obj1_info->name, obj_name1) == 0, "obj1 name matched", "obj1 name did NOT match"); + + TASSERT(obj1_info->obj_pt->type == PDC_DOUBLE, "Type is properly inherited from object property", + "Type is NOT properly inherited from object property"); + TASSERT(obj1_info->obj_pt->ndim == ndim, + "Number of dimensions is properly inherited from object property", + "Number of dimensions is NOT properly inherited from object property"); + TASSERT(obj1_info->obj_pt->dims[0] == dims[0], + "First dimension is properly inherited from object property", + "First dimension is NOT properly inherited from object property"); + TASSERT(obj1_info->obj_pt->dims[1] == dims[1], + "Second dimension is properly inherited from object property", + "Second dimension is NOT properly inherited from object property"); + TASSERT(obj1_info->obj_pt->dims[2] == dims[2], + "Third dimension is properly inherited from object property", + "Third dimension is NOT properly inherited from object property"); + + TASSERT(strcmp(obj2_info->name, obj_name2) == 0, "obj2 name matched", "obj2 name did NOT match"); + + TASSERT(obj2_info->obj_pt->type == PDC_DOUBLE, "Type is properly inherited from object property", + "Type is NOT properly inherited from object property"); + TASSERT(obj2_info->obj_pt->ndim == ndim, + "Number of dimensions is properly inherited from object property", + "Number of dimensions is NOT properly inherited from object property"); + TASSERT(obj2_info->obj_pt->dims[0] == dims[0], + "First dimension is properly inherited from object property", + "First dimension is NOT properly inherited from object property"); + TASSERT(obj2_info->obj_pt->dims[1] == dims[1], + "Second dimension is properly inherited from object property", + "Second dimension is NOT properly inherited from object property"); + TASSERT(obj2_info->obj_pt->dims[2] == dims[2], + "Third dimension is properly inherited from object property", + "Third dimension is NOT properly inherited from object property"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property\n"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_iter.c b/src/tests/obj/obj_iter.c index 8a14dbf39..4609e1caf 100644 --- a/src/tests/obj/obj_iter.c +++ b/src/tests/obj/obj_iter.c @@ -27,6 +27,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -35,7 +36,7 @@ main(int argc, char **argv) int rank = 0, size = 1; obj_handle * oh; struct pdc_obj_info *info; - int ret_value = 0, ret; + int ret_value = TSUCCEED; char cont_name[128], obj_name1[128], obj_name2[128], obj_name3[128]; size_t ndim = 3; @@ -50,68 +51,30 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - ret = PDCprop_set_obj_dims(obj_prop, ndim, dims); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } - ret = PDCprop_set_obj_type(obj_prop, PDC_DOUBLE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, ndim, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_DOUBLE) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj1", "Call to PDCobj_create failed for obj1"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj2", "Call to PDCobj_create failed for obj2"); // create third object sprintf(obj_name3, "o3_%d", rank); obj3 = PDCobj_create(cont, obj_name3, obj_prop); @@ -124,86 +87,44 @@ main(int argc, char **argv) } // start object iteration oh = PDCobj_iter_start(cont); - while (!PDCobj_iter_null(oh)) { info = PDCobj_iter_get_info(oh); - if (info->obj_pt->type != PDC_DOUBLE) { - LOG_ERROR("Type is not properly inherited from object property.\n"); - ret_value = 1; - } - if (info->obj_pt->ndim != ndim) { - LOG_ERROR("Number of dimensions is not properly inherited from object property.\n"); - ret_value = 1; - } - if (info->obj_pt->dims[0] != dims[0]) { - LOG_ERROR("First dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - if (info->obj_pt->dims[1] != dims[1]) { - LOG_ERROR("Second dimension is not properly inherited from object property.\n"); - ret_value = 1; - } - if (info->obj_pt->dims[2] != dims[2]) { - LOG_ERROR("Third dimension is not properly inherited from object property.\n"); - ret_value = 1; - } + TASSERT(info->obj_pt->type == PDC_DOUBLE, "Type is properly inherited from object property", + "Type is NOT properly inherited from object property"); + TASSERT(info->obj_pt->ndim == ndim, "Number of dimensions is properly inherited from object property", + "Number of dimensions is NOT properly inherited from object property"); + TASSERT(info->obj_pt->dims[0] == dims[0], + "First dimension is properly inherited from object property", + "First dimension is NOT properly inherited from object property"); + TASSERT(info->obj_pt->dims[1] == dims[1], + "Second dimension is properly inherited from object property", + "Second dimension is NOT properly inherited from object property"); + TASSERT(info->obj_pt->dims[2] == dims[2], + "Third dimension is properly inherited from object property", + "Third dimension is NOT properly inherited from object property"); oh = PDCobj_iter_next(oh, cont); } // close first object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded for obj1", + "Call to PDCobj_close failed for obj1"); // close second object - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded for obj2", + "Call to PDCobj_close failed for obj2"); // close third object - if (PDCobj_close(obj3) < 0) { - LOG_ERROR("Failed to close object o3\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o3\n"); - } + TASSERT(PDCobj_close(obj3) >= 0, "Call to PDCobj_close succeeded for obj3", + "Call to PDCobj_close failed for obj3"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property\n"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_life.c b/src/tests/obj/obj_life.c index 0c2cf23ed..b2b4e125a 100644 --- a/src/tests/obj/obj_life.c +++ b/src/tests/obj/obj_life.c @@ -26,13 +26,14 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { - pdcid_t pdc, cont_prop, cont /*, obj1*/; - // struct PDC_obj_prop *op; - int rank = 0, size = 1; + pdcid_t pdc, cont_prop, cont; + int rank = 0, size = 1; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -40,49 +41,23 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - return 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create("c1", cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - return 1; - } + TASSERT((cont = PDCcont_create_col("c1", cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - return 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - return 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - return 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/obj/obj_map.c b/src/tests/obj/obj_map.c index 6332500fb..365c217fa 100644 --- a/src/tests/obj/obj_map.c +++ b/src/tests/obj/obj_map.c @@ -169,7 +169,6 @@ main(int argc, char **argv) ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; LOG_INFO("Total map overhead : %.5e\n", ht_total_sec); - fflush(stdout); gettimeofday(&ht_total_start, 0); diff --git a/src/tests/obj/obj_put_data.c b/src/tests/obj/obj_put_data.c index 2893a3da7..6416b7744 100644 --- a/src/tests/obj/obj_put_data.c +++ b/src/tests/obj/obj_put_data.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" #define BUF_LEN 16 @@ -48,86 +49,34 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Rank %d Create a container %s\n", rank, cont_name); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_put_data(obj_name1, (void *)data, BUF_LEN * sizeof(double), cont); - if (obj1 > 0) { - LOG_INFO("Rank %d Put data to %s\n", rank, obj_name1); - } - else { - LOG_ERROR("Failed to put data into object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_put_data(obj_name1, (void *)data, BUF_LEN * sizeof(double), cont)) > 0, + "Call to DCobj_put_data succeeded", "Call to DCobj_put_data failed"); sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_put_data(obj_name2, (void *)data, BUF_LEN * sizeof(double), cont); - if (obj2 > 0) { - LOG_INFO("Rank %d Put data to %s\n", rank, obj_name2); - } - else { - LOG_ERROR("Failed to put data into object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_put_data(obj_name2, (void *)data, BUF_LEN * sizeof(double), cont)) > 0, + "Call to DCobj_put_data succeeded", "Call to DCobj_put_data failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } - + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_round_robin_io.c b/src/tests/obj/obj_round_robin_io.c index e539d9b75..b6836fd98 100644 --- a/src/tests/obj/obj_round_robin_io.c +++ b/src/tests/obj/obj_round_robin_io.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -33,9 +34,8 @@ main(int argc, char **argv) pdcid_t pdc, cont_prop, cont, obj_prop; pdcid_t obj1, obj2; int rank = 0, size = 1, i, j, ret, target_rank; - int ret_value = 0; + int ret_value = TSUCCEED; char cont_name[128], obj_name1[128], obj_name2[128]; - // struct pdc_obj_info *obj1_info, *obj2_info; size_t ndim; uint64_t dims[3]; @@ -102,9 +102,9 @@ main(int argc, char **argv) dims[1] = rank * 3 + 16; dims[2] = rank * 5 + 16; my_data_size = 1; - for (i = 0; i < (int)ndim; ++i) { + + for (i = 0; i < (int)ndim; ++i) my_data_size *= dims[i]; - } mydata = (char *)malloc(my_data_size * type_size); @@ -116,167 +116,81 @@ main(int argc, char **argv) mysize[0] = my_data_size; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Rank %d Create a container property\n", rank); - } - else { - LOG_ERROR("Rank %d fail to create container property!\n", rank); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c"); - cont = PDCcont_create_col(cont_name, cont_prop); - // cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Rank %d Create a container %s\n", rank, cont_name); - } - else { - LOG_ERROR("Rank %d fail to create container!\n", rank); - ret_value = 1; - } + TASSERT((cont = PDCcont_create_col(cont_name, cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Rank %d Create an object property\n", rank); - } - else { - LOG_ERROR("Rank %d fail to create object property!\n", rank); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - ret = PDCprop_set_obj_dims(obj_prop, ndim, dims); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } - PDCprop_set_obj_type(obj_prop, var_type); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } + TASSERT(PDCprop_set_obj_dims(obj_prop, ndim, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_type(obj_prop, var_type) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - local_region = PDCregion_create(1, offset, mysize); - global_region = PDCregion_create(ndim, offset, dims); + TASSERT((local_region = PDCregion_create(1, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, dims)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Rank %d Create an object %s\n", rank, obj_name1); - } - else { - LOG_ERROR("Rank %d fail to create object\n", rank); - ret_value = 1; - } for (i = 0; i < (int)my_data_size; i++) { - for (j = 0; j < (int)type_size; ++j) { + for (j = 0; j < (int)type_size; ++j) mydata[i * type_size + j] = (char)(i * type_size + j + rank); - } - } - transfer_request = PDCregion_transfer_create(mydata, PDC_WRITE, obj1, local_region, global_region); - if (transfer_request == 0) { - LOG_ERROR("PDCregion_transfer_create failed"); - ret_value = 1; - } - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start for region"); - ret_value = 1; } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } - - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } - - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT((transfer_request = + PDCregion_transfer_create(mydata, PDC_WRITE, obj1, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); - local_region = PDCregion_create(1, offset, mysize); - global_region = PDCregion_create(ndim, offset, dims); - if (obj2 > 0) { - LOG_INFO("Rank %d Create an object %s\n", rank, obj_name2); - } - else { - LOG_ERROR("Rank %d fail to create object!\n", rank); - ret_value = 1; - } + TASSERT((local_region = PDCregion_create(1, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, dims)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + for (i = 0; i < (int)my_data_size; i++) { - for (j = 0; j < (int)type_size; ++j) { + for (j = 0; j < (int)type_size; ++j) mydata[i * type_size + j] = (char)(i * type_size + j + rank * 5 + 3); - } - } - transfer_request = PDCregion_transfer_create(mydata, PDC_WRITE, obj2, local_region, global_region); - if (transfer_request == 0) { - LOG_ERROR("PDCregion_transfer_create failed"); - ret_value = 1; - } - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; } - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } + TASSERT((transfer_request = + PDCregion_transfer_create(mydata, PDC_WRITE, obj2, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close created objects - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Rank %d fail to close object o1_%d %d\n", rank, rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object o1_%d\n", rank, rank); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Rank %d fail to close object o2_%d\n", rank, rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object o2_%d\n", rank, rank); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + // Wait for all processes to finish their object creation #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -284,23 +198,11 @@ main(int argc, char **argv) for (i = 1; i < size; ++i) { target_rank = (rank + i) % size; sprintf(obj_name1, "o1_%d", target_rank); - obj1 = PDCobj_open(obj_name1, pdc); - if (obj1 == 0) { - LOG_ERROR("Rank %d fail to open object %s\n", rank, obj_name1); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Opened object %s\n", rank, obj_name1); - } + TASSERT((obj1 = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); sprintf(obj_name2, "o2_%d", target_rank); - obj2 = PDCobj_open(obj_name2, pdc); - if (obj2 == 0) { - LOG_ERROR("Rank %d fail to open object %s\n", rank, obj_name2); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Open object %s\n", rank, obj_name2); - } + TASSERT((obj2 = PDCobj_open(obj_name2, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); dims[0] = target_rank * 2 + 16; dims[1] = target_rank * 3 + 16; @@ -310,105 +212,55 @@ main(int argc, char **argv) my_data_size *= dims[j]; } - mysize[0] = my_data_size; - local_region = PDCregion_create(1, offset, mysize); - global_region = PDCregion_create(ndim, offset, dims); - data_read = (char *)malloc(my_data_size * type_size); - - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj2, local_region, global_region); - if (transfer_request == 0) { - LOG_ERROR("PDCregion_transfer_create for read obj2 failed\n"); - ret_value = 1; - } - - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } + mysize[0] = my_data_size; + TASSERT((local_region = PDCregion_create(1, offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, dims)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + data_read = (char *)malloc(my_data_size * type_size); + + TASSERT((transfer_request = + PDCregion_transfer_create(data_read, PDC_READ, obj2, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (j = 0; j < (int)(my_data_size * type_size); ++j) { if (data_read[j] != (char)(j + target_rank * 5 + 3)) { - LOG_ERROR("rank %d, i = %d, j = %d, wrong value %d!=%d\n", rank, i, j, data_read[j], - (char)(j + target_rank * 5 + 3)); - ret_value = 1; - break; + TGOTO_ERROR(TFAIL, "Rank %d, i = %d, j = %d, wrong value %d!=%d", rank, i, j, data_read[j], + (char)(j + target_rank * 5 + 3)); } } free(data_read); - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } - - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Rank %d fail to close object %s\n", rank, obj_name1); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object %s\n", rank, obj_name1); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Rank %d fail to close object %s\n", rank, obj_name2); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object %s\n", rank, obj_name2); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); } // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Rank %d fail to close container\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed container c\n", rank); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Rank %d fail to close property\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object property\n", rank); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Rank %d fail to close property\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed container property\n", rank); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Rank %d fail to close PDC\n", rank); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); free(mydata); free(offset); free(mysize); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_round_robin_io_all.c b/src/tests/obj/obj_round_robin_io_all.c index 4e18a18d1..418f685aa 100644 --- a/src/tests/obj/obj_round_robin_io_all.c +++ b/src/tests/obj/obj_round_robin_io_all.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" #define WRITE_REQ_SIZE 2 @@ -120,158 +121,82 @@ main(int argc, char **argv) mysize[0] = my_data_size; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Rank %d Create a container property\n", rank); - } - else { - LOG_ERROR("Rank %d fail to create container property\n", rank); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c"); - cont = PDCcont_create_col(cont_name, cont_prop); - // cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Rank %d Create a container %s\n", rank, cont_name); - } - else { - LOG_ERROR("Rank %d fail to create container\n", rank); - ret_value = 1; - } + TASSERT((cont = PDCcont_create_col(cont_name, cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Rank %d Create an object property\n", rank); - } - else { - LOG_ERROR("Rank %d fail to create object property\n", rank); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - ret = PDCprop_set_obj_dims(obj_prop, ndim, dims); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } - PDCprop_set_obj_type(obj_prop, var_type); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj time step"); - ret_value = 1; - } + TASSERT(PDCprop_set_obj_type(obj_prop, var_type) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, ndim, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - local_region = PDCregion_create(1, offset, mysize); - global_region = PDCregion_create(ndim, offset, dims); + TASSERT((local_region = PDCregion_create(1, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, dims)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Rank %d Create an object %s\n", rank, obj_name1); - } - else { - LOG_ERROR("Rank %d fail to create object\n", rank); - ret_value = 1; - } for (i = 0; i < (int)my_data_size; i++) { - for (j = 0; j < (int)type_size; ++j) { + for (j = 0; j < (int)type_size; ++j) mydata[0][i * type_size + j] = (char)(i * type_size + j + rank); - } } for (i = 0; i < (int)my_data_size; i++) { - for (j = 0; j < (int)type_size; ++j) { + for (j = 0; j < (int)type_size; ++j) mydata[1][i * type_size + j] = (char)(i * type_size + j + rank * 5 + 3); - } } transfer_request = (pdcid_t *)malloc(sizeof(pdcid_t) * size * 2); - transfer_request[0] = PDCregion_transfer_create(mydata[0], PDC_WRITE, obj1, local_region, global_region); - if (transfer_request[0] == 0) { - LOG_ERROR("PDCregion_transfer_create failed"); - ret_value = 1; - } - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } + TASSERT((transfer_request[0] = + PDCregion_transfer_create(mydata[0], PDC_WRITE, obj1, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - - local_region = PDCregion_create(1, offset, mysize); - global_region = PDCregion_create(ndim, offset, dims); - if (obj2 > 0) { - LOG_INFO("Rank %d Create an object %s\n", rank, obj_name2); - } - else { - LOG_ERROR("Rank %d fail to create object!\n", rank); - ret_value = 1; - } - - transfer_request[1] = PDCregion_transfer_create(mydata[1], PDC_WRITE, obj2, local_region, global_region); - if (transfer_request[1] == 0) { - LOG_ERROR("PDCregion_transfer_create failed"); - ret_value = 1; - } - ret = PDCregion_transfer_start_all(transfer_request, WRITE_REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_wait_all(transfer_request, WRITE_REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request[0]); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request[1]); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } - - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } - - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); + TASSERT((local_region = PDCregion_create(1, offset, mysize)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, dims)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + + TASSERT((transfer_request[1] = + PDCregion_transfer_create(mydata[1], PDC_WRITE, obj2, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start_all(transfer_request, WRITE_REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", "Call to PDCregion_transfer_start_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request, WRITE_REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + TASSERT(PDCregion_transfer_close(transfer_request[0]) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request[1]) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close created objects - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Rank %d fail to close object o1_%d\n", rank, rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object o1_%d\n", rank, rank); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Rank %d fail to close object o2_%d\n", rank, rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object o2_%d\n", rank, rank); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + // Wait for all processes to finish their object creation #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -284,14 +209,8 @@ main(int argc, char **argv) for (i = 1; i < size; ++i) { target_rank = (rank + i) % size; sprintf(obj_name1, "o1_%d", target_rank); - obj1_list[i - 1] = PDCobj_open(obj_name1, pdc); - if (obj1_list[i - 1] == 0) { - LOG_ERROR("Rank %d fail to open object %s\n", rank, obj_name1); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Opened object %s\n", rank, obj_name1); - } + TASSERT((obj1_list[i - 1] = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); dims[0] = target_rank * 2 + 16; dims[1] = target_rank * 3 + 16; @@ -301,9 +220,11 @@ main(int argc, char **argv) my_data_size *= dims[j]; } - mysize[0] = my_data_size; - local_region = PDCregion_create(1, offset, mysize); - global_region = PDCregion_create(ndim, offset, dims); + mysize[0] = my_data_size; + TASSERT((local_region = PDCregion_create(1, offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, dims)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); data_read[(i - 1)] = (char *)malloc(my_data_size * type_size); transfer_request[(i - 1)] = @@ -313,15 +234,10 @@ main(int argc, char **argv) ret_value = 1; } - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } - - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); sprintf(obj_name2, "o2_%d", target_rank); obj2_list[i - 1] = PDCobj_open(obj_name2, pdc); @@ -330,7 +246,7 @@ main(int argc, char **argv) ret_value = 1; } else { - LOG_INFO("Rank %d Open object %s\n", rank, obj_name2); + LOG_INFO("Rank %d opened object %s\n", rank, obj_name2); } mysize[0] = my_data_size; @@ -338,116 +254,61 @@ main(int argc, char **argv) global_region = PDCregion_create(ndim, offset, dims); data_read[(i - 1) + size - 1] = (char *)malloc(my_data_size * type_size); - transfer_request[(i - 1) + size - 1] = PDCregion_transfer_create( - data_read[(i - 1) + size - 1], PDC_READ, obj2, local_region, global_region); - if (transfer_request[(i - 1) + size - 1] == 0) { - LOG_ERROR("PDCregion_transfer_create for read obj2 failed\n"); - ret_value = 1; - } - - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } - - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } - } + TASSERT((transfer_request[(i - 1) + size - 1] = PDCregion_transfer_create( + data_read[(i - 1) + size - 1], PDC_READ, obj2, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); - ret = PDCregion_transfer_start_all(transfer_request, (size - 1) * 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start_all for region"); - ret_value = 1; + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } - ret = PDCregion_transfer_wait_all(transfer_request, (size - 1) * 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait_all for region"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, (size - 1) * 2) >= 0, + "Call to PDCregion_transfer_start_all succeeded", "Call to PDCregion_transfer_start_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request, (size - 1) * 2) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); for (i = 1; i < size; ++i) { target_rank = (rank + i) % size; - ret = PDCregion_transfer_close(transfer_request[(i - 1)]); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request[(i - 1) + size - 1]); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i - 1]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); + TASSERT(PDCregion_transfer_close(transfer_request[i - 1] + size - 1) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); for (j = 0; j < (int)(my_data_size * type_size); ++j) { if (data_read[(i - 1)][j] != (char)(j + target_rank)) { - LOG_ERROR("rank %d, i = %d, j = %d, wrong value %d!=%d\n", rank, i, j, data_read[(i - 1)][j], - (char)(j + target_rank)); - ret_value = 1; - break; + TGOTO_ERROR(TFAIL, "Rank %d, i = %d, j = %d, wrong value %d!=%d\n", rank, i, j, + data_read[(i - 1)][j], (char)(j + target_rank)); } } for (j = 0; j < (int)(my_data_size * type_size); ++j) { if (data_read[(i - 1) + size - 1][j] != (char)(j + target_rank * 5 + 3)) { - LOG_ERROR("rank %d, i = %d, j = %d, wrong value %d!=%d\n", rank, i, j, - data_read[(i - 1) + size - 1][j], (char)(j + target_rank * 5 + 3)); - ret_value = 1; - break; + TGOTO_ERROR(TFAIL, "Rank %d, i = %d, j = %d, wrong value %d!=%d", rank, i, j, + data_read[(i - 1) + size - 1][j], (char)(j + target_rank * 5 + 3)); } } + free(data_read[(i - 1)]); free(data_read[(i - 1) + size - 1]); - if (PDCobj_close(obj1_list[i - 1]) < 0) { - LOG_ERROR("Rank %d fail to close object\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object\n", rank); - } - if (PDCobj_close(obj2_list[i - 1]) < 0) { - LOG_ERROR("Rank %d fail to close object\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object\n", rank); - } + + TASSERT(PDCobj_close(obj1_list[i - 1]) >= 0, "Call to PDCobj_close succeeded", + "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2_list[i - 1]) >= 0, "Call to PDCobj_close succeeded", + "Call to PDCobj_close failed"); } // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Rank %d fail to close container c\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed container c\n", rank); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Rank %d fail to close property\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed object property\n", rank); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Rank %d fail to close property\n", rank); - ret_value = 1; - } - else { - LOG_INFO("Rank %d Successfully closed container property\n", rank); - } - - LOG_INFO("total number of read request = %d\n", (size - 1) * 2); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + LOG_INFO("Total number of read request = %d\n", (size - 1) * 2); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Rank %d fail to close PDC\n", rank); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); free(transfer_request); free(obj1_list); @@ -458,6 +319,8 @@ main(int argc, char **argv) free(mydata); free(offset); free(mysize); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/obj_tags.c b/src/tests/obj/obj_tags.c index 97161b84a..1675f05a3 100644 --- a/src/tests/obj/obj_tags.c +++ b/src/tests/obj/obj_tags.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -33,7 +34,7 @@ main(int argc, char **argv) pdcid_t pdc, cont_prop, cont, obj_prop; perr_t ret; pdcid_t obj1, obj2; - int ret_value = 0; + int ret_value = TSUCCEED; int rank = 0, size = 1; @@ -56,181 +57,86 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_ERROR("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_ERROR("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_ERROR("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_ERROR("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_dims(obj_prop, ndim, dims); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj dim"); - ret_value = 1; - } - ret = PDCprop_set_obj_type(obj_prop, PDC_DOUBLE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, ndim, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_DOUBLE) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_ERROR("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj1", "Call to PDCobj_create failed for obj1"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_ERROR("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } - - ret = PDCobj_put_tag(obj1, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at object 1\n"); - ret_value = 1; - } - ret = PDCobj_put_tag(obj1, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at object 1\n"); - ret_value = 1; - } - - ret = PDCobj_put_tag(obj2, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at object 2\n"); - ret_value = 1; - } - - ret = PDCobj_put_tag(obj2, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1); - if (ret != SUCCEED) { - LOG_ERROR("Put tag failed at object 2\n"); - ret_value = 1; - } - - ret = PDCobj_get_tag(obj1, "some tag", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at object 1\n"); - ret_value = 1; - } - + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, + "Call to PDCobj_create succeeded for obj2", "Call to PDCobj_create failed for obj2"); + + // put tags in obj1 + TASSERT(PDCobj_put_tag(obj1, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1) >= 0, + "Call to PDCobj_put_tag succeeded for obj1", "Call to PDCobj_put_tag failed for obj1"); + TASSERT(PDCobj_put_tag(obj1, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1) >= 0, + "Call to PDCobj_put_tag succeeded for obj1", "Call to PDCobj_put_tag failed for obj1"); + + // put tags in obj2 + TASSERT(PDCobj_put_tag(obj2, "some tag", tag_value, PDC_STRING, strlen(tag_value) + 1) >= 0, + "Call to PDCobj_put_tag succeeded for obj2", "Call to PDCobj_put_tag failed for obj2"); + TASSERT(PDCobj_put_tag(obj2, "some tag 2", tag_value2, PDC_STRING, strlen(tag_value2) + 1) >= 0, + "Call to PDCobj_put_tag succeeded for obj2", "Call to PDCobj_put_tag failed for obj2"); + + // get tags in obj1 + TASSERT(PDCobj_get_tag(obj1, "some tag", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj1", "Call to PDCobj_get_tag failed for obj1"); if (strcmp(tag_value, tag_value_ret) != 0) { LOG_ERROR("Wrong tag value at object 1, expected = %s, get %s\n", tag_value, tag_value_ret); - ret_value = 1; - } - - ret = PDCobj_get_tag(obj1, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at object 1\n"); - ret_value = 1; + PGOTO_DONE(TFAIL); } - + TASSERT(PDCobj_get_tag(obj1, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj1", "Call to PDCobj_get_tag failed for obj1"); if (strcmp(tag_value2, tag_value_ret) != 0) { LOG_ERROR("Wrong tag value 2 at object 1, expected = %s, get %s\n", tag_value2, tag_value_ret); - ret_value = 1; - } - - ret = PDCobj_get_tag(obj2, "some tag", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at object 2\n"); - ret_value = 1; + PGOTO_DONE(TFAIL); } + // get tags in obj2 + TASSERT(PDCobj_get_tag(obj2, "some tag", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj2", "Call to PDCobj_get_tag failed for obj2"); if (strcmp(tag_value, tag_value_ret) != 0) { LOG_ERROR("Wrong tag value at object 2, expected = %s, get %s\n", tag_value, tag_value_ret); - ret_value = 1; + PGOTO_DONE(TFAIL); } - - ret = PDCobj_get_tag(obj2, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size); - if (ret != SUCCEED) { - LOG_ERROR("Get tag failed at object 2\n"); - ret_value = 1; - } - + TASSERT(PDCobj_get_tag(obj2, "some tag 2", (void **)&tag_value_ret, &value_type, &value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj2", "Call to PDCobj_get_tag failed for obj2"); if (strcmp(tag_value2, tag_value_ret) != 0) { LOG_ERROR("Wrong tag value 2 at object 2, expected = %s, get %s\n", tag_value2, tag_value_ret); - ret_value = 1; - } - - // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1\n"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2\n"); - } - // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1\n"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1\n"); - } - // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property\n"); - } - // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property\n"); - } + PGOTO_DONE(TFAIL); + } + + // close objects + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded for obj1", + "Call to PDCobj_close failed for obj1"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded for obj2", + "Call to PDCobj_close failed for obj2"); + // close container + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + // close properties + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/open_obj.c b/src/tests/obj/open_obj.c index a9ee4d184..53f0151fc 100644 --- a/src/tests/obj/open_obj.c +++ b/src/tests/obj/open_obj.c @@ -26,6 +26,7 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) @@ -42,168 +43,48 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Rank %d Create a container property\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create container property!\n", rank); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Rank %d Create a container c1\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create container!\n", rank); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Rank %d Create an object property\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create object property!\n", rank); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Rank %d Create an object o1\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create object!\n", rank); - ret_value = 1; - goto done; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Rank %d Create an object o2\n", rank); - } - else { - LOG_ERROR("Rank %d Fail to create object!\n", rank); - ret_value = 1; - goto done; - } - + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // open first object twice - open11 = PDCobj_open(obj_name1, cont); - if (open11 == 0) { - LOG_ERROR("Rank %d Fail to open object o1\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Open object o1\n", rank); - } - open12 = PDCobj_open(obj_name1, cont); - if (open12 == 0) { - LOG_ERROR("Rank %d Fail to open object o1\n", rank); - ret_value = 1; - goto done; - } - else if (open12 != open11) { - LOG_ERROR("Rank %d opened object o1 with different ID %llu / %llu\n", rank, open12, open11); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Re-open object o1\n", rank); - } + TASSERT((open11 = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + TASSERT((open12 = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); + LOG_INFO("Rank [%d]: Re-open object o1\n", rank); // open second object once - open21 = PDCobj_open(obj_name2, cont); - if (open21 == 0) { - LOG_ERROR("Rank %d Fail to open object o2\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Open object o2\n", rank); - } + TASSERT((open21 = PDCobj_open(obj_name2, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Rank %d Fail to close object o1\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed object o1\n", rank); - } - if (PDCobj_close(open11) < 0) { - LOG_ERROR("Rank %d Fail to close object open11\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed object open11\n", rank); - } - if (PDCobj_close(open12) < 0) { - LOG_ERROR("Rank %d Fail to close object open12\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed object open12\n", rank); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Rank %d Fail to close object o2\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed object o2\n", rank); - } - if (PDCobj_close(open21) < 0) { - LOG_ERROR("Rank %d Fail to close object open21\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed object open21\n", rank); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(open11) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(open12) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(open21) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Rank %d Fail to close container c1\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed container c1\n", rank); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Rank %d Fail to close property\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed object property\n", rank); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Rank %d Fail to close property\n", rank); - ret_value = 1; - goto done; - } - else { - LOG_INFO("Rank %d Successfully closed container property\n", rank); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Rank %d Fail to close PDC\n", rank); - ret_value = 1; - goto done; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); done: #ifdef ENABLE_MPI diff --git a/src/tests/obj/open_obj_round_robin.c b/src/tests/obj/open_obj_round_robin.c index bee7592a9..3a13d8d16 100644 --- a/src/tests/obj/open_obj_round_robin.c +++ b/src/tests/obj/open_obj_round_robin.c @@ -59,7 +59,7 @@ main(int argc, char **argv) LOG_INFO("Rank %d Create a container property\n", rank); } else { - LOG_ERROR("Rank %d Fail to create container property!\n", rank); + LOG_ERROR("Rank %d Fail to create container property\n", rank); ret_value = 1; } // create a container @@ -70,7 +70,7 @@ main(int argc, char **argv) LOG_INFO("Rank %d Create a container %s\n", rank, cont_name); } else { - LOG_ERROR("Rank %d Fail to create container!\n", rank); + LOG_ERROR("Rank %d Fail to create container\n", rank); ret_value = 1; } // create an object property @@ -79,7 +79,7 @@ main(int argc, char **argv) LOG_INFO("Rank %d Create an object property\n", rank); } else { - LOG_ERROR("Rank %d Fail to create object property!\n", rank); + LOG_ERROR("Rank %d Fail to create object property\n", rank); ret_value = 1; } ret = PDCprop_set_obj_dims(obj_prop, ndim, dims); @@ -100,7 +100,7 @@ main(int argc, char **argv) LOG_INFO("Rank %d Create an object %s\n", rank, obj_name1); } else { - LOG_ERROR("Rank %d Fail to create object!\n", rank); + LOG_ERROR("Rank %d Fail to create object\n", rank); ret_value = 1; } @@ -111,7 +111,7 @@ main(int argc, char **argv) LOG_INFO("Rank %d Create an object %s\n", rank, obj_name2); } else { - LOG_ERROR("Rank %d Fail to create object!\n", rank); + LOG_ERROR("Rank %d Fail to create object\n", rank); ret_value = 1; } diff --git a/src/tests/obj/read_obj.c b/src/tests/obj/read_obj.c index 50a8e206e..1e751c29a 100644 --- a/src/tests/obj/read_obj.c +++ b/src/tests/obj/read_obj.c @@ -7,8 +7,7 @@ #include #include #include "pdc.h" -#include "pdc_client_connect.h" -#include "pdc_client_server_common.h" +#include "test_helper.h" void print_usage() @@ -23,7 +22,7 @@ main(int argc, char **argv) uint64_t size_MB, size_B; perr_t ret; int ndim = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Comm comm; #else @@ -59,11 +58,10 @@ main(int argc, char **argv) if (argc != 4) { print_usage(); - ret_value = 1; #ifdef ENABLE_MPI MPI_Finalize(); #endif - return ret_value; + TGOTO_DONE(TFAIL); } sprintf(obj_name, "%s_%d", argv[1], rank); @@ -112,40 +110,36 @@ main(int argc, char **argv) size_B = size_MB * 1048576; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop <= 0) { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont <= 0) { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create_col(cont_name, cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop <= 0) { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); dims[0] = size_B; my_data_size = size_B / size; LOG_INFO("my_data_size at rank %d is %llu\n", rank, (long long unsigned)my_data_size); mydata = (char *)malloc(my_data_size * type_size); - PDCprop_set_obj_type(obj_prop, var_type); - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT(PDCprop_set_obj_type(obj_prop, var_type) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // Create a object #ifdef ENABLE_MPI @@ -154,11 +148,8 @@ main(int argc, char **argv) global_obj = PDCobj_create(cont, obj_name, obj_prop); #endif - if (global_obj <= 0) { - LOG_ERROR("Error creating an object [%s], exit...\n", obj_name); - ret_value = 1; - goto done; - } + if (global_obj <= 0) + TGOTO_ERROR(TFAIL, "Error creating an object [%s]\n", obj_name); offset = (uint64_t *)malloc(sizeof(uint64_t) * ndim); local_offset = (uint64_t *)malloc(sizeof(uint64_t) * ndim); @@ -167,84 +158,59 @@ main(int argc, char **argv) local_offset[0] = 0; mysize[0] = my_data_size; - local_region = PDCregion_create(ndim, local_offset, mysize); - global_region = PDCregion_create(ndim, offset, mysize); + TASSERT((local_region = PDCregion_create(ndim, local_offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < (int)my_data_size; i++) { for (j = 0; j < (int)type_size; ++j) { mydata[i * type_size + j] = i; } } - transfer_request = PDCregion_transfer_create(mydata, PDC_WRITE, global_obj, local_region, global_region); - if (transfer_request == 0) { - LOG_ERROR("PDCregion_transfer_create failed"); - ret_value = 1; - } + TASSERT((transfer_request = + PDCregion_transfer_create(mydata, PDC_WRITE, global_obj, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif gettimeofday(&pdc_timer_start, 0); - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_closefailed"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif gettimeofday(&pdc_timer_end, 0); write_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to process write data with %d ranks: %.5e\n", size, write_time); - fflush(stdout); - } - transfer_request = PDCregion_transfer_create(mydata, PDC_READ, global_obj, local_region, global_region); - if (transfer_request == 0) { - LOG_INFO("PDCregion_transfer_create failed"); - ret_value = 1; - } + TASSERT((transfer_request = + PDCregion_transfer_create(mydata, PDC_READ, global_obj, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - gettimeofday(&pdc_timer_start, 0); - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_start for region"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region_transfer_wait for region"); - ret_value = 1; - } - - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_close failed"); - ret_value = 1; - } + gettimeofday(&pdc_timer_start, 0); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < (int)my_data_size; i++) { for (j = 0; j < (int)type_size; ++j) { if (mydata[i * type_size + j] != (char)i) { - LOG_ERROR("Wrong value detected %d != %d!\n", mydata[i * type_size + j], i); + LOG_ERROR("Wrong value detected %d != %d\n", mydata[i * type_size + j], i); ret_value = 1; i = my_data_size; break; @@ -255,45 +221,26 @@ main(int argc, char **argv) #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif + gettimeofday(&pdc_timer_end, 0); write_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to process read data with %d ranks: %.5e\n", size, write_time); - fflush(stdout); - } free(offset); free(local_offset); free(mysize); free(mydata); - if (PDCobj_close(global_obj) < 0) { - LOG_ERROR("Failed to close global obj"); - ret_value = 1; - } - - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container"); - ret_value = 1; - } - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + TASSERT(PDCobj_close(global_obj) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); done: #ifdef ENABLE_MPI diff --git a/src/tests/obj/read_obj_shared.c b/src/tests/obj/read_obj_shared.c index f75eb6c51..f617e12f9 100644 --- a/src/tests/obj/read_obj_shared.c +++ b/src/tests/obj/read_obj_shared.c @@ -7,7 +7,7 @@ #include #include #include "pdc.h" -#include "pdc_timing.h" +#include "test_helper.h" void print_usage() @@ -22,11 +22,11 @@ main(int argc, char **argv) uint64_t size_MB, size_B; perr_t ret; int ndim = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Comm comm; #else - int comm = 1; + int comm = 1; #endif pdcid_t global_obj = 0; pdcid_t local_region, global_region; @@ -55,15 +55,13 @@ main(int argc, char **argv) if (argc != 4) { print_usage(); - ret_value = 1; #ifdef ENABLE_MPI MPI_Finalize(); #endif - return ret_value; + TGOTO_DONE(TFAIL); } sprintf(obj_name, "%s", argv[1]); - size_MB = atoi(argv[2]); if (!strcmp(argv[3], "float")) { @@ -108,47 +106,45 @@ main(int argc, char **argv) size_B = size_MB * 1048576; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop <= 0) { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container /* sprintf(cont_name, "c%d", rank); */ sprintf(cont_name, "c"); - cont = PDCcont_create_col(cont_name, cont_prop); - if (cont <= 0) { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create_col(cont_name, cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop <= 0) { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); dims[0] = size_B; my_data_size = size_B / size; LOG_INFO("my_data_size at rank %d is %llu\n", rank, (long long unsigned)my_data_size); mydata = (char *)malloc(my_data_size * type_size); - PDCprop_set_obj_type(obj_prop, var_type); - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT(PDCprop_set_obj_type(obj_prop, var_type) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // Create a object #ifdef ENABLE_MPI - global_obj = PDCobj_create_mpi(cont, obj_name, obj_prop, 0, comm); + TASSERT((global_obj = PDCobj_create_mpi(cont, obj_name, obj_prop, 0, comm)) != 0, + "Call to PDCobj_create succeeded", "Call to PDCobj_create failed"); #else - global_obj = PDCobj_create(cont, obj_name, obj_prop); + TASSERT((global_obj = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); #endif if (global_obj <= 0) { @@ -163,56 +159,38 @@ main(int argc, char **argv) offset[0] = rank * my_data_size; local_offset[0] = 0; mysize[0] = my_data_size; - LOG_INFO("rank %d offset = %llu, length = %llu, unit size = %ld\n", rank, offset[0], mysize[0], + LOG_INFO("Rank %d offset = %llu, length = %llu, unit size = %ld\n", rank, offset[0], mysize[0], type_size); - local_region = PDCregion_create(ndim, local_offset, mysize); - global_region = PDCregion_create(ndim, offset, mysize); + TASSERT((local_region = PDCregion_create(ndim, local_offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < (int)my_data_size; i++) { for (j = 0; j < (int)type_size; ++j) { mydata[i * type_size + j] = i; } } - transfer_request = PDCregion_transfer_create(mydata, PDC_WRITE, global_obj, local_region, global_region); - if (transfer_request == 0) { - LOG_ERROR("PDCregion_transfer_create failed\n"); - ret_value = 1; - } + + TASSERT((transfer_request = + PDCregion_transfer_create(mydata, PDC_WRITE, global_obj, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to PDCregion_transfer_start"); - ret_value = 1; - } - - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_wait failed"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - - if (PDCobj_close(global_obj) < 0) { - LOG_ERROR("Failed to close global obj"); - ret_value = 1; - } - - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCobj_close(global_obj) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif @@ -224,80 +202,51 @@ main(int argc, char **argv) LOG_INFO("rank %d offset = %llu, length = %llu, unit size = %ld\n", rank, offset[0], mysize[0], type_size); - local_region = PDCregion_create(ndim, local_offset, mysize); - global_region = PDCregion_create(ndim, offset, mysize); + TASSERT((local_region = PDCregion_create(ndim, local_offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((global_region = PDCregion_create(ndim, offset, mysize)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - global_obj = PDCobj_open(obj_name, pdc); + TASSERT((global_obj = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); memset(mydata, 0, my_data_size * type_size); - transfer_request = PDCregion_transfer_create(mydata, PDC_READ, global_obj, local_region, global_region); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_create failed\n"); - ret_value = 1; - } + TASSERT((transfer_request = + PDCregion_transfer_create(mydata, PDC_READ, global_obj, local_region, global_region)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); #endif - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to PDCregion_transfer_start"); - ret_value = 1; - } - - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("PDCregion_transfer_wait failed"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < (int)my_data_size; i++) { - for (j = 0; j < (int)type_size; ++j) { if (mydata[i * type_size + j] != (char)i) { - LOG_ERROR("Wrong value detected %d != %d!\n", mydata[i * type_size + j], i); - ret_value = 1; - i = my_data_size; - break; + TGOTO_ERROR(TFAIL, "Wrong value detected %d != %d\n", mydata[i * type_size + j], i); } } } - if (PDCobj_close(global_obj) < 0) { - LOG_ERROR("Failed to close global obj\n"); - ret_value = 1; - } - - if (PDCregion_close(local_region) < 0) { - LOG_ERROR("Failed to close local region\n"); - ret_value = 1; - } - if (PDCregion_close(global_region) < 0) { - LOG_ERROR("Failed to close global region\n"); - ret_value = 1; - } + TASSERT(PDCobj_close(global_obj) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCregion_close(local_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(global_region) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container\n"); - ret_value = 1; - } - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } free(mydata); free(offset); free(local_offset); free(mysize); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/obj/search_obj.c b/src/tests/obj/search_obj.c index 77c21f351..97b908908 100644 --- a/src/tests/obj/search_obj.c +++ b/src/tests/obj/search_obj.c @@ -189,7 +189,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Searching %d objects per MPI rank\n", count); - fflush(stdout); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -215,10 +214,8 @@ main(int argc, char **argv) ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("searched %10d ... %.5e\n", i * size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -233,10 +230,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to partial query %d obj/rank with %d ranks: %.5e\n\n\n", count, size, ht_total_sec); - fflush(stdout); - } // close a container if (PDCcont_close(cont) < 0) diff --git a/src/tests/obj/search_obj_scale.c b/src/tests/obj/search_obj_scale.c index 47cab7cf7..c3b5934a5 100644 --- a/src/tests/obj/search_obj_scale.c +++ b/src/tests/obj/search_obj_scale.c @@ -109,7 +109,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Creating %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc pdc = PDCinit("pdc"); @@ -181,7 +180,6 @@ main(int argc, char **argv) ht_total_sec = ht_total_elapsed / 1000000.0; LOG_INFO("%10d queried ... %.5es\n", i * size, ht_total_sec); - fflush(stdout); } } #ifdef ENABLE_MPI @@ -192,10 +190,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to create %d obj/rank with %d ranks: %.5e\n", count, size, ht_total_sec); - fflush(stdout); - } done: diff --git a/src/tests/obj/stat_obj.c b/src/tests/obj/stat_obj.c index fe13ac434..6426c8250 100644 --- a/src/tests/obj/stat_obj.c +++ b/src/tests/obj/stat_obj.c @@ -183,7 +183,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Stating %d objects per MPI rank\n", count); - fflush(stdout); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -206,10 +205,8 @@ main(int argc, char **argv) ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("stated %10d ... %.5e\n", i * size, ht_total_sec); - fflush(stdout); - } #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -224,10 +221,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to stat %d obj/rank with %d ranks: %.5e\n", count, size, ht_total_sec); - fflush(stdout); - } // close a container if (PDCcont_close(cont) < 0) diff --git a/src/tests/obj/update_obj.c b/src/tests/obj/update_obj.c index fc68f1177..cb0c0640f 100644 --- a/src/tests/obj/update_obj.c +++ b/src/tests/obj/update_obj.c @@ -98,7 +98,6 @@ main(int argc, char **argv) if (rank == 0) LOG_INFO("Update/Delete %d objects per MPI rank\n", count); - fflush(stdout); // create a pdc pdc = PDCinit("pdc"); @@ -212,7 +211,6 @@ main(int argc, char **argv) ht_total_sec = ht_total_elapsed / 1000000.0; LOG_INFO("updated %10d ... %.5e\n", i * size, ht_total_sec); - fflush(stdout); } } } @@ -224,10 +222,8 @@ main(int argc, char **argv) ht_total_elapsed = (ht_total_end.tv_sec - ht_total_start.tv_sec) * 1000000LL + ht_total_end.tv_usec - ht_total_start.tv_usec; ht_total_sec = ht_total_elapsed / 1000000.0; - if (rank == 0) { + if (rank == 0) LOG_INFO("Time to update %d obj/rank with %d ranks: %.5e\n\n\n", count, size, ht_total_sec); - fflush(stdout); - } // close a container if (PDCcont_close(cont) < 0) diff --git a/src/tests/obj/write_obj_shared.c b/src/tests/obj/write_obj_shared.c index 51125a1bd..bc2fb18da 100644 --- a/src/tests/obj/write_obj_shared.c +++ b/src/tests/obj/write_obj_shared.c @@ -208,10 +208,8 @@ main(int argc, char **argv) gettimeofday(&pdc_timer_end, 0); write_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); - if (rank == 0) { + if (rank == 0) LOG_ERROR("Time to lock and release data with %d ranks: %.5e\n", size, write_time); - fflush(stdout); - } done: if (PDCobj_close(global_obj) < 0) { LOG_ERROR("Failed to close global obj\n"); diff --git a/src/tests/prop/dup_prop.c b/src/tests/prop/dup_prop.c index 54dcd0e15..ea4af5238 100644 --- a/src/tests/prop/dup_prop.c +++ b/src/tests/prop/dup_prop.c @@ -26,13 +26,14 @@ #include #include #include "pdc.h" +#include "test_helper.h" int main(int argc, char **argv) { pdcid_t pdc, create_prop1, create_prop2, dup_prop; int rank = 0, size = 1; - int ret_value = 0; + int ret_value = TSUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -41,50 +42,27 @@ main(int argc, char **argv) #endif // create a pdc - pdc = PDCinit("pdc"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create an object property - create_prop1 = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (create_prop1 <= 0) { - LOG_ERROR("Failed to create"); - ret_value = 1; - } + TASSERT((create_prop1 = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create another object property - create_prop2 = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (create_prop2 <= 0) { - LOG_ERROR("Failed to create"); - ret_value = 1; - } + TASSERT((create_prop2 = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - dup_prop = PDCprop_obj_dup(create_prop2); - if (PDCprop_close(dup_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed first property\n"); - } + TASSERT((dup_prop = PDCprop_obj_dup(create_prop2)) != 0, "Call to PDCprop_obj_dup succeeded", + "Call to PDCprop_obj_dup failed"); - if (PDCprop_close(create_prop1) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed first property\n"); - } + TASSERT(PDCprop_close(create_prop1) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed for first property"); + TASSERT(PDCprop_close(create_prop2) >= 0, "Call to PDCprop_close succeeded", + "Call to PDCprop_close failed for second property"); - if (PDCprop_close(create_prop2) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed second property\n"); - } // close a pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC\n"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/query/query_data.c b/src/tests/query/query_data.c index 22db011a7..03bd169ff 100644 --- a/src/tests/query/query_data.c +++ b/src/tests/query/query_data.c @@ -97,7 +97,6 @@ main(int argc, char **argv) // Create a object with only rank 0 if (rank == 0) { LOG_INFO("Creating an object with name [%s]\n", obj_name); - fflush(stdout); obj_id = PDCobj_create(cont, obj_name, obj_prop); if (obj_id <= 0) { LOG_ERROR("Error getting an object id of %s from server, exit...\n", "DataServerTestBin"); @@ -112,7 +111,7 @@ main(int argc, char **argv) // Query the created object PDC_Client_query_metadata_name_timestep(obj_name, 0, &metadata, &metadata_server_id); if (metadata == NULL || metadata->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); ret_value = 1; } @@ -143,7 +142,6 @@ main(int argc, char **argv) if (rank == 0) { LOG_INFO("Time to write data with %d ranks: %.5e\n", size, ht_total_sec); - fflush(stdout); } // Construct query constraints diff --git a/src/tests/query/query_metadata_agg.c b/src/tests/query/query_metadata_agg.c index a1ac2228c..329cafc83 100644 --- a/src/tests/query/query_metadata_agg.c +++ b/src/tests/query/query_metadata_agg.c @@ -58,8 +58,6 @@ main(int argc, const char *argv[]) // Create a object with only rank 0 if (rank == 0) { - - /* fflush(stdout); */ test_obj = PDCobj_create(cont, obj_name, obj_prop); if (test_obj <= 0) { LOG_ERROR("Error getting an object id of %s from server, exit...\n", "DataServerTestBin"); @@ -76,7 +74,7 @@ main(int argc, const char *argv[]) pdc_metadata_t *metadata; PDC_Client_query_metadata_name_timestep_agg(obj_name, 0, &metadata); if (metadata == NULL || metadata->obj_id == 0) { - LOG_ERROR("Proc %d: Error with metadata!\n", rank); + LOG_ERROR("Proc %d: Error with metadata\n", rank); exit(-1); } diff --git a/src/tests/query/query_vpic.c b/src/tests/query/query_vpic.c index 35853e995..91173434e 100644 --- a/src/tests/query/query_vpic.c +++ b/src/tests/query/query_vpic.c @@ -28,7 +28,7 @@ main(void) PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -71,7 +71,7 @@ main(void) LOG_ERROR("Error with result %" PRIu64 ": %.5e\n", i, energy_data[i]); } } - LOG_INFO("Verified: all correct!\n"); + LOG_INFO("Verified: all correct\n"); PDCquery_free_all(q); PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_bin_sds1_nopreload.c b/src/tests/query/query_vpic_bin_sds1_nopreload.c index 0e9ba53fa..6d9674c48 100644 --- a/src/tests/query/query_vpic_bin_sds1_nopreload.c +++ b/src/tests/query/query_vpic_bin_sds1_nopreload.c @@ -30,21 +30,21 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("x", 0, &x_meta); if (x_meta == NULL || x_meta->obj_id == 0) { - LOG_ERROR("Error with x metadata!\n"); + LOG_ERROR("Error with x metadata\n"); goto done; } x_id = x_meta->obj_id; PDC_Client_query_metadata_name_timestep("y", 0, &y_meta); if (y_meta == NULL || y_meta->obj_id == 0) { - LOG_ERROR("Error with y metadata!\n"); + LOG_ERROR("Error with y metadata\n"); goto done; } y_id = y_meta->obj_id; PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -96,8 +96,6 @@ main(void) gettimeofday(&pdc_timer_end, 0); get_data_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); LOG_INFO("Get data time: %.5e\n", get_data_time); - - fflush(stdout); } PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_bin_sds1_preload.c b/src/tests/query/query_vpic_bin_sds1_preload.c index 50aa09e1e..45686c9ff 100644 --- a/src/tests/query/query_vpic_bin_sds1_preload.c +++ b/src/tests/query/query_vpic_bin_sds1_preload.c @@ -35,21 +35,21 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("x", 0, &x_meta); if (x_meta == NULL || x_meta->obj_id == 0) { - LOG_ERROR("Error with x metadata!\n"); + LOG_ERROR("Error with x metadata\n"); goto done; } x_id = x_meta->obj_id; PDC_Client_query_metadata_name_timestep("y", 0, &y_meta); if (y_meta == NULL || y_meta->obj_id == 0) { - LOG_ERROR("Error with y metadata!\n"); + LOG_ERROR("Error with y metadata\n"); goto done; } y_id = y_meta->obj_id; PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -109,8 +109,6 @@ main(void) gettimeofday(&pdc_timer_end, 0); get_data_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); LOG_INFO("Get data time: %.5e\n", get_data_time); - - fflush(stdout); } PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_bin_sds_nopreload.c b/src/tests/query/query_vpic_bin_sds_nopreload.c index 7738e8e40..9cd9bccf2 100644 --- a/src/tests/query/query_vpic_bin_sds_nopreload.c +++ b/src/tests/query/query_vpic_bin_sds_nopreload.c @@ -36,7 +36,7 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("x", 0, &x_meta); if (x_meta == NULL || x_meta->obj_id == 0) { - LOG_ERROR("Error with x metadata!\n"); + LOG_ERROR("Error with x metadata\n"); goto done; } x_id = x_meta->obj_id; @@ -45,7 +45,7 @@ main(void) PDC_Client_query_metadata_name_timestep("y", 0, &y_meta); if (y_meta == NULL || y_meta->obj_id == 0) { - LOG_ERROR("Error with y metadata!\n"); + LOG_ERROR("Error with y metadata\n"); goto done; } y_id = y_meta->obj_id; @@ -54,7 +54,7 @@ main(void) PDC_Client_query_metadata_name_timestep("z", 0, &z_meta); if (z_meta == NULL || z_meta->obj_id == 0) { - LOG_ERROR("Error with z metadata!\n"); + LOG_ERROR("Error with z metadata\n"); goto done; } z_id = z_meta->obj_id; @@ -63,7 +63,7 @@ main(void) PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -115,8 +115,6 @@ main(void) gettimeofday(&pdc_timer_end, 0); get_data_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); LOG_INFO("Get data time: %.5e\n", get_data_time); - - fflush(stdout); } PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_bin_sds_preload.c b/src/tests/query/query_vpic_bin_sds_preload.c index 86bb3b55e..21daf9e9a 100644 --- a/src/tests/query/query_vpic_bin_sds_preload.c +++ b/src/tests/query/query_vpic_bin_sds_preload.c @@ -34,21 +34,21 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("x", 0, &x_meta); if (x_meta == NULL || x_meta->obj_id == 0) { - LOG_ERROR("Error with x metadata!\n"); + LOG_ERROR("Error with x metadata\n"); goto done; } x_id = x_meta->obj_id; PDC_Client_query_metadata_name_timestep("y", 0, &y_meta); if (y_meta == NULL || y_meta->obj_id == 0) { - LOG_ERROR("Error with y metadata!\n"); + LOG_ERROR("Error with y metadata\n"); goto done; } y_id = y_meta->obj_id; PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -111,8 +111,6 @@ main(void) gettimeofday(&pdc_timer_end, 0); get_data_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); LOG_INFO("Get data time: %.5e\n", get_data_time); - - fflush(stdout); } PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_create_data.c b/src/tests/query/query_vpic_create_data.c index 71598eaa6..64bbd124d 100644 --- a/src/tests/query/query_vpic_create_data.c +++ b/src/tests/query/query_vpic_create_data.c @@ -77,8 +77,7 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #else - LOG_INFO("MPI NOT Enabled!\n"); - fflush(stdout); + LOG_INFO("MPI NOT Enabled\n"); #endif if (argc > 1) @@ -174,7 +173,7 @@ main(int argc, char **argv) ret = PDC_Client_query_metadata_name_timestep(obj_names[i], 0, &obj_metas[i]); #endif if (ret != SUCCEED || obj_metas[i] == NULL || obj_metas[i]->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); exit(-1); } } @@ -202,7 +201,7 @@ main(int argc, char **argv) for (i = 0; i < write_var; i++) { ret = PDC_Client_write(obj_metas[i], &obj_regions[i], mydata[i]); if (ret != SUCCEED) { - LOG_ERROR("Error with PDC_Client_iwrite!\n"); + LOG_ERROR("Error with PDC_Client_iwrite\n"); goto done; } } @@ -216,7 +215,6 @@ main(int argc, char **argv) total_size = nparticles * 4.0 * write_var * size / 1048576.0; if (rank == 0) { LOG_INFO("Write %f MB data with %d ranks\nTotal write time: %.2f\n", total_size, size, write_time); - fflush(stdout); } done: diff --git a/src/tests/query/query_vpic_exyz_nopreload.c b/src/tests/query/query_vpic_exyz_nopreload.c index 50f1bf301..a5dcb0859 100644 --- a/src/tests/query/query_vpic_exyz_nopreload.c +++ b/src/tests/query/query_vpic_exyz_nopreload.c @@ -42,13 +42,13 @@ main(int argc, char **argv) z_hi = atof(argv[8]); } else { - LOG_ERROR("Not sufficient query conditions!\n"); + LOG_ERROR("Not sufficient query conditions\n"); } // Query the created object PDC_Client_query_metadata_name_timestep("x", 0, &x_meta); if (x_meta == NULL || x_meta->obj_id == 0) { - LOG_ERROR("Error with x metadata!\n"); + LOG_ERROR("Error with x metadata\n"); goto done; } x_id = x_meta->obj_id; @@ -56,7 +56,7 @@ main(int argc, char **argv) PDC_Client_query_metadata_name_timestep("y", 0, &y_meta); if (y_meta == NULL || y_meta->obj_id == 0) { - LOG_ERROR("Error with y metadata!\n"); + LOG_ERROR("Error with y metadata\n"); goto done; } y_id = y_meta->obj_id; @@ -64,7 +64,7 @@ main(int argc, char **argv) PDC_Client_query_metadata_name_timestep("z", 0, &z_meta); if (z_meta == NULL || z_meta->obj_id == 0) { - LOG_ERROR("Error with z metadata!\n"); + LOG_ERROR("Error with z metadata\n"); goto done; } z_id = z_meta->obj_id; @@ -72,7 +72,7 @@ main(int argc, char **argv) PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -139,7 +139,6 @@ main(int argc, char **argv) break; } } - fflush(stdout); } PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_exyz_preload.c b/src/tests/query/query_vpic_exyz_preload.c index b0d38208e..9d812a3c9 100644 --- a/src/tests/query/query_vpic_exyz_preload.c +++ b/src/tests/query/query_vpic_exyz_preload.c @@ -43,7 +43,7 @@ main(int argc, char **argv) z_hi = atof(argv[8]); } else { - LOG_ERROR("Not sufficient query conditions!\n"); + LOG_ERROR("Not sufficient query conditions\n"); } pdc = PDCinit("pdc"); @@ -51,14 +51,14 @@ main(int argc, char **argv) // Query the created object PDC_Client_query_metadata_name_timestep("x", 0, &x_meta); if (x_meta == NULL || x_meta->obj_id == 0) { - LOG_ERROR("Error with x metadata!\n"); + LOG_ERROR("Error with x metadata\n"); goto done; } x_id = x_meta->obj_id; PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -110,8 +110,6 @@ main(int argc, char **argv) gettimeofday(&pdc_timer_end, 0); get_data_time = PDC_get_elapsed_time_double(&pdc_timer_start, &pdc_timer_end); LOG_INFO("Get data time: %.5e\n", get_data_time); - - fflush(stdout); } PDCselection_free(&sel); diff --git a/src/tests/query/query_vpic_multi.c b/src/tests/query/query_vpic_multi.c index 03991643d..9b67ee671 100644 --- a/src/tests/query/query_vpic_multi.c +++ b/src/tests/query/query_vpic_multi.c @@ -32,7 +32,7 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -70,9 +70,8 @@ main(void) LOG_ERROR("Error with result %" PRIu64 ": %.5e\n", i, energy_data[i]); } } - LOG_INFO("Verified: all correct!\n"); + LOG_INFO("Verified: all correct\n"); PDCselection_free(&sel); - fflush(stdout); sleep(5); } diff --git a/src/tests/query/query_vpic_multi_nopreload.c b/src/tests/query/query_vpic_multi_nopreload.c index 7ed287a2e..fb39198e8 100644 --- a/src/tests/query/query_vpic_multi_nopreload.c +++ b/src/tests/query/query_vpic_multi_nopreload.c @@ -32,7 +32,7 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -70,9 +70,8 @@ main(void) LOG_ERROR("Error with result %" PRIu64 ": %.5e\n", i, energy_data[i]); } } - LOG_INFO("Verified: all correct!\n"); + LOG_INFO("Verified: all correct\n"); PDCselection_free(&sel); - fflush(stdout); sleep(5); } diff --git a/src/tests/query/query_vpic_multi_nopreload1.c b/src/tests/query/query_vpic_multi_nopreload1.c index a56e7ba3a..ac78c7ec1 100644 --- a/src/tests/query/query_vpic_multi_nopreload1.c +++ b/src/tests/query/query_vpic_multi_nopreload1.c @@ -32,7 +32,7 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -70,9 +70,8 @@ main(void) LOG_ERROR("Error with result %" PRIu64 ": %.5e\n", i, energy_data[i]); } } - LOG_INFO("Verified: all correct!\n"); + LOG_INFO("Verified: all correct\n"); PDCselection_free(&sel); - fflush(stdout); sleep(5); } diff --git a/src/tests/query/query_vpic_multi_preload.c b/src/tests/query/query_vpic_multi_preload.c index 03991643d..9b67ee671 100644 --- a/src/tests/query/query_vpic_multi_preload.c +++ b/src/tests/query/query_vpic_multi_preload.c @@ -32,7 +32,7 @@ main(void) // Query the created object PDC_Client_query_metadata_name_timestep("Energy", 0, &energy_meta); if (energy_meta == NULL || energy_meta->obj_id == 0) { - LOG_ERROR("Error with energy metadata!\n"); + LOG_ERROR("Error with energy metadata\n"); goto done; } energy_id = energy_meta->obj_id; @@ -70,9 +70,8 @@ main(void) LOG_ERROR("Error with result %" PRIu64 ": %.5e\n", i, energy_data[i]); } } - LOG_INFO("Verified: all correct!\n"); + LOG_INFO("Verified: all correct\n"); PDCselection_free(&sel); - fflush(stdout); sleep(5); } diff --git a/src/tests/region/region_obj_map_overlap_3D.c b/src/tests/region/region_obj_map_overlap_3D.c index fbc96c9ac..c909754a2 100644 --- a/src/tests/region/region_obj_map_overlap_3D.c +++ b/src/tests/region/region_obj_map_overlap_3D.c @@ -76,35 +76,35 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_buf(obj_prop, obj_data); @@ -118,20 +118,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -156,11 +156,11 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 8; @@ -179,18 +179,18 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -226,18 +226,18 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local regio\nn"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -267,19 +267,19 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } offset[0] = 0; @@ -315,66 +315,66 @@ main(int argc, char **argv) } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); free(obj_data); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer.c b/src/tests/region/region_transfer.c index 76642a58b..2e8d25ac6 100644 --- a/src/tests/region/region_transfer.c +++ b/src/tests/region/region_transfer.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -43,7 +45,7 @@ main(int argc, char **argv) pdcid_t transfer_request; int rank = 0, size = 1, i; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3], local_offset[1]; uint64_t dims[1]; @@ -64,218 +66,103 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + // create a pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - for (i = 0; i < BUF_LEN; ++i) { - data[i] = i; - } - - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + for (i = 0; i < BUF_LEN; ++i) + data[i] = i; - reg = PDCregion_create(1, local_offset, offset_length); - reg_global = PDCregion_create(1, offset, offset_length); + // write transfer request + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT((reg = PDCregion_create(1, local_offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); memset(data_read, 0, sizeof(int) * BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + // read transfer request + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d", data_read[i], i); - ret_value = 1; - break; - } - } - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); + if (data_read[i] != i) + PGOTO_ERROR(FAIL, "Wrong value %d!=%d", data_read[i], i); } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_2D.c b/src/tests/region/region_transfer_2D.c index 4cf3b23dc..4eb7da696 100644 --- a/src/tests/region/region_transfer_2D.c +++ b/src/tests/region/region_transfer_2D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -58,192 +60,115 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + // create a pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d_2d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 2, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to (PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d_2d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d_2d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = BUF_LEN / 4; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < BUF_LEN; ++i) { data[i] = i; } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = BUF_LEN / 4; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d\n", data_read[i], i); } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_2D_partial.c b/src/tests/region/region_transfer_2D_partial.c index d10c3ee27..0ea3f1912 100644 --- a/src/tests/region/region_transfer_2D_partial.c +++ b/src/tests/region/region_transfer_2D_partial.c @@ -190,7 +190,7 @@ main(int argc, char **argv) for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i * 2 + 1) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i * 2 + 1); + LOG_ERROR("Wrong value %d!=%d\n", data_read[i], i * 2 + 1); ret_value = 1; break; } diff --git a/src/tests/region/region_transfer_2D_skewed.c b/src/tests/region/region_transfer_2D_skewed.c index e952ba210..47e27e969 100644 --- a/src/tests/region/region_transfer_2D_skewed.c +++ b/src/tests/region/region_transfer_2D_skewed.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 1024 int @@ -43,7 +45,7 @@ main(int argc, char **argv) pdcid_t transfer_request; int rank = 0, size = 1, i, value; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3]; uint64_t dims[2]; @@ -58,276 +60,183 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + // create a pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 2, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // Testing first object offset[0] = 0; offset[1] = 0; offset_length[0] = dims[0] / 4; offset_length[1] = dims[1]; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = dims[0] / 2; offset[1] = dims[1] / 2; offset_length[0] = dims[0] / 2; offset_length[1] = dims[1] / 2; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = dims[0] / 4; offset_length[1] = dims[1]; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = dims[0] / 2; offset[1] = dims[1] / 2; offset_length[0] = dims[0] / 2; offset_length[1] = dims[1] / 2; - reg_global = PDCregion_create(2, offset, offset_length); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN / 4; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d\n", data_read[i], i); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + // Testing second object memset(data_read, 0, sizeof(int) * BUF_LEN); offset[0] = dims[0] / 2; offset[1] = dims[1] / 2; offset_length[0] = dims[0] / 2; offset_length[1] = dims[1] / 2; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = dims[0] / 2; offset[1] = dims[1] / 2; offset_length[0] = dims[0] / 2; offset_length[1] = dims[0] / 2; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj2, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj2, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = dims[0] / 4; offset_length[1] = dims[1]; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = dims[0] / 2; offset[1] = dims[1] / 2; offset_length[0] = dims[0] / 2; offset_length[1] = dims[1] / 2; - reg_global = PDCregion_create(2, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj2, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj2, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN / 4; ++i) { value = (BUF_LEN / 2 + offset_length[1]) + (i / offset_length[1]) * dims[1] + i % offset_length[1]; - if (data_read[i] != (int)value) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], (int)value); - ret_value = 1; - break; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); + if (data_read[i] != value) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d\n", data_read[i], value); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_3D.c b/src/tests/region/region_transfer_3D.c index 56c836f2d..0622714d3 100644 --- a/src/tests/region/region_transfer_3D.c +++ b/src/tests/region/region_transfer_3D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 256 int @@ -38,8 +40,8 @@ main(int argc, char **argv) { pdcid_t pdc, cont_prop, cont, obj_prop, reg, reg_global; perr_t ret; - pdcid_t obj1, obj2; - char cont_name[128], obj_name1[128], obj_name2[128]; + pdcid_t obj1; + char cont_name[128], obj_name1[128]; pdcid_t transfer_request; int rank = 0, size = 1, i; @@ -60,195 +62,113 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 3, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } - // create second object - sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset[2] = 0; offset_length[0] = BUF_LEN / 16; offset_length[1] = 4; offset_length[2] = 4; - reg_global = PDCregion_create(3, offset, offset_length); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < BUF_LEN; ++i) { data[i] = i; } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset[2] = 0; offset_length[0] = BUF_LEN / 16; offset_length[1] = 4; offset_length[2] = 4; - reg_global = PDCregion_create(3, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d\n", data_read[i], i); } + // close regions + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_3D_partial.c b/src/tests/region/region_transfer_3D_partial.c index 007e48027..7a859b856 100644 --- a/src/tests/region/region_transfer_3D_partial.c +++ b/src/tests/region/region_transfer_3D_partial.c @@ -75,7 +75,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -94,7 +94,7 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } @@ -126,7 +126,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -188,7 +188,7 @@ main(int argc, char **argv) for (i = 0; i < BUF_LEN / 8; ++i) { if (data_read[i] != (BUF_LEN / 8 + i) * 4 + 3) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], (BUF_LEN / 8 + i) * 4 + 3); + LOG_ERROR("Wrong value %d!=%d\n", data_read[i], (BUF_LEN / 8 + i) * 4 + 3); ret_value = 1; break; } @@ -243,7 +243,7 @@ main(int argc, char **argv) } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { diff --git a/src/tests/region/region_transfer_3D_skewed.c b/src/tests/region/region_transfer_3D_skewed.c index 4c0a56b89..cf833f09a 100644 --- a/src/tests/region/region_transfer_3D_skewed.c +++ b/src/tests/region/region_transfer_3D_skewed.c @@ -110,7 +110,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object @@ -120,7 +120,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // Testing the first object @@ -194,7 +194,7 @@ main(int argc, char **argv) ((i % (offset_length[1] * offset_length[2])) / offset_length[2]) * dims[2] + i % offset_length[2]; if (data_read[value] != i) { - LOG_ERROR("wrong value %d!=%d, value = %d\n", data_read[value], i, (int)value); + LOG_ERROR("Wrong value %d!=%d, value = %d\n", data_read[value], i, (int)value); ret_value = 1; break; } @@ -282,7 +282,7 @@ main(int argc, char **argv) ((i % (offset_length[1] * offset_length[2])) / offset_length[2]) * dims[2] + i % offset_length[2]; if (data_read[i] != (int)value) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], (int)value); + LOG_ERROR("Wrong value %d!=%d\n", data_read[i], (int)value); ret_value = 1; break; } @@ -328,7 +328,7 @@ main(int argc, char **argv) } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { diff --git a/src/tests/region/region_transfer_all.c b/src/tests/region/region_transfer_all.c index 7a384dc9e..85cee2081 100644 --- a/src/tests/region/region_transfer_all.c +++ b/src/tests/region/region_transfer_all.c @@ -88,7 +88,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -98,7 +98,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -107,13 +107,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, 1, dims); @@ -156,7 +156,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -168,7 +168,7 @@ main(int argc, char **argv) LOG_INFO("Create local region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } @@ -179,7 +179,7 @@ main(int argc, char **argv) LOG_INFO("Create global region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (j = 0; j < OBJ_NUM; ++j) { @@ -196,7 +196,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -204,7 +204,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -212,7 +212,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -225,7 +225,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -235,7 +235,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -243,24 +243,24 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -277,7 +277,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -285,7 +285,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -293,7 +293,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -306,7 +306,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -316,7 +316,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -324,7 +324,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -332,11 +332,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -351,44 +351,44 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data[0]); free(data_read[0]); @@ -398,7 +398,7 @@ main(int argc, char **argv) free(transfer_request); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_all_2D.c b/src/tests/region/region_transfer_all_2D.c index d27f6ec95..6ce4899c6 100644 --- a/src/tests/region/region_transfer_all_2D.c +++ b/src/tests/region/region_transfer_all_2D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 256 #define OBJ_NUM 13 @@ -44,7 +46,7 @@ main(int argc, char **argv) pdcid_t *transfer_request; int rank = 0, size = 1, i, j; - int ret_value = 0; + int ret_value = TSUCCEED; int **data, **data_read; uint64_t offset[2], offset_length[2]; @@ -78,328 +80,234 @@ main(int argc, char **argv) dims[1] = 4; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 2, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create many objects obj = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); for (i = 0; i < OBJ_NUM; ++i) { switch (i % 4) { case 0: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 1: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 2: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } - /* case 3: { */ - /* ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); */ - /* break; */ - /* } */ default: { + break; } } sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = BUF_LEN / 4; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i; - } } transfer_request = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); // Place a transfer request for every objects for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); int request_size = 0; + for (i = 0; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = BUF_LEN / 4; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); - transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } + if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); int request_size = 0; + for (i = 0; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } + for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], i); } } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data[0]); free(data_read[0]); free(data); free(data_read); free(obj); free(transfer_request); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_all_3D.c b/src/tests/region/region_transfer_all_3D.c index 358c7c30e..2c1a14968 100644 --- a/src/tests/region/region_transfer_all_3D.c +++ b/src/tests/region/region_transfer_all_3D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 #define OBJ_NUM 17 @@ -44,7 +46,7 @@ main(int argc, char **argv) pdcid_t *transfer_request; int rank = 0, size = 1, i, j; - int ret_value = 0; + int ret_value = TSUCCEED; int **data, **data_read; uint64_t offset[3], offset_length[3]; @@ -81,316 +83,207 @@ main(int argc, char **argv) dims[2] = 4; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 3, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create many objects obj = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); for (i = 0; i < OBJ_NUM; ++i) { switch (i % 4) { case 0: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 1: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 2: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } - /* case 3: { */ - /* ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); */ - /* break; */ - /* } */ default: { + break; } } sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset[2] = 0; offset_length[0] = BUF_LEN / 16; offset_length[1] = 4; offset_length[2] = 4; - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i; - } } + transfer_request = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); // Place a transfer request for every objects for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { for (i = 0; i < OBJ_NUM; i += 2) { - ret = PDCregion_transfer_wait(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_wait succeeded", "Call to PDCregion_transfer_wait failed"); } for (i = 1; i < OBJ_NUM; i += 2) { - ret = PDCregion_transfer_wait(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_wait succeeded", "Call to PDCregion_transfer_wait failed"); } } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset[2] = 0; offset_length[0] = BUF_LEN / 16; offset_length[1] = 4; offset_length[2] = 4; - reg_global = PDCregion_create(3, offset, offset_length); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); - transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { for (i = 0; i < OBJ_NUM; i += 2) { - ret = PDCregion_transfer_wait(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_wait succeeded", "Call to PDCregion_transfer_wait failed"); } for (i = 1; i < OBJ_NUM; i += 2) { - ret = PDCregion_transfer_wait(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_wait succeeded", "Call to PDCregion_transfer_wait failed"); } } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], i); } } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data[0]); free(data_read[0]); free(data); free(data_read); free(obj); free(transfer_request); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_all_append.c b/src/tests/region/region_transfer_all_append.c index efd5b9d60..dbbec89f4 100644 --- a/src/tests/region/region_transfer_all_append.c +++ b/src/tests/region/region_transfer_all_append.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 64 #define OBJ_NUM 17 #define REQ_SIZE 8 @@ -45,7 +47,7 @@ main(int argc, char **argv) pdcid_t *transfer_request; int rank = 0, size = 1, i, j; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[1], offset_length[1]; uint64_t dims[1]; @@ -84,82 +86,69 @@ main(int argc, char **argv) dims[0] = BUF_LEN; // create a pdc - pdc = PDCinit("pdc"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop <= 0) { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont <= 0) { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop <= 0) { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create many objects obj = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); for (i = 0; i < OBJ_NUM; ++i) { switch (i % 4) { case 0: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 1: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 2: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } - /* case 3: { */ - /* ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); */ - /* break; */ - /* } */ default: { + break; } } sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj[i] <= 0) { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); } offset[0] = 0; offset_length[0] = BUF_LEN / REQ_SIZE; - reg = PDCregion_create(1, offset, offset_length); - if (reg <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i; - } } transfer_request = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -168,211 +157,153 @@ main(int argc, char **argv) for (j = 0; j < REQ_SIZE; ++j) { offset[0] = j * (BUF_LEN / REQ_SIZE); offset_length[0] = BUF_LEN / REQ_SIZE; - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( - data[i] + j * BUF_LEN / REQ_SIZE, PDC_WRITE, obj[i], reg, reg_global); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - /* else { */ - - /* } */ + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( + data[i] + j * BUF_LEN / REQ_SIZE, PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", + "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM * REQ_SIZE; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); int request_size = 0; + for (i = 0; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { for (j = 0; j < REQ_SIZE; ++j) { - ret = PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - } - - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; + TASSERT(PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - /* else { */ - - /* } */ } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - /* else { */ + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); - /* } */ - - if (rank == 0) - LOG_INFO("Test 0 done\n"); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] <= 0) { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } offset[0] = 0; offset_length[0] = BUF_LEN / REQ_SIZE; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); for (j = 0; j < REQ_SIZE; ++j) { offset[0] = j * (BUF_LEN / REQ_SIZE); offset_length[0] = BUF_LEN / REQ_SIZE; - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( - data_read[i] + j * BUF_LEN / REQ_SIZE, PDC_READ, obj[i], reg, reg_global); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - /* else { */ - - /* } */ + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( + data_read[i] + j * BUF_LEN / REQ_SIZE, PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", + "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM * REQ_SIZE; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); int request_size = 0; + for (i = 0; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { for (j = 0; j < REQ_SIZE; ++j) { - ret = PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - /* else { */ - - /* } */ - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], i); } } @@ -381,186 +312,128 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] <= 0) { - LOG_ERROR("Failed to open object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - /* else { */ - /* } */ + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); int request_size = 0; + for (i = 0; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - /* else { */ - - /* } */ - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], i); } } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - /* else { */ - - /* } */ - - if (rank == 0) - LOG_INFO("Test 2 done\n"); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); // Now we rewrite the whole object and check its values. // open object for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] <= 0) { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i + 84441111 * j + 3; - } } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -569,111 +442,71 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - /* else { */ - - /* } */ - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - /* else { */ - /* } */ + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - /* else { */ - - /* } */ - } - - if (rank == 0) - LOG_INFO("Test 3 done\n"); + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // open object for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] <= 0) { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global <= 0) { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -682,112 +515,58 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - /* else { */ + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); - /* } */ - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - /* else { */ - - /* } */ - - // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - /* else { */ - - /* } */ - } + // close objects + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i + 84441111 * j + 3) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], 84441111 * j + 3); - ret_value = 1; - break; - } + if (data_read[j][i] != i + 84441111 * j + 3) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], 84441111 * j + 3); } } - if (rank == 0) - LOG_INFO("Test 4 done\n"); - - // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - /* else { */ - - /* } */ - // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - /* else { */ - - /* } */ - // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - /* else { */ + // close container + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + // close object property + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close container property + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); - /* } */ free(data); free(data_read); free(obj); free(transfer_request); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } - - if (rank == 0) { - if (ret_value == 0) - LOG_INFO("Test succeed!\n"); - else - LOG_ERROR("ErROR: Test failed!\n"); - } +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_all_append_2D.c b/src/tests/region/region_transfer_all_append_2D.c index 17dd253af..d69d59f6a 100644 --- a/src/tests/region/region_transfer_all_append_2D.c +++ b/src/tests/region/region_transfer_all_append_2D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define DIM0 77 #define DIM1 32 #define BUF_LEN (DIM0 * DIM1) @@ -47,7 +49,7 @@ main(int argc, char **argv) pdcid_t *transfer_request; int rank = 0, size = 1, i, j, x, y, s, b; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[2], offset_length[2]; uint64_t dims[2]; @@ -83,98 +85,69 @@ main(int argc, char **argv) dims[1] = DIM1; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 2, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create many objects obj = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); for (i = 0; i < OBJ_NUM; ++i) { switch (i % 4) { case 0: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 1: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 2: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } - /* case 3: { */ - /* ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); */ - /* break; */ - /* } */ default: { + break; } } sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); } offset[0] = 0; offset_length[0] = BUF_LEN / REQ_SIZE; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i; - } } transfer_request = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -185,48 +158,32 @@ main(int argc, char **argv) offset_length[0] = DIM0; offset[1] = j * DIM1 / REQ_SIZE; offset_length[1] = DIM1 / REQ_SIZE; - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( - data[i] + j * BUF_LEN / REQ_SIZE, PDC_WRITE, obj[i], reg, reg_global); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( + data[i] + j * BUF_LEN / REQ_SIZE, PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", + "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM * REQ_SIZE; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -235,64 +192,44 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { for (j = 0; j < REQ_SIZE; ++j) { - ret = PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - } - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); + TASSERT(PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN / REQ_SIZE; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } for (i = 0; i < OBJ_NUM; ++i) { @@ -302,55 +239,34 @@ main(int argc, char **argv) offset_length[0] = DIM0; offset[1] = j * DIM1 / REQ_SIZE; offset_length[1] = DIM1 / REQ_SIZE; - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( - data_read[i] + j * BUF_LEN / REQ_SIZE, PDC_READ, obj[i], reg, reg_global); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( + data_read[i] + j * BUF_LEN / REQ_SIZE, PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", + "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM * REQ_SIZE; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -359,133 +275,82 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { for (j = 0; j < REQ_SIZE; ++j) { - ret = PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], i); } } for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = DIM0; offset_length[1] = DIM1; - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -494,41 +359,31 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { @@ -537,10 +392,8 @@ main(int argc, char **argv) y = i / DIM1; s = DIM1 / REQ_SIZE; b = s * DIM0; - if (data_read[j][i] != (x / s) * b + y * s + x % s) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], (x / s) * b + y * s + x % s); - ret_value = 1; - } + if (data_read[j][i] != (x / s) * b + y * s + x % s) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], (x / s) * b + y * s + x % s); } } @@ -548,72 +401,47 @@ main(int argc, char **argv) // open object for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i + 84441111 * j + 3; - } } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = DIM0; offset_length[1] = DIM1; - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -622,121 +450,75 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // open object for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset_length[0] = DIM0; offset_length[1] = DIM1; - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -745,101 +527,58 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i + 84441111 * j + 3) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], 84441111 * j + 3); - ret_value = 1; - break; - } + if (data_read[j][i] != i + 84441111 * j + 3) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], 84441111 * j + 3); } } - // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } - // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } - // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + // close container + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + // close object property + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close container property + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); free(obj); free(transfer_request); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_all_append_3D.c b/src/tests/region/region_transfer_all_append_3D.c index bbdfb62a0..e50bcd362 100644 --- a/src/tests/region/region_transfer_all_append_3D.c +++ b/src/tests/region/region_transfer_all_append_3D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define DIM0 34 #define DIM1 13 #define DIM2 24 @@ -49,7 +51,7 @@ main(int argc, char **argv) pdcid_t *transfer_request; int rank = 0, size = 1, i, j, x, y, z, s, b; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3]; uint64_t dims[3]; @@ -89,94 +91,70 @@ main(int argc, char **argv) LOG_INFO("create a new pdc\n"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + // create a pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); + // create a container property + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 3, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create many objects obj = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); for (i = 0; i < OBJ_NUM; ++i) { switch (i % 4) { case 0: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 1: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 2: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } - /* case 3: { */ - /* ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); */ - /* break; */ - /* } */ default: { + break; } } sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); } offset[0] = 0; offset_length[0] = BUF_LEN / REQ_SIZE; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i; - } } transfer_request = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -189,48 +167,32 @@ main(int argc, char **argv) offset_length[1] = DIM1; offset[2] = j * DIM2 / REQ_SIZE; offset_length[2] = DIM2 / REQ_SIZE; - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( - data[i] + j * BUF_LEN / REQ_SIZE, PDC_WRITE, obj[i], reg, reg_global); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( + data[i] + j * BUF_LEN / REQ_SIZE, PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", + "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM * REQ_SIZE; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -239,73 +201,45 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { for (j = 0; j < REQ_SIZE; ++j) { - ret = PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN / REQ_SIZE; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } for (i = 0; i < OBJ_NUM; ++i) { @@ -317,47 +251,31 @@ main(int argc, char **argv) offset_length[1] = DIM1; offset[2] = j * DIM2 / REQ_SIZE; offset_length[2] = DIM2 / REQ_SIZE; - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( - data_read[i] + j * BUF_LEN / REQ_SIZE, PDC_READ, obj[i], reg, reg_global); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((transfer_request[i * REQ_SIZE + j] = PDCregion_transfer_create( + data_read[i] + j * BUF_LEN / REQ_SIZE, PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", + "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM * REQ_SIZE; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM * REQ_SIZE) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM * REQ_SIZE); @@ -366,143 +284,87 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM * REQ_SIZE; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { for (j = 0; j < REQ_SIZE; ++j) { - ret = PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i * REQ_SIZE + j]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], i); } } for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset_length[0] = DIM0; offset[1] = 0; offset_length[1] = DIM1; offset[2] = 0; offset_length[2] = DIM2; - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -511,41 +373,31 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { @@ -555,12 +407,9 @@ main(int argc, char **argv) z = i / (DIM1 * DIM2); s = DIM2 / REQ_SIZE; b = s * DIM0 * DIM1; - if (data_read[j][i] != (x / s) * b + z * s * DIM1 + y * s + x % s) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], - (x / s) * b + z * s * DIM1 + y * s + x % s); - ret_value = 1; - break; - } + if (data_read[j][i] != (x / s) * b + z * s * DIM1 + y * s + x % s) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], + (x / s) * b + z * s * DIM1 + y * s + x % s); } } @@ -568,74 +417,49 @@ main(int argc, char **argv) // open object for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } for (j = 0; j < OBJ_NUM; ++j) { - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[j][i] = i + 84441111 * j + 3; - } } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset[2] = 0; offset_length[0] = DIM0; offset_length[1] = DIM1; offset_length[2] = DIM2; - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -644,123 +468,78 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } - for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); + for (i = 0; i < OBJ_NUM; ++i) { + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // open object for (i = 0; i < OBJ_NUM; ++i) { sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_open(obj_name, pdc); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_open(obj_name, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset[1] = 0; offset[2] = 0; offset_length[0] = DIM0; offset_length[1] = DIM1; offset_length[2] = DIM2; - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); } if (start_method) { - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_start_all succeeded", + "Call to PDCregion_transfer_start_all failed"); } else { for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_start(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_start(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_start succeeded", "Call to PDCregion_transfer_start failed"); } } if (wait_method == 1) { - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); } else if (wait_method == 0) { pdcid_t *transfer_request_all = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); @@ -769,101 +548,58 @@ main(int argc, char **argv) transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + request_size = 0; for (i = 1; i < OBJ_NUM; i += 2) { transfer_request_all[request_size] = transfer_request[i]; request_size++; } - ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + + TASSERT(PDCregion_transfer_wait_all(transfer_request_all, request_size) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", + "Call to PDCregion_transfer_wait_all failed"); + free(transfer_request_all); } for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i + 84441111 * j + 3) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], 84441111 * j + 3); - ret_value = 1; - break; - } + if (data_read[j][i] != i + 84441111 * j + 3) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[j][i], 84441111 * j + 3); } } // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } - // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } - // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + // close object property + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close container property + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); free(obj); free(transfer_request); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_all_split_wait.c b/src/tests/region/region_transfer_all_split_wait.c index 15732a9fb..b583a20c2 100644 --- a/src/tests/region/region_transfer_all_split_wait.c +++ b/src/tests/region/region_transfer_all_split_wait.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 4096 #define OBJ_NUM 20 @@ -73,100 +75,71 @@ main(int argc, char **argv) LOG_INFO("create a new pdc\n"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); + // create a container property + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create many objects obj = (pdcid_t *)malloc(sizeof(pdcid_t) * OBJ_NUM); for (i = 0; i < OBJ_NUM; ++i) { switch (i % 4) { case 0: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 1: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC); + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_OBJ_STATIC) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } case 2: { - ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); - break; - } - case 3: { - /* ret = PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_DYNAMIC); */ + TASSERT(PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL) >= 0, + "Call to PDCprop_set_obj_transfer_region_type succeeded", + "Call to PDCprop_set_obj_transfer_region_type failed"); break; } default: { + break; } } sprintf(obj_name, "o%d_%d", i, rank); - obj[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj[i] > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); } offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create local region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create global region\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { data[j][i] = i; @@ -176,172 +149,95 @@ main(int argc, char **argv) // Place a transfer request for every objects for (i = 0; i < OBJ_NUM; ++i) { - transfer_request[i] = PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global); - } - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM / 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_start_all(transfer_request + OBJ_NUM / 2, OBJ_NUM / 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait_all(transfer_request + OBJ_NUM / 4, OBJ_NUM / 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM / 4); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_wait_all(transfer_request + OBJ_NUM * 3 / 4, OBJ_NUM / 4); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data[i], PDC_WRITE, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + } + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM / 2) >= 0, + "Call to PDCregion_transfer_start_all succeeded", "Call to PDCregion_transfer_start_all failed"); + TASSERT(PDCregion_transfer_start_all(transfer_request + OBJ_NUM / 2, OBJ_NUM / 2) >= 0, + "Call to PDCregion_transfer_start_all succeeded", "Call to PDCregion_transfer_start_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request + OBJ_NUM / 4, OBJ_NUM / 2) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM / 4) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request + OBJ_NUM * 3 / 4, OBJ_NUM / 4) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, + "Call to PDCregion_transfer_close succeeded", "Call to PDCregion_transfer_close failed"); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg_global = PDCregion_create(1, offset, offset_length); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < OBJ_NUM; ++i) { memset(data_read[i], 0, sizeof(int) * BUF_LEN); - transfer_request[i] = PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global); - } - ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM / 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_start_all(transfer_request + OBJ_NUM / 2, OBJ_NUM / 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait_all(transfer_request + OBJ_NUM / 4, OBJ_NUM / 2); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM / 4); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_wait_all(transfer_request + OBJ_NUM * 3 / 4, OBJ_NUM / 4); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT((transfer_request[i] = + PDCregion_transfer_create(data_read[i], PDC_READ, obj[i], reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + } + + TASSERT(PDCregion_transfer_start_all(transfer_request, OBJ_NUM / 2) >= 0, + "Call to PDCregion_transfer_start_all succeeded", "Call to PDCregion_transfer_start_all failed"); + TASSERT(PDCregion_transfer_start_all(transfer_request + OBJ_NUM / 2, OBJ_NUM / 2) >= 0, + "Call to PDCregion_transfer_start_all succeeded", "Call to PDCregion_transfer_start_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request + OBJ_NUM / 4, OBJ_NUM / 2) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request, OBJ_NUM / 4) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + TASSERT(PDCregion_transfer_wait_all(transfer_request + OBJ_NUM * 3 / 4, OBJ_NUM / 4) >= 0, + "Call to PDCregion_transfer_wait_all succeeded", "Call to PDCregion_transfer_wait_all failed"); + for (i = 0; i < OBJ_NUM; ++i) { - ret = PDCregion_transfer_close(transfer_request[i]); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_close(transfer_request[i]) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); } // close object - for (i = 0; i < OBJ_NUM; ++i) { - if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - } + for (i = 0; i < OBJ_NUM; ++i) + TASSERT(PDCobj_close(obj[i]) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // Check if data written previously has been correctly read. for (j = 0; j < OBJ_NUM; ++j) { for (i = 0; i < BUF_LEN; ++i) { - if (data_read[j][i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[j][i], i); - ret_value = 1; - break; - } + if (data_read[j][i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d\n", data_read[j][i], i); } } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + + // close container + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + // close object property + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close container property + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); - // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } - // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } - // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } free(data[0]); free(data_read[0]); free(data); free(data_read); free(obj); free(transfer_request); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_all_test.c b/src/tests/region/region_transfer_all_test.c index c40447b71..f3a1b4d36 100644 --- a/src/tests/region/region_transfer_all_test.c +++ b/src/tests/region/region_transfer_all_test.c @@ -78,7 +78,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -88,7 +88,7 @@ main(int argc, char **argv) LOG_ERROR("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -97,13 +97,13 @@ main(int argc, char **argv) LOG_ERROR("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, 1, dims); @@ -121,7 +121,7 @@ main(int argc, char **argv) LOG_ERROR("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -133,7 +133,7 @@ main(int argc, char **argv) LOG_INFO("Create local region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } @@ -144,7 +144,7 @@ main(int argc, char **argv) LOG_ERROR("Create global region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (j = 0; j < OBJ_NUM; ++j) { @@ -161,18 +161,18 @@ main(int argc, char **argv) ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -184,72 +184,72 @@ main(int argc, char **argv) ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - zv("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data[0]); free(data_read[0]); @@ -259,11 +259,11 @@ main(int argc, char **argv) free(transfer_request); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed PDC"); + LOG_INFO("Successfully closed PDC\n"); } #ifdef ENABLE_MPI MPI_Finalize(); diff --git a/src/tests/region/region_transfer_merge.c b/src/tests/region/region_transfer_merge.c index 323899e68..df1a2b6e6 100644 --- a/src/tests/region/region_transfer_merge.c +++ b/src/tests/region/region_transfer_merge.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -43,7 +45,7 @@ main(int argc, char **argv) pdcid_t transfer_request; int rank = 0, size = 1, i; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3]; uint64_t dims[1]; @@ -65,206 +67,126 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 2; - reg = PDCregion_create(1, offset, offset_length); - reg_global = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = BUF_LEN / 2; offset_length[0] = BUF_LEN / 2; - reg_global = PDCregion_create(1, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data + offset[0], PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = + PDCregion_transfer_create(data + offset[0], PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg_global = PDCregion_create(1, offset, offset_length); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d!\n", data_read[i], i); - ret_value = 1; - break; - } + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[i], i); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_overlap.c b/src/tests/region/region_transfer_overlap.c index 3facad7cf..a179eb5fa 100644 --- a/src/tests/region/region_transfer_overlap.c +++ b/src/tests/region/region_transfer_overlap.c @@ -71,35 +71,35 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, 1, dims); @@ -112,20 +112,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -146,11 +146,11 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 2; @@ -165,18 +165,18 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -197,26 +197,26 @@ main(int argc, char **argv) for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i + BUF_LEN / 4) { - LOG_ERROR("wrong value %d!=%d!\n", data_read[i], i + BUF_LEN / 4); + LOG_ERROR("Wrong value %d!=%d\n", data_read[i], i + BUF_LEN / 4); ret_value = 1; break; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Write the same object again. This time we test writing a region contained in the previously written @@ -240,19 +240,19 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Read the region that has been just written. offset[0] = 0; @@ -273,71 +273,71 @@ main(int argc, char **argv) for (i = 0; i < BUF_LEN / 2; ++i) { if (data_read[i] != i + BUF_LEN / 8 + BUF_LEN) { - LOG_ERROR("wrong value %d!=%d!\n", data_read[i], i + BUF_LEN / 8 + BUF_LEN); + LOG_ERROR("wrong value %d!=%d\n", data_read[i], i + BUF_LEN / 8 + BUF_LEN); ret_value = 1; break; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_overlap_2D.c b/src/tests/region/region_transfer_overlap_2D.c index ef5437b6c..cc610dbf5 100644 --- a/src/tests/region/region_transfer_overlap_2D.c +++ b/src/tests/region/region_transfer_overlap_2D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -43,7 +45,7 @@ main(int argc, char **argv) pdcid_t transfer_request; int rank = 0, size = 1, i; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3]; uint64_t dims[2]; @@ -66,300 +68,201 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 2, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg = PDCregion_create(2, offset, offset_length); - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); offset[0] = BUF_LEN / 8; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data + BUF_LEN / 2, PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = + PDCregion_transfer_create(data + BUF_LEN / 2, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = BUF_LEN / 16; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < BUF_LEN / 2; ++i) { - if (data_read[i] != i + BUF_LEN / 4) { - LOG_ERROR("i = %d, wrong value %d!=%d!\n", i, data_read[i], i + BUF_LEN / 4); - ret_value = 1; - break; - } - } - if (ret_value == 0) { - LOG_INFO("successfuly verified read 0\n"); + if (data_read[i] != i + BUF_LEN / 4) + TGOTO_ERROR(TFAIL, "i = %d, wrong value %d!=%d", i, data_read[i], i + BUF_LEN / 4); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } + if (ret_value == 0) + LOG_INFO("Successfuly verified read 0\n"); + + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } // Partial write for a region that has been written before offset[0] = 0; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = BUF_LEN / 32; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i + BUF_LEN; - } - - transfer_request = PDCregion_transfer_create(data + BUF_LEN / 8, PDC_WRITE, obj1, reg, reg_global); - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); + TASSERT((transfer_request = + PDCregion_transfer_create(data + BUF_LEN / 8, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = BUF_LEN / 32; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg_global = PDCregion_create(2, offset, offset_length); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 4; - reg = PDCregion_create(2, offset, offset_length); + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < BUF_LEN / 2; ++i) { - if (data_read[i] != i + BUF_LEN + BUF_LEN / 8) { - LOG_ERROR("i = %d, wrong value %d!=%d!\n", i, data_read[i], i + BUF_LEN + BUF_LEN / 8); - ret_value = 1; - break; - } - } - if (ret_value == 0) { - LOG_INFO("successfuly verified read 1\n"); + if (data_read[i] != i + BUF_LEN + BUF_LEN / 8) + TGOTO_ERROR(TFAIL, "i = %d, wrong value %d!=%d", i, data_read[i], i + BUF_LEN + BUF_LEN / 8); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + if (ret_value == 0) + LOG_INFO("Successfuly verified read 1\n"); + + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_overlap_3D.c b/src/tests/region/region_transfer_overlap_3D.c index 6e58dc053..6447ccae0 100644 --- a/src/tests/region/region_transfer_overlap_3D.c +++ b/src/tests/region/region_transfer_overlap_3D.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -43,7 +45,7 @@ main(int argc, char **argv) pdcid_t transfer_request; int rank = 0, size = 1, i; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3]; uint64_t dims[3]; @@ -67,69 +69,40 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 3, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; @@ -137,27 +110,25 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg = PDCregion_create(3, offset, offset_length); - reg_global = PDCregion_create(3, offset, offset_length); + TASSERT((reg = PDCregion_create(3, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = BUF_LEN / 8; offset_length[0] = BUF_LEN / 8; @@ -165,29 +136,22 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg_global = PDCregion_create(3, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data + BUF_LEN / 2, PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = + PDCregion_transfer_create(data + BUF_LEN / 2, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); + + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; @@ -195,46 +159,36 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg = PDCregion_create(3, offset, offset_length); + TASSERT((reg = PDCregion_create(3, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = BUF_LEN / 16; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg_global = PDCregion_create(3, offset, offset_length); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < BUF_LEN / 2; ++i) { - if (data_read[i] != i + BUF_LEN / 4) { - LOG_ERROR("i = %d, wrong value %d!=%d\n", i, data_read[i], i + BUF_LEN / 4); - ret_value = 1; - break; - } + if (data_read[i] != i + BUF_LEN / 4) + TGOTO_ERROR(TFAIL, "i = %d, wrong value %d!=%d", i, data_read[i], i + BUF_LEN / 4); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; @@ -242,41 +196,33 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg = PDCregion_create(3, offset, offset_length); + TASSERT((reg = PDCregion_create(3, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = BUF_LEN / 32; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg_global = PDCregion_create(3, offset, offset_length); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - for (i = 0; i < BUF_LEN; ++i) { + for (i = 0; i < BUF_LEN; ++i) data[i] = i + BUF_LEN; - } - - transfer_request = PDCregion_transfer_create(data + BUF_LEN / 8, PDC_WRITE, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = + PDCregion_transfer_create(data + BUF_LEN / 8, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN / 8; @@ -284,94 +230,53 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg = PDCregion_create(3, offset, offset_length); + TASSERT((reg = PDCregion_create(3, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); offset[0] = BUF_LEN / 32; offset_length[0] = BUF_LEN / 8; offset[1] = 0; offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg_global = PDCregion_create(3, offset, offset_length); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - PDCregion_transfer_start(transfer_request); - PDCregion_transfer_wait(transfer_request); - - PDCregion_transfer_close(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); for (i = 0; i < BUF_LEN / 2; ++i) { - if (data_read[i] != i + BUF_LEN / 8 + BUF_LEN) { - LOG_ERROR("i = %d, wrong value %d!=%d\n", i, data_read[i], i + BUF_LEN / 8 + BUF_LEN); - ret_value = 1; - break; - } - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); + if (data_read[i] != i + BUF_LEN / 8 + BUF_LEN) + TGOTO_ERROR(TFAIL, "i = %d, wrong value %d!=%d", i, data_read[i], i + BUF_LEN / 8 + BUF_LEN); } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + // close pdc + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + free(data); free(data_read); - // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_partial.c b/src/tests/region/region_transfer_partial.c index 9519135b1..071122ccc 100644 --- a/src/tests/region/region_transfer_partial.c +++ b/src/tests/region/region_transfer_partial.c @@ -73,7 +73,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -83,7 +83,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -92,13 +92,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, 1, dims); @@ -114,7 +114,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object @@ -124,7 +124,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -225,7 +225,7 @@ main(int argc, char **argv) } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { @@ -233,7 +233,7 @@ main(int argc, char **argv) } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { diff --git a/src/tests/region/region_transfer_query.c b/src/tests/region/region_transfer_query.c index 017f8c0cc..a9a762015 100644 --- a/src/tests/region/region_transfer_query.c +++ b/src/tests/region/region_transfer_query.c @@ -74,7 +74,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -84,7 +84,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -93,7 +93,7 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } @@ -115,7 +115,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -126,7 +126,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(1, offset, offset_length); @@ -134,7 +134,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (i = 0; i < BUF_LEN; ++i) { @@ -145,17 +145,17 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } @@ -181,58 +181,58 @@ main(int argc, char **argv) PDCselection_free(&sel); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj_id) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_read_only.c b/src/tests/region/region_transfer_read_only.c index feef7707a..d9324d712 100644 --- a/src/tests/region/region_transfer_read_only.c +++ b/src/tests/region/region_transfer_read_only.c @@ -65,7 +65,7 @@ main(int argc, char **argv) LOG_INFO("Open a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } @@ -76,7 +76,7 @@ main(int argc, char **argv) LOG_INFO("Open an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object @@ -86,7 +86,7 @@ main(int argc, char **argv) LOG_INFO("Open an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create third object @@ -96,7 +96,7 @@ main(int argc, char **argv) LOG_INFO("Open an object o3\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -109,12 +109,12 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } // Check if data written previously has been correctly read. @@ -127,23 +127,23 @@ main(int argc, char **argv) } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Read the second object @@ -156,7 +156,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(2, offset, offset_length); @@ -164,7 +164,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } memset(data_read, 0, BUF_LEN); @@ -172,12 +172,12 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } // Check if data written previously has been correctly read. @@ -190,23 +190,23 @@ main(int argc, char **argv) } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Read the third object @@ -221,7 +221,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(3, offset, offset_length); @@ -229,7 +229,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } memset(data_read, 0, BUF_LEN); @@ -237,12 +237,12 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } // Check if data written previously has been correctly read. @@ -255,58 +255,58 @@ main(int argc, char **argv) } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } if (PDCobj_close(obj3) < 0) { - LOG_ERROR("Failed to close object o3"); + LOG_ERROR("Failed to close object o3\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o3"); + LOG_INFO("Successfully closed object o3\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } free(data_read); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_set_dims.c b/src/tests/region/region_transfer_set_dims.c index d397006c8..802459227 100644 --- a/src/tests/region/region_transfer_set_dims.c +++ b/src/tests/region/region_transfer_set_dims.c @@ -89,7 +89,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -99,7 +99,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -108,7 +108,7 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } @@ -157,7 +157,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -169,7 +169,7 @@ main(int argc, char **argv) LOG_INFO("Create local region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } @@ -180,7 +180,7 @@ main(int argc, char **argv) LOG_INFO("Create global region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (j = 0; j < OBJ_NUM; ++j) { @@ -197,7 +197,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -205,7 +205,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -213,7 +213,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -226,7 +226,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -236,7 +236,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -244,24 +244,24 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -278,7 +278,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -286,7 +286,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -294,7 +294,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -307,7 +307,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -317,7 +317,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -325,7 +325,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -341,19 +341,19 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } dims[0] = BUF_LEN * 2; @@ -386,25 +386,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -412,7 +412,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -420,7 +420,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -433,7 +433,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -443,7 +443,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -451,7 +451,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -469,25 +469,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -495,7 +495,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -503,7 +503,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -516,7 +516,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -526,7 +526,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -534,7 +534,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -542,11 +542,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -569,7 +569,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -610,25 +610,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -636,7 +636,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -644,7 +644,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -657,7 +657,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -667,7 +667,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -675,7 +675,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -683,11 +683,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -705,27 +705,27 @@ main(int argc, char **argv) // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data[0]); free(data_read[0]); @@ -735,7 +735,7 @@ main(int argc, char **argv) free(transfer_request); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_set_dims_2D.c b/src/tests/region/region_transfer_set_dims_2D.c index 350f40852..e48a09444 100644 --- a/src/tests/region/region_transfer_set_dims_2D.c +++ b/src/tests/region/region_transfer_set_dims_2D.c @@ -92,7 +92,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -102,7 +102,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -111,13 +111,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, ndim, dims); @@ -150,7 +150,7 @@ main(int argc, char **argv) } } if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } @@ -160,7 +160,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -174,7 +174,7 @@ main(int argc, char **argv) LOG_INFO("Create local region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } @@ -187,7 +187,7 @@ main(int argc, char **argv) LOG_INFO("Create global region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (j = 0; j < OBJ_NUM; ++j) { @@ -204,7 +204,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -212,7 +212,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -220,7 +220,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -233,7 +233,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -243,7 +243,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -251,24 +251,24 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -285,7 +285,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -293,7 +293,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -301,7 +301,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -314,7 +314,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -324,7 +324,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -332,7 +332,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -348,19 +348,19 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } dims[0] = DIM0 * 2; @@ -373,7 +373,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { PDCobj_get_dims(obj[i], &ndim, &new_dims); if (new_dims[0] != DIM0 * 2 || new_dims[1] != DIM1) { - LOG_ERROR("wrong dimension reported after reset for rank %d\n", rank); + LOG_ERROR("Wrong dimension reported after reset for rank %d\n", rank); ret_value = 1; } free(new_dims); @@ -394,25 +394,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -420,7 +420,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -428,7 +428,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -441,7 +441,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -451,7 +451,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -459,7 +459,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -477,25 +477,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -503,7 +503,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -511,7 +511,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -524,7 +524,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -534,7 +534,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -542,7 +542,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -550,11 +550,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -577,7 +577,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -619,25 +619,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -645,7 +645,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -653,7 +653,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -666,7 +666,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -676,7 +676,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -684,7 +684,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -692,11 +692,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -715,27 +715,27 @@ main(int argc, char **argv) // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data[0]); free(data_read[0]); @@ -745,7 +745,7 @@ main(int argc, char **argv) free(transfer_request); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_set_dims_3D.c b/src/tests/region/region_transfer_set_dims_3D.c index dff1e7bb9..289ca716f 100644 --- a/src/tests/region/region_transfer_set_dims_3D.c +++ b/src/tests/region/region_transfer_set_dims_3D.c @@ -94,7 +94,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -104,7 +104,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -113,13 +113,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_dims(obj_prop, ndim, dims); @@ -152,7 +152,7 @@ main(int argc, char **argv) } } if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } @@ -162,7 +162,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -178,7 +178,7 @@ main(int argc, char **argv) LOG_INFO("Create local region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } @@ -193,7 +193,7 @@ main(int argc, char **argv) LOG_INFO("Create global region\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (j = 0; j < OBJ_NUM; ++j) { @@ -210,7 +210,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -218,7 +218,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -226,7 +226,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -239,7 +239,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -249,7 +249,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -257,24 +257,24 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -293,7 +293,7 @@ main(int argc, char **argv) if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -301,7 +301,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -309,7 +309,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -322,7 +322,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -332,7 +332,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -340,7 +340,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -356,19 +356,19 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } dims[0] = DIM0 * 2; @@ -405,25 +405,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -431,7 +431,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -439,7 +439,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -452,7 +452,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -462,7 +462,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -470,7 +470,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -490,25 +490,25 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { ret = PDCregion_transfer_start_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -516,7 +516,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -524,7 +524,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -537,7 +537,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -547,7 +547,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -555,7 +555,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -563,11 +563,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -590,7 +590,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } } @@ -635,19 +635,19 @@ main(int argc, char **argv) } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } if (start_method) { @@ -661,7 +661,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_start(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } } @@ -669,7 +669,7 @@ main(int argc, char **argv) if (wait_method == 1) { ret = PDCregion_transfer_wait_all(transfer_request, OBJ_NUM); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } } @@ -682,7 +682,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } request_size = 0; @@ -692,7 +692,7 @@ main(int argc, char **argv) } ret = PDCregion_transfer_wait_all(transfer_request_all, request_size); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } free(transfer_request_all); @@ -700,7 +700,7 @@ main(int argc, char **argv) for (i = 0; i < OBJ_NUM; ++i) { ret = PDCregion_transfer_close(transfer_request[i]); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } } @@ -708,11 +708,11 @@ main(int argc, char **argv) // close object for (i = 0; i < OBJ_NUM; ++i) { if (PDCobj_close(obj[i]) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } } @@ -731,27 +731,27 @@ main(int argc, char **argv) // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data[0]); free(data_read[0]); @@ -761,7 +761,7 @@ main(int argc, char **argv) free(transfer_request); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_skewed.c b/src/tests/region/region_transfer_skewed.c index c045d715d..1a2926aec 100644 --- a/src/tests/region/region_transfer_skewed.c +++ b/src/tests/region/region_transfer_skewed.c @@ -64,29 +64,29 @@ main(int argc, char **argv) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) { - LOG_INFO("Create a container property"); + LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container sprintf(cont_name, "c%d", rank); cont = PDCcont_create(cont_name, cont_prop); if (cont > 0) { - LOG_INFO("Create a container c1"); + LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop > 0) { - LOG_INFO("Create an object property"); + LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } @@ -105,20 +105,20 @@ main(int argc, char **argv) sprintf(obj_name1, "o1_%d", rank); obj1 = PDCobj_create(cont, obj_name1, obj_prop); if (obj1 > 0) { - LOG_INFO("Create an object o1"); + LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object sprintf(obj_name2, "o2_%d", rank); obj2 = PDCobj_create(cont, obj_name2, obj_prop); if (obj2 > 0) { - LOG_INFO("Create an object o2"); + LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -140,19 +140,19 @@ main(int argc, char **argv) PDCregion_transfer_close(transfer_request); if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = BUF_LEN / 2; @@ -178,59 +178,59 @@ main(int argc, char **argv) } } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully local region"); + LOG_INFO("successfully local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); free(data_read); diff --git a/src/tests/region/region_transfer_status.c b/src/tests/region/region_transfer_status.c index 6544ee322..7140b6bb0 100644 --- a/src/tests/region/region_transfer_status.c +++ b/src/tests/region/region_transfer_status.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -67,232 +69,134 @@ main(int argc, char **argv) MPI_Comm_size(MPI_COMM_WORLD, &size); #endif // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_dims(obj_prop, 1, dims); - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to (PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); for (i = 0; i < BUF_LEN; ++i) { data[i] = i; } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); - PDCregion_transfer_start(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); while (1) { - PDCregion_transfer_status(transfer_request, &completed); - if (completed == PDC_TRANSFER_STATUS_COMPLETE) { - break; - } - else if (completed == PDC_TRANSFER_STATUS_NOT_FOUND) { - LOG_ERROR("transfer request status not found"); - ret_value = 1; + TASSERT(PDCregion_transfer_status(transfer_request, &completed) >= 0, + "Call to region_transfer_status succeeded", "Call to region_transfer_status failed"); + if (completed == PDC_TRANSFER_STATUS_COMPLETE) break; - } + else if (completed == PDC_TRANSFER_STATUS_NOT_FOUND) + TGOTO_ERROR(FAIL, "Transfer request status not found"); sleep(1); } - PDCregion_transfer_status(transfer_request, &completed); - if (completed != PDC_TRANSFER_STATUS_NOT_FOUND) { - LOG_ERROR("transfer request status wrong value"); - ret_value = 1; - } - PDCregion_transfer_wait(transfer_request); - PDCregion_transfer_close(transfer_request); + TASSERT(PDCregion_transfer_status(transfer_request, &completed) >= 0, + "Call to region_transfer_status succeeded", "Call to region_transfer_status failed"); + if (completed != PDC_TRANSFER_STATUS_NOT_FOUND) + TGOTO_ERROR(TFAIL, "Transfer request status wrong value"); - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } - - reg = PDCregion_create(1, local_offset, offset_length); - reg_global = PDCregion_create(1, offset, offset_length); + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); + TASSERT((reg = PDCregion_create(1, local_offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - PDCregion_transfer_start(transfer_request); + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); while (1) { - PDCregion_transfer_status(transfer_request, &completed); - if (completed != PDC_TRANSFER_STATUS_PENDING) { - break; - } - else if (completed == PDC_TRANSFER_STATUS_NOT_FOUND) { - LOG_ERROR("transfer request status not found"); - ret_value = 1; + TASSERT(PDCregion_transfer_status(transfer_request, &completed) >= 0, + "Call to region_transfer_status succeeded", "Call to region_transfer_status failed"); + if (completed != PDC_TRANSFER_STATUS_PENDING) break; - } + else if (completed == PDC_TRANSFER_STATUS_NOT_FOUND) + TGOTO_ERROR(TFAIL, "Transfer request status not found"); sleep(1); } - PDCregion_transfer_status(transfer_request, &completed); - if (completed != PDC_TRANSFER_STATUS_NOT_FOUND) { - LOG_ERROR("transfer request status wrong value"); - ret_value = 1; - } + TASSERT(PDCregion_transfer_status(transfer_request, &completed) >= 0, + "Call to region_transfer_status succeeded", "Call to region_transfer_status failed"); + if (completed != PDC_TRANSFER_STATUS_NOT_FOUND) + TGOTO_ERROR(TFAIL, "Transfer request status wrong value"); - PDCregion_transfer_wait(transfer_request); - PDCregion_transfer_close(transfer_request); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d @ line\n", data_read[i], i); - ret_value = 1; - break; - } - } - - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully local region"); - } - - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d\n", data_read[i], i); } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); free(data); free(data_read); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/region/region_transfer_write_only.c b/src/tests/region/region_transfer_write_only.c index 759e063cc..bf7c22c0b 100644 --- a/src/tests/region/region_transfer_write_only.c +++ b/src/tests/region/region_transfer_write_only.c @@ -66,7 +66,7 @@ main(int argc, char **argv) LOG_INFO("Create a container property\n"); } else { - LOG_ERROR("Failed to create container property"); + LOG_ERROR("Failed to create container property\n"); ret_value = 1; } // create a container @@ -76,7 +76,7 @@ main(int argc, char **argv) LOG_INFO("Create a container c1\n"); } else { - LOG_ERROR("Failed to create container"); + LOG_ERROR("Failed to create container\n"); ret_value = 1; } // create an object property @@ -85,13 +85,13 @@ main(int argc, char **argv) LOG_INFO("Create an object property\n"); } else { - LOG_ERROR("Failed to create object property"); + LOG_ERROR("Failed to create object property\n"); ret_value = 1; } ret = PDCprop_set_obj_type(obj_prop, PDC_INT); if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); + LOG_ERROR("Failed to set obj type\n"); ret_value = 1; } PDCprop_set_obj_user_id(obj_prop, getuid()); @@ -108,7 +108,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o1\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create second object @@ -121,7 +121,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o2\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } // create third object @@ -135,7 +135,7 @@ main(int argc, char **argv) LOG_INFO("Create an object o3\n"); } else { - LOG_ERROR("Failed to create object"); + LOG_ERROR("Failed to create object\n"); ret_value = 1; } @@ -146,7 +146,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(1, offset, offset_length); @@ -154,7 +154,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (i = 0; i < BUF_LEN; ++i) { @@ -165,33 +165,33 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } offset[0] = 0; @@ -201,7 +201,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(1, offset, offset_length); @@ -209,7 +209,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (i = 0; i < BUF_LEN; ++i) { @@ -220,33 +220,33 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Write the second object offset[0] = 0; @@ -259,7 +259,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(2, offset, offset_length); @@ -267,7 +267,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (i = 0; i < BUF_LEN; ++i) { @@ -278,33 +278,33 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // Write the third object @@ -319,7 +319,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } reg_global = PDCregion_create(3, offset, offset_length); @@ -327,7 +327,7 @@ main(int argc, char **argv) LOG_INFO("Create an region o1\n"); } else { - LOG_ERROR("Failed to create region"); + LOG_ERROR("Failed to create region\n"); ret_value = 1; } for (i = 0; i < BUF_LEN; ++i) { @@ -338,85 +338,85 @@ main(int argc, char **argv) ret = PDCregion_transfer_start(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); + LOG_ERROR("Failed to region transfer start\n"); ret_value = 1; } ret = PDCregion_transfer_wait(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); + LOG_ERROR("Failed to region transfer wait\n"); ret_value = 1; } ret = PDCregion_transfer_close(transfer_request); if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); + LOG_ERROR("Failed to region transfer close\n"); ret_value = 1; } if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); + LOG_ERROR("Failed to close local region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed local region"); + LOG_INFO("successfully closed local region\n"); } if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); + LOG_ERROR("Failed to close global region\n"); ret_value = 1; } else { - LOG_INFO("successfully closed global region"); + LOG_INFO("successfully closed global region\n"); } // close object if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); + LOG_ERROR("Failed to close object o1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o1"); + LOG_INFO("Successfully closed object o1\n"); } if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); + LOG_ERROR("Failed to close object o2\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } if (PDCobj_close(obj3) < 0) { - LOG_ERROR("Failed to close object o3"); + LOG_ERROR("Failed to close object o3\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object o2"); + LOG_INFO("Successfully closed object o2\n"); } // close a container if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); + LOG_ERROR("Failed to close container c1\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container c1"); + LOG_INFO("Successfully closed container c1\n"); } // close a object property if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed object property"); + LOG_INFO("Successfully closed object property\n"); } // close a container property if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); + LOG_ERROR("Failed to close property\n"); ret_value = 1; } else { - LOG_INFO("Successfully closed container property"); + LOG_INFO("Successfully closed container property\n"); } free(data); // close pdc if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); + LOG_ERROR("Failed to close PDC\n"); ret_value = 1; } #ifdef ENABLE_MPI diff --git a/src/tests/region/region_transfer_write_read.c b/src/tests/region/region_transfer_write_read.c index dcf5a3507..6b678632c 100644 --- a/src/tests/region/region_transfer_write_read.c +++ b/src/tests/region/region_transfer_write_read.c @@ -31,6 +31,8 @@ #include #include #include "pdc.h" +#include "test_helper.h" + #define BUF_LEN 128 int @@ -43,7 +45,7 @@ main(int argc, char **argv) pdcid_t transfer_request; int rank = 0, size = 1, i; - int ret_value = 0; + int ret_value = TSUCCEED; uint64_t offset[3], offset_length[3]; uint64_t dims[3]; @@ -63,256 +65,129 @@ main(int argc, char **argv) MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #endif - // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + // create a pdc + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) { - LOG_INFO("Create a container property\n"); - } - else { - LOG_ERROR("Failed to create container property"); - ret_value = 1; - } + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container sprintf(cont_name, "c%d", rank); - cont = PDCcont_create(cont_name, cont_prop); - if (cont > 0) { - LOG_INFO("Create a container c1\n"); - } - else { - LOG_ERROR("Failed to create container"); - ret_value = 1; - } + TASSERT((cont = PDCcont_create(cont_name, cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop > 0) { - LOG_INFO("Create an object property\n"); - } - else { - LOG_ERROR("Failed to create object property"); - ret_value = 1; - } - - ret = PDCprop_set_obj_type(obj_prop, PDC_INT); - if (ret != SUCCEED) { - LOG_ERROR("Failed to set obj type"); - ret_value = 1; - } - PDCprop_set_obj_user_id(obj_prop, getuid()); - PDCprop_set_obj_time_step(obj_prop, 0); - PDCprop_set_obj_app_name(obj_prop, "DataServerTest"); - PDCprop_set_obj_tags(obj_prop, "tag0=1"); + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + + TASSERT(PDCprop_set_obj_type(obj_prop, PDC_INT) >= 0, "Call to PDCprop_set_obj_type succeeded", + "Call to PDCprop_set_obj_type failed"); + TASSERT(PDCprop_set_obj_user_id(obj_prop, getuid()) >= 0, "Call to PDCprop_set_obj_user_id succeeded", + "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_time_step(obj_prop, 0) >= 0, "Call to PDCprop_set_obj_time_step succeeded", + "Call to PDCprop_set_obj_time_step failed"); + TASSERT(PDCprop_set_obj_app_name(obj_prop, "DataServerTest") >= 0, + "Call to PDCprop_set_obj_user_id succeeded", "Call to PDCprop_set_obj_user_id failed"); + TASSERT(PDCprop_set_obj_tags(obj_prop, "tag0=1") >= 0, "Call to PDCprop_set_obj_tags succeeded", + "Call to PDCprop_set_obj_tags failed"); // create first object dims[0] = BUF_LEN; - PDCprop_set_obj_dims(obj_prop, 1, dims); + TASSERT(PDCprop_set_obj_dims(obj_prop, 1, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_create(cont, obj_name1, obj_prop); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_create(cont, obj_name1, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create second object dims[0] = BUF_LEN / 4; dims[1] = 4; - PDCprop_set_obj_dims(obj_prop, 2, dims); + TASSERT(PDCprop_set_obj_dims(obj_prop, 2, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_create(cont, obj_name2, obj_prop); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_create(cont, obj_name2, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); // create third object dims[0] = BUF_LEN / 4; dims[1] = 2; dims[2] = 2; - PDCprop_set_obj_dims(obj_prop, 3, dims); + TASSERT(PDCprop_set_obj_dims(obj_prop, 3, dims) >= 0, "Call to PDCprop_set_obj_dims succeeded", + "Call to PDCprop_set_obj_dims failed"); sprintf(obj_name3, "o3_%d", rank); - obj3 = PDCobj_create(cont, obj_name3, obj_prop); - if (obj3 > 0) { - LOG_INFO("Create an object o3\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj3 = PDCobj_create(cont, obj_name3, obj_prop)) != 0, "Call to PDCobj_create succeeded", + "Call to PDCobj_create failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - for (i = 0; i < BUF_LEN; ++i) { - data[i] = i; - } + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); + for (i = 0; i < BUF_LEN; ++i) + data[i] = i; - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); offset[0] = 0; offset_length[0] = BUF_LEN; - reg = PDCregion_create(1, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(1, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - for (i = 0; i < BUF_LEN; ++i) { + + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + for (i = 0; i < BUF_LEN; ++i) data[i] = i; - } - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global); + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } // Write the second object offset[0] = 0; offset_length[0] = BUF_LEN / 4; offset[1] = 0; offset_length[1] = 4; - reg = PDCregion_create(2, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - for (i = 0; i < BUF_LEN; ++i) { - data[i] = i; - } + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj2, reg, reg_global); + for (i = 0; i < BUF_LEN; ++i) + data[i] = i; - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj2, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // Write the third object offset[0] = 0; @@ -321,231 +196,93 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg = PDCregion_create(3, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - for (i = 0; i < BUF_LEN; ++i) { - data[i] = i; - } + TASSERT((reg = PDCregion_create(3, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); - transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj3, reg, reg_global); + for (i = 0; i < BUF_LEN; ++i) + data[i] = i; - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT((transfer_request = PDCregion_transfer_create(data, PDC_WRITE, obj3, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } - if (PDCobj_close(obj3) < 0) { - LOG_ERROR("Failed to close object o3"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj3) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close a container - if (PDCcont_close(cont) < 0) { - LOG_ERROR("Failed to close container c1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container c1"); - } + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close a object property - if (PDCprop_close(obj_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object property"); - } + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - LOG_ERROR("Failed to close property"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed container property"); - } + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + free(data); // create first object sprintf(obj_name1, "o1_%d", rank); - obj1 = PDCobj_open(obj_name1, pdc); - if (obj1 > 0) { - LOG_INFO("Create an object o1\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj1 = PDCobj_open(obj_name1, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); // create second object sprintf(obj_name2, "o2_%d", rank); - obj2 = PDCobj_open(obj_name2, pdc); - if (obj2 > 0) { - LOG_INFO("Create an object o2\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj2 = PDCobj_open(obj_name2, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); // create third object sprintf(obj_name3, "o3_%d", rank); - obj3 = PDCobj_open(obj_name3, pdc); - if (obj3 > 0) { - LOG_INFO("Create an object o3\n"); - } - else { - LOG_ERROR("Failed to create object"); - ret_value = 1; - } + TASSERT((obj3 = PDCobj_open(obj_name3, pdc)) != 0, "Call to PDCobj_open succeeded", + "Call to PDCobj_open failed"); offset[0] = 0; offset_length[0] = BUF_LEN; + TASSERT((reg = PDCregion_create(1, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(1, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - reg = PDCregion_create(1, offset, offset_length); - reg_global = PDCregion_create(1, offset, offset_length); - - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj1, reg, reg_global); - - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - // Check if data written previously has been correctly read. - for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } // Read the second object offset[0] = 0; offset_length[0] = BUF_LEN / 4; offset[1] = 0; offset_length[1] = 4; - reg = PDCregion_create(2, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(2, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + TASSERT((reg = PDCregion_create(2, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(2, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj2, reg, reg_global); - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } - // Check if data written previously has been correctly read. - for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); - } + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj2, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); // Read the third object offset[0] = 0; @@ -554,91 +291,42 @@ main(int argc, char **argv) offset_length[1] = 2; offset[2] = 0; offset_length[2] = 2; - reg = PDCregion_create(3, offset, offset_length); - if (reg > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } - reg_global = PDCregion_create(3, offset, offset_length); - if (reg_global > 0) { - LOG_INFO("Create an region o1\n"); - } - else { - LOG_ERROR("Failed to create region"); - ret_value = 1; - } + + TASSERT((reg = PDCregion_create(3, offset, offset_length)) != 0, "Call to PDCregion_create succeeded", + "Call to PDCregion_create failed"); + TASSERT((reg_global = PDCregion_create(3, offset, offset_length)) != 0, + "Call to PDCregion_create succeeded", "Call to PDCregion_create failed"); + memset(data_read, 0, BUF_LEN); - transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj3, reg, reg_global); - ret = PDCregion_transfer_start(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer start"); - ret_value = 1; - } - ret = PDCregion_transfer_wait(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer wait"); - ret_value = 1; - } + TASSERT((transfer_request = PDCregion_transfer_create(data_read, PDC_READ, obj3, reg, reg_global)) != 0, + "Call to PDCregion_transfer_create succeeded", "Call to PDCregion_transfer_create failed"); + TASSERT(PDCregion_transfer_start(transfer_request) >= 0, "Call to PDCregion_transfer_start succeeded", + "Call to PDCregion_transfer_start failed"); + TASSERT(PDCregion_transfer_wait(transfer_request) >= 0, "Call to PDCregion_transfer_wait succeeded", + "Call to PDCregion_transfer_wait failed"); + // Check if data written previously has been correctly read. for (i = 0; i < BUF_LEN; ++i) { - if (data_read[i] != i) { - LOG_ERROR("wrong value %d!=%d\n", data_read[i], i); - ret_value = 1; - break; - } - } - ret = PDCregion_transfer_close(transfer_request); - if (ret != SUCCEED) { - LOG_ERROR("Failed to region transfer close"); - ret_value = 1; - } - if (PDCregion_close(reg) < 0) { - LOG_ERROR("Failed to close local region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed local region"); + if (data_read[i] != i) + TGOTO_ERROR(TFAIL, "Wrong value %d!=%d", data_read[i], i); } - if (PDCregion_close(reg_global) < 0) { - LOG_ERROR("Failed to close global region"); - ret_value = 1; - } - else { - LOG_INFO("successfully closed global region"); - } + TASSERT(PDCregion_transfer_close(transfer_request) >= 0, "Call to PDCregion_transfer_close succeeded", + "Call to PDCregion_transfer_close failed"); - // close object - if (PDCobj_close(obj1) < 0) { - LOG_ERROR("Failed to close object o1"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o1"); - } - if (PDCobj_close(obj2) < 0) { - LOG_ERROR("Failed to close object o2"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } - if (PDCobj_close(obj3) < 0) { - LOG_ERROR("Failed to close object o3"); - ret_value = 1; - } - else { - LOG_INFO("Successfully closed object o2"); - } + // close regions + TASSERT(PDCregion_close(reg) >= 0, "Call to PDCregion_close succeeded", "Call to PDCregion_close failed"); + TASSERT(PDCregion_close(reg_global) >= 0, "Call to PDCregion_close succeeded", + "Call to PDCregion_close failed"); + // close objects + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); + TASSERT(PDCobj_close(obj3) >= 0, "Call to PDCobj_close succeeded", "Call to PDCobj_close failed"); // close pdc - if (PDCclose(pdc) < 0) { - LOG_ERROR("Failed to close PDC"); - ret_value = 1; - } + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif diff --git a/src/tests/tags/kvtag_add_get.c b/src/tests/tags/kvtag_add_get.c index 5915c405e..37511f615 100644 --- a/src/tests/tags/kvtag_add_get.c +++ b/src/tests/tags/kvtag_add_get.c @@ -28,7 +28,7 @@ #include #include #include "pdc.h" -#include "pdc_client_connect.h" +#include "test_helper.h" int main() @@ -41,51 +41,28 @@ main() pdc_var_type_t type1, type2, type3; void * value1, *value2, *value3; psize_t value_size; + int ret_value = SUCCEED; + int rank = 0; // create a pdc - pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop > 0) - LOG_INFO("Create a container property\n"); - else - LOG_ERROR("Failed to create container property"); - + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create("c1", cont_prop); - if (cont > 0) - LOG_INFO("Create a container c1\n"); - else - LOG_ERROR("Failed to create container"); - - // create an object property - obj_prop1 = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop1 > 0) - LOG_INFO("Create an object property\n"); - else - LOG_ERROR("Failed to create object property"); - - obj_prop2 = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop2 > 0) - LOG_INFO("Create an object property\n"); - else - LOG_ERROR("Failed to create object property"); - + TASSERT((cont = PDCcont_create("c1", cont_prop)) != 0, "Call to PDCcont_create succeeded", + "Call to PDCcont_create failed"); + // create object properties + TASSERT((obj_prop1 = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); + TASSERT((obj_prop2 = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create first object - obj1 = PDCobj_create(cont, "o1", obj_prop1); - if (obj1 > 0) - LOG_INFO("Create an object o1\n"); - else - LOG_ERROR("Failed to create object"); - + TASSERT((obj1 = PDCobj_create(cont, "o1", obj_prop1)) != 0, "Call to PDCobj_create succeeded for obj1", + "Call to PDCobj_create failed for obj1"); // create second object - obj2 = PDCobj_create(cont, "o2", obj_prop2); - if (obj2 > 0) - LOG_INFO("Create an object o2\n"); - else - LOG_ERROR("Failed to create object"); + TASSERT((obj2 = PDCobj_create(cont, "o2", obj_prop2)) != 0, "Call to PDCobj_create succeeded for obj2", + "Call to PDCobj_create failed for obj2"); kvtag1.name = "key1string"; kvtag1.value = (void *)v1; @@ -102,98 +79,49 @@ main() kvtag3.type = PDC_DOUBLE; kvtag3.size = sizeof(double); - if (PDCobj_put_tag(obj1, kvtag1.name, kvtag1.value, kvtag1.type, kvtag1.size) < 0) - LOG_ERROR("Failed to add a kvtag to o1\n"); - else - LOG_INFO("successfully added a kvtag to o1\n"); - - if (PDCobj_put_tag(obj2, kvtag2.name, kvtag2.value, kvtag2.type, kvtag2.size) < 0) - LOG_ERROR("Failed to add a kvtag to o1\n"); - else - LOG_INFO("successfully added a kvtag to o1\n"); - - if (PDCobj_put_tag(obj2, kvtag3.name, kvtag3.value, kvtag3.type, kvtag3.size) < 0) - LOG_ERROR("Failed to add a kvtag to o1\n"); - else - LOG_INFO("successfully added a kvtag to o1\n"); - - if (PDCobj_get_tag(obj1, kvtag1.name, (void *)&value1, (void *)&type1, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o1\n"); - else - LOG_INFO("successfully retrieved a kvtag [%s] = [%s] from o1\n", kvtag1.name, (char *)value1); - - if (PDCobj_get_tag(obj2, kvtag2.name, (void *)&value2, (void *)&type2, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o2\n"); - else - LOG_INFO("successfully retrieved a kvtag [%s] = [%d] from o2\n", kvtag2.name, *(int *)value2); - - if (PDCobj_get_tag(obj2, kvtag3.name, (void *)&value3, (void *)&type3, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o2\n"); - else - LOG_INFO("successfully retrieved a kvtag [%s] = [%f] from o2\n", kvtag3.name, *(double *)value3); - - if (PDCobj_del_tag(obj1, kvtag1.name) < 0) - LOG_ERROR("Failed to delete a kvtag from o1\n"); - else - LOG_INFO("successfully deleted a kvtag [%s] from o1\n", kvtag1.name); + // puts tags for obj1 + TASSERT(PDCobj_put_tag(obj1, kvtag1.name, kvtag1.value, kvtag1.type, kvtag1.size) >= 0, + "Call to PDCobj_put_tag succeeded for obj1", "Call to PDCobj_put_tag failed for obj1"); + TASSERT(PDCobj_put_tag(obj1, kvtag2.name, kvtag2.value, kvtag2.type, kvtag2.size) >= 0, + "Call to PDCobj_put_tag succeeded for obj1", "Call to PDCobj_put_tag failed for obj1"); + // put tag for obj2 + TASSERT(PDCobj_put_tag(obj2, kvtag3.name, kvtag3.value, kvtag3.type, kvtag3.size) >= 0, + "Call to PDCobj_put_tag succeeded for obj2", "Call to PDCobj_put_tag failed for obj2"); + // get tag for obj1 + TASSERT(PDCobj_get_tag(obj1, kvtag1.name, (void *)&value1, (void *)&type1, (void *)&value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj1", "Call to PDCobj_get_tag failed for obj1"); + // get tags for obj2 + TASSERT(PDCobj_get_tag(obj2, kvtag1.name, (void *)&value2, (void *)&type2, (void *)&value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj2", "Call to PDCobj_get_tag failed for obj2"); + TASSERT(PDCobj_get_tag(obj2, kvtag3.name, (void *)&value3, (void *)&type3, (void *)&value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj2", "Call to PDCobj_get_tag failed for obj2"); + // delete tag for obj1 + TASSERT(PDCobj_del_tag(obj1, kvtag1.name) >= 0, "Call to PDCobj_del_tag succeeded", + "Call to PDCobj_del_tag failed"); v1 = "New Value After Delete"; kvtag1.value = (void *)v1; kvtag1.type = PDC_STRING; kvtag1.size = strlen(v1) + 1; - if (PDCobj_put_tag(obj1, kvtag1.name, kvtag1.value, kvtag1.type, kvtag1.size) < 0) - LOG_ERROR("Failed to add a kvtag to o1\n"); - else - LOG_INFO("successfully added a kvtag to o1\n"); - - /* PDC_free_kvtag(&value1); */ - - if (PDCobj_get_tag(obj1, kvtag1.name, (void *)&value1, (void *)&type1, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o1\n"); - else - LOG_INFO("successfully retrieved a kvtag [%s] = [%s] from o1\n", kvtag1.name, (char *)value1); - - /* PDC_free_kvtag(&value1); */ - /* PDC_free_kvtag(&value2); */ - /* PDC_free_kvtag(&value3); */ - + TASSERT(PDCobj_put_tag(obj1, kvtag1.name, kvtag1.value, kvtag1.type, kvtag1.size) >= 0, + "Call to PDCobj_put_tag succeeded for obj1", "Call to PDCobj_put_tag failed for obj1"); + TASSERT(PDCobj_get_tag(obj1, kvtag1.name, (void *)&value1, (void *)&type1, (void *)&value_size) >= 0, + "Call to PDCobj_get_tag succeeded for obj1", "Call to PDCobj_get_tag failed for obj1"); // close first object - if (PDCobj_close(obj1) < 0) - LOG_ERROR("Failed to close object o1\n"); - else - LOG_INFO("Successfully closed object o1\n"); - + TASSERT(PDCobj_close(obj1) >= 0, "Call to PDCobj_close succeeded for obj1", + "Call to PDCobj_close failed for obj1"); // close second object - if (PDCobj_close(obj2) < 0) - LOG_ERROR("Failed to close object o2\n"); - else - LOG_INFO("Successfully closed object o2\n"); - + TASSERT(PDCobj_close(obj2) >= 0, "Call to PDCobj_close succeeded for obj2", + "Call to PDCobj_close failed for obj2"); // close a container - if (PDCcont_close(cont) < 0) - LOG_ERROR("Failed to close container c1\n"); - else - LOG_INFO("Successfully closed container c1\n"); - - // close a container property - if (PDCprop_close(obj_prop1) < 0) - LOG_ERROR("Failed to close property"); - else - LOG_INFO("Successfully closed object property\n"); - - if (PDCprop_close(obj_prop2) < 0) - LOG_ERROR("Failed to close property"); - else - LOG_INFO("Successfully closed object property\n"); - - if (PDCprop_close(cont_prop) < 0) - LOG_ERROR("Failed to close property"); - else - LOG_INFO("Successfully closed container property\n"); - + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); + // close properties + TASSERT(PDCprop_close(obj_prop1) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCprop_close(obj_prop2) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) - LOG_ERROR("Failed to close PDC\n"); + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); - return 0; +done: + return ret_value; } diff --git a/src/tests/tags/kvtag_add_get_benchmark.c b/src/tests/tags/kvtag_add_get_benchmark.c index e7d7bd196..11e888403 100644 --- a/src/tests/tags/kvtag_add_get_benchmark.c +++ b/src/tests/tags/kvtag_add_get_benchmark.c @@ -64,7 +64,7 @@ int assign_work_to_rank(uint64_t rank, uint64_t size, uint64_t nwork, uint64_t *my_count, uint64_t *my_start) { if (rank > size || my_count == NULL || my_start == NULL) { - LOG_ERROR("assign_work_to_rank(): Error with input!\n"); + LOG_ERROR("assign_work_to_rank(): Error with input\n"); return -1; } if (nwork < size) { @@ -337,6 +337,7 @@ main(int argc, char *argv[]) uint64_t total_object_count = 0, total_tag_count = 0, total_query_count = 0; void ** query_rst_cache; uint64_t *value_size; + int ret_value = SUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -359,14 +360,13 @@ main(int argc, char *argv[]) if (n_obj_incr > n_obj) { if (my_rank == 0) LOG_ERROR("n_obj_incr cannot be larger than n_obj! Exiting...\n"); - goto done; + PGOTO_DONE(FAIL); } if (n_query > n_obj_incr) { - if (my_rank == 0) { + if (my_rank == 0) LOG_ERROR("n_query cannot be larger than n_obj_incr! Exiting...\n"); - } - goto done; + PGOTO_DONE(FAIL); } if (my_rank == 0) @@ -380,7 +380,6 @@ main(int argc, char *argv[]) char **tag_values = gen_strings(n_attr, n_attr_len); do { - k++; #ifdef ENABLE_MPI @@ -461,7 +460,6 @@ main(int argc, char *argv[]) check_and_release_query_result(my_query, my_obj, my_obj_s, n_attr, tag_values, query_rst_cache, obj_ids); - fflush(stdout); my_obj_s += n_obj_incr; my_query_s += n_obj_incr; @@ -469,14 +467,14 @@ main(int argc, char *argv[]) } while (total_object_count < n_obj); if (my_rank == 0) { - LOG_ERROR("Final Report: \n"); + LOG_INFO("Final Report: \n"); LOG_INFO("[Final Report 1] Servers: %" PRIu64 " , Clients: %" PRIu64 " , C/S ratio: %.5e \n", n_servers, n_clients, (double)n_clients / (double)n_servers); LOG_INFO("[Final Report 2] Iterations: %" PRIu64 " , Objects: %" PRIu64 " , Tags/Object: %" PRIu64 " , Queries/Iteration: " "%" PRIu64 " , \n", k, total_object_count, n_attr, n_query); - LOG_INFO("[Final Report 3] Object throughput: %.5e , Tag Throughput: %.5e , Query Throughput: %.5e ,", + LOG_INFO("[Final Report 3] Object throughput: %.5e , Tag Throughput: %.5e , Query Throughput: %.5e\n", (double)total_object_count / total_object_time, (double)(total_object_count * n_attr) / total_tag_time, (double)(total_query_count * n_attr) / total_query_time); @@ -488,14 +486,10 @@ main(int argc, char *argv[]) free(tag_values); free(obj_ids); - // FIXME: the following is currently commented off to reduce node hours taken by time-consuming resource - // releasing procedure. - // closePDC(pdc, cont_prop, cont, obj_prop); - done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/tags/kvtag_add_get_scale.c b/src/tests/tags/kvtag_add_get_scale.c index 9c1bad2b2..aec25090a 100644 --- a/src/tests/tags/kvtag_add_get_scale.c +++ b/src/tests/tags/kvtag_add_get_scale.c @@ -34,7 +34,7 @@ int assign_work_to_rank(int rank, int size, int nwork, int *my_count, int *my_start) { if (rank > size || my_count == NULL || my_start == NULL) { - LOG_INFO("assign_work_to_rank(): Error with input!\n"); + LOG_INFO("assign_work_to_rank(): Error with input\n"); return -1; } if (nwork < size) { @@ -78,6 +78,8 @@ main(int argc, char *argv[]) void ** values; pdc_var_type_t value_type; size_t value_size; + int ret_value = SUCCEED; + #ifdef ENABLE_MPI MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &proc_num); @@ -86,7 +88,7 @@ main(int argc, char *argv[]) if (argc < 4) { if (my_rank == 0) print_usage(argv[0]); - goto done; + PGOTO_DONE(FAIL); } n_obj = atoi(argv[1]); n_add_tag = atoi(argv[2]); @@ -95,7 +97,7 @@ main(int argc, char *argv[]) if (n_add_tag > n_obj || n_query > n_obj) { if (my_rank == 0) LOG_ERROR("n_add_tag or n_query larger than n_obj! Exiting...\n"); - goto done; + PGOTO_DONE(FAIL); } assign_work_to_rank(my_rank, proc_num, n_add_tag, &my_add_tag, &my_add_tag_s); @@ -115,17 +117,17 @@ main(int argc, char *argv[]) // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop <= 0) - LOG_ERROR("Failed to create container property"); + PGOTO_ERROR(FAIL, "Failed to create container property"); // create a container cont = PDCcont_create("c1", cont_prop); if (cont <= 0) - LOG_ERROR("Failed to create container"); + PGOTO_ERROR(FAIL, "Failed to create container"); // create an object property obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop <= 0) - LOG_ERROR("Failed to create object property"); + PGOTO_ERROR(FAIL, "Failed to create object property"); // Create a number of objects, add at least one tag to that object obj_ids = (pdcid_t *)calloc(my_obj, sizeof(pdcid_t)); @@ -139,7 +141,7 @@ main(int argc, char *argv[]) sprintf(obj_name, "obj%d", my_obj_s + i); obj_ids[i] = PDCobj_create(cont, obj_name, obj_prop); if (obj_ids[i] <= 0) - LOG_ERROR("Failed to create object"); + PGOTO_ERROR(FAIL, "Failed to create object"); if (i > 0 && i % obj_1percent == 0) { #ifdef ENABLE_MPI @@ -178,7 +180,7 @@ main(int argc, char *argv[]) for (i = 0; i < my_add_tag; i++) { v = i + my_add_tag_s; if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); if (i % tag_1percent == 0) { #ifdef ENABLE_MPI @@ -212,7 +214,7 @@ main(int argc, char *argv[]) for (i = 0; i < my_query; i++) { if (PDCobj_get_tag(obj_ids[i], kvtag.name, (void *)&values[i], (void *)&value_type, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o%d\n", i + my_query_s); + PGOTO_ERROR(FAIL, "Failed to get a kvtag from o%d\n", i + my_query_s); if (i % query_1percent == 0) { #ifdef ENABLE_MPI @@ -237,17 +239,14 @@ main(int argc, char *argv[]) LOG_INFO("Total time to retrieve 1 tag from %11d objects: %7.2f , throughput %10.2f \n", n_query, total_time, n_query / total_time); - fflush(stdout); - for (i = 0; i < my_query; i++) { if (*(int *)(values[i]) != i + my_add_tag_s) - LOG_ERROR("Error with retrieved tag from o%d\n", i + my_query_s); + PGOTO_ERROR(FAIL, "Error with retrieved tag from o%d", i + my_query_s); free(values[i]); } free(values); if (my_rank == 0) { LOG_INFO("Done checking values\n"); - fflush(stdout); } done: @@ -255,5 +254,5 @@ main(int argc, char *argv[]) MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/tags/kvtag_affix_query_scale.c b/src/tests/tags/kvtag_affix_query_scale.c index 7470fc742..c153650fb 100644 --- a/src/tests/tags/kvtag_affix_query_scale.c +++ b/src/tests/tags/kvtag_affix_query_scale.c @@ -37,7 +37,7 @@ int assign_work_to_rank(int rank, int size, int nwork, int *my_count, int *my_start) { if (rank > size || my_count == NULL || my_start == NULL) { - LOG_ERROR("assign_work_to_rank(): Error with input!\n"); + LOG_ERROR("assign_work_to_rank(): Error with input\n"); return -1; } if (nwork < size) { @@ -90,23 +90,17 @@ prepare_container(pdcid_t *pdc, pdcid_t *cont_prop, pdcid_t *cont, pdcid_t *obj_ // create a container property *cont_prop = PDCprop_create(PDC_CONT_CREATE, *pdc); - if (*cont_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create container property\n", my_rank); - goto done; - } + if (*cont_prop <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create container property", my_rank); // create a container *cont = PDCcont_create("c1", *cont_prop); - if (*cont <= 0) { - LOG_ERROR("[Client %d] Fail to create container!\n", my_rank); - goto done; - } + if (*cont <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create container", my_rank); // create an object property *obj_prop = PDCprop_create(PDC_OBJ_CREATE, *pdc); - if (*obj_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create object property!\n", my_rank); - goto done; - } + if (*obj_prop <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create object property", my_rank); ret_value = SUCCEED; done: @@ -123,10 +117,8 @@ creating_objects(pdcid_t **obj_ids, int my_obj, int my_obj_s, pdcid_t cont, pdci for (int i = 0; i < my_obj; i++) { sprintf(obj_name, "obj%" PRId64 "%d", timestamp, my_obj_s + i); (*obj_ids)[i] = PDCobj_create(cont, obj_name, obj_prop); - if ((*obj_ids)[i] <= 0) { - LOG_ERROR("[Client %d] Fail to create object!\n", my_rank); - goto done; - } + if ((*obj_ids)[i] <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create object", my_rank); } ret_value = SUCCEED; done: @@ -146,6 +138,7 @@ main(int argc, char *argv[]) int nres, ntotal; int * my_cnt_round; int * total_cnt_round; + int ret_value = SUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -168,22 +161,21 @@ main(int argc, char *argv[]) int bypass_query = query_type == -1 ? 1 : 0; // prepare container - if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, my_rank) < 0) { - println("Failed to prepare container"); - goto done; - } + if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, my_rank) < 0) + PGOTO_ERROR(FAIL, "Failed to prepare container"); + // Create a number of objects, add at least one tag to that object assign_work_to_rank(my_rank, proc_num, n_obj, &my_obj, &my_obj_s); if (my_rank == 0) { - println("Each client will create about %d obj", my_obj); + LOG_INFO("Each client will create about %d obj\n", my_obj); } // creating objects creating_objects(&obj_ids, my_obj, my_obj_s, cont, obj_prop, my_rank); if (my_rank == 0) - println("All clients created %d objects", n_obj); + LOG_INFO("All clients created %d objects\n", n_obj); dart_object_ref_type_t ref_type = REF_PRIMARY_ID; dart_hash_algo_t hash_algo = DART_HASH; @@ -212,30 +204,25 @@ main(int argc, char *argv[]) kvtag.size = (strlen(tag_value) + 1) * sizeof(char); pdcid_t meta_id = PDC_obj_get_info(obj_ids[i])->obj_info_pub->meta_id; if (is_using_dart) { - if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } + if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); if (PDC_Client_insert_obj_ref_into_dart(hash_algo, kvtag.name, kvtag.value, kvtag.size, - kvtag.type, ref_type, meta_id) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } + kvtag.type, ref_type, meta_id) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); } else { - if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } + if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); } free(kvtag.name); free(kvtag.value); - // TODO: this is for checking the correctness of the query results. - // my_cnt_round[iter]++; + // TODO: Check correctness of the query results. } // TODO: why n_obj has to be larger than 1000? - if (my_rank == 0 /*&& n_obj > 1000 */) { - println("Rank %d: Added %d kvtag to the %d / %d th object, I'm applying selectivity %d to %d " - "objects.\n", - my_rank, round, i + 1, my_obj_after_selectivity, selectivity, my_obj); - } + if (my_rank == 0 /*&& n_obj > 1000 */) + LOG_INFO("Rank %d: Added %d kvtag to the %d / %d th object, I'm applying selectivity %d to %d " + "objects.\n", + my_rank, round, i + 1, my_obj_after_selectivity, selectivity, my_obj); } #ifdef ENABLE_MPI @@ -244,24 +231,22 @@ main(int argc, char *argv[]) #endif if (my_rank == 0) { - println("[TAG Creation] Rank %d: Added %d kvtag to %d objects, time: %.5f ms", my_rank, round, my_obj, - total_time * 1000.0); + LOG_INFO("[TAG Creation] Rank %d: Added %d kvtag to %d objects, time: %.5f ms\n", my_rank, round, + my_obj, total_time * 1000.0); } #ifdef ENABLE_MPI - // TODO: This is for checking the correctness of the query results. - // for (i = 0; i < round; i++) - // MPI_Allreduce(&my_cnt_round[i], &total_cnt_round[i], 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); + // TODO: Check correctness of the query results MPI_Barrier(MPI_COMM_WORLD); #endif if (bypass_query) { if (my_rank == 0) { - println("Rank %d: All queries are bypassed.", my_rank); + LOG_INFO("Rank %d: All queries are bypassed\n", my_rank); report_avg_server_profiling_rst(); } - goto done; + PGOTO_DONE(SUCCEED); } // For the queries, we issue #round queries. @@ -274,8 +259,7 @@ main(int argc, char *argv[]) for (comm_type = 1; comm_type >= 0; comm_type--) { for (query_type = 0; query_type < 4; query_type++) { - perr_t ret_value; - int round_total = 0; + int round_total = 0; for (iter = -1; iter < iter_round; iter++) { // -1 is for warm up #ifdef ENABLE_MPI if (iter == 0) { @@ -329,10 +313,8 @@ main(int argc, char *argv[]) ret_value = PDC_Client_query_kvtag(&kvtag, &nres, &pdc_ids); #endif } - if (ret_value < 0) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d\n", kvtag.name, my_rank); - break; - } + if (ret_value < 0) + PGOTO_ERROR(FAIL, "Failed to query kvtag [%s] with rank %d", kvtag.name, my_rank); // TODO: Check correctness of query results @@ -354,16 +336,16 @@ main(int argc, char *argv[]) query_type_str = "SUFFIX"; else if (query_type == 3) query_type_str = "INFIX"; - println("[%s Client %s Query with%sINDEX] %d rounds with %d results, time: %.5f ms", - comm_type == 0 ? "Single" : "Multi", query_type_str, - is_using_dart == 0 ? " NO " : " DART ", round, round_total, total_time * 1000.0); + LOG_INFO("[%s Client %s Query with%sINDEX] %d rounds with %d results, time: %.5f ms\n", + comm_type == 0 ? "Single" : "Multi", query_type_str, + is_using_dart == 0 ? " NO " : " DART ", round, round_total, total_time * 1000.0); } #endif } // end query type } // end comm type if (my_rank == 0) { - println("Rank %d: All queries are done.", my_rank); + LOG_INFO("Rank %d: All queries are done\n", my_rank); report_avg_server_profiling_rst(); } @@ -403,51 +385,36 @@ main(int argc, char *argv[]) total_time = MPI_Wtime() - stime; #endif if (my_rank == 0) { - println("[TAG Deletion] Rank %d: Deleted %d kvtag from %d objects, time: %.5f ms", my_rank, round, - my_obj, total_time * 1000.0); + LOG_INFO("[TAG Deletion] Rank %d: Deleted %d kvtag from %d objects, time: %.5f ms\n", my_rank, round, + my_obj, total_time * 1000.0); } -done: // close a container - if (PDCcont_close(cont) < 0) { - if (my_rank == 0) { - LOG_ERROR("Failed to close container c1\n"); - } - } - else { - if (my_rank == 0) - LOG_INFO("Successfully closed container c1\n"); - } + if (PDCcont_close(cont) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close container c1"); + else if (my_rank == 0) + LOG_INFO("Successfully closed container c1\n"); // close an object property - if (PDCprop_close(obj_prop) < 0) { - if (my_rank == 0) - LOG_ERROR("Failed to close property"); - } - else { - if (my_rank == 0) - LOG_INFO("Successfully closed object property\n"); - } + if (PDCprop_close(obj_prop) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close property"); + else if (my_rank == 0) + LOG_INFO("Successfully closed object property\n"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - if (my_rank == 0) - LOG_ERROR("Failed to close property"); - } - else { - if (my_rank == 0) - LOG_INFO("Successfully closed container property\n"); - } + if (PDCprop_close(cont_prop) < 0 && my_rank == 0) + LOG_ERROR("Failed to close property"); + else if (my_rank == 0) + LOG_INFO("Successfully closed container property\n"); // close pdc - if (PDCclose(pdc) < 0) { - if (my_rank == 0) - LOG_ERROR("Failed to close PDC\n"); - } + if (PDCclose(pdc) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close PDC\n"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/tags/kvtag_get.c b/src/tests/tags/kvtag_get.c index e66d98c23..0569b8c43 100644 --- a/src/tests/tags/kvtag_get.c +++ b/src/tests/tags/kvtag_get.c @@ -28,7 +28,6 @@ #include #include #include "pdc.h" -#include "pdc_client_connect.h" int main() @@ -37,74 +36,75 @@ main() pdc_kvtag_t * value1, *value2, *value3; pdc_var_type_t type1, type2, type3; psize_t value_size; + int ret_value = SUCCEED; // create a pdc pdc = PDCinit("pdc"); - LOG_INFO("create a new pdc\n"); + LOG_INFO("Created a new pdc\n"); // create a container property cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); if (cont_prop > 0) - LOG_INFO("Create a container property\n"); + LOG_INFO("Created a container property\n"); else - LOG_ERROR("Failed to create container property"); + PGOTO_ERROR(FAIL, "Failed to create container property"); // create a container cont = PDCcont_create("c1", cont_prop); if (cont > 0) - LOG_INFO("Create a container c1\n"); + LOG_INFO("Created a container c1\n"); else - LOG_ERROR("Failed to create container"); + PGOTO_ERROR(FAIL, "Failed to create container"); // create an object property obj_prop1 = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop1 > 0) - LOG_INFO("Create an object property\n"); + LOG_INFO("Created an object property\n"); else - LOG_ERROR("Failed to create object property"); + PGOTO_ERROR(FAIL, "Failed to create object property"); obj_prop2 = PDCprop_create(PDC_OBJ_CREATE, pdc); if (obj_prop2 > 0) - LOG_INFO("Create an object property\n"); + LOG_INFO("Created an object property\n"); else - LOG_ERROR("Failed to create object property"); + PGOTO_ERROR(FAIL, "Failed to create object property"); // create first object obj1 = PDCobj_create(cont, "o1", obj_prop1); if (obj1 > 0) - LOG_INFO("Create an object o1\n"); + LOG_INFO("Created an object o1\n"); else - LOG_ERROR("Failed to create object"); + PGOTO_ERROR(FAIL, "Failed to create object"); // create second object obj2 = PDCobj_create(cont, "o2", obj_prop2); if (obj2 > 0) - LOG_INFO("Create an object o2\n"); + LOG_INFO("Created an object o2\n"); else - LOG_ERROR("Failed to create object"); + PGOTO_ERROR(FAIL, "Failed to create object"); if (PDCobj_get_tag(obj1, "key1string", (void *)&value1, (void *)&type1, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o1\n"); + PGOTO_ERROR(FAIL, "Failed to get a kvtag from o1"); else - LOG_INFO("successfully retrieved a kvtag [%s] = [%s] from o1\n", value1->name, (char *)value1->value); + LOG_INFO("Successfully retrieved a kvtag [%s] = [%s] from o1\n", value1->name, (char *)value1->value); if (PDCobj_get_tag(obj2, "key2int", (void *)&value2, (void *)&type2, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o2\n"); + PGOTO_ERROR(FAIL, "Failed to get a kvtag from o2"); else - LOG_INFO("successfully retrieved a kvtag [%s] = [%d] from o2\n", value2->name, *(int *)value2->value); + LOG_INFO("Successfully retrieved a kvtag [%s] = [%d] from o2\n", value2->name, *(int *)value2->value); if (PDCobj_get_tag(obj2, "key3double", (void *)&value3, (void *)&type3, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o2\n"); + PGOTO_ERROR(FAIL, "Failed to get a kvtag from o2"); else - LOG_INFO("successfully retrieved a kvtag [%s] = [%f] from o2\n", value3->name, + LOG_INFO("Successfully retrieved a kvtag [%s] = [%f] from o2\n", value3->name, *(double *)value3->value); PDC_free_kvtag(&value1); if (PDCobj_get_tag(obj1, "key1string", (void *)&value1, (void *)&type1, (void *)&value_size) < 0) - LOG_ERROR("Failed to get a kvtag from o1\n"); + PGOTO_ERROR(FAIL, "Failed to get a kvtag from o1"); else - LOG_INFO("successfully retrieved a kvtag [%s] = [%s] from o1\n", value1->name, (char *)value1->value); + LOG_INFO("Successfully retrieved a kvtag [%s] = [%s] from o1\n", value1->name, (char *)value1->value); PDC_free_kvtag(&value1); PDC_free_kvtag(&value2); @@ -112,41 +112,42 @@ main() // close first object if (PDCobj_close(obj1) < 0) - LOG_ERROR("Failed to close object o1\n"); + PGOTO_ERROR(FAIL, "Failed to close object o1"); else LOG_INFO("Successfully closed object o1\n"); // close second object if (PDCobj_close(obj2) < 0) - LOG_ERROR("Failed to close object o2\n"); + PGOTO_ERROR(FAIL, "Failed to close object o2"); else LOG_INFO("Successfully closed object o2\n"); // close a container if (PDCcont_close(cont) < 0) - LOG_ERROR("Failed to close container c1\n"); + PGOTO_ERROR(FAIL, "Failed to close container c1"); else LOG_INFO("Successfully closed container c1\n"); // close a container property if (PDCprop_close(obj_prop1) < 0) - LOG_ERROR("Failed to close property"); + PGOTO_ERROR(FAIL, "Failed to close property"); else LOG_INFO("Successfully closed object property\n"); if (PDCprop_close(obj_prop2) < 0) - LOG_ERROR("Failed to close property"); + PGOTO_ERROR(FAIL, "Failed to close property"); else LOG_INFO("Successfully closed object property\n"); if (PDCprop_close(cont_prop) < 0) - LOG_ERROR("Failed to close property"); + PGOTO_ERROR(FAIL, "Failed to close property"); else LOG_INFO("Successfully closed container property\n"); // close pdc if (PDCclose(pdc) < 0) - LOG_ERROR("Failed to close PDC\n"); + PGOTO_ERROR(FAIL, "Failed to close PDC"); - return 0; +done: + return ret_value; } diff --git a/src/tests/tags/kvtag_query.c b/src/tests/tags/kvtag_query.c index 3f11bae79..8470d6f6d 100644 --- a/src/tests/tags/kvtag_query.c +++ b/src/tests/tags/kvtag_query.c @@ -28,13 +28,13 @@ #include #include #include "pdc.h" -#include "pdc_client_connect.h" +#include "test_helper.h" int assign_work_to_rank(int rank, int size, int nwork, int *my_count, int *my_start) { if (rank > size || my_count == NULL || my_start == NULL) { - LOG_ERROR("assign_work_to_rank(): Error with input!\n"); + LOG_ERROR("assign_work_to_rank(): Error with input\n"); return -1; } if (nwork < size) { @@ -82,23 +82,24 @@ main(int argc, char *argv[]) pdcid_t pdc, cont_prop, cont, obj_prop; pdcid_t * obj_ids; int n_obj, n_add_tag, my_obj, my_obj_s, my_add_tag, my_add_tag_s; - int proc_num = 1, my_rank = 0, i, v, iter, round, selectivity, is_using_dart; + int proc_num = 1, rank = 0, i, v, iter, round, selectivity, is_using_dart; char obj_name[128]; double stime, total_time; pdc_kvtag_t kvtag; uint64_t * pdc_ids; int nres, ntotal; + int ret_value = SUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &proc_num); - MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); #endif if (argc < 5) { - if (my_rank == 0) + if (rank == 0) print_usage(argv[0]); - goto done; + PGOTO_DONE(ret_value); } n_obj = atoi(argv[1]); round = atoi(argv[2]); @@ -107,39 +108,28 @@ main(int argc, char *argv[]) n_add_tag = n_obj * selectivity / 100; // create a pdc - pdc = PDCinit("pdc"); - + TASSERT((pdc = PDCinit("pdc")) != 0, "Call to PDCinit succeeded", "Call to PDCinit failed"); // create a container property - cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc); - if (cont_prop <= 0) - LOG_ERROR("Failed to create container property"); - + TASSERT((cont_prop = PDCprop_create(PDC_CONT_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // create a container - cont = PDCcont_create("c1", cont_prop); - if (cont <= 0) - LOG_ERROR("Failed to create container"); - + TASSERT((cont = PDCcont_create_col("c1", cont_prop)) != 0, "Call to PDCcont_create_col succeeded", + "Call to PDCcont_create_col failed"); // create an object property - obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc); - if (obj_prop <= 0) - LOG_ERROR("Failed to create object property"); - + TASSERT((obj_prop = PDCprop_create(PDC_OBJ_CREATE, pdc)) != 0, "Call to PDCprop_create succeeded", + "Call to PDCprop_create failed"); // Create a number of objects, add at least one tag to that object - assign_work_to_rank(my_rank, proc_num, n_obj, &my_obj, &my_obj_s); - if (my_rank == 0) - LOG_INFO("I will create %d obj\n", my_obj); + assign_work_to_rank(rank, proc_num, n_obj, &my_obj, &my_obj_s); obj_ids = (pdcid_t *)calloc(my_obj, sizeof(pdcid_t)); for (i = 0; i < my_obj; i++) { sprintf(obj_name, "obj%d", my_obj_s + i); - obj_ids[i] = PDCobj_create(cont, obj_name, obj_prop); - if (obj_ids[i] <= 0) - LOG_ERROR("Failed to create object"); + TASSERT((obj_ids[i] = PDCobj_create(cont, obj_name, obj_prop)) != 0, + "Call to PDCobj_create succeeded", "Call to PDCobj_create failed"); } - if (my_rank == 0) + if (rank == 0) LOG_INFO("Created %d objects\n", n_obj); - fflush(stdout); char *attr_name_per_rank = gen_random_strings(1, 6, 8, 26)[0]; // Add tags @@ -155,28 +145,22 @@ main(int argc, char *argv[]) dart_object_ref_type_t ref_type = REF_PRIMARY_ID; dart_hash_algo_t hash_algo = DART_HASH; - assign_work_to_rank(my_rank, proc_num, n_add_tag, &my_add_tag, &my_add_tag_s); + assign_work_to_rank(rank, proc_num, n_add_tag, &my_add_tag, &my_add_tag_s); // This is for adding #rounds tags to the objects. for (i = 0; i < my_add_tag; i++) { for (iter = 0; iter < round; iter++) { v = iter; sprintf(value, "%d", v); - if (is_using_dart) { - if (PDC_Client_insert_obj_ref_into_dart(hash_algo, kvtag.name, value, strlen(value), - PDC_STRING, ref_type, (uint64_t)obj_ids[i]) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } - } - else { - /* println("Rank %d: [%s] [%d], len %d\n", my_rank, kvtag.name, v, kvtag.size); */ - if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } - } + if (is_using_dart && + PDC_Client_insert_obj_ref_into_dart(hash_algo, kvtag.name, value, strlen(value), PDC_STRING, + ref_type, (uint64_t)obj_ids[i]) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d\n", i + my_obj_s); + else if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d\n", i + my_obj_s); } - if (my_rank == 0) - println("Rank %d: Added %d kvtag to the %d th object\n", my_rank, round, i); + if (rank == 0) + LOG_JUST_PRINT("Rank %d: Added %d kvtag to the %d th object\n", rank, round, i); } #ifdef ENABLE_MPI @@ -199,22 +183,23 @@ main(int argc, char *argv[]) sprintf(value, "%ld", v); sprintf(exact_query, "%s=%s", kvtag.name, value); #ifdef ENABLE_MPI - PDC_Client_search_obj_ref_through_dart_mpi(hash_algo, exact_query, ref_type, &nres, &pdc_ids, - MPI_COMM_WORLD); + if (PDC_Client_search_obj_ref_through_dart_mpi(hash_algo, exact_query, ref_type, &nres, &pdc_ids, + MPI_COMM_WORLD) < 0) { #else - PDC_Client_search_obj_ref_through_dart(hash_algo, exact_query, ref_type, &nres, &pdc_ids); + if (PDC_Client_search_obj_ref_through_dart(hash_algo, exact_query, ref_type, &nres, &pdc_ids) < + 0) { #endif + PGOTO_ERROR(TFAIL, "Failed to PDC_Client_search_obj_ref_through_dart_mpi\n", kvtag.name, + rank); + } } else { - /* println("Rank %d: round %d, query kvtag [%s] [%d]\n", my_rank, round, kvtag.name, - * *((int*)kvtag.value)); */ #ifdef ENABLE_MPI if (PDC_Client_query_kvtag_mpi(&kvtag, &nres, &pdc_ids, MPI_COMM_WORLD) < 0) { #else if (PDC_Client_query_kvtag(&kvtag, &nres, &pdc_ids) < 0) { #endif - LOG_ERROR("Failed to query kvtag [%s] with rank %d\n", kvtag.name, my_rank); - break; + PGOTO_ERROR(TFAIL, "Failed to query kvtag [%s] with rank %d\n", kvtag.name, rank); } } } @@ -224,36 +209,25 @@ main(int argc, char *argv[]) MPI_Reduce(&nres, &ntotal, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); total_time = MPI_Wtime() - stime; - if (my_rank == 0) - println("Total time to query %d objects with tag: %.5f", ntotal, total_time); + if (rank == 0) + LOG_INFO("Total time to query %d objects with tag: %.5f\n", ntotal, total_time); #else - println("Query found %d objects", nres); + LOG_INFO("Query found %d objects\n", nres); #endif // close a container - if (PDCcont_close(cont) < 0) - LOG_ERROR("Failed to close container c1\n"); - else - LOG_INFO("Successfully closed container c1\n"); - + TASSERT(PDCcont_close(cont) >= 0, "Call to PDCcont_close succeeded", "Call to PDCcont_close failed"); // close an object property - if (PDCprop_close(obj_prop) < 0) - LOG_ERROR("Failed to close property"); - else - LOG_INFO("Successfully closed object property\n"); - + TASSERT(PDCprop_close(obj_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close a container property - if (PDCprop_close(cont_prop) < 0) - LOG_ERROR("Failed to close property"); - else - LOG_INFO("Successfully closed container property\n"); + TASSERT(PDCprop_close(cont_prop) >= 0, "Call to PDCprop_close succeeded", "Call to PDCprop_close failed"); // close pdc - if (PDCclose(pdc) < 0) - LOG_ERROR("Failed to close PDC\n"); + TASSERT(PDCclose(pdc) >= 0, "Call to PDCclose succeeded", "Call to PDCclose failed"); + done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/tags/kvtag_range_query_scale.c b/src/tests/tags/kvtag_range_query_scale.c index 61bec3292..da9cec14d 100644 --- a/src/tests/tags/kvtag_range_query_scale.c +++ b/src/tests/tags/kvtag_range_query_scale.c @@ -32,13 +32,14 @@ #include "pdc_client_connect.h" #include "string_utils.h" -int +perr_t assign_work_to_rank(int rank, int size, int nwork, int *my_count, int *my_start) { - if (rank > size || my_count == NULL || my_start == NULL) { - LOG_ERROR("assign_work_to_rank(): Error with input!\n"); - return -1; - } + perr_t ret_value = SUCCEED; + + if (rank > size || my_count == NULL || my_start == NULL) + PGOTO_ERROR(FAIL, "Error with input"); + if (nwork < size) { if (rank < nwork) *my_count = 1; @@ -57,7 +58,8 @@ assign_work_to_rank(int rank, int size, int nwork, int *my_count, int *my_start) } } - return 1; +done: + return ret_value; } void @@ -83,31 +85,24 @@ print_usage(char *name) perr_t prepare_container(pdcid_t *pdc, pdcid_t *cont_prop, pdcid_t *cont, pdcid_t *obj_prop, int my_rank) { - perr_t ret_value = FAIL; + perr_t ret_value = SUCCEED; // create a pdc *pdc = PDCinit("pdc"); // create a container property *cont_prop = PDCprop_create(PDC_CONT_CREATE, *pdc); - if (*cont_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create container property!\n", my_rank); - goto done; - } + if (*cont_prop <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create container property", my_rank); // create a container *cont = PDCcont_create("c1", *cont_prop); - if (*cont <= 0) { - LOG_ERROR("[Client %d] Fail to create container!\n", my_rank); - goto done; - } + if (*cont <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create container", my_rank); // create an object property *obj_prop = PDCprop_create(PDC_OBJ_CREATE, *pdc); - if (*obj_prop <= 0) { - LOG_ERROR("[Client %d] Fail to create object property!\n", my_rank); - goto done; - } + if (*obj_prop <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create object property", my_rank); - ret_value = SUCCEED; done: return ret_value; } @@ -115,19 +110,16 @@ prepare_container(pdcid_t *pdc, pdcid_t *cont_prop, pdcid_t *cont, pdcid_t *obj_ perr_t creating_objects(pdcid_t **obj_ids, int my_obj, int my_obj_s, pdcid_t cont, pdcid_t obj_prop, int my_rank) { - perr_t ret_value = FAIL; + perr_t ret_value = SUCCEED; char obj_name[128]; int64_t timestamp = get_timestamp_ms(); *obj_ids = (pdcid_t *)calloc(my_obj, sizeof(pdcid_t)); for (int i = 0; i < my_obj; i++) { sprintf(obj_name, "obj%" PRId64 "%d", timestamp, my_obj_s + i); (*obj_ids)[i] = PDCobj_create(cont, obj_name, obj_prop); - if ((*obj_ids)[i] <= 0) { - LOG_ERROR("[Client %d] Fail to create object!\n", my_rank); - goto done; - } + if ((*obj_ids)[i] <= 0) + PGOTO_ERROR(FAIL, "[Client %d] Failed to create object", my_rank); } - ret_value = SUCCEED; done: return ret_value; } @@ -145,6 +137,7 @@ main(int argc, char *argv[]) int nres, ntotal; int * my_cnt_round; int * total_cnt_round; + int ret_value = SUCCEED; #ifdef ENABLE_MPI MPI_Init(&argc, &argv); @@ -155,7 +148,7 @@ main(int argc, char *argv[]) if (argc < 7) { if (my_rank == 0) print_usage(argv[0]); - goto done; + PGOTO_DONE(FAIL); } n_obj = atoi(argv[1]); round = atoi(argv[2]); @@ -167,17 +160,16 @@ main(int argc, char *argv[]) int bypass_query = query_type == -1 ? 1 : 0; // prepare container - if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, my_rank) < 0) { - LOG_ERROR("Failed to prepare container"); - goto done; - } + if (prepare_container(&pdc, &cont_prop, &cont, &obj_prop, my_rank) < 0) + PGOTO_ERROR(FAIL, "Failed to prepare container"); // Create a number of objects, add at least one tag to that object - assign_work_to_rank(my_rank, proc_num, n_obj, &my_obj, &my_obj_s); - - if (my_rank == 0) { - LOG_INFO("Each client will create about %d obj", my_obj); + if (assign_work_to_rank(my_rank, proc_num, n_obj, &my_obj, &my_obj_s) != SUCCEED) { + PGOTO_ERROR(FAIL, "Failed to assign_work_to_rank"); } + if (my_rank == 0) + LOG_INFO("Each client will create about %d objects", my_obj); + // creating objects creating_objects(&obj_ids, my_obj, my_obj_s, cont, obj_prop, my_rank); @@ -207,30 +199,25 @@ main(int argc, char *argv[]) snprintf(attr_name, 63, "attr_name"); kvtag.name = strdup(attr_name); kvtag.value = malloc(sizeof(int64_t)); - if (kvtag.value == NULL) { - LOG_ERROR("Failed to allocate tag_value\n"); - goto done; - } + if (kvtag.value == NULL) + PGOTO_ERROR(FAIL, "Failed to allocate tag_value"); int64_t iter_val = iter; memcpy(kvtag.value, &iter_val, sizeof(int64_t)); kvtag.type = PDC_INT64; kvtag.size = get_size_by_class_n_type(kvtag.value, 1, PDC_CLS_ITEM, PDC_INT64); pdcid_t meta_id = PDC_obj_get_info(obj_ids[i])->obj_info_pub->meta_id; if (is_using_dart) { - if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } + if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); // NOTE: object ID is a local ID, we need to get the global object metadata ID if (PDC_Client_insert_obj_ref_into_dart(hash_algo, kvtag.name, kvtag.value, kvtag.size, - kvtag.type, ref_type, meta_id) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } + kvtag.type, ref_type, meta_id) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); total_insert++; } else { - if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) { - LOG_ERROR("Failed to add a kvtag to o%d\n", i + my_obj_s); - } + if (PDCobj_put_tag(obj_ids[i], kvtag.name, kvtag.value, kvtag.type, kvtag.size) < 0) + PGOTO_ERROR(FAIL, "Failed to add a kvtag to o%d", i + my_obj_s); } free(kvtag.name); free(kvtag.value); @@ -239,9 +226,10 @@ main(int argc, char *argv[]) } // TODO: why n_obj has to be larger than 1000? if (my_rank == 0 /*&& n_obj > 1000 */) { - println("Rank %d: Added %d kvtag to the %d / %d th object, I'm applying selectivity %d to %d " - "objects.\n", - my_rank, round, i + 1, my_obj_after_selectivity, selectivity, my_obj); + LOG_JUST_PRINT( + "Rank %d: Added %d kvtag to the %d / %d th object, I'm applying selectivity %d to %d\n" + "objects.\n", + my_rank, round, i + 1, my_obj_after_selectivity, selectivity, my_obj); } } @@ -251,8 +239,9 @@ main(int argc, char *argv[]) #endif if (my_rank == 0) { - println("[TAG Creation] Rank %d: Added %d kvtag to %d objects, time: %.5f ms, dart_insert_count=%d", - my_rank, round, my_obj, total_time * 1000.0, get_dart_insert_count()); + LOG_JUST_PRINT( + "[TAG Creation] Rank %d: Added %d kvtag to %d objects, time: %.5f ms, dart_insert_count=%d\n", + my_rank, round, my_obj, total_time * 1000.0, get_dart_insert_count()); } #ifdef ENABLE_MPI @@ -265,24 +254,22 @@ main(int argc, char *argv[]) if (bypass_query) { if (my_rank == 0) { - println("Rank %d: All queries are bypassed.", my_rank); + LOG_JUST_PRINT("Rank %d: All queries are bypassed\n", my_rank); report_avg_server_profiling_rst(); } - goto done; + PGOTO_DONE(SUCCEED); } // For the queries, we issue #round queries. // The selectivity of each exact query should be #selectivity / 100 * #n_obj. // Namely, if you have 1M objects, selectivity is 10, then each query should return 100K objects. int iter_round = round; - if (comm_type == 0 && is_using_dart == 0) { + if (comm_type == 0 && is_using_dart == 0) iter_round = 2; - } for (comm_type = 1; comm_type >= 0; comm_type--) { for (query_type = 4; query_type < 6; query_type++) { - perr_t ret_value; - int round_total = 0; + int round_total = 0; for (iter = -1; iter < iter_round; iter++) { // -1 is for warm up #ifdef ENABLE_MPI if (iter == 0) { @@ -329,9 +316,6 @@ main(int argc, char *argv[]) else { kvtag.name = output.key_query; kvtag.value = output.value_query; - /* LOG_ERROR(" Rank %d: key [%s] value [%s]\n", my_rank, kvtag.name, - * kvtag.value); */ - #ifdef ENABLE_MPI ret_value = (comm_type == 0) ? PDC_Client_query_kvtag(&kvtag, &nres, &pdc_ids) @@ -340,18 +324,14 @@ main(int argc, char *argv[]) ret_value = PDC_Client_query_kvtag(&kvtag, &nres, &pdc_ids); #endif } - if (ret_value < 0) { - LOG_ERROR("Failed to query kvtag [%s] with rank %d\n", kvtag.name, my_rank); - break; - } + if (ret_value < 0) + PGOTO_ERROR(FAIL, "Failed to query kvtag [%s] with rank %d", kvtag.name, my_rank); // TODO: This is for checking the correctness of the query results. - if (iter >= 0) { - if (nres != total_cnt_round[iter]) - LOG_ERROR( - "Rank %d: query %d, comm %d, round %d - results %d do not match expected %d\n ", - my_rank, query_type, comm_type, iter, nres, total_cnt_round[iter]); - } + if (iter >= 0 && nres != total_cnt_round[iter]) + PGOTO_ERROR(FAIL, + "Rank %d: query %d, comm %d, round %d - results %d do not match expected %d", + my_rank, query_type, comm_type, iter, nres, total_cnt_round[iter]); round_total += nres; free(kvtag.name); @@ -369,21 +349,21 @@ main(int argc, char *argv[]) query_type_str = "EXACT"; else if (query_type == 5) query_type_str = "RANGE"; - println("[%s Client %s Query with%sINDEX] %d rounds with %d results, time: %.5f ms", - comm_type == 0 ? "Single" : "Multi", query_type_str, - is_using_dart == 0 ? " NO " : " DART ", round, round_total, total_time * 1000.0); + LOG_JUST_PRINT("[%s Client %s Query with%sINDEX] %d rounds with %d results, time: %.5f ms\n", + comm_type == 0 ? "Single" : "Multi", query_type_str, + is_using_dart == 0 ? " NO " : " DART ", round, round_total, + total_time * 1000.0); } #endif } // end query type } // end comm type if (my_rank == 0) { - println("Rank %d: All queries are done.", my_rank); + LOG_JUST_PRINT("Rank %d: All queries are done\n", my_rank); report_avg_server_profiling_rst(); } // delete all tags - #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); stime = MPI_Wtime(); @@ -397,10 +377,8 @@ main(int argc, char *argv[]) snprintf(attr_name, 63, "attr_name"); kvtag.name = strdup(attr_name); kvtag.value = malloc(sizeof(int64_t)); - if (kvtag.value == NULL) { - LOG_ERROR("Failed to allocate tag_value\n"); - goto done; - } + if (kvtag.value == NULL) + PGOTO_ERROR(FAIL, "Failed to allocate tag_value"); int64_t iter_val = iter; memcpy(kvtag.value, &iter_val, sizeof(int64_t)); kvtag.type = PDC_INT64; @@ -410,9 +388,8 @@ main(int argc, char *argv[]) PDC_Client_delete_obj_ref_from_dart(hash_algo, kvtag.name, (char *)kvtag.value, kvtag.size, kvtag.type, ref_type, meta_id); } - else { + else PDCobj_del_tag(obj_ids[i], kvtag.name); - } free(kvtag.name); free(kvtag.value); } @@ -422,52 +399,36 @@ main(int argc, char *argv[]) MPI_Barrier(MPI_COMM_WORLD); total_time = MPI_Wtime() - stime; #endif - if (my_rank == 0) { - println("[TAG Deletion] Rank %d: Deleted %d kvtag from %d objects, time: %.5f ms", my_rank, round, - my_obj, total_time * 1000.0); - } + if (my_rank == 0) + LOG_JUST_PRINT("[TAG Deletion] Rank %d: Deleted %d kvtag from %d objects, time: %.5f ms\n", my_rank, + round, my_obj, total_time * 1000.0); -done: // close a container - if (PDCcont_close(cont) < 0) { - if (my_rank == 0) { - LOG_ERROR("Failed to close container c1\n"); - } - } - else { - if (my_rank == 0) - LOG_INFO("Successfully closed container c1\n"); - } + if (PDCcont_close(cont) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close container c1"); + else if (my_rank == 0) + LOG_INFO("Successfully closed container c1\n"); // close an object property - if (PDCprop_close(obj_prop) < 0) { - if (my_rank == 0) - LOG_ERROR("Failed to close property"); - } - else { - if (my_rank == 0) - LOG_INFO("Successfully closed object property\n"); - } + if (PDCprop_close(obj_prop) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close property"); + else if (my_rank == 0) + LOG_INFO("Successfully closed object property\n"); // close a container property - if (PDCprop_close(cont_prop) < 0) { - if (my_rank == 0) - LOG_ERROR("Failed to close property"); - } - else { - if (my_rank == 0) - LOG_INFO("Successfully closed container property\n"); - } + if (PDCprop_close(cont_prop) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close property"); + else if (my_rank == 0) + LOG_INFO("Successfully closed container property\n"); // close pdc - if (PDCclose(pdc) < 0) { - if (my_rank == 0) - LOG_ERROR("Failed to close PDC\n"); - } + if (PDCclose(pdc) < 0 && my_rank == 0) + PGOTO_ERROR(FAIL, "Failed to close PDC"); +done: #ifdef ENABLE_MPI MPI_Finalize(); #endif - return 0; + return ret_value; } diff --git a/src/tests/transform/pdc_transforms_lib.c b/src/tests/transform/pdc_transforms_lib.c index a3a65e299..4d3d08e97 100644 --- a/src/tests/transform/pdc_transforms_lib.c +++ b/src/tests/transform/pdc_transforms_lib.c @@ -603,7 +603,7 @@ pdc_transform_increment(void *dataIn, PDC_var_type_t srcType, int ndim, uint64_t } break; default: - LOG_INFO("\n[TRANSFORM] Unable to increment values\n"); + LOG_ERROR("\n[TRANSFORM] Unable to increment values\n"); return -1; break; } @@ -650,9 +650,9 @@ pdc_transform_compress(void *dataIn, PDC_var_type_t srcType, int ndim, uint64_t csize = blosc_compress(clevel, doshuffle, typesize, nbytes, dataIn, destBuff, destsize); if (csize < 0) - LOG_INFO("[TRANSFORM] Error while compressing data (errcode: %ld)\n", csize); + LOG_ERROR("[TRANSFORM] Error while compressing data (errcode: %ld)\n", csize); if (csize == 0) - LOG_INFO("[TRANSFORM] Unable to compress data (errcode: %ld)\n", csize); + LOG_ERROR("[TRANSFORM] Unable to compress data (errcode: %ld)\n", csize); if (csize > 0) { LOG_INFO("[TRANSFORM] Data sucessfully compressed from %ld B to %ld B\n", nbytes, csize); @@ -688,8 +688,8 @@ pdc_transform_decompress(void *dataIn, PDC_var_type_t srcType, int ndim, uint64_ dsize = (size_t)blosc_decompress(dataIn, destBuff, destsize); if (dsize <= 0) - LOG_INFO("[TRANSFORM] Error while decompressing data (errcode: %zu)\n", dsize); + LOG_ERROR("[TRANSFORM] Error while decompressing data (errcode: %zu)\n", dsize); else - LOG_INFO("[TRANSFORM] Data sucessfully decompressed!\n"); + LOG_INFO("[TRANSFORM] Data sucessfully decompressed\n"); return dsize; } diff --git a/src/tools/hdf5_access_eqsim.c b/src/tools/hdf5_access_eqsim.c index b37b0956c..c251c9582 100644 --- a/src/tools/hdf5_access_eqsim.c +++ b/src/tools/hdf5_access_eqsim.c @@ -188,8 +188,8 @@ main(int argc, char **argv) LOG_INFO("Round %d: Scanning data took %.4lf\n", r, t1 - t0); } - LOG_INFO("Rank %d: %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n", rank, cnt[0], cnt[1], cnt[2], cnt[3], - cnt[4], cnt[5], cnt[6], cnt[7], cnt[8], cnt[9]); + LOG_INFO("%d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n", cnt[0], cnt[1], cnt[2], cnt[3], cnt[4], cnt[5], + cnt[6], cnt[7], cnt[8], cnt[9]); MPI_Barrier(MPI_COMM_WORLD); //=============PATTERN 2=============== @@ -211,8 +211,8 @@ main(int argc, char **argv) mspace = H5Screate_simple(4, size, NULL); if (nproc <= 16) - LOG_INFO("Rank %d: offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, offset[0], offset[1], - offset[2], size[0], size[1], size[2]); + LOG_INFO("Offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, offset[0], offset[1], offset[2], + size[0], size[1], size[2]); if (rank == 0) opensees_data = (double *)malloc(sizeof(double) * dims[0] * opensees_size * opensees_size); diff --git a/src/tools/meta_json/metadata_json_importer.c b/src/tools/meta_json/metadata_json_importer.c index d937325de..4a75e938a 100644 --- a/src/tools/meta_json/metadata_json_importer.c +++ b/src/tools/meta_json/metadata_json_importer.c @@ -88,7 +88,7 @@ import_object_base(cJSON *name, cJSON *type, cJSON *full_path, MD_JSON_ARGS *md_ pdc_importer_args_t *pdc_args = (pdc_importer_args_t *)md_json_args->processor_args; if (cJSON_GetStringValue(name) == NULL) { - LOG_ERROR("Object name is NULL!\n"); + LOG_ERROR("Object name is NULL\n"); return -1; } char datetime_buff[15]; @@ -101,18 +101,18 @@ import_object_base(cJSON *name, cJSON *type, cJSON *full_path, MD_JSON_ARGS *md_ sprintf(object_name, "%s_%d%s", cJSON_GetStringValue(name), md_json_args->mpi_rank, datetime_buff); pdc_args->obj_id = PDCobj_create(pdc_args->cont, object_name, pdc_args->obj_prop); if (pdc_args->obj_id <= 0) { - LOG_ERROR("Failed to create object!\n"); + LOG_ERROR("Failed to create object\n"); return -1; } if (PDCobj_put_tag(pdc_args->obj_id, "obj_full_path", (void *)cJSON_GetStringValue(full_path), PDC_STRING, strlen(cJSON_GetStringValue(full_path)) + 1) != SUCCEED) { - LOG_ERROR("Failed to put tag!\n"); + LOG_ERROR("Failed to put tag\n"); return -1; } if (PDCobj_put_tag(pdc_args->obj_id, "obj_type", (void *)cJSON_GetStringValue(type), PDC_STRING, strlen(cJSON_GetStringValue(type)) + 1) != SUCCEED) { - LOG_ERROR("Failed to put tag!\n"); + LOG_ERROR("Failed to put tag\n"); return -1; } @@ -170,7 +170,7 @@ import_object_property(cJSON *name, cJSON *type, cJSON *cls, cJSON *value, MD_JS if (PDCobj_put_tag(pdc_args->obj_id, name->valuestring, (void *)&property_value, pdc_type, property_value_size) != SUCCEED) { - LOG_ERROR("Failed to add tag!\n"); + LOG_ERROR("Failed to add tag\n"); } end: diff --git a/src/tools/metadata_json_loader.c b/src/tools/metadata_json_loader.c index 77ba9859f..6f6c2e6af 100644 --- a/src/tools/metadata_json_loader.c +++ b/src/tools/metadata_json_loader.c @@ -135,7 +135,7 @@ parseJSON(const char *jsonString, void *args) int num_objects = cJSON_GetArraySize(objects); #ifdef JMD_VERBOSE - println("Start to import %d objects...\n", num_objects); + LOG_JUST_PRINT("Start to import %d objects...\n", num_objects); timer_start(&total_timer); #endif @@ -153,7 +153,7 @@ parseJSON(const char *jsonString, void *args) int object_creation_result = md_json_processor->process_object_base(name, type, full_path, md_json_args); if (object_creation_result != 0) { - println("Error: failed to create object %s\n", cJSON_GetStringValue(name)); + LOG_ERROR("Error: failed to create object %s\n", cJSON_GetStringValue(name)); continue; } int num_properties = parseProperties(properties, md_json_args); @@ -161,13 +161,13 @@ parseJSON(const char *jsonString, void *args) md_json_args->total_prop_count += num_properties; #ifdef JMD_VERBOSE timer_pause(&obj_timer); - println(" Imported object %s with %d properties in %.4f ms.\n", cJSON_GetStringValue(name), - num_properties, timer_delta_ms(&obj_timer)); + LOG_JUST_PRINT(" Imported object %s with %d properties in %.4f ms.\n", cJSON_GetStringValue(name), + num_properties, timer_delta_ms(&obj_timer)); #endif } md_json_args->total_obj_count += num_objects; #ifdef JMD_VERBOSE - println("Imported %d objects in %.4f ms.\n", num_objects, timer_delta_ms(&total_timer)); + LOG_JUST_PRINT("Imported %d objects in %.4f ms.\n", num_objects, timer_delta_ms(&total_timer)); md_json_processor->complete_one_json_file(md_json_args); #endif end: @@ -259,10 +259,7 @@ main(int argc, char **argv) // check the current working directory char cwd[768]; - if (getcwd(cwd, sizeof(cwd)) != NULL) { - // println("Current working dir: %s\n", cwd); - } - else { + if (getcwd(cwd, sizeof(cwd)) == NULL) { perror("getcwd() error"); return 1; } @@ -287,7 +284,7 @@ main(int argc, char **argv) MD_JSON_ARGS *md_json_args = (MD_JSON_ARGS *)malloc(sizeof(MD_JSON_ARGS)); // we initialize PDC in the function below if (md_json_processor->init_processor(md_json_args) < 0) { - println("Error: failed to initialize the JSON processor.\n"); + LOG_ERROR("Error: failed to initialize the JSON processor.\n"); return EXIT_FAILURE; } @@ -322,11 +319,10 @@ main(int argc, char **argv) num_files = md_json_args->processed_file_count; #endif - if (rank == 0) { - println("Processed %d files, imported %" PRIu64 " objects and %" PRIu64 - " attributes. Total duration: %.4f seconds.\n", - num_files, total_obj_count, total_prop_count, duration); - } + if (rank == 0) + LOG_JUST_PRINT("Processed %d files, imported %" PRIu64 " objects and %" PRIu64 + " attributes. Total duration: %.4f seconds.\n", + num_files, total_obj_count, total_prop_count, duration); md_json_processor->finalize_processor(md_json_args); diff --git a/src/tools/pdc_access_eqsim.c b/src/tools/pdc_access_eqsim.c index 624895895..902a46fce 100644 --- a/src/tools/pdc_access_eqsim.c +++ b/src/tools/pdc_access_eqsim.c @@ -74,8 +74,8 @@ main(int argc, char **argv) remote_reg = PDCregion_create(3, pdc_offset, pdc_size); if (nproc <= 16) - LOG_INFO("Rank %d: offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, pdc_offset[0], - pdc_offset[1], pdc_offset[2], pdc_size[0], pdc_size[1], pdc_size[2]); + LOG_INFO("Offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, pdc_offset[0], pdc_offset[1], + pdc_offset[2], pdc_size[0], pdc_size[1], pdc_size[2]); // Tag retrieval sprintf(tag_name, "%llu-%llu\n", pdc_offset[1], pdc_offset[2]); diff --git a/src/tools/pdc_export.c b/src/tools/pdc_export.c index 473bf2e1f..bbe5039b4 100644 --- a/src/tools/pdc_export.c +++ b/src/tools/pdc_export.c @@ -390,7 +390,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) FILE *file = fopen(filename, "r"); if (file == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file open FAILED [%s]!", pdc_server_rank_g, filename); + LOG_ERROR("Checkpoint file open FAILED [%s]\n", filename); ret_value = FAIL; continue; } @@ -499,7 +499,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) LOG_ERROR("Read failed for n_region\n"); } if (n_region < 0) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file region number ERROR!", pdc_server_rank_g); + LOG_ERROR("Checkpoint file region number error\n"); ret_value = FAIL; continue; } @@ -525,8 +525,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) LOG_ERROR("Read failed for region_list->region_hist->nbin\n"); } if (region_list->region_hist->nbin == 0) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file histogram size is 0!", - pdc_server_rank_g); + LOG_ERROR("Checkpoint file histogram size is 0\n"); } region_list->region_hist->range = @@ -647,9 +646,8 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) MetadataNode * cur_metadata_node = metadata_head; pdc_metadata_t *cur_metadata; hid_t file_id; - fflush(stdout); - hid_t group_id; - hid_t dset_id; + hid_t group_id; + hid_t dset_id; // iterate through each node while (cur_metadata_node != NULL) { cur_metadata = cur_metadata_node->metadata_ptr; diff --git a/src/tools/pdc_import.c b/src/tools/pdc_import.c index 0fb670df6..25488baad 100644 --- a/src/tools/pdc_import.c +++ b/src/tools/pdc_import.c @@ -109,9 +109,6 @@ main(int argc, char **argv) int displs[MAX_FILES]; int total_dset = 0; container_names = newList(); - /* char* summary_fname = "/global/cscratch1/sd/houhun/tag_size_summary.csv"; */ - - /* summary_fp_g = fopen(summary_fname, "a+"); */ // create a pdc pdc_id_g = PDCinit("pdc"); @@ -156,7 +153,6 @@ main(int argc, char **argv) fclose(filenames_fp); LOG_INFO("Running with %d clients, %d files\n", size, total_count); - fflush(stdout); } } if (argc > 2) { @@ -209,10 +205,9 @@ main(int argc, char **argv) #endif - LOG_INFO("Importer%2d: Importing %d files\n", rank, my_count); + LOG_INFO("Importing %d files\n", my_count); for (i = 0; i < my_count; i++) - LOG_INFO("Importer%2d: [%s] \n", rank, my_filenames[i]); - fflush(stdout); + LOG_INFO("[%s] \n", my_filenames[i]); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); @@ -223,12 +218,10 @@ main(int argc, char **argv) for (i = 0; i < my_count; i++) { filename = my_filenames[i]; - LOG_INFO("Importer%2d: processing [%s]\n", rank, my_filenames[i]); - fflush(stdout); + LOG_INFO("Processing [%s]\n", my_filenames[i]); file = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT); if (file < 0) { LOG_ERROR("Failed to open file [%s]\n", filename); - fflush(stdout); continue; } @@ -266,8 +259,6 @@ main(int argc, char **argv) } } - /* fclose(summary_fp_g); */ - done: #ifdef ENABLE_MPI MPI_Finalize(); @@ -281,7 +272,6 @@ main(int argc, char **argv) * This can be used as a model to implement different actions and * searches. */ - void scan_group(hid_t gid, int level, char *app_name) { @@ -303,11 +293,6 @@ scan_group(hid_t gid, int level, char *app_name) */ len = H5Iget_name(gid, group_name, MAX_NAME); - /* - * process the attributes of the group, if any. - */ - // scan_attrs(gid); - /* * Get all the members of the groups, one at a time. */ @@ -346,7 +331,7 @@ scan_group(hid_t gid, int level, char *app_name) cont_id_g = PDCcont_create(group_name, cont_prop_g); if (cont_id_g <= 0) LOG_ERROR("Failed to create container"); - LOG_INFO("Importer%2d: Created container [%s]\n", rank, group_name); + LOG_INFO("Created container [%s]\n", group_name); add(container_names, group_name); } dsid = H5Dopen(gid, memb_name, H5P_DEFAULT); @@ -359,7 +344,7 @@ scan_group(hid_t gid, int level, char *app_name) H5Tclose(typeid); break; default: - LOG_ERROR(" Unknown Object Type!\n"); + LOG_ERROR(" Unknown Object Type\n"); break; } } @@ -465,7 +450,6 @@ do_dset(hid_t did, char *name, char *app_name) buf = malloc(dset_size); H5Dread(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf); - /* H5Pclose(pid); */ H5Tclose(tid); H5Sclose(sid); @@ -475,7 +459,6 @@ do_dset(hid_t did, char *name, char *app_name) scan_attrs(did, obj_id); - // pdc_metadata_t *meta = NULL; obj_region.ndim = ndim; for (i = 0; i < ndim; i++) { region_offset[i] = 0; @@ -502,7 +485,6 @@ do_dset(hid_t did, char *name, char *app_name) (write_timer_end_g.tv_nsec - write_timer_start_g.tv_nsec); // calculate duration in nanoseconds; LOG_INFO("Importer%2d: Finished written 100 objects, took %.2f, my total %d\n", rank, elapsed_time / 1e9, ndset_g); - fflush(stdout); clock_gettime(CLOCK_MONOTONIC, &write_timer_start_g); } @@ -530,27 +512,19 @@ do_dtype(hid_t tid, hid_t oid, int is_compound) hid_t atype, aspace, naive_type; H5T_class_t t_class, compound_class; t_class = H5Tget_class(tid); - if (t_class < 0) { - /* puts(" Invalid datatype.\n"); */ - } - else { + if (t_class >= 0) { attr_size = H5Tget_size(tid); /* * Each class has specific properties that can be * retrieved, e.g., attr_size, byte order, exponent, etc. */ if (t_class == H5T_INTEGER) { - /* puts(" 'H5T_INTEGER'."); */ return PDC_INT; - - /* display size, signed, endianess, etc. */ } else if (t_class == H5T_FLOAT) { - /* puts(" 'H5T_FLOAT'."); */ return PDC_FLOAT; } else if (t_class == H5T_STRING) { - /* puts(" 'H5T_STRING'."); */ return PDC_CHAR; } else if (t_class == H5T_COMPOUND) { diff --git a/src/tools/pdc_import_eqsim.c b/src/tools/pdc_import_eqsim.c index fe7099ede..a2ddae19c 100644 --- a/src/tools/pdc_import_eqsim.c +++ b/src/tools/pdc_import_eqsim.c @@ -67,7 +67,6 @@ main(int argc, char **argv) offset[2] = chunk_size[2] * start_y[rank]; offset[3] = 0; - /* size[0] = chunk_size[0]; */ size[0] = dims[0]; size[1] = chunk_size[1]; size[2] = chunk_size[2]; @@ -80,7 +79,6 @@ main(int argc, char **argv) local_offset[2] = 0; local_offset[3] = 0; - /* local_size[0] = chunk_size[0]; */ local_size[0] = dims[0]; local_size[1] = chunk_size[1]; local_size[2] = chunk_size[2]; @@ -91,8 +89,8 @@ main(int argc, char **argv) data = (double *)malloc(sizeof(double) * local_size[0] * local_size[1] * local_size[2]); if (nproc <= 16) - LOG_INFO("Rank %d: offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, offset[0], offset[1], - offset[2], size[0], size[1], size[2]); + LOG_INFO("Offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, offset[0], offset[1], offset[2], + size[0], size[1], size[2]); #ifdef ENABLE_MPI t0 = MPI_Wtime(); @@ -126,7 +124,7 @@ main(int argc, char **argv) pdc_dims[0] = dims[0]; pdc_dims[1] = max_start_x + chunk_size[1]; pdc_dims[2] = max_start_y + chunk_size[2]; - LOG_INFO("Rank %d: create obj dims %llu %llu %llu\n", rank, pdc_dims[0], pdc_dims[1], pdc_dims[2]); + LOG_INFO("Create obj dims %llu %llu %llu\n", rank, pdc_dims[0], pdc_dims[1], pdc_dims[2]); for (i = 0; i < 3; i++) { pdc_offset[i] = (uint64_t)offset[i]; @@ -149,7 +147,6 @@ main(int argc, char **argv) PDCprop_set_obj_transfer_region_type(obj_prop, PDC_REGION_LOCAL); obj = PDCobj_create_mpi(cont, "run1", obj_prop, 0, MPI_COMM_WORLD); - /* obj = PDCobj_create(cont, "run1", obj_prop); */ if (obj <= 0) LOG_ERROR("Failed to create object"); @@ -167,7 +164,7 @@ main(int argc, char **argv) value_size = 4 * sizeof(double); if (PDCobj_put_tag(obj, tag_name, tag_value, PDC_DOUBLE, value_size) < 0) - LOG_ERROR("Rank %d fail to put tag!\n", rank); + LOG_ERROR("Failed to put tag\n", rank); #ifdef ENABLE_MPI MPI_Barrier(MPI_COMM_WORLD); diff --git a/src/tools/pdc_ls.c b/src/tools/pdc_ls.c index 798a2c679..c9fae337e 100644 --- a/src/tools/pdc_ls.c +++ b/src/tools/pdc_ls.c @@ -446,7 +446,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) FILE *file = fopen(filename, "r"); if (file == NULL) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file open FAILED [%s]!", pdc_server_rank_g, filename); + LOG_ERROR("Checkpoint file open FAILED [%s]", filename); ret_value = FAIL; continue; } @@ -493,7 +493,6 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) entry->bloom = NULL; entry->metadata = NULL; - /* LOG_ERROR("size of metadata: %lu\n", sizeof(pdc_metadata_t)); */ metadata = (pdc_metadata_t *)calloc(sizeof(pdc_metadata_t), count); for (i = 0; i < count; i++) { if (fread(metadata + i, sizeof(pdc_metadata_t), 1, file) != 1) { @@ -563,7 +562,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) LOG_ERROR("Read failed for n_region\n"); } if (n_region < 0) { - LOG_ERROR("==PDC_SERVER[%d] Checkpoint file region number ERROR!", pdc_server_rank_g); + LOG_ERROR("Checkpoint file region number error\n"); ret_value = FAIL; continue; } @@ -589,8 +588,7 @@ pdc_ls(FileNameNode *file_name_node, int argc, char *argv[]) LOG_ERROR("Read failed for region_list->region_hist->nbin\n"); } if (region_list->region_hist->nbin == 0) { - LOG_ERROR("==PDC_SERVER[%d]: Checkpoint file histogram size is 0!", - pdc_server_rank_g); + LOG_ERROR("Checkpoint file histogram size is 0\n"); } region_list->region_hist->range = diff --git a/src/tools/pdc_query_eqsim.c b/src/tools/pdc_query_eqsim.c index cc62cc909..233249255 100644 --- a/src/tools/pdc_query_eqsim.c +++ b/src/tools/pdc_query_eqsim.c @@ -92,8 +92,8 @@ main(int argc, char **argv) data = (double *)malloc(sizeof(double) * local_size[0] * local_size[1] * local_size[2]); if (nproc <= 16) - LOG_INFO("Rank %d: offset %llu, %llu, %llu size %llu, %llu, %llu\n", rank, offset[0], offset[1], - offset[2], size[0], size[1], size[2]); + LOG_INFO("Offset %llu, %llu, %llu size %llu, %llu, %llu\n", offset[0], offset[1], offset[2], size[0], + size[1], size[2]); #ifdef ENABLE_MPI t0 = MPI_Wtime(); @@ -158,14 +158,14 @@ main(int argc, char **argv) value_size = 4 * sizeof(double); if (PDCobj_put_tag(obj, tag_name, tag_value, PDC_DOUBLE, value_size) < 0) - LOG_ERROR("Rank %d fail to put tag\n", rank); + LOG_ERROR("Failed to put tag\n", rank); // Query the created object pdc_metadata_t *metadata; uint32_t metadata_server_id; PDC_Client_query_metadata_name_timestep("run1", 0, &metadata, &metadata_server_id); if (metadata == NULL || metadata->obj_id == 0) { - LOG_ERROR("Error with metadata!\n"); + LOG_ERROR("Error with metadata\n"); } int ndim = 3; diff --git a/src/utils/pdc_interface.c b/src/utils/pdc_interface.c index 69ef92857..be38eb8b4 100644 --- a/src/utils/pdc_interface.c +++ b/src/utils/pdc_interface.c @@ -64,7 +64,6 @@ PDC_find_id(pdcid_t idid) PDC_LIST_SEARCH(ret_value, &type_ptr->ids, entry, id, idid); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -102,7 +101,6 @@ PDC_register_type(PDC_type_t type_id, PDC_free_t free_func) type_ptr->init_count++; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -118,12 +116,12 @@ PDC_id_register(PDC_type_t type, void *object) /* Check arguments */ if (type <= PDC_BADID || type >= PDC_next_type) - PGOTO_ERROR(ret_value, "invalid type number"); + PGOTO_ERROR(ret_value, "Invalid type number"); type_ptr = (pdc_id_list_g->PDC_id_type_list_g)[type]; if (NULL == type_ptr || type_ptr->init_count <= 0) - PGOTO_ERROR(ret_value, "invalid type"); + PGOTO_ERROR(ret_value, "Invalid type"); if (NULL == (id_ptr = (struct _pdc_id_info *)PDC_malloc(sizeof(struct _pdc_id_info)))) - PGOTO_ERROR(ret_value, "memory allocation failed"); + PGOTO_ERROR(ret_value, "Memory allocation failed"); /* Create the struct & it's ID */ PDC_MUTEX_LOCK(type_ptr->ids); @@ -145,7 +143,6 @@ PDC_id_register(PDC_type_t type, void *object) ret_value = new_id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -160,7 +157,7 @@ PDC_dec_ref(pdcid_t id) /* General lookup of the ID */ if (NULL == (id_ptr = PDC_find_id(id))) - PGOTO_ERROR(FAIL, "can't locate ID"); + PGOTO_ERROR(FAIL, "Cannot locate ID"); ret_value = hg_atomic_decr32(&(id_ptr->count)); if (ret_value == 0) { @@ -169,7 +166,7 @@ PDC_dec_ref(pdcid_t id) if (!type_ptr->free_func || (type_ptr->free_func)((void *)id_ptr->obj_ptr) >= 0) { /* check if list is empty before remove */ if (PDC_LIST_IS_EMPTY(&type_ptr->ids)) - PGOTO_ERROR(FAIL, "can't remove ID node"); + PGOTO_ERROR(FAIL, "Cannot remove ID node"); PDC_MUTEX_LOCK(type_ptr->ids); /* Remove the node from the type */ @@ -185,7 +182,6 @@ PDC_dec_ref(pdcid_t id) } done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -199,7 +195,7 @@ PDC_find_byname(PDC_type_t type, const char *byname) struct PDC_id_type * type_ptr; if (type <= PDC_BADID || type >= PDC_next_type) - PGOTO_ERROR(0, "invalid type number"); + PGOTO_ERROR(0, "Invalid type number"); type_ptr = (pdc_id_list_g->PDC_id_type_list_g)[type]; @@ -209,7 +205,6 @@ PDC_find_byname(PDC_type_t type, const char *byname) ret_value = id_ptr->id; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -223,13 +218,12 @@ PDC_inc_ref(pdcid_t id) /* General lookup of the ID */ if (NULL == (id_ptr = PDC_find_id(id))) - PGOTO_ERROR(0, "can't locate ID"); + PGOTO_ERROR(0, "Cannot locate ID"); /* Set return value */ ret_value = hg_atomic_incr32(&(id_ptr->count)); done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -242,14 +236,17 @@ PDC_id_list_null(PDC_type_t type) struct PDC_id_type *type_ptr; if (type <= PDC_BADID || type >= PDC_next_type) - PGOTO_ERROR(FAIL, "invalid type number"); + PGOTO_ERROR(FAIL, "Invalid type number"); + if (pdc_id_list_g == NULL) + PGOTO_ERROR(FAIL, "pdc_id_list_g was NULL"); type_ptr = (pdc_id_list_g->PDC_id_type_list_g)[type]; + if (type_ptr == NULL) + PGOTO_ERROR(FAIL, "type_ptr was NULL"); if (type_ptr->id_count != 0) ret_value = type_ptr->id_count; done: - fflush(stdout); FUNC_LEAVE(ret_value); } @@ -288,12 +285,13 @@ PDC_destroy_type(PDC_type_t type) perr_t ret_value = SUCCEED; struct PDC_id_type *type_ptr = NULL; + if (pdc_id_list_g == NULL) + PGOTO_ERROR(FAIL, "pdc_id_list_g was NULL"); type_ptr = (pdc_id_list_g->PDC_id_type_list_g)[type]; if (type_ptr == NULL) - PGOTO_ERROR(FAIL, "type was not initialized correctly"); + PGOTO_ERROR(FAIL, "Type was not initialized correctly"); type_ptr = (struct PDC_id_type *)(intptr_t)PDC_free(type_ptr); done: - fflush(stdout); FUNC_LEAVE(ret_value); } diff --git a/src/utils/pdc_region_utils.c b/src/utils/pdc_region_utils.c index 2be688f46..32a7d13d7 100644 --- a/src/utils/pdc_region_utils.c +++ b/src/utils/pdc_region_utils.c @@ -27,14 +27,14 @@ PDC_region_overlap_detect(int ndim, uint64_t *offset1, uint64_t *size1, uint64_t { FUNC_ENTER(NULL); + int ret_value = 0; int i; // First we check if two regions overlaps with each other. If any of the dimensions do not overlap, then // we are done. if (!check_overlap(ndim, offset1, size1, offset2, size2)) { *output_offset = NULL; *output_size = NULL; - LOG_DEBUG("PDC_region_overlap_detect, overlap detect failed\n"); - goto done; + PGOTO_DONE(ret_value); } // Overlapping exist. *output_offset = (uint64_t *)PDC_malloc(sizeof(uint64_t) * ndim * 2); @@ -47,7 +47,7 @@ PDC_region_overlap_detect(int ndim, uint64_t *offset1, uint64_t *size1, uint64_t } done: - FUNC_LEAVE(0); + FUNC_LEAVE(ret_value); } /*