/* static int checkCompatibility(ADIOS_QUERY* q) { if ((q->left != NULL) && (q->right != NULL)) { return isCompatible(q->left, q->right); } return 0; // ok, no need to check } */ static ADIOS_VARBLOCK * computePGBounds(ADIOS_QUERY *q, int wbindex, int timestep, int *out_ndim) { if (!q->left && !q->right) { // In this case, we have reached a leaf query node, so directly // retrieve the varblock from the varinfo assert(q->varinfo); // Read the blockinfo if not already present if (!q->varinfo->blockinfo) { adios_read_set_data_view(q->file, LOGICAL_DATA_VIEW); common_read_inq_var_blockinfo(q->file, q->varinfo); } // Note: adios_get_absolute_writeblock_index ensures that timestep and wbindex // are both in bounds, signalling an adios_error if not. However, there will be // no variable name cited in the error, so perhaps better error handling would // be desirable in the future //const int abs_wbindex = adios_get_absolute_writeblock_index(q->varinfo, wbindex, timestep); int abs_wbindex = wbindex; if (q->varinfo->nsteps > 1) { // varinfo contains ALL timesteps, not just one step, so streaming mode files will not need call this func abs_wbindex = adios_get_absolute_writeblock_index(q->varinfo, wbindex, timestep); } // Finally, return ndim and the varblock *out_ndim = q->varinfo->ndim; return &q->varinfo->blockinfo[abs_wbindex]; } else if (!q->left || !q->right) { // In this case, we have only one subtree, so just return the // ndim and varblock from that subtree directly, since there's // nothing to compare against ADIOS_QUERY *present_subtree = q->left ? (ADIOS_QUERY*)q->left : (ADIOS_QUERY*)q->right; return computePGBounds(present_subtree, wbindex, timestep, out_ndim); } else { // In this final case, we have two subtrees, and we must compare // the resultant varblock from each one to ensure they are equal // before returning ADIOS_QUERY *left = (ADIOS_QUERY *)q->left; ADIOS_QUERY *right = (ADIOS_QUERY *)q->right; // Next, retrieve the ndim and varblock for each subtree int left_ndim, right_ndim; ADIOS_VARBLOCK *left_vb = computePGBounds(left, wbindex, timestep, &left_ndim); ADIOS_VARBLOCK *right_vb = computePGBounds(right, wbindex, timestep, &right_ndim); // If either subtree returns an invalid (NULL) varblock, fail immediately if (!left_vb || !right_vb) { return NULL; } // Check that the ndims are equal, failing if not int ndim; if (left_ndim != right_ndim) { return NULL; } else { ndim = left_ndim; } // Check the start/count coordinate in each dimension for equality, // failing if any coordinate is not equal between the subtrees int i; for (i = 0; i < ndim; i++) { if (left_vb->start[i] != right_vb->start[i] || left_vb->count[i] != right_vb->count[i]) { return NULL; } } // Finally, we have ensured that both subtrees yield valid and equal // varblocks, so return the common ndim and varblock (arbitrarily use // left_vb, since right and left equal) *out_ndim = ndim; return left_vb; } }
ADIOS_PG_INTERSECTIONS * adios_find_intersecting_pgs(const ADIOS_FILE *fp, int varid, const ADIOS_SELECTION *sel, const int from_step, const int nsteps) { // Declares adios_transform_read_request *new_reqgroup; int blockidx, timestep, timestep_blockidx; int curblocks, start_blockidx, end_blockidx; int intersects; ADIOS_VARBLOCK *raw_vb, *vb; enum ADIOS_FLAG swap_endianness = (fp->endianness == get_system_endianness()) ? adios_flag_no : adios_flag_yes; int to_steps = from_step + nsteps; // As long as we don't free/destroy it, using the infocache from the file will have no effect on future // operations using the file (except possibly speeding them up, so "constness" is still respected adios_infocache *infocache = common_read_get_file_infocache((ADIOS_FILE*)fp); ADIOS_PG_INTERSECTIONS *resulting_intersections = (ADIOS_PG_INTERSECTIONS *)calloc(1, sizeof(ADIOS_PG_INTERSECTIONS)); resulting_intersections->npg = 0; int intersection_capacity = INITIAL_INTERSECTION_CAPACITY; resulting_intersections->intersections = (ADIOS_PG_INTERSECTION *)calloc(intersection_capacity, sizeof(ADIOS_PG_INTERSECTION)); // Precondition checking if (sel->type != ADIOS_SELECTION_BOUNDINGBOX && sel->type != ADIOS_SELECTION_POINTS) { adios_error(err_operation_not_supported, "Only bounding box and point selections are currently supported during read on transformed variables."); } // Still respecting constness, since we're going to undo this const data_view_t old_view = adios_read_set_data_view((ADIOS_FILE*)fp, LOGICAL_DATA_VIEW); // Temporarily go to logical data view const ADIOS_VARINFO *varinfo = adios_infocache_inq_varinfo(fp, infocache, varid); assert(from_step >= 0 && to_steps <= varinfo->nsteps); // Compute the blockidx range, given the timesteps compute_blockidx_range(varinfo, from_step, to_steps, &start_blockidx, &end_blockidx); // Retrieve blockinfos, if they haven't been done retrieved if (!varinfo->blockinfo) common_read_inq_var_blockinfo(fp, (ADIOS_VARINFO *)varinfo); // Undoing view set (returning to const state) adios_read_set_data_view((ADIOS_FILE*)fp, old_view); // Reset the data view to whatever it was before // Assemble read requests for each varblock blockidx = start_blockidx; timestep = from_step; timestep_blockidx = 0; while (blockidx != end_blockidx) { //for (blockidx = startblock_idx; blockidx != endblock_idx; blockidx++) { ADIOS_SELECTION *pg_bounds_sel; ADIOS_SELECTION *pg_intersection_sel; vb = &varinfo->blockinfo[blockidx]; pg_bounds_sel = create_pg_bounds(varinfo->ndim, vb); // Find the intersection, if any pg_intersection_sel = adios_selection_intersect_global(pg_bounds_sel, sel); if (pg_intersection_sel) { // Expand the PG intersection array, if needed if (resulting_intersections->npg == intersection_capacity) { intersection_capacity *= 2; resulting_intersections->intersections = (ADIOS_PG_INTERSECTION *)realloc(resulting_intersections->intersections, intersection_capacity * sizeof(ADIOS_PG_INTERSECTION)); if (!resulting_intersections->intersections) { adios_error (err_no_memory, "Cannot allocate buffer for PG intersection results in adios_find_intersecting_pgs (required %llu bytes)\n", intersection_capacity * sizeof(ADIOS_PG_INTERSECTION)); return NULL; } } ADIOS_PG_INTERSECTION *intersection = &resulting_intersections->intersections[resulting_intersections->npg]; intersection->timestep = timestep; intersection->blockidx = blockidx; intersection->blockidx_in_timestep = timestep_blockidx; intersection->intersection_sel = pg_intersection_sel; intersection->pg_bounds_sel = pg_bounds_sel; resulting_intersections->npg++; } else { // Cleanup common_read_selection_delete(pg_bounds_sel); // OK to delete, because this function only frees the outer struct, not the arrays within } // Increment block indexes blockidx++; timestep_blockidx++; if (timestep_blockidx == varinfo->nblocks[timestep]) { timestep_blockidx = 0; timestep++; } } return resulting_intersections; }