static int split_string(char ***split_strs, char *str, char *delim) {
char *temp=NULL,*copy;
int ret=0;
size_t malloc_len = 8;
static gasneti_mutex_t lock= GASNETI_MUTEX_INITIALIZER;
copy = gasneti_malloc(sizeof(char)*(strlen(str)+1));
/*since the strtok function is desructive we have to
create a copy of the string first to preserve the orignal*/
GASNETE_FAST_UNALIGNED_MEMCPY_CHECK(copy, str, sizeof(char)*(strlen(str)+1));
gasneti_mutex_lock(&lock);
*split_strs = (char **) gasneti_malloc(sizeof(char*) * malloc_len);
temp = strtok(copy, delim);
while(temp != NULL) {
if(ret == malloc_len) {
/*we've run out of space so grow the array by another factor*/
malloc_len +=malloc_len;
*split_strs = (char**) gasneti_realloc(*split_strs, sizeof(char*) * malloc_len);
gasneti_fatalerror("more than 8 params not yet supported");
}
(*split_strs)[ret] = temp;
ret++;
temp=strtok(NULL, delim);
}
*split_strs = (char**) gasneti_realloc(*split_strs, sizeof(char*) * ret);
gasneti_mutex_unlock(&lock);
return ret;
}
void myxml_addAttributeInt(myxml_node_t *node, const char *attribute_name, int attribute_value) {
char buffer[50];
if(attribute_name == NULL ) {
fprintf(stderr, "myxml error: attribute_name must be non null when adding new attribute!\n");
exit(1);
}
sprintf(buffer, "%d", attribute_value);
node->attribute_list = gasneti_realloc(node->attribute_list, sizeof(myxml_attribute_t)*(node->num_attributes+1));
STR_ALLOC_AND_COPY(node->attribute_list[node->num_attributes].attribute_name, attribute_name);
STR_ALLOC_AND_COPY(node->attribute_list[node->num_attributes].attribute_value, buffer);
node->num_attributes++;
}
void myxml_addAttribute(myxml_node_t *node, const char *attribute_name, const char *attribute_value) {
node->attribute_list = gasneti_realloc(node->attribute_list, sizeof(myxml_attribute_t)*(node->num_attributes+1));
/*if adding an attribute name and value can't be NULL*/
if(attribute_name == NULL || attribute_value == NULL) {
fprintf(stderr, "myxml error: attribute_name and attribute value must be non null when adding new attribute!\n");
exit(1);
}
STR_ALLOC_AND_COPY(node->attribute_list[node->num_attributes].attribute_name, attribute_name);
STR_ALLOC_AND_COPY(node->attribute_list[node->num_attributes].attribute_value, attribute_value);
node->num_attributes++;
}
myxml_node_t *myxml_createNode_attr_list(myxml_node_t* parent, const char *tag, const char **attribute_list, const char **attribute_vals, int num_attributes, const char *value) {
int i;
myxml_node_t *ret=gasneti_calloc(1,sizeof(myxml_node_t));
ret->parent = parent;
ret->num_children = 0;
ret->children = NULL;
/*make sure that we aren't adding to a leaf or know that this is the root node*/
if(parent==NULL) {
ret->nodeclass = MYXML_ROOT_NODE;
} else if(parent->nodeclass == MYXML_LEAF_NODE) {
fprintf(stderr, "can't add a child to a leaf node!\n");
exit(1);
}
if(tag==NULL) {
fprintf(stderr, "tag can't be null!\n");
exit(1);
} else {
STR_ALLOC_AND_COPY(ret->tag, tag);
}
/*this mustbe a leaf node since an explicit value was declared*/
if(value) {
STR_ALLOC_AND_COPY(ret->value, value);
ret->nodeclass = MYXML_LEAF_NODE;
} else if(parent!=NULL) {
ret->nodeclass = MYXML_INTER_NODE;
}
ret->attribute_list = gasneti_malloc(sizeof(myxml_attribute_t)*num_attributes);
for(i=0; i<num_attributes; i++) {
STR_ALLOC_AND_COPY(ret->attribute_list[i].attribute_name, attribute_list[i]);
STR_ALLOC_AND_COPY(ret->attribute_list[i].attribute_value, attribute_vals[i]);
}
/*add myself to my parents children list*/
if(parent) {
parent->num_children++;
if(parent->children) {
parent->children = gasneti_realloc(parent->children,parent->num_children*sizeof(myxml_node_t*));
} else {
parent->children = gasneti_malloc(parent->num_children*sizeof(myxml_node_t*));
}
parent->children[parent->num_children-1] = ret;
}
return ret;
}
/* Packetizes remotelist into a list of gasnete_packetdesc_t entries based on maxpayload packet size
sharedpacket => metadata and corresponding data travel together in unified packets (put)
so that for each packet i: datasz_i + metadatasz_i <= maxpayload
!sharedpacket => metadata and corresponding data travel in separate packets (get)
so that for each packet i: MAX(datasz_i,metadatasz_i) <= maxpayload
A local packet table is also computed to match the remote packetization boundaries of the data
on a byte-for-byte basis
Allocates and populates the plocalpt and premotept arrays with the packetization information
Returns the number of packets described by the resulting plocalpt and premotept arrays
*/
size_t gasnete_packetize_memvec(size_t remotecount, gasnet_memvec_t const remotelist[],
size_t localcount, gasnet_memvec_t const locallist[],
gasnete_packetdesc_t **premotept,
gasnete_packetdesc_t **plocalpt,
size_t maxpayload, int sharedpacket) {
size_t ptidx;
int done = 0;
size_t ridx = 0, roffset = 0, lidx = 0, loffset = 0;
size_t const metadatasz = sizeof(gasnet_memvec_t);
size_t ptsz = 4; /* initial size guess - no fast way to know for sure */
gasnete_packetdesc_t *remotept = gasneti_malloc(ptsz*sizeof(gasnete_packetdesc_t));
gasnete_packetdesc_t *localpt = gasneti_malloc(ptsz*sizeof(gasnete_packetdesc_t));
gasneti_assert(premotept && plocalpt && remotecount && localcount);
gasneti_assert(gasnete_memveclist_totalsz(remotecount,remotelist) ==
gasnete_memveclist_totalsz(localcount,locallist));
for (ptidx = 0; ; ptidx++) {
ssize_t packetremain = maxpayload;
ssize_t packetdata = 0;
size_t rdatasz, ldatasz;
if (ptidx == ptsz) { /* grow the packet tables */
ptsz *= 2;
remotept = gasneti_realloc(remotept, ptsz*sizeof(gasnete_packetdesc_t));
localpt = gasneti_realloc(localpt, ptsz*sizeof(gasnete_packetdesc_t));
}
/* begin remote packet */
remotept[ptidx].firstidx = ridx;
remotept[ptidx].firstoffset = roffset;
/* begin local packet */
if_pf (lidx == localcount) localpt[ptidx].firstidx = lidx-1; /* might happen if remote has trailing empties */
else localpt[ptidx].firstidx = lidx;
localpt[ptidx].firstoffset = loffset;
while (packetremain > metadatasz) { /* room for more entries */
gasneti_assert(roffset < remotelist[ridx].len || (remotelist[ridx].len == 0 && roffset == 0));
rdatasz = remotelist[ridx].len - roffset; /* data left in current entry */
/* try to add the entire entry to packet */
if (sharedpacket) packetremain -= (metadatasz + rdatasz);
else packetremain -= MAX(metadatasz, rdatasz);
if (packetremain < 0) { /* overflowed - finished a packet, and spill to next */
rdatasz += packetremain; /* compute truncated datasz that fits in this packet */
roffset += rdatasz; /* update offset into current entry */
packetdata += rdatasz;
break;
} else {
packetdata += rdatasz;
roffset = 0; /* finished an entry */
ridx++;
if (ridx == remotecount) { done = 1; break; } /* done - this is last packet */
}
}
/* end remote packet */
if (roffset == 0) remotept[ptidx].lastidx = ridx-1;
else remotept[ptidx].lastidx = ridx;
remotept[ptidx].lastlen = rdatasz;
#if GASNET_DEBUG /* verify packing properties */
gasnete_packetize_verify(remotept, ptidx, done, remotecount, 0, remotelist);
{ size_t datachk = 0, i;
size_t entries = remotept[ptidx].lastidx - remotept[ptidx].firstidx + 1;
for (i = remotept[ptidx].firstidx; i <= remotept[ptidx].lastidx; i++) {
if (i == remotept[ptidx].lastidx) datachk += remotept[ptidx].lastlen;
else if (i == remotept[ptidx].firstidx) datachk += (remotelist[i].len - remotept[ptidx].firstoffset);
else datachk += remotelist[i].len;
}
gasneti_assert(packetdata == datachk);
if (sharedpacket) {
gasneti_assert((metadatasz*entries + packetdata) <= maxpayload); /* not overfull */
gasneti_assert(((metadatasz*entries + packetdata) >= maxpayload - metadatasz) || done); /* not underfull */
} else {
gasneti_assert(MAX(metadatasz*entries,packetdata) <= maxpayload); /* not overfull */
/* algorithm currently may underfill for !sharedpacket, because it effectively always
subtracts the MAX(metadatasz, datasz) from *both* packets being managed simultaneously in packetremain,
rather than maintaining independent packetremains and updating each accordingly (increasing arithmetic complexity)
In vectors whose entries are dominated by datasz or metadatasz, the effect should be neglible
In perverse cases we might end up with a packet which where the maximal packet is only 2/3 full
this means in datasz dominated vectors with a few entries where datasz < metadatasz (or vice-versa)
*/
gasneti_assert((MAX(metadatasz*entries,packetdata) >= (maxpayload - metadatasz)/2) || done); /* not underfull */
}
}
#endif
ldatasz = 0;
while (packetdata > 0 || (lidx < localcount && locallist[lidx].len == 0)) {
gasneti_assert(loffset < locallist[lidx].len || (locallist[lidx].len == 0 && loffset == 0));
ldatasz = locallist[lidx].len - loffset; /* data left in current entry */
packetdata -= ldatasz;
if (packetdata < 0) { /* overflowed - this entry spills into next packet */
ldatasz += packetdata; /* compute truncated datasz that fits in this packet */
loffset += ldatasz; /* update offset into current entry */
break;
} else {
loffset = 0; /* finished an entry */
lidx++;
}
}
/* end local packet */
if (loffset == 0) localpt[ptidx].lastidx = lidx-1;
else localpt[ptidx].lastidx = lidx;
localpt[ptidx].lastlen = ldatasz;
#if GASNET_DEBUG /* verify packing properties */
gasnete_packetize_verify(localpt, ptidx, done, localcount, 0, locallist);
#endif
if (done) {
gasneti_assert(ridx == remotecount && roffset == 0 && lidx == localcount && loffset == 0);
*premotept = remotept;
*plocalpt = localpt;
return ptidx+1;
}
}
