//---------------------------------------------------------------- static int parse_var_list() { FILE *fp = fopen(var_list, "r"); if (fp == NULL) { fprintf(stdout, "Error Opening %s\n", var_list); return PIDX_err_file; } int variable_counter = 0, count = 0, len = 0; char *pch1; char line [ 512 ]; while (fgets(line, sizeof (line), fp) != NULL) { line[strcspn(line, "\r\n")] = 0; if (strcmp(line, "(fields)") == 0) { if( fgets(line, sizeof line, fp) == NULL) return PIDX_err_file; line[strcspn(line, "\r\n")] = 0; count = 0; variable_counter = 0; while (line[X] != '(') { pch1 = strtok(line, " +"); while (pch1 != NULL) { if (count == 0) { //char* temp_name = strdup(pch1); strcpy(var_name[variable_counter], pch1); //free(temp_name); } if (count == 1) { len = strlen(pch1) - 1; if (pch1[len] == '\n') pch1[len] = 0; strcpy(type_name[variable_counter], pch1); int ret; int bits_per_sample = 0; ret = PIDX_default_bits_per_datatype(type_name[variable_counter], &bits_per_sample); if (ret != PIDX_success) return PIDX_err_file; bpv[variable_counter] = bits_per_sample; vps[variable_counter] = 1; } count++; pch1 = strtok(NULL, " +"); } count = 0; if( fgets(line, sizeof line, fp) == NULL) return PIDX_err_file; line[strcspn(line, "\r\n")] = 0; variable_counter++; } variable_count = variable_counter; } } fclose(fp); int rank = 0; MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { int v = 0; for(v = 0; v < variable_count; v++) fprintf(stderr, "[%d] -> %s %d %d\n", v, var_name[v], bpv[v], vps[v]); } return PIDX_success; }
int main(int argc, char **argv) { int ret; int i, j, k; int var, vps; int slice = 0; int nprocs = 1, rank = 0; char output_file_name[512]; // MPI initialization #if PIDX_HAVE_MPI MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &rank); #endif double **data; // variable data buffer int *values_per_sample; // Example: 1 for scalar 3 for vector int local_box_offset[3]; if (rank == 0) { ret = parse_args(argc, argv); if (ret < 0) { usage(); #if PIDX_HAVE_MPI MPI_Abort(MPI_COMM_WORLD, -1); #else exit(-1); #endif } // check if the num procs is appropriate int num_bricks = (global_box_size[0] / local_box_size[0]) * (global_box_size[1] / local_box_size[1]) * (global_box_size[2] / local_box_size[2]); if(num_bricks != nprocs) { fprintf(stderr, "Error: number of sub-blocks (%d) doesn't match number of procs (%d)\n", num_bricks, nprocs); fprintf(stderr, "Incorrect distribution of data across processes i.e.\n(global_x / local_x) X (global_x / local_x) X (global_x / local_x) != nprocs\n(%d/%d) X (%d/%d) X (%d/%d) != %d\n", global_box_size[0], local_box_size[0], global_box_size[1], local_box_size[1], global_box_size[2], local_box_size[2], nprocs); #if PIDX_HAVE_MPI MPI_Abort(MPI_COMM_WORLD, -1); #else exit(-1); #endif } } // The command line arguments are shared by all processes #if PIDX_HAVE_MPI MPI_Bcast(global_box_size, 3, MPI_INT, 0, MPI_COMM_WORLD); MPI_Bcast(local_box_size, 3, MPI_INT, 0, MPI_COMM_WORLD); MPI_Bcast(&time_step_count, 1, MPI_INT, 0, MPI_COMM_WORLD); MPI_Bcast(&output_file_template, 512, MPI_CHAR, 0, MPI_COMM_WORLD); #endif // Creating the filename sprintf(output_file_name, "%s%s", output_file_template,".idx"); // Calculating every process data's offset and size int sub_div[3]; sub_div[0] = (global_box_size[0] / local_box_size[0]); sub_div[1] = (global_box_size[1] / local_box_size[1]); sub_div[2] = (global_box_size[2] / local_box_size[2]); local_box_offset[2] = (rank / (sub_div[0] * sub_div[1])) * local_box_size[2]; slice = rank % (sub_div[0] * sub_div[1]); local_box_offset[1] = (slice / sub_div[0]) * local_box_size[1]; local_box_offset[0] = (slice % sub_div[0]) * local_box_size[0]; PIDX_file file; // IDX file descriptor PIDX_variable* variable; // variable descriptor PIDX_point global_size, local_offset, local_size; PIDX_set_point_5D(global_size, global_box_size[0], global_box_size[1], global_box_size[2], 1, 1); PIDX_set_point_5D(local_offset, local_box_offset[0], local_box_offset[1], local_box_offset[2], 0, 0); PIDX_set_point_5D(local_size, local_box_size[0], local_box_size[1], local_box_size[2], 1, 1); // Creating access PIDX_access access; PIDX_create_access(&access); #if PIDX_HAVE_MPI PIDX_set_mpi_access(access, MPI_COMM_WORLD); #endif // PIDX mandatory calls ret = PIDX_file_open(output_file_name, PIDX_MODE_RDONLY, access, &file); if (ret != PIDX_success) report_error("PIDX_file_create", __FILE__, __LINE__); ret = PIDX_get_dims(file, global_size); if (ret != PIDX_success) report_error("PIDX_set_dims", __FILE__, __LINE__); ret = PIDX_get_variable_count(file, &variable_count); if (ret != PIDX_success) report_error("PIDX_set_variable_count", __FILE__, __LINE__); ret = PIDX_set_current_time_step(file, 0); if (ret != PIDX_success) report_error("PIDX_set_current_time_step", __FILE__, __LINE__); values_per_sample = malloc(sizeof(*values_per_sample) * variable_count); memset(values_per_sample, 0, sizeof(*values_per_sample) * variable_count); variable = malloc(sizeof(*variable) * variable_count); memset(variable, 0, sizeof(*variable) * variable_count); data = (double**)malloc(sizeof(*data) * variable_count); memset(data, 0, sizeof(*data) * variable_count); //printf("Variable Count %d\n", variable_count); for (var = 0; var < variable_count; var++) { ret = PIDX_get_next_variable(file, &variable[var]); if (ret != PIDX_success) report_error("PIDX_get_next_variable", __FILE__, __LINE__); values_per_sample[var] = variable[var]->values_per_sample; int bits_per_sample = 0; ret = PIDX_default_bits_per_datatype(variable[var]->type_name, &bits_per_sample); if (ret != PIDX_success) report_error("PIDX_default_bytes_per_datatype", __FILE__, __LINE__); data[var] = malloc((bits_per_sample/8) * local_box_size[0] * local_box_size[1] * local_box_size[2] * variable[var]->values_per_sample); memset(data[var], 0, (bits_per_sample/8) * local_box_size[0] * local_box_size[1] * local_box_size[2] * variable[var]->values_per_sample); ret = PIDX_read_next_variable(file, variable[var]); if (ret != PIDX_success) report_error("PIDX_read_next_variable", __FILE__, __LINE__); } ret = PIDX_reset_variable_counter(file); if (ret != PIDX_success) report_error("PIDX_reset_variable_counter", __FILE__, __LINE__); for (var = 0; var < variable_count; var++) { ret = PIDX_get_next_variable(file, &variable[var]); if (ret != PIDX_success) report_error("PIDX_get_next_variable", __FILE__, __LINE__); ret = PIDX_variable_read_data_layout(variable[var], local_offset, local_size, data[var], PIDX_row_major); if (ret != PIDX_success) report_error("PIDX_variable_read_data_layout", __FILE__, __LINE__); ret = PIDX_read_next_variable(file, variable[var]); if (ret != PIDX_success) report_error("PIDX_read_next_variable", __FILE__, __LINE__); } ret = PIDX_close(file); if (ret != PIDX_success) report_error("PIDX_close", __FILE__, __LINE__); ret = PIDX_close_access(access); if (ret != PIDX_success) report_error("PIDX_close_access", __FILE__, __LINE__); int read_error_count = 0, read_count = 0; for(var = 0; var < variable_count; var++) { for (k = 0; k < local_box_size[2]; k++) for (j = 0; j < local_box_size[1]; j++) for (i = 0; i < local_box_size[0]; i++) { int64_t index = (int64_t) (local_box_size[0] * local_box_size[1] * k) + (local_box_size[0] * j) + i; for (vps = 0; vps < values_per_sample[var]; vps++) if (data[var][index * values_per_sample[var] + vps] != 100 + var + vps + ((global_box_size[0] * global_box_size[1]*(local_box_offset[2] + k))+(global_box_size[0]*(local_box_offset[1] + j)) + (local_box_offset[0] + i))) { read_error_count++; if (rank == 0) printf("[%d %d %d] Read error %f %d\n", i,j ,k, data[var][index * values_per_sample[var] + vps], 100 + var + vps + ((global_box_size[0] * global_box_size[1]*(local_box_offset[2] + k))+(global_box_size[0]*(local_box_offset[1] + j)) + (local_box_offset[0] + i))); } else read_count++; } } int var_sample_count = 0; for(var = 0; var < variable_count; var++) var_sample_count = var_sample_count + values_per_sample[var]; printf("Read Error Count + Right Count : [%d + %d] Total Count = %d\n", read_error_count, read_count, global_box_size[0]*global_box_size[1]*global_box_size[2] * var_sample_count); for(var = 0; var < variable_count; var++) { free(data[var]); data[var] = 0; } free(data); data = 0; free(values_per_sample); // MPI finalize #if PIDX_HAVE_MPI MPI_Finalize(); #endif return 0; }