/* input: array, size in bytes(!), size of one element */
void change_endianness( void *data, uint64_t slice_size, enum ADIOS_DATATYPES type)
{
int size_of_type = bp_get_type_size(type, "");
uint64_t n = slice_size / size_of_type;
uint64_t i;
char *ptr = (char *) data;
if (slice_size % size_of_type != 0) {
log_error ("Adios error in bp_utils.c:change_endianness(): "
"An array's endianness is to be converted but the size of array "
"is not dividable by the size of the elements: "
"size = %lld, element size = %d\n", slice_size, size_of_type);
}
switch (type)
{
case adios_byte:
case adios_short:
case adios_integer:
case adios_long:
case adios_unsigned_byte:
case adios_unsigned_short:
case adios_unsigned_integer:
case adios_unsigned_long:
case adios_real:
case adios_double:
case adios_long_double:
switch (size_of_type) {
/* case 1: nothing to do */
case 2:
for (i=0; i < n; i++) {
swap_16_ptr(ptr);
ptr += size_of_type;
}
break;
case 4:
for (i=0; i < n; i++) {
swap_32_ptr(ptr);
ptr += size_of_type;
}
break;
case 8:
for (i=0; i < n; i++) {
swap_64_ptr(ptr);
ptr += size_of_type;
}
break;
case 16:
for (i=0; i < n; i++) {
swap_128_ptr(ptr);
ptr += size_of_type;
}
break;
}
break;
case adios_complex:
for (i=0; i < n; i++) {
swap_32_ptr(ptr); // swap REAL part 4 bytes
swap_32_ptr(ptr+4); // swap IMG part 4 bytes
ptr += size_of_type;
}
break;
case adios_double_complex:
for (i=0; i < n; i++) {
swap_64_ptr(ptr); // swap REAL part 8 bytes
swap_64_ptr(ptr+8); // swap IMG part 8 bytes
ptr += size_of_type;
}
break;
case adios_string:
default:
/* nothing to do */
break;
}
}
int adios_transform_aplod_apply(struct adios_file_struct *fd,
struct adios_var_struct *var,
uint64_t *transformed_len,
int use_shared_buffer,
int *wrote_to_shared_buffer)
{
// Get the input data and data length
const uint64_t input_size = adios_transform_get_pre_transform_var_size(var);
const void *input_buff = var->data;
// max size supported is long double
int32_t componentVector[MAX_COMPONENTS];
int8_t numComponents = 0;
int32_t componentTotals = 0;
// printf ("[%s] byte = %d, real = %d, double = %d, this = %d\n", var->name, adios_byte, adios_real, adios_double, var->pre_transform_type);
// parse the aplod component vector parameters
/* Old, pre-specparse parameter parsing
if(var->transform_type_param)
{
char transform_param [1024];
char *transform_param_ptr = 0;
uint16_t transform_param_length = 0;
char transform_param_option [256];
uint16_t idx = 0;
strcpy (transform_param, var->transform_type_param);
transform_param_ptr = transform_param;
transform_param_length = strlen (transform_param);
// Get the key
char *key = strtok (transform_param, "=");
if (strcmp (key, "CV") == 0) {
char *value = strtok (key, ",");
int32_t componentID = 0;
while (value) {
int32_t component = atoi (value);
if (component <= 0) {
numComponents = 0;
break ;
}
componentVector [componentID] = component;
componentTotals += component;
componentID ++;
}
}
}
*/
int i;
int paramError = 0;
for (i = 0; i < var->transform_spec->param_count; i++) {
const char *comp = var->transform_spec->params[i].key;
int compInt = atoi(comp);
// Error if any component is non-positive
if (compInt <= 0 || numComponents >= MAX_COMPONENTS) {
numComponents = 0;
paramError = 1;
break;
}
componentVector[numComponents++] = compInt;
componentTotals += compInt;
}
uint32_t pre_transform_type_size = bp_get_type_size (var->pre_transform_type, "");
// Error if components were specified, and the components don't sum to the type size
if ((numComponents > 0) && (componentTotals != pre_transform_type_size)) {
paramError = 1;
}
if (paramError) {
fprintf(stderr, "Warning: at least one APLOD byte component is a non-positive integer, or all components do not sum to the type size (%d) for variable %s/%s. Using default APLOD configuration instead.\n",
bp_get_type_size (var->pre_transform_type, ""), var->path, var->name);
}
if ((numComponents == 0) || (componentTotals != pre_transform_type_size)) {
if (var->pre_transform_type == adios_double) {
componentVector [0] = 2;
componentVector [1] = 2;
componentVector [2] = 2;
componentVector [3] = 2;
numComponents = 4;
} else if (var->pre_transform_type == adios_real) {
componentVector [0] = 2;
componentVector [1] = 2;
numComponents = 2;
} else {
numComponents = 0;
while (componentTotals < pre_transform_type_size - 2) {
componentVector [numComponents ++] = 2;
componentTotals += 2;
}
componentVector [numComponents ++] = pre_transform_type_size - componentTotals;
}
}
// decide the output buffer
uint64_t output_size = input_size;
void* output_buff = NULL;
if (use_shared_buffer) {
// If shared buffer is permitted, serialize to there
assert(shared_buffer_reserve(fd, output_size));
// Write directly to the shared buffer
output_buff = fd->buffer + fd->offset;
} else { // Else, fall back to var->adata memory allocation
output_buff = malloc(output_size);
assert(output_buff);
}
*wrote_to_shared_buffer = use_shared_buffer;
// APLOD specific code - Start
uint32_t numElements = input_size / bp_get_type_size (var->pre_transform_type, "");
APLODConfig_t *config;
if (var->pre_transform_type == adios_double) {
config = APLODConfigure (componentVector, numComponents, APLOD_DOUBLE, APLOD_LITTLE_E);
} else if (var->pre_transform_type == adios_real) {
config = APLODConfigure (componentVector, numComponents, APLOD_FLOAT, APLOD_LITTLE_E);
}
// config->blockLengthElts = numElements; // Bug workaround, disable chunking
config->blockLengthElts = (numElements >= 65536 ? 65536: numElements);
APLODShuffleComponents (config, numElements, 0, numComponents, input_buff, output_buff);
// APLOD specific code - End
// Wrap up, depending on buffer mode
if (*wrote_to_shared_buffer) {
shared_buffer_mark_written(fd, output_size);
} else {
var->adata = output_buff;
var->data_size = output_size;
var->free_data = adios_flag_yes;
}
*transformed_len = output_size; // Return the size of the data buffer
// Do I copy the PLODHandle_t object as the metadata or do I serialize it into the buffer as well
if(var->transform_metadata && var->transform_metadata_len > 0)
{
memcpy ((char*)var->transform_metadata, &input_size, sizeof(uint64_t));
memcpy ((char*)var->transform_metadata + sizeof (uint64_t), &numComponents, sizeof (numComponents));
memcpy ((char*)var->transform_metadata + sizeof (uint64_t) + sizeof (numComponents), componentVector, numComponents * sizeof (int32_t));
}
// Cleanup time
APLODDestroy(config);
return 1;
}
