//----------------------------------------------------------------
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;
}
