NODE *lkindof(NODE *args) {
NODE *argcopy = args;
NODE *val = UNBOUND;
if (is_list(car(args))) {
if (cdr(args) != NIL) {
err_logo(TOO_MUCH, NIL); /* too many inputs */
}
args = car(args);
}
/* now args is always a list of objects */
/* make sure they're all really objects */
for (argcopy = args; (argcopy != NIL && NOT_THROWING);
argcopy = cdr(argcopy)) {
while (!is_object(car(argcopy)) && NOT_THROWING) {
setcar(argcopy, err_logo(BAD_DATA, car(argcopy)));
}
}
if (NOT_THROWING) {
val = newobj();
setparents(val, args);
}
return val;
}
NODE *loneof(NODE *args) {
NODE *val = UNBOUND, *argcopy;
if (!is_list(car(args))) {
setcar(args, cons(car(args), NIL));
}
/* now the first arg is always a list of objects */
/* make sure they're really objects */
argcopy = car(args);
while (argcopy != NIL && NOT_THROWING) {
while (!is_object(car(argcopy)) && NOT_THROWING) {
setcar(argcopy, err_logo(BAD_DATA, car(argcopy)));
}
argcopy = cdr(argcopy);
}
if (NOT_THROWING) {
val = newobj();
setparents(val, car(args));
/* apply [[InitList] [Exist Output Self]] cdr(args) */
return make_cont(withobject_continuation,
cons(val,
make_cont(begin_apply,
cons(askexist,
cons(cons(cdr(args), NIL),
NIL)))));
}
return val;
}
/* Creates and outputs an object whose parent is the Logo object.
* @params - none
*/
NODE *lsomething(NODE *args) {
NODE *val;
val = newobj();
setparents(val, cons(logo_object, NIL));
return val;
}
/*this fucntion is already serialized in the function that calls this
so from here on out there is no worry about locking*/
gasnete_coll_local_tree_geom_t *gasnete_coll_tree_geom_create_local(gasnete_coll_tree_type_t in_type, int rootrank, gasnete_coll_team_t team, gasnete_coll_tree_geom_t *base_geom) {
gasnete_coll_local_tree_geom_t *geom;
int i;
gasnete_coll_tree_type_t intype_copy;
tree_node_t *allnodes = (tree_node_t*) team->tree_construction_scratch;
tree_node_t rootnode,mynode;
gasneti_assert(rootrank<team->total_ranks && rootrank >=0);
gasneti_assert_always(in_type);
intype_copy = in_type;
geom = (gasnete_coll_local_tree_geom_t*)gasneti_malloc(sizeof(gasnete_coll_local_tree_geom_t));
gasneti_assert_always(in_type==intype_copy);
switch (in_type->tree_class) {
#if 1
case GASNETE_COLL_NARY_TREE:
gasneti_assert(in_type->num_params ==1);
allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank);
rootnode = make_nary_tree(allnodes, team->total_ranks, in_type->params[0]);
geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1);
geom->num_rotations = 1;
geom->rotation_points[0] = rootrank;
break;
case GASNETE_COLL_KNOMIAL_TREE:
gasneti_assert(in_type->num_params ==1);
allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank);
rootnode = make_knomial_tree(allnodes, team->total_ranks, in_type->params[0]);
geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1);
geom->num_rotations = 1;
geom->rotation_points[0] = rootrank;
break;
case GASNETE_COLL_FLAT_TREE:
allocate_nodes((tree_node_t**) &team->tree_construction_scratch , team, rootrank);
rootnode = make_flat_tree(team->tree_construction_scratch, team->total_ranks);
geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1);
geom->num_rotations = 1;
geom->rotation_points[0] = rootrank;
break;
case GASNETE_COLL_RECURSIVE_TREE:
gasneti_assert(in_type->num_params ==1);
allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank);
rootnode = make_recursive_tree(allnodes, team->total_ranks, in_type->params[0]);
geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1);
geom->num_rotations = 1;
geom->rotation_points[0] = rootrank;
break;
case GASNETE_COLL_FORK_TREE:
allnodes = allocate_nodes((tree_node_t**) &team->tree_construction_scratch, team, rootrank);
rootnode = make_fork_tree(allnodes, team->total_ranks, in_type->params, in_type->num_params);
geom->rotation_points = (int*) gasneti_malloc(sizeof(int)*1);
geom->num_rotations = 1;
geom->rotation_points[0] = rootrank;
break;
case GASNETE_COLL_HIERARCHICAL_TREE:
#if 0
allnodes = team->tree_construction_scratch = allocate_nodes(allnodes, team, 0);
rootnode = make_hiearchical_tree(in_type, allnodes, team->total_ranks);
/* XXX ADD CODE TO GET ROTATION POINTS*/
break;
#else
gasneti_fatalerror("HIERARCHICAL_TREE not yet fully supported");
#endif
#endif
default:
gasneti_fatalerror("unknown tree type");
break;
}
rootnode = setparents(rootnode);
mynode = find_node(rootnode, team->myrank);
geom->root = rootrank;
geom->tree_type = in_type;
geom->total_size = team->total_ranks;
geom->parent = GET_PARENT_ID(mynode);
geom->child_count = GET_NUM_CHILDREN(mynode);
geom->mysubtree_size = treesize(mynode);
geom->parent_subtree_size = treesize(mynode->parent);
geom->children_reversed = mynode->children_reversed;
if(rootrank != team->myrank) {
geom->num_siblings = GET_NUM_CHILDREN(mynode->parent);
geom->sibling_id = -1;
geom->sibling_offset = 0;
for(i=0; i<geom->num_siblings; i++) {
int tmp_id;
if(mynode->parent->children_reversed==1) {
tmp_id = geom->num_siblings-1-i;
} else {
tmp_id =i;
}
if(GET_NODE_ID(GET_CHILD_IDX(mynode->parent, tmp_id))==team->myrank) {
geom->sibling_id = tmp_id;
break;
} else {
geom->sibling_offset += treesize(GET_CHILD_IDX(mynode->parent, tmp_id));
}
}
} else {
geom->num_siblings = 0;
geom->sibling_id = 0;
geom->sibling_offset = 0;
/***** THIS NEEDS TO BE TAKEN OUT
The DFS ordering that we impose on the trees will mean that this no longer needs to be kept around
but it's in here for now for backward compatability sake until we make the neccessary changes to all the other collective algorithms
****/
geom->dfs_order = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*team->total_ranks);
for(i=0; i<team->total_ranks; i++) {
geom->dfs_order[i] = (i+rootrank)%team->total_ranks;
}
}
geom->seq_dfs_order = 1;
geom->child_list = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count);
geom->subtree_sizes = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count);
geom->child_offset = (gasnet_node_t*) gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count);
geom->grand_children = (gasnet_node_t*)gasneti_malloc(sizeof(gasnet_node_t)*geom->child_count);
geom->num_non_leaf_children=0;
geom->num_leaf_children=0;
geom->child_contains_wrap = 0;
for(i=0; i<geom->child_count; i++) {
geom->child_list[i] = GET_NODE_ID(GET_CHILD_IDX(mynode,i));
geom->subtree_sizes[i] = treesize(GET_CHILD_IDX(mynode,i));
geom->grand_children[i] = GET_NUM_CHILDREN(GET_CHILD_IDX(mynode, i));
if(geom->subtree_sizes[i] > 1) {
geom->num_non_leaf_children++;
} else {
geom->num_leaf_children++;
}
if(geom->child_list[i]+geom->subtree_sizes[i] > geom->total_size) {
geom->child_contains_wrap = 1;
}
}
gasneti_assert((geom->num_leaf_children+geom->num_non_leaf_children) == geom->child_count);
if(mynode->children_reversed==1) {
size_t temp_offset = 0;
for(i=geom->child_count-1; i>=0; i--) {
geom->child_offset[i] = temp_offset;
temp_offset+=geom->subtree_sizes[i];
}
} else {
size_t temp_offset = 0;
for(i=0; i<geom->child_count; i++) {
geom->child_offset[i] = temp_offset;
temp_offset+=geom->subtree_sizes[i];
}
}
#if 0
/* Not using the reference counts for now */
gasneti_weakatomic_set(&(geom->ref_count), 0, 0);
geom->base_geom = base_geom;
#endif
#if 0
gasnete_coll_print_tree(geom, gasneti_mynode);
#endif
return geom;
}
