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