c_graph c_minigraph(){
c_graph tetrahedron;
tetrahedron.d_graph = d_minigraph();
tetrahedron.X = malloc(tetrahedron.d_graph.number_of_nodes*sizeof(double));
tetrahedron.Y = malloc(tetrahedron.d_graph.number_of_nodes*sizeof(double));
/* for (int i = 0; i < tetrahedron.d_graph.number_of_nodes; i++) { */
/* tetrahedron.X[i] = ((double)i)/((double)tetrahedron.d_graph.number_of_nodes ); */
/* tetrahedron.Y[i] = (double)(i+1)/(double)(tetrahedron.d_graph.number_of_nodes*i+1); */
/* } */
tetrahedron.X[0] = -0.5;
tetrahedron.Y[0] = -0.5*sqrt(3.0);
tetrahedron.X[1] = 1;
tetrahedron.Y[1] = 0;
tetrahedron.X[2] = -0.5;
tetrahedron.Y[2] = 0.5*sqrt(3.0);
double eps;
eps = -0.1;
tetrahedron.X[3] = -0.5*eps;
tetrahedron.Y[3] = -0.5*sqrt(3.0)*eps;
tetrahedron.X[4] = 1*eps;
tetrahedron.Y[4] = 0*eps;
tetrahedron.X[5] = -0.5*eps;
tetrahedron.Y[5] = 0.5*sqrt(3.0)*eps;
tetrahedron = set_nodes(tetrahedron.d_graph, 4);
return tetrahedron;
}
/**
* @brief
* assign_resv_resc - function examines the reservation object
* and server global parameters to obtain the node specification.
* If the above yields a non-NULL node spec, global function
* set_nodes() is called to locate a set of nodes for the subject
* reservation and allocate them to the reservation - each node
* that's allocated to the reservation gets a resvinfo structure
* added to its list of resvinfo structures and that structure
* points to the reservation.
*
* @parm[in,out] presv - reservation structure
* @parm[in] vnodes - original vnode list from scheduler/operator
*
* @return int
* @return 0 : no problems detected in the process
* @retval non-zero : error code if problem occurs
*/
int
assign_resv_resc(resc_resv *presv, char *vnodes)
{
int ret;
char *node_str = NULL;
char *host_str = NULL; /* used only as arg to set_nodes */
char * host_str2 = NULL;
if ((vnodes == NULL) || (*vnodes == '\0'))
return (PBSE_BADNODESPEC);
ret = set_nodes((void *)presv, presv->ri_qs.ri_type, vnodes,
&node_str, &host_str, &host_str2, 0, FALSE);
if (ret == PBSE_NONE) {
/*update resc_resv object's RESV_ATR_resv_nodes attribute*/
resv_attr_def[(int)RESV_ATR_resv_nodes].at_free(
&presv->ri_wattr[(int)RESV_ATR_resv_nodes]);
(void)resv_attr_def[(int)RESV_ATR_resv_nodes].at_decode(
&presv->ri_wattr[(int)RESV_ATR_resv_nodes],
NULL,
NULL,
node_str);
presv->ri_modified = 1;
}
return (ret);
}
void nodes::init()
{
entity_ = GetEntityRoot()->AddEntity(new Entity("typewriter"));
//entity_->GetFunction("next_char")->sig_function.connect(boost::bind(&typewriter::next_char, this, _1));
r_batch_nodes = new RenderBatcher();
node_ = new Surface("interface/node.rttex");
node_visited_ = new Surface("interface/node_clear.rttex");
node_station_ = new Surface("interface/eco_node.rttex");
ship_ = new Surface("interface/ship.rttex");
set_nodes(0);
}
/**
* Add nodes using copy on write semantics.
*/
void
as_cluster_add_nodes_copy(as_cluster* cluster, as_vector* /* <as_node*> */ nodes_to_add)
{
// Create temporary nodes array.
as_nodes* nodes_old = cluster->nodes;
as_nodes* nodes_new = as_nodes_create(nodes_old->size + nodes_to_add->size);
// Add existing nodes.
memcpy(nodes_new->array, nodes_old->array, sizeof(as_node*) * nodes_old->size);
// Add new nodes.
memcpy(&nodes_new->array[nodes_old->size], nodes_to_add->list, sizeof(as_node*) * nodes_to_add->size);
// Replace nodes with copy.
set_nodes(cluster, nodes_new);
// Put old nodes on garbage collector stack.
as_gc_item item;
item.data = nodes_old;
item.release_fn = (as_release_fn)release_nodes;
as_vector_append(cluster->gc, &item);
}
void
acl_init(void)
{
// FIXME: read from db
set_nodes(&acl_gids, 10, strdup("System.Package System.Service Time.Clock Net.Stack Net.Link Net.Filter\n\n"));
}
static int assign_hosts(
job *pjob, /* I (modified) */
char *given, /* I (optional) list of requested hosts */
int set_exec_host, /* I (boolean) */
char *FailHost, /* O (optional,minsize=1024) */
char *EMsg) /* O (optional,minsize=1024) */
{
unsigned int dummy;
char *list = NULL;
char *hosttoalloc = NULL;
pbs_net_t momaddr = 0;
int rc = 0, procs=0;
extern char *mom_host;
char *to_free = NULL;
resource *pres;
if (EMsg != NULL)
EMsg[0] = '\0';
if (FailHost != NULL)
FailHost[0] = '\0';
#ifdef __TREQSCHED
if ((given == NULL) || (given[0] == '\0'))
{
/* scheduler must specify node allocation for all jobs */
return(PBSE_UNKNODEATR);
}
#endif /* __TREQSCHED */
if ((given != NULL) && (given[0] != '\0'))
{
#ifdef NVIDIA_GPUS
hosttoalloc = get_correct_spec_string(given, pjob);
to_free = hosttoalloc;
#else
/* assign what was specified in run request */
hosttoalloc = given;
#endif
}
else
{
/* Build our host list from what is in the job attrs */
pres = find_resc_entry(
&pjob->ji_wattr[(int)JOB_ATR_resource],
find_resc_def(svr_resc_def, "neednodes", svr_resc_size));
if (pres != NULL)
{
/* assign what was in "neednodes" */
hosttoalloc = pres->rs_value.at_val.at_str;
if ((hosttoalloc == NULL) || (hosttoalloc[0] == '\0'))
{
return(PBSE_UNKNODEATR);
}
}
pres = find_resc_entry(
&pjob->ji_wattr[(int)JOB_ATR_resource],
find_resc_def(svr_resc_def, "procs", svr_resc_size));
if (pres != NULL)
{
/* assign what was in "neednodes" */
procs = pres->rs_value.at_val.at_long;
if ((hosttoalloc == NULL) || (hosttoalloc[0] == '\0'))
{
return(PBSE_UNKNODEATR);
}
}
}
if (hosttoalloc != NULL)
{
/* NO-OP */
}
else if (svr_totnodes == 0)
{
/* assign "local" */
if ((server.sv_attr[(int)SRV_ATR_DefNode].at_flags & ATR_VFLAG_SET) &&
(server.sv_attr[(int)SRV_ATR_DefNode].at_val.at_str != NULL))
{
hosttoalloc = server.sv_attr[(int)SRV_ATR_DefNode].at_val.at_str;
}
else
{
hosttoalloc = mom_host;
momaddr = pbs_mom_addr;
}
}
else if ((server.sv_attr[(int)SRV_ATR_DefNode].at_flags & ATR_VFLAG_SET) &&
(server.sv_attr[(int)SRV_ATR_DefNode].at_val.at_str != 0))
{
/* alloc server default_node */
hosttoalloc = server.sv_attr[(int)SRV_ATR_DefNode].at_val.at_str;
}
else if (svr_tsnodes != 0)
{
/* find first time-shared node */
if ((hosttoalloc = find_ts_node()) == NULL)
{
/* FAILURE */
return(PBSE_NOTSNODE);
}
}
else
{
/* fall back to 1 cluster node */
hosttoalloc = PBS_DEFAULT_NODE;
}
/* do we need to allocate the (cluster) node(s)? */
if (svr_totnodes != 0)
{
if ((rc = is_ts_node(hosttoalloc)) != 0)
{
rc = set_nodes(pjob, hosttoalloc, procs, &list, FailHost, EMsg);
set_exec_host = 1; /* maybe new VPs, must set */
hosttoalloc = list;
}
}
if (rc == 0)
{
/* set_nodes succeeded */
if (set_exec_host != 0)
{
job_attr_def[(int)JOB_ATR_exec_host].at_free(
&pjob->ji_wattr[(int)JOB_ATR_exec_host]);
job_attr_def[(int)JOB_ATR_exec_host].at_decode(
&pjob->ji_wattr[(int)JOB_ATR_exec_host],
NULL,
NULL,
hosttoalloc); /* O */
pjob->ji_modified = 1;
}
else
{
/* leave exec_host alone and reuse old IP address */
momaddr = pjob->ji_qs.ji_un.ji_exect.ji_momaddr;
hosttoalloc = pjob->ji_wattr[(int)JOB_ATR_exec_host].at_val.at_str;
}
strncpy(
pjob->ji_qs.ji_destin,
parse_servername(hosttoalloc, &dummy),
PBS_MAXROUTEDEST);
if (momaddr == 0)
{
momaddr = get_hostaddr(pjob->ji_qs.ji_destin);
if (momaddr == 0)
{
free_nodes(pjob);
if (list != NULL)
free(list);
sprintf(log_buffer, "ALERT: job cannot allocate node '%s' (could not determine IP address for node)",
pjob->ji_qs.ji_destin);
log_event(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
if (to_free != NULL)
free(to_free);
return(PBSE_BADHOST);
}
}
pjob->ji_qs.ji_un.ji_exect.ji_momaddr = momaddr;
} /* END if (rc == 0) */
if (list != NULL)
free(list);
if (to_free != NULL)
free(to_free);
return(rc);
} /* END assign_hosts() */
void disque_job::set_nodes_confirmed(const redis_result& rr)
{
set_nodes(rr, nodes_confirmed_);
}
void disque_job::set_nodes_delivered(const redis_result& rr)
{
set_nodes(rr, nodes_delivered_);
}
