Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
/*
* writer.cpp
*
* Created on: Feb 13, 2017
* Author: pnorbert
*/
#include <vector>
#include <iostream>
#include <mpi.h>
#include "ADIOS_CPP.h"
namespace adios {
typedef enum {
VARYING_DIMENSION = -1,
LOCAL_VALUE = 0,
GLOBAL_VALUE = 1
};
}
int main( int argc, char* argv [] )
{
int rank, nproc;
MPI_Init( &argc, &argv );
MPI_Comm_rank( MPI_COMM_WORLD, &rank);
MPI_Comm_size( MPI_COMM_WORLD, &nproc);
const bool adiosDebug = true;
const int NSTEPS = 5;
adios::ADIOS adios( MPI_COMM_WORLD, adiosDebug );
//Application variable
const unsigned int Nx = 10;
int Nparts; // random size per process, 5..10 each
std::vector<double> NiceArray( Nx );
for( int i=0; i < Nx; i++ )
{
NiceArray[i] = rank*Nx + (double)i;
}
std::vector<float> RaggedArray;
try
{
//Define group and variables with transforms, variables don't have functions, only group can access variables
adios::Variable<unsigned int>& varNX = adios.DefineVariable<unsigned int>( "NX" ); // global single-value across processes
adios::Variable<int>& varNproc = adios.DefineVariable<int>( "nproc", adios::GLOBAL_VALUE ); // same def for global value
adios::Variable<int>& varNparts = adios.DefineVariable<int>( "Nparts", adios::LOCAL_VALUE ); // a single-value different on every process
adios::Variable<double>& varNice = adios.DefineVariable<double>( "Nice", {nproc*Nx} ); // 1D global array
adios::Variable<float>& varRagged = adios.DefineVariable<float>( "Ragged", {nproc,adios::VARYING_DIMENSION} ); // ragged array
//add transform to variable in group...not executed (just testing API)
adios::Transform bzip2 = adios::transform::BZIP2( );
varNice->AddTransform( bzip2, 1 );
//Define method for engine creation
// 1. Get method def from config file or define new one
adios::Method& bpWriterSettings = adios.GetMethod( "output" );
if( bpWriterSettings.undeclared() )
{
// if not defined by user, we can change the default settings
bpWriterSettings.SetEngine( "BP" ); // BP is the default engine
bpWriterSettings.AddTransport( "File", "lucky=yes" ); // ISO-POSIX file is the default transport
// Passing parameters to the transport
bpWriterSettings.SetParameters("have_metadata_file","yes" ); // Passing parameters to the engine
bpWriterSettings.SetParameters( "Aggregation", (nproc+1)/2 ); // number of aggregators
}
//Open returns a smart pointer to Engine containing the Derived class Writer
// "w" means we overwrite any existing file on disk, but AdvanceStep will append steps later.
auto bpWriter = adios.Open( "myNumbers.bp", "w", bpWriterSettings );
if( bpWriter == nullptr )
throw std::ios_base::failure( "ERROR: failed to open ADIOS bpWriter\n" );
for ( int step; step < NSTEPS; step++ )
{
int Nparts = rand()%6 + 5; // random size per process, 5..10 each
RaggedArray.reserve(Nparts);
for( int i=0; i < Nparts; i++ )
{
RaggedArray[i] = rank*Nx + (float)i;
}
if( rank == 0 )
{
// Writing a global scalar from only one process
bpWriter->Write<unsigned int>( varNX, &Nx );
}
// Writing a local scalar on every process. Will be shown at reading as a 1D array
bpWriter->Write<int>( varNparts, &Nparts );
// Writing a global scalar on every process is useless. Information will be thrown away
// and only rank 0's data will be in the output
bpWriter->Write<int>( varNproc, &nproc );
// Make a 1D selection to describe the local dimensions of the variable we write and
// its offsets in the global spaces
adios::Selection& sel = adios.SelectionBoundingBox( {Nx}, {rank*Nx} ); // local dims and offsets; both as list
NiceArray.SetSelection( sel );
bpWriter->Write<double>( varNice, NiceArray.data() ); // Base class Engine own the Write<T> that will call overloaded Write from Derived
adios::Selection& lsel = adios.SelectionBoundingBox( {1,Nparts}, {rank,0} );
RaggedArray.SetSelection( sel );
bpWriter->Write<float>( varRagged, RaggedArray.data() ); // Base class Engine own the Write<T> that will call overloaded Write from Derived
// Indicate we are done for this step
// N-to-M Aggregation, disk I/O will be performed during this call, unless
// time aggregation postpones all of that to some later step
bpWriter->Advance( );
}
// Called once: indicate that we are done with this output for the run
bpWriter->Close( );
}
catch( std::invalid_argument& e )
{
if( rank == 0 )
{
std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
}
catch( std::ios_base::failure& e )
{
if( rank == 0 )
{
std::cout << "System exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
}
catch( std::exception& e )
{
if( rank == 0 )
{
std::cout << "Exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
}
MPI_Finalize( );
return 0;
}