int main(int argc, char **argv)
{
int ts = 0, var = 0;
init_mpi(argc, argv);
parse_args(argc, argv);
check_args();
calculate_per_process_offsets();
create_synthetic_simulation_data();
rank_0_print("Simulation Data Created\n");
create_pidx_var_point_and_access();
for (ts = 0; ts < time_step_count; ts++)
{
set_pidx_file(ts);
for (var = 0; var < variable_count; var++)
set_pidx_variable(var);
PIDX_close(file);
}
destroy_pidx_var_point_and_access();
destroy_synthetic_simulation_data();
shutdown_mpi();
return 0;
}
/// main
int main(int argc, char **argv)
{
init_mpi(argc, argv);
parse_args(argc, argv);
check_args();
calculate_per_process_offsets();
create_synthetic_simulation_data();
int var, p;
PIDX_point global_bounding_box, **local_offset_point, **local_box_count_point;
local_offset_point = malloc(sizeof(PIDX_point*) * variable_count);
local_box_count_point = malloc(sizeof(PIDX_point*) * variable_count);
for(var = 0; var < variable_count; var++)
{
local_offset_point[var] = malloc(sizeof(PIDX_point) * patch_count);
local_box_count_point[var] = malloc(sizeof(PIDX_point) * patch_count);
for(p = 0 ; p < patch_count ; p++)
{
PIDX_set_point_5D(local_offset_point[var][p], (int64_t)var_offset[var][p][0], (int64_t)var_offset[var][p][1], (int64_t)var_offset[var][p][2], 0, 0);
PIDX_set_point_5D(local_box_count_point[var][p], (int64_t)var_count[var][p][0], (int64_t)var_count[var][p][1], (int64_t)var_count[var][p][2], 1, 1);
}
}
PIDX_file file; // IDX file descriptor
PIDX_variable* variable; // variable descriptor
variable = malloc(sizeof(*variable) * variable_count);
memset(variable, 0, sizeof(*variable) * variable_count);
PIDX_set_point_5D(global_bounding_box, (int64_t)global_box_size[0], (int64_t)global_box_size[1], (int64_t)global_box_size[2], 1, 1);
PIDX_access access;
PIDX_create_access(&access);
#if PIDX_HAVE_MPI
PIDX_set_mpi_access(access, MPI_COMM_WORLD);
#endif
int ts;
for (ts = 0; ts < time_step_count; ts++)
{
PIDX_file_create(output_file_name, PIDX_MODE_CREATE, access, &file);
PIDX_set_dims(file, global_bounding_box);
PIDX_set_current_time_step(file, ts);
PIDX_set_variable_count(file, variable_count);
PIDX_debug_rst(file, 1);
PIDX_debug_hz(file, 1);
for (var = 0; var < variable_count; var++)
{
char variable_name[512];
sprintf(variable_name, "variable_%d", var);
PIDX_variable_create(variable_name, sizeof(double) * 8, FLOAT64, &variable[var]);
for (p = 0 ; p < patch_count ; p++)
PIDX_variable_write_data_layout(variable[var], local_offset_point[var][p], local_box_count_point[var][p], double_data[var][p], PIDX_row_major);
PIDX_append_and_write_variable(file, variable[var]/*, local_offset_point[var][p], local_box_count_point[var][p], double_data[var][p], PIDX_row_major*/);
}
PIDX_close(file);
}
PIDX_close_access(access);
destroy_synthetic_simulation_data();
for(var = 0; var < variable_count; var++)
{
free(local_offset_point[var]);
free(local_box_count_point[var]);
}
free(local_offset_point);
free(local_box_count_point);
free(variable);
variable = 0;
shutdown_mpi();
return 0;
}
int main(int argc, char **argv)
{
init_mpi(argc, argv);
parse_args(argc, argv);
check_args();
calculate_per_process_offsets();
create_synthetic_simulation_data();
rank_0_print("Simulation Data Created\n");
int ret;
int var;
int ts;
PIDX_file file; // IDX file descriptor
PIDX_variable* variable; // variable descriptor
variable = malloc(sizeof(*variable) * variable_count);
memset(variable, 0, sizeof(*variable) * variable_count);
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
for (ts = 0; ts < time_step_count; ts++)
{
// PIDX mandatory calls
ret = PIDX_file_create(output_file_name, PIDX_MODE_CREATE, access, global_size, &file);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_file_create");
ret = PIDX_set_current_time_step(file, ts);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_current_time_step");
ret = PIDX_set_variable_count(file, variable_count);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_variable_count");
ret = PIDX_set_resolution(file, 0, reduced_resolution);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_resolution");
char var_name[512];
for (var = 0; var < variable_count; var++)
{
sprintf(var_name, "variable_%d", var);
ret = PIDX_variable_create(var_name, sizeof(unsigned long long) * 8, FLOAT64, &variable[var]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_variable_create");
ret = PIDX_variable_write_data_layout(variable[var], local_offset, local_size, data[var], PIDX_row_major);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_variable_data_layout");
ret = PIDX_append_and_write_variable(file, variable[var]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_append_and_write_variable");
}
ret = PIDX_close(file);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_close");
}
ret = PIDX_close_access(access);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_close_access");
free(variable);
variable = 0;
destroy_synthetic_simulation_data();
shutdown_mpi();
return 0;
}
//----------------------------------------------------------------
int main(int argc, char **argv)
{
init_mpi(argc, argv);
printf("start %d %d\n",rank,process_count);
int i;
if(rank==0) {
parse_args(argc, argv);
// var_count = read_list_in_file(var_file, &netcdf_var_names);
// rank_0_print("Number of variables = %d\n", var_count);
// time_step_count = read_list_in_file(netcdf_file_list, &netcdf_file_names);
// rank_0_print("Number of timesteps = %d\n", time_step_count);
check_args();
}
// The command line arguments are shared by all processes
#if PIDX_HAVE_MPI
MPI_Bcast(global_box_size, 3, MPI_LONG_LONG, 0, MPI_COMM_WORLD);
MPI_Bcast(local_box_size, 3, MPI_LONG_LONG, 0, MPI_COMM_WORLD);
// MPI_Bcast(&time_step_count, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&var_file, 512, MPI_CHAR, 0, MPI_COMM_WORLD);
MPI_Bcast(&netcdf_file_list, 512, MPI_CHAR, 0, MPI_COMM_WORLD);
// MPI_Bcast(&var_count, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&output_file_name, 512, MPI_CHAR, 0, MPI_COMM_WORLD);
#endif
//TODO: Only the rank 0 should read the input files and broadcast the data
var_count = read_list_in_file(var_file, &netcdf_var_names);
rank_0_print("Number of variables = %d\n", var_count);
time_step_count = read_list_in_file(netcdf_file_list, &netcdf_file_names);
rank_0_print("Number of timesteps = %d\n", time_step_count);
calculate_per_process_offsets();
create_pidx_var_names();
PIDX_access pidx_access;
create_pidx_access(&pidx_access);
PIDX_time_step_caching_ON();
determine_var_types();
create_pidx_vars();
int t = 0,plist_id;
for (t = 0; t < time_step_count; ++t)
{
rank_0_print("Processing time step %d (file %s)\n", t, netcdf_file_names[t]);
PIDX_file pidx_file;
int ret = PIDX_file_create(output_file_name, PIDX_MODE_CREATE, pidx_access, &pidx_file);
if (ret != PIDX_success)
terminate_with_error_msg("ERROR: Failed to create PIDX file\n");
set_pidx_params(pidx_file);
PIDX_set_current_time_step(pidx_file, t);
int file_id = ncmpi_open(MPI_COMM_WORLD,netcdf_file_names[t], NC_NOWRITE, MPI_INFO_NULL, &plist_id);
if (file_id !=0)
terminate_with_error_msg("ERROR: Failed to open file %s\n", netcdf_file_names[t]);
int v = 0;
for(v = 0; v < var_count; ++v)
{
rank_0_print("Processing variable %s\n", netcdf_var_names[v]);
var_data = malloc(var_types[v].atomic_type * var_types[v].num_values * local_box_size[0] * local_box_size[1] * local_box_size[2]);
read_var_from_netcdf(plist_id, netcdf_var_names[v], var_types[v]);
write_var_to_idx(pidx_file, pidx_var_names[v], pidx_vars[v]);
if (PIDX_flush(pidx_file) != PIDX_success)
terminate_with_error_msg("ERROR: Failed to flush variable %s, time step %d\n", pidx_var_names[v], t);
free(var_data);
}
ncmpi_close(plist_id);
PIDX_close(pidx_file);
}
PIDX_time_step_caching_OFF();
PIDX_close_access(pidx_access);
free_memory();
shutdown_mpi();
return 0;
}
int main(int argc, char **argv)
{
init_mpi(argc, argv);
parse_args(argc, argv);
check_args();
calculate_per_process_offsets();
create_synthetic_simulation_data();
rank_0_print("Simulation Data Created\n");
int ret, var, ts;
PIDX_file file; // IDX file descriptor
PIDX_variable* variable; // variable descriptor
variable = (PIDX_variable*)malloc(sizeof(*variable) * variable_count);
memset(variable, 0, sizeof(*variable) * variable_count);
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
for (ts = 0; ts < time_step_count; ts++)
{
// PIDX mandatory calls
ret = PIDX_file_create(output_file_name, PIDX_MODE_CREATE, access, global_size, &file);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_file_create");
ret = PIDX_set_current_time_step(file, ts);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_current_time_step");
ret = PIDX_set_variable_count(file, variable_count);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_variable_count");
PIDX_disable_agg(file);
PIDX_save_big_endian(file);
//PIDX_dump_rst_info(file, 1);
//PIDX_debug_rst(file, 1);
//PIDX_debug_hz(file, 1);
PIDX_point reg_patch_size;
PIDX_set_point_5D(reg_patch_size, 128, 128, 128, 1, 1);
PIDX_set_restructuring_box(file, reg_patch_size);
//PIDX_GLOBAL_PARTITION_IDX_IO
//PIDX_IDX_IO
ret = PIDX_set_io_mode(file, PIDX_RAW_IO);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_variable_count");
ret = PIDX_set_partition_size(file, partition_size[0], partition_size[1], partition_size[2]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_partition_size");
PIDX_set_block_count(file, 128);
//ret = PIDX_set_aggregator_multiplier(file, aggregator_multiplier);
//if (ret != PIDX_success) terminate_with_error_msg("PIDX_set_partition_size");
/*
int io_type = PIDX_IDX_IO;
switch (io_type)
{
case PIDX_GLOBAL_PARTITION_IDX_IO:
PIDX_set_block_count(file,blocks_per_file);
PIDX_set_block_size(file, 13);
break;
case PIDX_IDX_IO:
PIDX_set_block_count(file,blocks_per_file);
break;
case PIDX_RAW_IO:
PIDX_raw_io_pipe_length(file, 2);
PIDX_point reg_patch_size;
PIDX_set_point_5D(reg_patch_size, 128, 128, 128, 1, 1);
PIDX_set_restructuring_box(file, reg_patch_size);
break;
}
*/
//ret = PIDX_debug_disable_agg(file);
//if (ret != PIDX_success) terminate_with_error_msg("PIDX_debug_output");
//ret = PIDX_debug_disable_io(file);
//if (ret != PIDX_success) terminate_with_error_msg("PIDX_debug_output");
//ret = PIDX_debug_disable_hz(file);
//if (ret != PIDX_success) terminate_with_error_msg("PIDX_debug_output");
for (var = 0; var < variable_count; var++)
{
if (bpv[var] == 32)
{
ret = PIDX_variable_create(var_name[var], bpv[var], FLOAT32 , &variable[var]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_variable_create");
}
else if (bpv[var] == 192)
{
ret = PIDX_variable_create(var_name[var], bpv[var], FLOAT64_RGB , &variable[var]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_variable_create");
}
else if (bpv[var] == 64)
{
ret = PIDX_variable_create(var_name[var], bpv[var], FLOAT64 , &variable[var]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_variable_create");
}
ret = PIDX_variable_write_data_layout(variable[var], local_offset, local_size, data[var], PIDX_row_major);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_variable_data_layout");
ret = PIDX_append_and_write_variable(file, variable[var]);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_append_and_write_variable");
//PIDX_flush(file);
}
ret = PIDX_close(file);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_close");
}
ret = PIDX_close_access(access);
if (ret != PIDX_success) terminate_with_error_msg("PIDX_close_access");
free(variable);
variable = 0;
destroy_synthetic_simulation_data();
shutdown_mpi();
return 0;
}
