/* fh_hash_create(keylen,entries)
*
* Allocates a table large enough to hold 'entries' entries of size 'keylen'.
* Note that 'entries' must be a power of two.
*/
static
fh_hash_t *
fh_hash_create(size_t entries)
{
fh_hash_t *hash;
if (!IS_POWER_OF_2(entries))
gasneti_fatalerror("fh_hash_create requires a power of 2!");
hash = (fh_hash_t *) gasneti_malloc(sizeof(fh_hash_t));
if (hash == NULL)
gasneti_fatalerror("Can't allocate memory for hash structure");
memset(hash, 0, sizeof(fh_hash_t));
hash->fh_table = (void **) gasneti_calloc(entries, sizeof(void *));
hash->fh_mask = entries-1;
hash->fh_entries = entries;
#ifdef FH_HASH_STATS
hash->fh_col_table = (int *) gasneti_malloc(entries * sizeof(int));
/*printf("hash create: entries=%d, mask=%x\n", entries, entries-1);*/
hash->fh_used = 0;
hash->fh_collisions = 0;
#endif
return hash;
}
gasnet_mxm_send_req_t * gasnetc_alloc_send_req(void)
{
gasnet_mxm_send_req_t * sreq = (gasnet_mxm_send_req_t *)
#if GASNET_DEBUG
gasneti_calloc(1, sizeof(gasnet_mxm_send_req_t));
#else
gasneti_malloc(sizeof(gasnet_mxm_send_req_t));
#endif
gasneti_assert(sreq && "Out of memory");
return sreq;
}
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;
}
myxml_bytestream_t myxml_loadFile_into_bytestream(FILE *instream) {
myxml_bytestream_t ret;
ret.offset = 0;
fseek(instream, 0L, SEEK_END);
ret.size = ftell(instream);
rewind(instream);
printf("loading %d bytes\n", (int)ret.size);
ret.bytes = gasneti_calloc(sizeof(char),ret.size);
if(fread(ret.bytes, 1, ret.size, instream)!=ret.size) {
fprintf(stderr, "error reading input file!\n");
exit(1);
}
return ret;
}
static tree_node_t *allocate_nodes(tree_node_t **curr_nodes, gasnet_team_handle_t team, int rootrank) {
gasnet_node_t i;
int new_allocation=0;
if(!(*curr_nodes)) {
*curr_nodes = (tree_node_t*) gasneti_malloc(sizeof(tree_node_t)*team->total_ranks);
new_allocation=1;
}
for(i=0; i<team->total_ranks; i++) {
if(new_allocation) {
(*curr_nodes)[i] = (struct tree_node_t_*) gasneti_calloc(1,sizeof(struct tree_node_t_));
} else {
gasneti_free((*curr_nodes)[i]->children);
(*curr_nodes)[i]->children = NULL;
(*curr_nodes)[i]->num_children = 0;
(*curr_nodes)[i]->children_reversed = 0;
}
(*curr_nodes)[i]->id = (i+rootrank)%team->total_ranks;
(*curr_nodes)[i]->parent = NULL;
}
return *curr_nodes;
}
/* allocate more eops */
GASNETI_NEVER_INLINE(gasnete_eop_alloc,
static void gasnete_eop_alloc(gasneti_threaddata_t * const thread)) {
gasnete_eopaddr_t addr;
int bufidx = thread->eop_num_bufs;
gasnete_eop_t *buf;
int i;
gasnete_threadidx_t threadidx = thread->threadidx;
if (bufidx == 256) gasneti_fatalerror("GASNet Extended API: Ran out of explicit handles (limit=65535)");
thread->eop_num_bufs++;
buf = (gasnete_eop_t *)gasneti_calloc(256,sizeof(gasnete_eop_t));
gasneti_leak(buf);
for (i=0; i < 256; i++) {
addr.bufferidx = bufidx;
#if GASNETE_SCATTER_EOPS_ACROSS_CACHELINES
#ifdef GASNETE_EOP_MOD
addr.eopidx = (i+32) % 255;
#else
{ int k = i+32;
addr.eopidx = k > 255 ? k - 255 : k;
}
#endif
#else
addr.eopidx = i+1;
#endif
buf[i].threadidx = threadidx;
buf[i].addr = addr;
#if 0 /* these can safely be skipped when the values are zero */
SET_OPSTATE(&(buf[i]),OPSTATE_FREE);
SET_OPTYPE(&(buf[i]),OPTYPE_EXPLICIT);
#if GASNETE_EOP_COUNTED
buff[i].initiated_cnt = 0;
#endif
#endif
#if GASNETE_EOP_COUNTED
gasnetc_atomic_set(&(buf[i].completed_cnt), 0, 0);
#endif
}
/* add a list terminator */
#if GASNETE_SCATTER_EOPS_ACROSS_CACHELINES
#ifdef GASNETE_EOP_MOD
buf[223].addr.eopidx = 255; /* modular arithmetic messes up this one */
#endif
buf[255].addr = EOPADDR_NIL;
#else
buf[255].addr = EOPADDR_NIL;
#endif
thread->eop_bufs[bufidx] = buf;
addr.bufferidx = bufidx;
addr.eopidx = 0;
thread->eop_free = addr;
#if GASNET_DEBUG
{ /* verify new free list got built correctly */
int i;
int seen[256];
gasnete_eopaddr_t addr = thread->eop_free;
#if 0
if (gasneti_mynode == 0)
for (i=0;i<256;i++) {
fprintf(stderr,"%i: %i: next=%i\n",gasneti_mynode,i,buf[i].addr.eopidx);
fflush(stderr);
}
sleep(5);
#endif
gasneti_memcheck(thread->eop_bufs[bufidx]);
memset(seen, 0, 256*sizeof(int));
for (i=0;i<(bufidx==255?255:256);i++) {
gasnete_eop_t *eop;
gasneti_assert(!gasnete_eopaddr_isnil(addr));
eop = GASNETE_EOPADDR_TO_PTR(thread,addr);
gasneti_assert(OPTYPE(eop) == OPTYPE_EXPLICIT);
gasneti_assert(OPSTATE(eop) == OPSTATE_FREE);
gasneti_assert(eop->threadidx == threadidx);
gasneti_assert(addr.bufferidx == bufidx);
gasneti_assert(!seen[addr.eopidx]);/* see if we hit a cycle */
seen[addr.eopidx] = 1;
addr = eop->addr;
}
gasneti_assert(gasnete_eopaddr_isnil(addr));
}
#endif
}
gasnete_coll_local_tree_geom_t *gasnete_coll_local_tree_geom_fetch(gasnete_coll_tree_type_t type, gasnet_node_t root, gasnete_coll_team_t team) {
gasnete_coll_tree_geom_t *geom_cache_head = team->tree_geom_cache_head;
gasnete_coll_local_tree_geom_t *ret;
gasnete_coll_tree_geom_t *curr_geom;
/*lock here so that only one multiple threads don't try to build it*/
gasneti_mutex_lock(&team->tree_geom_cache_lock);
curr_geom = gasnete_coll_tree_geom_fetch_helper(type, team);
if(curr_geom == NULL) {
int i;
#if 0
if(gasneti_mynode ==0) fprintf(stderr, "%d> new tree: %d type %d fanout\n",gasneti_mynode, type.tree_class, type.prams[0]);
#endif
/* allocate new geometry */
curr_geom = (gasnete_coll_tree_geom_t *) gasneti_malloc(sizeof(gasnete_coll_tree_geom_t));
curr_geom->local_views = (gasnete_coll_local_tree_geom_t**)
gasneti_malloc(sizeof(gasnete_coll_local_tree_geom_t*)*team->total_ranks);
for(i=0; i<team->total_ranks; i++) {
curr_geom->local_views[i] = NULL;
}
curr_geom->tree_type = type;
#if 0
/* Not using the ref_count for now */
gasneti_weakatomic_set(&(curr_geom->ref_count), 0, 0);
#endif
/* curr_geom->root = root; */
/* link it into the cache*/
if(geom_cache_head == NULL) {
/*cache is empty*/
curr_geom->prev = NULL;
curr_geom->next = NULL;
team->tree_geom_cache_head = curr_geom;
team->tree_geom_cache_tail = curr_geom;
} else {
curr_geom->prev = NULL; /* new head */
curr_geom->next = team->tree_geom_cache_head;
team->tree_geom_cache_head->prev = curr_geom;
team->tree_geom_cache_head = curr_geom;
}
curr_geom->local_views[root] = gasnete_coll_tree_geom_create_local(type, root, team, curr_geom);
ret = curr_geom->local_views[root];
/* create local view for the root that we request */
} else {
/* if it is already allocated for root go ahead and return it ... this should be the fast path*/
if(curr_geom->local_views[root] == NULL) {
curr_geom->local_views[root] = gasnete_coll_tree_geom_create_local(type, root, team, curr_geom);
}
ret = curr_geom->local_views[root];
}
#ifdef GASNETC_HAVE_AMRDMA
/*at the time of this writing no conduits support this yet*/
if(team->myrank != ret->root) {
int count = GASNETE_COLL_TREE_GEOM_CHILD_COUNT(ret);
gasnet_node_t *tmp = gasneti_calloc(1+count, sizeof(gasnet_node_t));
memcpy(tmp, GASNETE_COLL_TREE_GEOM_CHILDREN(ret), count*sizeof(gasnet_node_t));
tmp[count] = GASNETE_COLL_TREE_GEOM_PARENT(ret);
gasnetc_amrdma_init(1+count, tmp);
gasneti_free(tmp);
} else {
gasnetc_amrdma_init(GASNETE_COLL_TREE_GEOM_CHILD_COUNT(ret),
GASNETE_COLL_TREE_GEOM_CHILDREN(ret));
}
#endif
#if 0
/* Not using the reference counts for now */
gasneti_weakatomic_increment(&(curr_geom->ref_count), 0);
gasneti_weakatomic_increment(&(ret->ref_count), 0);
/*
fprintf(stderr, "[%u] gasnete_coll_local_tree_geom_fetch: curr_geom->ref_count %u, ret->ref_count %u \n",
gasnet_mynode(), gasneti_weakatomic_read(&(curr_geom->ref_count), 0),
gasneti_weakatomic_read(&(ret->ref_count), 0));
*/
#endif
gasneti_mutex_unlock(&team->tree_geom_cache_lock);
return ret;
}
