// Take an ADIOS_VARCHUNK that was just read and process it with the transform
// system. If it was part of a read request corresponding to a transformed
// variable, consume it, and (optionally) replace it with a detransformed chunk.
// Otherwise, do nothing, allowing the calling function to manage it as usual.
void adios_transform_process_read_chunk(adios_transform_read_request **reqgroups_head, ADIOS_VARCHUNK ** chunk) {
adios_transform_read_request *reqgroup;
adios_transform_pg_read_request *pg_reqgroup;
adios_transform_raw_read_request *subreq;
adios_datablock *result;
// Find the subrequest that matches the VARCHUNK that was just read (if any)
int found = adios_transform_read_request_list_match_chunk(*reqgroups_head, *chunk, 1, &reqgroup, &pg_reqgroup, &subreq);
// If no subrequest matches the VARCHUNK, it must correspond to a non-transformed variable.
// In this case, return immediately and let it be processed as-is.
if (!found)
return;
// Otherwise, this VARCHUNK corresponds to a subrequest.
// Therefore, consume it, and perhaps replace it with a detransformed chunk.
// Consume the chunk, as the data will be proceessed by a transform method to
// produce a new varchunk, so this varchunk should not be processed by the caller.
// (NOTE: Freeing this does not free the memory it points to, which we ASSUME
// is also pointed to by subreq->data, since currently we REQUIRE transform
// plugins to supply their own data buffers when submitting read requests)
common_read_free_chunk(*chunk);
*chunk = NULL;
// Next, update the subreq that corresponds to this VARCHUNK as completed, retrieving any
// produced result
result = finish_subreq(reqgroup, pg_reqgroup, subreq);
// Now, if a new adios_datablock is now available as a result of the above completed subreq,
// apply it as a result for the user in a way appropriate to the current result mode
if (result) {
// Then, return data as appropriate depending on the return mode of this read operation
// PARTIAL: no user-allocated buffer is given for the full result, so results must be
// returned one VARCHUNK at a time.
// FULL: the user has supplied a buffer for full results, so patch relevant data from
// the returned VARCHUNK into this buffer.
enum ADIOS_TRANSFORM_REQGROUP_RESULT_MODE result_mode = adios_transform_read_request_get_mode(reqgroup);
switch (result_mode) {
case PARTIAL_RESULT_MODE:
// Apply this VARCHUNK
*chunk = apply_datablock_to_chunk_and_free(result, reqgroup);
// (*chunk)->data points to a buffer allocated by the transform plugin, and which
// is now given to us to own. Record it here so we can free it once the user is done
// accessing it (i.e., at the next check_reads or on file close).
reqgroup->lent_varchunk_data = (*chunk)->data;
break;
case FULL_RESULT_MODE:
apply_datablock_to_result_and_free(result, reqgroup);
// If the whole variable is now ready, return it as a VARCHUNK
// Otherwise, return no chunk (NULL)
if (reqgroup->completed) {
*chunk = extract_chunk_from_finished_read_reqgroup(reqgroup);
} else {
assert(!*chunk); // No chunk to return, and *chunk is already NULL
}
break;
}
} else {
assert(!*chunk); // No chunk to return, and *chunk is already NULL
}
}
void adios_free_chunk (ADIOS_VARCHUNK *chunk)
{
common_read_free_chunk (chunk);
}
