int declare_group () { adios_set_max_buffer_size (10); adios_declare_group (&m_adios_group, "restart", "iter", adios_flag_yes); adios_select_method (m_adios_group, "MPI", "verbose=2", ""); adios_define_var (m_adios_group, "NX" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "t1" ,"", adios_double ,"NX", "100", "0"); adios_define_var (m_adios_group, "NX" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "t2" ,"", adios_double ,"NX", "100", "0"); return 0; }
int main (int argc, char ** argv) { MPI_Comm comm = 0; // dummy mpi /* ADIOS variables declarations for matching gwrite_temperature.ch */ uint64_t adios_groupsize, adios_totalsize; int64_t g; int64_t f; int64_t Tid, Pid, Vid; // variable IDs char dimstr[32]; sprintf (dimstr, "%d,%d", NX, NY); adios_init_noxml (comm); adios_set_max_buffer_size (1); adios_declare_group (&g, "vars", "", adios_flag_yes); adios_select_method (g, "POSIX", "", ""); Tid = adios_define_var (g, "T" ,"", adios_double, dimstr, dimstr, "0,0"); adios_set_transform (Tid, "none"); Pid = adios_define_var (g, "P" ,"", adios_double, dimstr, dimstr, "0,0"); adios_set_transform (Pid, "none"); Vid = adios_define_var (g, "V" ,"", adios_double, dimstr, dimstr, "0,0"); adios_set_transform (Vid, "none"); adios_read_init_method(ADIOS_READ_METHOD_BP,0,""); if (adios_query_is_method_available (ADIOS_QUERY_METHOD_ALACRITY)) { adios_set_transform (Tid, "alacrity"); adios_set_transform (Pid, "alacrity"); adios_set_transform (Vid, "alacrity"); printf ("Turned on ALACRITY transformation for array variables\n"); } adios_open (&f, "vars", "vars.bp", "w", comm); adios_groupsize = 3*NX*NY*sizeof(double); adios_group_size (f, adios_groupsize, &adios_totalsize); adios_write (f, "T", T); adios_write (f, "P", P); adios_write (f, "V", V); adios_close (f); adios_finalize (0); return 0; }
int output_init(MPI_Comm comm, int bufsizeMB) { char * wmethodname, *wmethodparams; MPI_Comm_rank (comm, &rank); adios_init_noxml(comm); adios_declare_group(&gh,"writer","",adios_flag_yes); adios_set_max_buffer_size (bufsizeMB); // Select output method wmethodname = getenv("ADIOSMETHOD"); wmethodparams = getenv("ADIOSMETHOD_PARAMS"); if (!wmethodname) wmethodname = DEFAULT_ADIOSMETHOD_NAME; if (!wmethodparams) wmethodparams = DEFAULT_ADIOSMETHOD_PARAMS; adios_select_method (gh, wmethodname, wmethodparams, ""); groupsize = 0; if (!strcmp(wmethodname, "POSIX1")) { file_per_process = 1; iocomm = MPI_COMM_SELF; } else { iocomm = comm; } if (!strcmp(wmethodname, "DATASPACES") || !strcmp(wmethodname, "DIMES") || !strcmp(wmethodname, "FLEXPATH") ) { streaming = 1; } else { streaming = 0; } return 0; }
/** * ADIOS init and create group etc. * Return: pointer to the ADIOS group structure */ SEXP R_create(SEXP R_groupname, SEXP R_buffersize, SEXP R_comm) { const char *groupname = CHARPT(R_groupname, 0); int buffer = asInteger(R_buffersize); MPI_Comm comm = MPI_Comm_f2c(INTEGER(R_comm)[0]); int64_t m_adios_group; adios_init_noxml (comm); adios_set_max_buffer_size (buffer); // Default buffer size for write is 20. User can change this value adios_declare_group (&m_adios_group, groupname, "", adios_flag_yes); adios_select_method (m_adios_group, "MPI", "", ""); // Default method is MPI. Let users choose different methods later. // Pass group pointer to R SEXP R_group = PROTECT(allocVector(REALSXP, 1)); REAL(R_group)[0] = (double)m_adios_group; UNPROTECT(1); return R_group; }
int main (int argc, char ** argv) { char filename [256]; int rank, size, i, j; int NX = 100, gb, offset; //local/global/offset double t[NX]; int nblocks = 3; MPI_Comm comm = MPI_COMM_WORLD; char g_str[100], o_str[100], l_str[100]; // attributes (from C variables) int someints[5] = {5,4,3,2,1}; double somedoubles[5] = {5.55555, 4.4444, 3.333, 2.22, 1.1}; /* ADIOS variables declarations for matching gwrite_temperature.ch */ uint64_t adios_groupsize, adios_totalsize; MPI_Init (&argc, &argv); MPI_Comm_rank (comm, &rank); MPI_Comm_size (comm, &size); gb = nblocks * NX * size; sprintf (g_str, "%d", gb); sprintf (l_str, "%d", NX); strcpy (filename, "no_xml_write_byid.bp"); adios_init_noxml (comm); adios_set_max_buffer_size (10); int64_t m_adios_group; int64_t m_adios_file; int64_t var_ids[nblocks]; adios_declare_group (&m_adios_group, "restart", "iter", adios_flag_yes); adios_select_method (m_adios_group, "MPI", "", ""); for (i = 0; i < nblocks; i++) { offset = rank * nblocks * NX + i * NX; sprintf (o_str, "%d", offset); var_ids[i] = adios_define_var (m_adios_group, "temperature" ,"", adios_double ,l_str, g_str, o_str ); adios_set_transform (var_ids[i], "none"); // This is here just for fun uint64_t varsize = adios_expected_var_size(var_ids[i]); // adios_expected_var_size() works here because the definition of the variable // does not depend on any dimension variable (but defined with numerical dimensions) fprintf (stderr, "Temperature block %d is %" PRIu64 " bytes\n", i, varsize); } // add some attributes adios_define_attribute_byvalue (m_adios_group, "single_string","", adios_string, 1, "A single string attribute"); char *strings[] = {"X","Yy","ZzZ"}; adios_define_attribute_byvalue (m_adios_group, "three_strings","", adios_string_array, 3, strings); adios_define_attribute_byvalue (m_adios_group, "single_int", "", adios_integer, 1, &someints); adios_define_attribute_byvalue (m_adios_group, "single_double","", adios_double, 1, &somedoubles); adios_define_attribute_byvalue (m_adios_group, "five_ints", "", adios_integer, 5, &someints); adios_define_attribute_byvalue (m_adios_group, "five_double", "", adios_double, 5, &somedoubles); adios_open (&m_adios_file, "restart", filename, "w", comm); adios_groupsize = nblocks * (4 + 4 + 4 + NX * 8); adios_group_size (m_adios_file, adios_groupsize, &adios_totalsize); /* now we will write the data for each sub block */ for (i = 0; i < nblocks; i++) { offset = rank * nblocks * NX + i * NX; for (j = 0; j < NX; j++) t[j] = offset + j; adios_write_byid(m_adios_file, var_ids[i], t); } adios_close (m_adios_file); MPI_Barrier (comm); adios_finalize (rank); MPI_Finalize (); return 0; }
int main (int argc, char ** argv) { MPI_Comm comm = MPI_COMM_WORLD; int rank; int ndx, ndy; // size of array per processor double * data; double *X; //X coordinate double *Y; //Y coordinate // Offsets and sizes int offs_x, offs_y; //offset in x and y direction int nx_local, ny_local; //local address int nx_global, ny_global; //global address int posx, posy; // position index in the array int i,j; int64_t m_adios_group; uint64_t adios_groupsize, adios_totalsize; int64_t adios_handle; MPI_Init (&argc, &argv); MPI_Comm_rank (comm, &rank); MPI_Comm_size (comm, &nproc); if (processArgs(argc, argv)) { return 1; } //will work with each core writing ndx = 65, ndy = 129, (65*4,129*3) global ndx = 65; ndy = 129; //2D array with block,block decomposition posx = rank%npx; // 1st dim posy = rank/npx; // 2nd dim offs_x = posx * ndx; offs_y = posy * ndy; nx_local = ndx; ny_local = ndy; nx_global = npx * ndx; ny_global = npy * ndy; data = malloc (ndx * ndy * sizeof(double)); for( i = 0; i < ndx; i++ ) for( j = 0; j < ndy; j++) data[i*ndy + j] = 1.0*rank; X = malloc (ndx * ndy * sizeof(double)); for( i = 0; i < ndx; i++ ) for( j = 0; j < ndy; j++) X[i*ndy + j] = offs_x + posy*ndx + i*ndx/ndx + (double)ndx*j/ndy; Y = malloc (ndx * ndy * sizeof(double)); Y[0] = offs_y; for( i = 0; i < ndx; i++ ) for( j = 0; j < ndy; j++) Y[i*ndy + j] = offs_y + ndy*j/ndy; char * schema_version = "1.1"; char * dimemsions = "nx_global,ny_global"; adios_init_noxml (comm); adios_set_max_buffer_size (50); adios_declare_group (&m_adios_group, "structured2d", "", adios_flag_yes); adios_select_method (m_adios_group, "MPI", "", ""); adios_define_var (m_adios_group, "nx_global" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "ny_global" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "nproc" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "offs_x" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "offs_y" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "nx_local" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "ny_local" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "X" ,"", adios_double ,"nx_local,ny_local", "nx_global,ny_global", "offs_x,offs_y"); adios_define_var (m_adios_group, "Y" ,"", adios_double ,"nx_local,ny_local", "nx_global,ny_global", "offs_x,offs_y"); adios_define_var (m_adios_group, "data" ,"", adios_double ,"nx_local,ny_local", "nx_global,ny_global", "offs_x,offs_y"); adios_define_schema_version (m_adios_group, schema_version); adios_define_mesh_structured (dimemsions, "X,Y", "2", m_adios_group, "structuredmesh"); adios_define_mesh_timevarying ("no", m_adios_group, "structuredmesh"); adios_define_var_mesh (m_adios_group, "data", "structuredmesh"); adios_define_var_centering (m_adios_group, "data", "point"); adios_open (&adios_handle, "structured2d", "structured2d_noxml.bp", "w", comm); adios_groupsize = 7*sizeof(int) \ + 3*sizeof(double) * (nx_local*ny_local); adios_group_size (adios_handle, adios_groupsize, &adios_totalsize); adios_write (adios_handle, "nproc", &nproc); adios_write (adios_handle, "nx_global", &nx_global); adios_write (adios_handle, "ny_global", &ny_global); adios_write (adios_handle, "offs_x", &offs_x); adios_write (adios_handle, "offs_y", &offs_y); adios_write (adios_handle, "nx_local", &nx_local); adios_write (adios_handle, "ny_local", &ny_local); adios_write (adios_handle, "X", X); adios_write (adios_handle, "Y", Y); adios_write (adios_handle, "data", data); adios_close (adios_handle); MPI_Barrier (comm); free (data); free (X); free (Y); adios_finalize (rank); MPI_Finalize (); return 0; }
int write_blocks () { int NX, G, O; double *t; /* ADIOS variables declarations for matching gwrite_temperature.ch */ int it, i, r; uint64_t adios_groupsize, adios_totalsize; if (!rank) printf ("------- Write blocks -------\n"); // We will have "3 steps * 2 blocks per process * number of processes" blocks nsteps = 3; nblocks_per_step = 2; block_offset = (uint64_t*) malloc (sizeof(uint64_t) * nsteps * nblocks_per_step * size); block_count = (uint64_t*) malloc (sizeof(uint64_t) * nsteps * nblocks_per_step * size); gdims = (uint64_t*) malloc (sizeof(uint64_t) * nsteps); adios_init_noxml (comm); adios_set_max_buffer_size (10); int64_t m_adios_group; int64_t m_adios_file; adios_declare_group (&m_adios_group, "restart", "", adios_flag_yes); adios_select_method (m_adios_group, "MPI", "", ""); adios_define_var (m_adios_group, "NX" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "G" ,"", adios_integer ,0, 0, 0); /* have to define O and temperature as many times as we write them within one step (twice) */ for (it=0; it < nblocks_per_step; it++) { adios_define_var (m_adios_group, "O" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "t" ,"", adios_double ,"NX", "G", "O"); } for (it =0; it < nsteps; it++) { if (!rank) printf ("Step %d:\n", it); NX = 10+it; G = nblocks_per_step * NX * size; t = (double *) malloc (NX*sizeof(double)); for (i = 0; i < NX; i++) t[i] = rank + it*0.1 + 0.01; MPI_Barrier (comm); if (it==0) adios_open (&m_adios_file, "restart", fname, "w", comm); else adios_open (&m_adios_file, "restart", fname, "a", comm); adios_groupsize = 4 + 4 + 4 + NX * 8 + 4 + 4 + 4 + NX * 8; adios_group_size (m_adios_file, adios_groupsize, &adios_totalsize); adios_write(m_adios_file, "NX", (void *) &NX); adios_write(m_adios_file, "G", (void *) &G); O = rank * nblocks_per_step * NX; adios_write(m_adios_file, "O", (void *) &O); adios_write(m_adios_file, "t", t); printf ("rank %d: block 1: size=%d, offset=%d\n", rank, NX, O); for (r = 0; r < size; r++) { block_count [it*nblocks_per_step*size + nblocks_per_step*r] = NX; block_offset [it*nblocks_per_step*size + nblocks_per_step*r] = r * nblocks_per_step * NX; } for (i = 0; i < NX; i++) t[i] += 0.01; O = rank * nblocks_per_step * NX + NX; adios_write(m_adios_file, "O", (void *) &O); adios_write(m_adios_file, "t", t); printf ("rank %d: block 2: size=%d, offset=%d\n", rank, NX, O); for (r = 0; r < size; r++) { block_count [it*nblocks_per_step*size + nblocks_per_step*r + 1] = NX; block_offset [it*nblocks_per_step*size + nblocks_per_step*r + 1] = r * nblocks_per_step * NX + NX; } gdims [it] = G; adios_close (m_adios_file); MPI_Barrier (comm); free(t); } adios_finalize (rank); return 0; }
int main (int argc, char ** argv) { char filename [256]; int rank, size, i, j, step, block; int Offset; int NX = 2; // number of records written per step per process int Width=20; int sub_blocks = 2; // number of record-blocks written per process in one step int steps = 3; char t[NX][Width]; MPI_Comm comm = MPI_COMM_WORLD; /* ADIOS variables declarations for matching gwrite_temperature.ch */ int adios_err; uint64_t adios_groupsize, adios_totalsize; int64_t adios_handle; MPI_Init (&argc, &argv); MPI_Comm_rank (comm, &rank); MPI_Comm_size (comm, &size); //Global_bounds = sub_blocks * NX * size; strcpy (filename, "steps.bp"); adios_init_noxml (comm); adios_set_max_buffer_size (1); int64_t m_adios_group; int64_t m_adios_file; adios_declare_group (&m_adios_group, "steps", "", adios_flag_yes); adios_select_method (m_adios_group, "MPI", "", ""); adios_define_var (m_adios_group, "NX" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "Width" ,"", adios_integer ,0, 0, 0); adios_define_var (m_adios_group, "nproc" ,"", adios_integer ,0, 0, 0); for (i=0;i<sub_blocks;i++) { adios_define_var (m_adios_group, "record" ,"", adios_byte ,"NX,Width", "", ""); } for (step=0; step<steps; step++) { adios_open (&m_adios_file, "steps", filename, "a", comm); adios_groupsize = sub_blocks * (4 + 4 + 4 + (uint64_t) NX * (uint64_t)Width); adios_group_size (m_adios_file, adios_groupsize, &adios_totalsize); adios_write(m_adios_file, "nproc", (void *) &size); adios_write(m_adios_file, "NX", (void *) &NX); adios_write(m_adios_file, "Width", (void *) &Width); /* now we will write the data for each sub block */ for (block=0;block<sub_blocks;block++) { for (i = 0; i < NX; i++) //print 19 chars here + '\0' sprintf (t[i], "r%2d b%2d s%2d i%2d ", rank, block, step, i); adios_write(m_adios_file, "record", t); } adios_close (m_adios_file); } MPI_Barrier (comm); adios_finalize (rank); MPI_Finalize (); return 0; }