static void VS_CC
set_limiter_data(generic_handler_t *gh, filter_id_t id, char *msg,
const VSMap *in, VSMap *out, const VSAPI *vsapi)
{
RET_IF_ERROR(!gh->vi->format, "format is not constant");
int err;
int th_min = (int)vsapi->propGetInt(in, "min", 0, &err);
if (err || th_min < 0) {
th_min = 0;
}
int max = (1 << gh->vi->format->bitsPerSample) - 1;
int th_max = (int)vsapi->propGetInt(in, "max", 0, &err);
if (err || th_max > max) {
th_max = max;
}
RET_IF_ERROR(th_min > th_max, "min is larger than max");
const char *ret = set_alone(gh);
RET_IF_ERROR(ret, "%s", ret);
alone_t *ah = (alone_t *)gh->fdata;
set_lut(ah, th_min, th_max);
}
int main(int argc, char ** argv){
int rank=0, size=0;
int NX = NX_DIM; // size of 1D array we will write
double t[NX_DIM]; // this will contain the variables
MPI_Comm comm = MPI_COMM_WORLD; // required for ADIOS
int64_t adios_handle; // the ADIOS file handler
int retval;
struct adios_tsprt_opts adios_opts;
int err_count = 0;
GET_ENTRY_OPTIONS(adios_opts, "Runs writers. It is recommended to run as many writers as readers.");
// I assume that I have all required options set in adios_opts
// sanity check
assert(NX==NX_DIM);
// ADIOS initialization
MPI_Init(&argc, &argv);
MPI_Comm_rank (comm, &rank);
MPI_Comm_size (comm, &size);
SET_ERROR_IF_NOT_ZERO(adios_init(adios_opts.xml_adios_init_filename, comm), err_count);
RET_IF_ERROR(err_count, rank);
// init the array that I will transport
if (gen_1D_array(t, NX, rank) == DIAG_ERR){
printf("ERROR: Generating 1D array. Quitting ...\n");
return DIAG_ERR;
}
uint64_t adios_groupsize, adios_totalsize;
// open with the group name as specified in the xml file
adios_open( &adios_handle, "temperature", FILE_NAME, "w", comm);
adios_groupsize = 4 + 4 + 4 + 8 * (NX);
retval=adios_group_size (adios_handle, adios_groupsize, &adios_totalsize);
fprintf(stderr, "Rank=%d adios_group_size(): adios_groupsize=%" PRIu64 ", adios_totalsize=%" PRIu64 ", retval=%d\n",
rank, adios_groupsize, adios_totalsize, retval);
// write; don't check errors for simplicity reasons
adios_write(adios_handle, "NX", &NX);
adios_write(adios_handle, "size", &size);
adios_write(adios_handle, "rank", &rank);
adios_write(adios_handle, "var_1d_array", t);
fprintf(stderr, "Rank=%d committed write\n", rank);
adios_close(adios_handle);
// clean and finalize the system
adios_finalize(rank);
MPI_Finalize();
return DIAG_OK;
}
static void VS_CC
set_levels_data(generic_handler_t *gh, filter_id_t id, char *msg,
const VSMap *in, VSMap *out, const VSAPI *vsapi)
{
RET_IF_ERROR(!gh->vi->format, "format is not constant");
const char *ret = set_alone(gh);
RET_IF_ERROR(ret, "%s", ret);
alone_t *ah = (alone_t *)gh->fdata;
int err;
int bps = gh->vi->format->bitsPerSample;
int size = 1 << bps;
int imin = (int)vsapi->propGetInt(in, "min_in", 0, &err);
if (err || imin < 0) {
imin = 0;
}
int imax = (int)vsapi->propGetInt(in, "max_in", 0, &err);
if (err || imax > size - 1) {
imax = 0xFF << (bps - 8);
}
int omin = (int)vsapi->propGetInt(in, "min_out", 0, &err);
if (err || omin < 0) {
omin = 0;
}
int omax = (int)vsapi->propGetInt(in, "max_out", 0, &err);
if (err || omax > size - 1) {
omax = 0xFF << (bps - 8);
}
double gamma = vsapi->propGetFloat(in, "gamma", 0, &err);
if (err || gamma <= 0.0f) {
gamma = 1.0;
}
set_lut(imin, imax, omin, omax, gamma, size, ah->lut);
}
int main (int argc, char **argv){
int rank =0, size =0;
int NX = 0;
double *t = NULL;
// this is an array we expect as a reference array
double *t_ref = NULL;
MPI_Comm comm = MPI_COMM_WORLD;
diag_t diag = DIAG_OK; // to store the diagnostic information
struct test_info test_result = {TEST_PASSED, "1D_arr_global_noxml"};
struct err_counts err = { 0, 0};
struct adios_tsprt_opts adios_opts;
GET_ENTRY_OPTIONS(adios_opts, "Runs readers. It is recommended to run as many readers as writers.");
// adios read initialization
MPI_Init( &argc, &argv);
MPI_Comm_rank (comm, &rank);
// depending on the method
SET_ERROR_IF_NOT_ZERO(adios_read_init_method(adios_opts.method, comm, adios_opts.adios_options), err.adios);
RET_IF_ERROR(err.adios, rank);
// I will be working with streams so the lock mode is necessary,
// return immediately if the stream unavailable
ADIOS_FILE *adios_handle = adios_read_open(FILE_NAME, adios_opts.method, comm, ADIOS_LOCKMODE_NONE, 0.0);
if ( !adios_handle){
p_error("Quitting ... (%d) %s\n", adios_errno, adios_errmsg());
return DIAG_ERR;
}
// define portions of data how they will be read
ADIOS_SELECTION *sel = NULL;
ADIOS_VARINFO *avi = NULL;
// for storing the variables
char buf[STR_BUFFER_SIZE];
int step = 0;
// read how many processors wrote that array
avi = adios_inq_var (adios_handle, "size");
if (!avi){
p_error("rank %d: Quitting ... (%d) %s\n", rank, adios_errno, adios_errmsg());
diag = DIAG_ERR;
goto close_adios;
}
size = *((int*)avi->value);
adios_free_varinfo(avi);
avi = NULL;
// if I run the more readers than writers; just release
// the excessive readers
if (rank >= size){
p_info("rank %d: I am an excessive rank. Nothing to read ...\n", rank);
diag = DIAG_OK;
goto close_adios;
}
// read the size of the array
avi = adios_inq_var (adios_handle, "NX");
if (!avi){
p_error("rank %d: Quitting ... (%d) %s\n", rank, adios_errno, adios_errmsg());
diag = DIAG_ERR;
goto close_adios;
}
// I expect a scalar that will tell me the size of an array
assert(0 == avi->ndim);
assert(adios_integer == avi->type);
NX = *((int*)avi->value);
// I don't need that variable any more
adios_free_varinfo(avi);
assert(NX_DIM == NX);
avi = NULL;
// this will define the slice that we want to read; each rank should
// read its own slice written by a corresponding writer rank
uint64_t count[1] = { NX };
uint64_t start[1] = { 0 };
start[0] = rank*NX;
sel = adios_selection_boundingbox(1,start, count);
if( !sel ){
p_error("rank %d: Quitting ... (%d) %s\n", rank, adios_errno, adios_errmsg());
diag = DIAG_ERR;
goto close_adios;
}
// make the reference array with reference values I expect to get
t_ref = calloc(NX, sizeof(double));
if (gen_1D_array(t_ref, NX, rank) == DIAG_ERR){
p_error("Generating 1D array. Quitting ...\n");
diag = DIAG_ERR;
goto close_adios;
}
// allocate the memory for the actual array to be read
t = calloc(NX, sizeof(double));
if (adios_schedule_read(adios_handle, sel, "var_1d_array",0,1,t) != 0){
p_error("rank %d: Quitting ...(%d) %s\n", rank, adios_errno, adios_errmsg());
diag = DIAG_ERR;
goto just_clean;
}
// not sure if this assumption is correct; difficult to find in the ADIOS sources
if (adios_perform_reads(adios_handle, 1) != 0){
p_error("rank %d: Quitting ...(%d) %s\n", rank, adios_errno, adios_errmsg());
diag = DIAG_ERR;
goto just_clean;
}
sprintf(buf, "Rank %d: var_1d_array: step %d: t: ", rank, step);
int i = 0;
for(i=0; i < NX; ++i){
if( t[i] != t_ref[i] ){
p_test_failed("%s: rank %d: for t[%d] (expected %.1f, got %.1f)\n", test_result.name, rank, i, t_ref[i], t[i] );
test_result.result = TEST_FAILED;
break;
}
}
if (TEST_PASSED == test_result.result)
p_test_passed("%s: rank %d\n", test_result.name, rank);
just_clean:
// clean everything
adios_selection_delete(sel);
sel = NULL;
free(t);
t = NULL;
free(t_ref);
t_ref = NULL;
close_adios:
CLOSE_ADIOS_READER(adios_handle, adios_opts.method);
if ((DIAG_OK == diag) && (TEST_PASSED == test_result.result)) {
return 0;
} else {
return 1;
}
}
