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