snet_stream_t *SNetStreamCreate(int capacity)
{
snet_stream_t *s = SNetMemAlloc(sizeof(snet_stream_t));
pthread_mutex_init(&s->lock, NULL);
pthread_cond_init(&s->notempty, NULL);
pthread_cond_init(&s->notfull, NULL);
s->size = (capacity > 0) ? capacity : SNET_STREAM_DEFAULT_CAPACITY;
s->head = 0;
s->tail = 0;
s->count = 0;
s->buffer = SNetMemAlloc( s->size*sizeof(void*) );
s->producer = NULL;
s->consumer = NULL;
s->is_poll = 0;
memset( s->buffer, 0, s->size*sizeof(void*) );
s->source = NULL;
s->callback_read.func = NULL;
s->callback_read.arg = NULL;
return s;
}
/**
* Collector creation function
* @pre num >= 1
*/
snet_stream_t *CollectorCreateStatic( int num, snet_stream_t **instreams, int location, snet_info_t *info)
{
snet_stream_t *outstream;
coll_arg_t *carg;
int i;
assert(num >= 1);
/* create outstream */
outstream = SNetStreamCreate(0);
/* create collector handle */
carg = (coll_arg_t *) SNetMemAlloc( sizeof( coll_arg_t));
carg->output = outstream;
carg->is_static = true;
CARG_ST(carg, num) = num;
/* copy instreams */
CARG_ST(carg, inputs) = SNetMemAlloc(num * sizeof(snet_stream_t *));
for(i=0; i<num; i++) {
CARG_ST(carg, inputs[i]) = instreams[i];
}
/* spawn collector task */
SNetThreadingSpawn(
SNetEntityCreate( ENTITY_collect, location, SNetLocvecGet(info),
"<collect>", CollectorTask, (void*)carg)
);
return outstream;
}
void SNetDistribInit(int argc, char **argv, snet_info_t *info)
{
int *counter = SNetMemAlloc(sizeof(int));
snet_dest_t *dest = SNetMemAlloc(sizeof(snet_dest_t));;
*counter = 0;
dest->node = 0;
dest->dest = *counter;
dest->parent = 0;
dest->parentNode = 0;
dest->dynamicIndex = 0;
dest->dynamicLoc = 0;
prevDest = SNetInfoCreateTag();
SNetInfoSetTag(info, prevDest, (uintptr_t) dest,
(void* (*)(void*)) &SNetDestCopy);
infoCounter = SNetInfoCreateTag();
SNetInfoSetTag(info, infoCounter, (uintptr_t) counter, NULL);
SNetDistribImplementationInit(argc, argv, info);
SNetReferenceInit();
SNetOutputManagerInit();
SNetInputManagerInit();
}
void SNetDistribZMQUnpack(zframe_t **srcframe, void *dst, size_t count)
{
if (*srcframe != NULL) {
size_t dst_size = count;
size_t srcframe_size = zframe_size(*srcframe);
byte *srcframe_data = zframe_data(*srcframe);
if(dst_size > srcframe_size) {
dst = NULL;
} else {
memcpy(dst, srcframe_data, dst_size);
if ((srcframe_size - dst_size) != 0) {
byte *newdst = SNetMemAlloc(srcframe_size - dst_size);
memcpy(newdst, srcframe_data + count, srcframe_size - dst_size);
zframe_reset(*srcframe, newdst, srcframe_size - dst_size);
SNetMemFree(newdst);
} else {
zframe_destroy(srcframe);
*srcframe = NULL;
}
}
} else {
dst = NULL;
}
}
/* Convert an array of chars to a nul-terminated string. */
static char* chars_to_string(c4snet_data_t *c4data)
{
size_t size = C4SNetArraySize(c4data);
char* str = SNetMemAlloc(size + 1);
memcpy(str, C4SNetGetData(c4data), size);
str[size] = '\0';
return str;
}
void * decompose (void *hnd, c4snet_data_t *InFile, c4snet_data_t *OutFile,
int a_size, int bs)
{
int p, i, j;
double *array;
tile *atiles, *ltiles;
char *infile;
if (bs <= 0) {
fprintf (stderr, "A block size must be greater than 0\n");
exit (1);
}
if (a_size <= 0) {
fprintf (stderr, "The dimension of matrix must be greater than 0\n");
exit (1);
}
if (a_size % bs) {
fprintf(stderr,
"matrix size %d is not a multiple of the block size %d\n",
a_size, bs);
exit(1);
}
p = a_size / bs;
/* Get the input filename as a string. */
infile = chars_to_string(InFile);
outfile = chars_to_string(OutFile);
C4SNetFree(InFile);
C4SNetFree(OutFile);
array = SNetMemAlloc(a_size * a_size * sizeof(double));
read_matrix(a_size, array, infile);
free(infile);
if (clock_gettime(CLOCK_REALTIME, &begin)) {
pexit("clock_gettime");
}
atiles = (tile *) malloc (sizeof (tile) * p * p);
ltiles = (tile *) malloc (sizeof (tile) * p * p);
memset (atiles, 0, sizeof (tile) * p * p);
memset (ltiles, 0, sizeof (tile) * p * p);
for (i = 0; i < p; i++)
for (j = 0; j <= i; j++) {
atiles[j * p + i] = (double *) malloc (sizeof (double) * bs * bs);
ltiles[j * p + i] = (double *) malloc (sizeof (double) * bs * bs);
int ai, aj, ti, tj;
for (ai = i * bs, ti = 0; ti < bs; ai++, ti++)
for (aj = j * bs, tj = 0; tj < bs; aj++, tj++)
atiles[j * p + i][tj * bs + ti] = array[aj * a_size + ai];
}
C4SNetOut (hnd, 1, C4SNetCreate (CTYPE_char, sizeof (void *), &atiles),
C4SNetCreate (CTYPE_char, sizeof (void *), <iles), bs, p, 0);
free(array);
return hnd;
}
snet_list_t *LIST_FUNCTION(LIST_NAME, Copy)(snet_list_t *list)
{
snet_list_t *result = SNetMemAlloc(sizeof(snet_list_t));
result->size = list->used;
result->used = list->used;
result->start = 0;
result->values = SNetMemAlloc(list->used * sizeof(LIST_VAL));
int startToArrayEnd = list->size - list->start;
memcpy(result->values, list->values + list->start,
startToArrayEnd * sizeof(LIST_VAL));
memcpy(result->values + startToArrayEnd, list->values,
(list->size - startToArrayEnd) * sizeof(LIST_VAL));
return result;
}
snet_list_t *LIST_FUNCTION(LIST_NAME, Create)(int size, ...)
{
int i;
va_list args;
snet_list_t *result = SNetMemAlloc(sizeof(snet_list_t));
result->size = size;
result->used = size;
result->start = 0;
result->values = SNetMemAlloc(size * sizeof(LIST_VAL));
va_start(args, size);
for (i = 0; i < size; i++) {
result->values[i] = va_arg(args, LIST_VAL);
}
va_end(args);
return result;
}
static usrdata_t *CheckCreateUsrdata(lpel_stream_t * ls)
{
usrdata_t *dat = LpelStreamGetUsrData(ls);
if (dat == NULL) {
dat = SNetMemAlloc(sizeof(usrdata_t));
dat->source = NULL;
dat->callback_read.func = NULL;
dat->callback_read.arg = NULL;
LpelStreamSetUsrData(ls, dat);
}
return dat;
}
static void *SCCUnpackFun(void *buf)
{
c4snet_data_t *result = SNetMemAlloc(sizeof(c4snet_data_t));
SNetDistribUnpack(result, buf, false, sizeof(c4snet_data_t));
result->ref_count = 1;
if (result->vtype == VTYPE_array) {
SNetDistribUnpack(&result->data.ptr, buf, true);
}
return result;
}
/* Get a copy of an unterminated char array as a proper C string. */
char* C4SNetGetString(c4snet_data_t *data)
{
if (data->type != CTYPE_char && data->type != CTYPE_uchar) {
SNetUtilDebugFatal("[%s]: Not a char array type %d.", __func__, data->type);
return NULL; /* NOT REACHED */
} else {
size_t size = C4SNetArraySize(data);
char* str = SNetMemAlloc(size + 1);
memcpy(str, C4SNetGetData(data), size);
str[size] = '\0';
return str;
}
}
void SNetThreadingSpawn(snet_entity_t ent, int loc, const char *name,
snet_taskfun_t func, void *arg)
{
int res;
pthread_t p;
pthread_attr_t attr;
/* create snet_thread_t */
snet_thread_t *thr = SNetMemAlloc(sizeof(snet_thread_t));
thr->fun = func;
pthread_mutex_init( &thr->lock, NULL );
pthread_cond_init( &thr->pollcond, NULL );
thr->wakeup_sd = NULL;
thr->inarg = arg;
thr->name = (char*) name;
/* increment entity counter */
pthread_mutex_lock( &entity_lock );
entity_count += 1;
pthread_mutex_unlock( &entity_lock );
/* create pthread: */
(void) pthread_attr_init( &attr);
size_t stacksize = StackSize(ent);
if (stacksize > 0) {
res = pthread_attr_setstacksize(&attr, stacksize);
if (res != 0) perror("Cannot set stack size!");
}
/* all threads are detached */
res = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (res != 0) perror("Cannot set detached!");
/* spawn off thread */
res = pthread_create( &p, &attr, &TaskWrapper, thr);
if (res != 0) perror("Cannot create pthread!");
pthread_attr_destroy( &attr);
/* core affinity */
#ifdef USE_CORE_AFFINITY
if (ent == ENTITY_other) {
SetThreadAffinity( &p, STRICTLYFIRST);
} else {
SetThreadAffinity( &p, DEFAULT);
}
#endif /* USE_CORE_AFFINITY */
}
static void *SAC4SNetMPIUnpackFun(void *buf)
{
int *shape;
SACarg *result = NULL;
void *contents = NULL;
int type, dims, num_elems = 1;
SNetDistribUnpack(buf, &type, sizeof(type));
SNetDistribUnpack(buf, &dims, sizeof(dims));
shape = SNetMemAlloc(dims * sizeof(int));
SNetDistribUnpack(buf, shape, dims * sizeof(int));
for (int i = 0; i < dims; i++) {
num_elems *= shape[i];
}
contents = SNetMemAlloc(num_elems * sizeOfType(type));
SNetDistribUnpack(buf, contents, num_elems * sizeOfType(type));
switch (type) {
case SACint:
result = SACARGconvertFromIntPointerVect(contents, dims, shape);
break;
case SACflt:
result = SACARGconvertFromFloatPointerVect(contents, dims, shape);
break;
case SACdbl:
result = SACARGconvertFromDoublePointerVect(contents, dims, shape);
break;
default:
Error( "Unsupported basetype in unpack function.");
break;
}
SNetMemFree(shape);
return result;
}
snet_record_t *SNetRecCopy( snet_record_t *rec)
{
snet_record_t *new_rec;
switch (REC_DESCR( rec)) {
case REC_data:
new_rec = SNetMemAlloc( sizeof( snet_record_t));
REC_DESCR( new_rec) = REC_data;
RECPTR( new_rec) = SNetMemAlloc( sizeof( snet_record_types_t));
RECORD( new_rec, data_rec) = SNetMemAlloc( sizeof( data_rec_t));
DATA_REC( new_rec, fields) = SNetRefMapCopy(DATA_REC(rec, fields));
DATA_REC( new_rec, tags) = SNetIntMapCopy( DATA_REC( rec, tags));
DATA_REC( new_rec, btags) = SNetIntMapCopy( DATA_REC( rec, btags));
SNetRecSetInterfaceId( new_rec, SNetRecGetInterfaceId( rec));
SNetRecSetDataMode( new_rec, SNetRecGetDataMode( rec));
DATA_REC( new_rec, parent_rids) = NULL;
/*
(DATA_REC( rec, parent_rids)==NULL) ?
NULL : SNetRecIdListCopy(DATA_REC( rec, parent_rids));
*/
break;
case REC_sort_end:
new_rec = SNetRecCreate( REC_DESCR( rec), SORT_E_REC( rec, level),
SORT_E_REC( rec, num));
break;
case REC_terminate:
new_rec = SNetRecCreate( REC_terminate);
TERM_REC(new_rec, local) = TERM_REC(rec, local);
break;
default:
new_rec = NULL;
SNetUtilDebugFatal("Can't copy record of type %d", REC_DESCR( rec));
break;
}
return new_rec;
}
void SAC4SNet_out( void *hnd, int variant_num, ...)
{
int i;
void **fields;
int *tags, *btags, name, f=0, t=0, b=0;
snet_int_list_t *variant;
snet_variant_t *v;
va_list args;
variant = SNetIntListListGet( SNetHndGetVariants( (struct handle *) hnd), variant_num-1);
v = SNetVariantListGet( SNetHndGetVariantList( (struct handle*) hnd), variant_num-1);
fields = SNetMemAlloc( SNetVariantNumFields( v) * sizeof( void*));
tags = SNetMemAlloc( SNetVariantNumTags( v) * sizeof( int));
btags = SNetMemAlloc( SNetVariantNumBTags( v) * sizeof( int));
va_start( args, variant_num);
for(i=0; i<SNetIntListLength( variant); i+=2) {
name = SNetIntListGet( variant, i+1);
switch(SNetIntListGet( variant, i)) {
case field:
fields[f++] = SACARGnewReference( va_arg( args, SACarg*));
break;
case tag:
tags[t++] = va_arg( args, int);
break;
case btag:
btags[b++] = va_arg( args, int);
break;
default:
assert(0);
}
}
va_end( args);
SNetOutRawArray( hnd, my_interface_id, v, fields, tags, btags);
}
/**
* Convenience function for creating
* Split, DetSplit, LocSplit or LocSplitDet,
* dependent on parameters is_byloc and is_det
*/
snet_stream_t *CreateSplit( snet_stream_t *input,
snet_info_t *info,
snet_locvec_t *locvec,
int location,
snet_ast_t *box_a,
int ltag, int utag,
bool is_byloc,
bool is_det
)
{
snet_info_t *newInfo = SNetInfoCopy(info);
snet_stream_t *initial, *output;
split_arg_t *sarg;
snet_locvec_t *locvec;
locvec = SNetLocvecGet(info);
SNetLocvecSplitEnter(locvec);
SNetLocvecSet(newInfo, SNetLocvecCopy(locvec));
input = SNetRouteUpdate(newInfo, input, location);
if(SNetDistribIsNodeLocation(location)) {
initial = SNetStreamCreate(0);
sarg = (split_arg_t *) SNetMemAlloc( sizeof( split_arg_t));
sarg->input = input;
sarg->output = initial;
sarg->boxfun = box_a;
sarg->info = newInfo;
sarg->ltag = ltag;
sarg->utag = utag;
sarg->is_det = is_det;
sarg->is_byloc = is_byloc;
sarg->location = location;
SNetThreadingSpawn(
SNetEntityCreate( ENTITY_split, location, locvec,
"<split>", SplitBoxTask, (void*)sarg)
);
output = CollectorCreateDynamic( initial, location, info);
} else {
SNetLocvecDestroy(SNetLocvecGet(newInfo));
SNetInfoDestroy(newInfo);
output = input;
}
SNetLocvecSplitLeave(locvec);
return output;
}
snet_msg_t SNetDistribRecvMsg(void)
{
int count;
snet_msg_t result;
MPI_Status status;
static mpi_buf_t recvBuf = {0, 0, NULL};
MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
MPI_Get_count(&status, MPI_PACKED, &count);
MPI_Pack_size(count, MPI_PACKED, MPI_COMM_WORLD, &recvBuf.offset);
if ((unsigned) recvBuf.offset > recvBuf.size) {
SNetMemFree(recvBuf.data);
recvBuf.data = SNetMemAlloc(recvBuf.offset);
recvBuf.size = recvBuf.offset;
}
MPI_Recv(recvBuf.data, count, MPI_PACKED, MPI_ANY_SOURCE, status.MPI_TAG,
MPI_COMM_WORLD, &status);
recvBuf.offset = 0;
result.type = status.MPI_TAG;
switch (result.type) {
case snet_rec:
result.rec = SNetRecDeserialise(&recvBuf, &UnpackInt, &UnpackRef);
case snet_block:
case snet_unblock:
result.dest.node = status.MPI_SOURCE;
UnpackDest(&recvBuf, &result.dest);
break;
case snet_ref_set:
result.ref = SNetRefDeserialise(&recvBuf, &UnpackInt, &UnpackByte);
result.data = (uintptr_t) SNetInterfaceGet(SNetRefInterface(result.ref))->unpackfun(&recvBuf);
break;
case snet_ref_fetch:
result.ref = SNetRefDeserialise(&recvBuf, &UnpackInt, &UnpackByte);
result.data = status.MPI_SOURCE;
break;
case snet_ref_update:
result.ref = SNetRefDeserialise(&recvBuf, &UnpackInt, &UnpackByte);
UnpackInt(&recvBuf, 1, &result.val);
break;
default:
break;
}
return result;
}
void SNetHndSetStringNames( snet_handle_t *hnd, int num, ...)
{
int i;
va_list args;
va_start( args, num);
hnd->mapping = (name_mapping_t *) SNetMemAlloc( sizeof( name_mapping_t));
hnd->mapping->num = num;
hnd->mapping->int_names = (int *) SNetMemAlloc( num * sizeof( int));
hnd->mapping->string_names = (char **) SNetMemAlloc( num * sizeof( char*));
for( i=0; i<num; i++) {
char *str;
int len;
hnd->mapping->int_names[i] = va_arg( args, int);
str = va_arg( args, char*);
len = strlen(str)+1;
hnd->mapping->string_names[i] = (char *) SNetMemAlloc( len * sizeof( char));
(void) strncpy( hnd->mapping->string_names[i], str, len);
hnd->mapping->string_names[i][len-1] = '\0';
}
}
snet_stream_desc_t *SNetStreamOpen(snet_stream_t *stream, char mode)
{
assert( mode=='w' || mode=='r' );
snet_stream_desc_t *sd = SNetMemAlloc(sizeof(snet_stream_t));
sd->stream = stream;
sd->next = NULL;
sd->mode = mode;
sd->thr = SNetThreadingSelf();
/* assign consumer or producer */
switch(mode) {
case 'w': stream->producer = sd; break;
case 'r': stream->consumer = sd; break;
default: assert(0);/*nop*/
}
return sd;
}
/* Deserializes textual data from a file. */
static c4snet_data_t *C4SNetDeserialise(FILE *file)
{
char buf[16];
c4snet_data_t *temp = SNetMemAlloc(sizeof(c4snet_data_t));
temp->size = 0;
temp->ref_count = 1;
if (fscanf(file, "(%15[^[)][%lu])", buf, &temp->size) == 2) {
temp->vtype = VTYPE_array;
} else {
temp->vtype = VTYPE_simple;
(void) fscanf(file, ")");
}
int size = strlen(buf);
if (strncmp(buf, "unsigned char", size) == 0) temp->type = CTYPE_uchar;
else if(strncmp(buf, "char", size) == 0) temp->type = CTYPE_char;
else if(strncmp(buf, "unsigned short", size) == 0) temp->type = CTYPE_ushort;
else if(strncmp(buf, "short", size) == 0) temp->type = CTYPE_short;
else if(strncmp(buf, "unsigned int", size) == 0) temp->type = CTYPE_uint;
else if(strncmp(buf, "int", size) == 0) temp->type = CTYPE_int;
else if(strncmp(buf, "unsigned long", size) == 0) temp->type = CTYPE_ulong;
else if(strncmp(buf, "long", size) == 0) temp->type = CTYPE_long;
else if(strncmp(buf, "float", size) == 0) temp->type = CTYPE_float;
else if(strncmp(buf, "double", size) == 0) temp->type = CTYPE_double;
else if(strncmp(buf, "long double", size) == 0) temp->type = CTYPE_ldouble;
else if(strncmp(buf, "pointer", size) == 0) temp->type = CTYPE_pointer;
else SNetUtilDebugFatal("[%s]: C4SNet interface encountered an unknown type.", __func__);
if (temp->vtype == VTYPE_simple) {
DeserialiseData(file, temp->type, &temp->data);
} else {
temp->data.ptr = MemAlloc(AllocatedSpace(temp));
for (int i = 0; i < temp->size; i++) {
if (i > 0 && fgetc(file) != ',') {
SNetUtilDebugFatal("[%s]: Parse error deserialising data.", __func__);
}
DeserialiseData(file, temp->type,
(char*) temp->data.ptr + i * C4SNetSizeof(temp));
}
}
return temp;
}
void SNetRouteDynamicEnter(snet_info_t *info, int dynamicIndex, int dynamicLoc,
snet_startup_fun_t fun)
{
snet_dest_t *dest = (snet_dest_t*) SNetInfoGetTag(info, prevDest);
dest->dynamicIndex = dynamicIndex;
int *counter = SNetMemAlloc(sizeof(int));
*counter = 0;
SNetInfoSetTag(info, infoCounter, (uintptr_t) counter, NULL);
if (fun != NULL) {
dest->parent = SNetNetToId(fun);
dest->parentNode = SNetDistribGetNodeId();
dest->dynamicLoc = dynamicLoc;
}
return;
}
void SNetInInputInit(FILE *file,
snetin_label_t *labels,
snetin_interface_t *interfaces,
snet_stream_t *in_buf
)
{
handle_t *hnd = SNetMemAlloc(sizeof(handle_t));
hnd->file = file;
hnd->labels = labels;
hnd->interfaces = interfaces;
hnd->buffer = in_buf;
SNetThreadingSpawn(
SNetEntityCreate( ENTITY_other, -2, NULL, /* SOSI */
"glob_input", GlobInputTask, (void*)hnd)
);
}
/* Decodes binary data from a file. */
static c4snet_data_t *C4SNetDecode(FILE *file)
{
c4snet_data_t *c = SNetMemAlloc(sizeof(c4snet_data_t));
Base64decodeDataType(file, (int*) &c->vtype);
Base64decode(file, &c->size, sizeof(int));
Base64decodeDataType(file, (int*) &c->type);
c->ref_count = 1;
if(c->vtype == VTYPE_array) {
c->data.ptr = MemAlloc(AllocatedSpace(c));
Base64decode(file, c->data.ptr, AllocatedSpace(c));
} else {
Base64decode(file, &c->data, C4SNetSizeof(c));
}
return c;
}
/* Creates a new c4snet_data_t struct. */
c4snet_data_t *C4SNetAlloc(c4snet_type_t type, size_t size, void **data)
{
c4snet_data_t *c = SNetMemAlloc(sizeof(c4snet_data_t));
c->type = type;
c->size = size;
c->ref_count = 1;
if (size == 1) {
c->vtype = VTYPE_simple;
*data = &c->data;
} else {
c->vtype = VTYPE_array;
c->data.ptr = MemAlloc(AllocatedSpace(c));
*data = c->data.ptr;
}
return c;
}
c4snet_data_t *C4SNetCreate(c4snet_type_t type, size_t size, const void *data)
{
c4snet_data_t *c = SNetMemAlloc(sizeof(c4snet_data_t));
c->type = type;
c->size = size;
c->ref_count = 1;
if (size == 1) {
c->vtype = VTYPE_simple;
memcpy(&c->data, data, C4SNetSizeof(c));
} else {
c->vtype = VTYPE_array;
c->data.ptr = MemAlloc(AllocatedSpace(c));
memcpy(c->data.ptr, data, AllocatedSpace(c));
}
return c;
}
void SNetDistribZMQPack(zframe_t **dstframe, void *src, size_t count)
{
if (*dstframe != NULL) {
size_t src_size = count;
size_t dstframe_size = zframe_size(*dstframe);
byte *dstframe_data = zframe_data(*dstframe);
byte *newsrc = SNetMemAlloc(src_size + dstframe_size);
memcpy(newsrc, dstframe_data, dstframe_size);
memcpy(newsrc + dstframe_size, src, src_size);
zframe_reset(*dstframe, newsrc, dstframe_size + src_size);
SNetMemFree(newsrc);
} else {
*dstframe = zframe_new(src, count);
}
}
/**
* Collector creation function
*/
snet_stream_t *CollectorCreateDynamic( snet_stream_t *instream, int location, snet_info_t *info)
{
snet_stream_t *outstream;
coll_arg_t *carg;
/* create outstream */
outstream = SNetStreamCreate(0);
/* create collector handle */
carg = (coll_arg_t *) SNetMemAlloc( sizeof( coll_arg_t));
carg->output = outstream;
carg->is_static = false;
CARG_DYN(carg, input) = instream;
/* spawn collector task */
SNetThreadingSpawn(
SNetEntityCreate( ENTITY_collect, location, SNetLocvecGet(info),
"<collect>", CollectorTask, (void*)carg)
);
return outstream;
}
static void SAC4SNetMPIPackFun(void *sacdata, void *buf)
{
int *shape;
void *contents = NULL;
SACarg *data = sacdata;
int type, dims, num_elems = 1;
type = SACARGgetBasetype(data);
dims = SACARGgetDim(data);
shape = SNetMemAlloc(dims * sizeof(int));
for (int i = 0; i < dims; i++) {
shape[i] = SACARGgetShape(data, i);
num_elems *= SACARGgetShape(data, i);
}
SNetDistribPack(&type, buf, MPI_INT, 1);
SNetDistribPack(&dims, buf, MPI_INT, 1);
SNetDistribPack(shape, buf, MPI_INT, dims);
SNetMemFree(shape);
switch (type) {
case SACint:
contents = SACARGconvertToIntArray(SACARGnewReference(data));
break;
case SACdbl:
contents = SACARGconvertToDoubleArray(SACARGnewReference(data));
break;
case SACflt:
contents = SACARGconvertToFloatArray(SACARGnewReference(data));
break;
default:
Error( "Unsupported basetype in pack function.");
break;
}
SNetDistribPack(contents, buf, SAC4SNetBasetypeToMPIType(type), num_elems);
SNetMemFree(contents);
}
static void *SAC4SNetDataDeserialise( FILE *file)
{
int i;
char buf[128], tstr[128];
char datafile_name[128];
FILE *datafile;
int basetype, dim, *shape;
SACarg *scanres, *sac_shp, *dummy;
fscanf( file, "%s", buf);
if( strcmp( IDSTRINGPRE, buf) == 0) {
fscanf( file, "%s%d", tstr, &dim);
basetype = TstrToNum ( tstr);
shape = SNetMemAlloc( dim * sizeof( int));
for( i=0; i<dim; i++) {
fscanf( file, "%d", &shape[i]);
}
fscanf( file, "%s", buf);
/* This is a temporary workaround to avoid
* having two yaccs accessing the same file (which results
* in interesting behaviour...)
*/
fscanf( file, "%s", datafile_name);
datafile = fopen( datafile_name, "r");
if( datafile == NULL) {
Error( "Failed to open datafile");
}
if( strcmp( IDSTRINGSUF, buf) == 0) {
/* create a stub hive for the SAC calls */
SAC_AttachHive(SAC_AllocHive(1, 2, NULL, NULL));
sac_shp = SACARGconvertFromIntPointerVect( shape, 1, &dim);
switch( basetype) {
case T_int:
SAC4SNetFibreIO__ScanIntArray2(
&dummy,
&scanres,
SACARGconvertFromVoidPointer( SACTYPE_StdIO_File, datafile),
sac_shp);
break;
case T_double:
SAC4SNetFibreIO__ScanDoubleArray2(
&dummy,
&scanres,
SACARGconvertFromVoidPointer( SACTYPE_StdIO_File, datafile),
sac_shp);
break;
case T_float:
SAC4SNetFibreIO__ScanFloatArray2(
&dummy,
&scanres,
SACARGconvertFromVoidPointer( SACTYPE_StdIO_File, datafile),
sac_shp);
break;
default: /* unsupported base type */
scanres = NULL;
printf( "\n>%d<\n", basetype);
Error("Unsupported Base Type. We only support int, float and double.");
break;
}
fclose( datafile);
/* release the stub hive */
SAC_ReleaseHive(SAC_DetachHive());
}
else { /* Illegal Header Suffix */
scanres = NULL;
Error( "Illegal Header Suffix");
}
}
else { /* Illegal Header Prefix */
scanres = NULL;
Error( "Illegal Header Prefix");
}
return( (void*)scanres);
}
static void SAC4SNetDataSerialise( FILE *file, void *ptr)
{
int i, dim;
SACarg *ret, *arg = (SACarg*)ptr;
char *basetype_str;
int btype;
btype = SACARGgetBasetype( arg);
if( btype <= MaxTNum()) {
basetype_str = SNetMemAlloc(
(strlen( t_descr[ btype]) + 1) * sizeof( char));
strcpy( basetype_str, t_descr[ btype]);
}
else {
basetype_str = SNetMemAlloc(
(strlen( "(UDT)") + 1) * sizeof( char));
strcpy( basetype_str, "(UDT)");
}
if( arg != NULL) {
dim = SACARGgetDim( arg);
fprintf( file, "\n%s %s %d ", IDSTRINGPRE,
basetype_str,
dim);
for( i=0; i<dim; i++) {
fprintf( file, "%d ",SACARGgetShape( arg, i));
}
fprintf(file, " %s\n", IDSTRINGSUF);
/* create a stub hive for the SAC calls */
SAC_AttachHive(SAC_AllocHive(1, 2, NULL, NULL));
switch( SACARGgetBasetype( arg)) {
case T_int:
SAC4SNetFibreIO__PrintIntArray2(
&ret,
SACARGconvertFromVoidPointer( SACTYPE_StdIO_File, file),
SACARGnewReference( arg));
break;
case T_float:
SAC4SNetFibreIO__PrintFloatArray2(
&ret,
SACARGconvertFromVoidPointer( SACTYPE_StdIO_File, file),
SACARGnewReference( arg));
break;
case T_double:
SAC4SNetFibreIO__PrintDoubleArray2(
&ret,
SACARGconvertFromVoidPointer( SACTYPE_StdIO_File, file),
SACARGnewReference( arg));
break;
default:
fprintf( file, "## UNSERIALISABLE BASETYPE (%d) ##\n", btype);
break;
}
/* release the stub hive */
SAC_ReleaseHive(SAC_DetachHive());
}
SNetMemFree( basetype_str);
}
