int
sys_migrate_pages(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%ld, ", (long) (pid_t) tcp->u_arg[0]);
get_nodes(tcp, tcp->u_arg[2], tcp->u_arg[1], 0);
tprints(", ");
get_nodes(tcp, tcp->u_arg[3], tcp->u_arg[1], 0);
}
return 0;
}
void BinTree::get_nodes(tree_node *ptr, std::vector<int> & nodes) {
std::cout<<"get_nodes"<<std::endl;
if (root == NULL) {
std::cout << "Tree is empty" << std::endl;
return;
}
if (ptr != NULL) {
nodes.push_back(ptr->key);
get_nodes(ptr->left,nodes);
get_nodes(ptr->right,nodes);
}
}
// ---------------------------------------------------------------------------
//
// ------------
int bXMapNetClean::join_on_nodes(bArray& loop, int* fields, bool report){
_bTrace_("bXMapNetClean::join_on_nodes",true);
bGenericGeoElement *oa,*op;
ivertices *vsa,*vsp;
bArray bdg(sizeof(bGenericGeoElement*));
bArray nod(sizeof(bGenericGeoElement*));
bool mod;
char msg[__MESSAGE_STRING_LENGTH_MAX__];
char ttl[__MESSAGE_STRING_LENGTH_MAX__];
get_localized_name(ttl,getbundle());
b_message_string(kXMapNetCleanJoinOnNodesMessage,msg,getbundle(),0);
bProgressWait wt(ttl,msg,true,true,loop.count());
for(long i=1;i<=loop.count();i++){
if(!wt.set_progress(i)){
break;
}
loop.get(i,&oa);
oa->getVertices(&vsa);
mod=false;
get_bridges(&vsa->vx.vx2[0],bdg);
if(bdg.count()==0){
get_nodes(&vsa->vx.vx2[0],nod);
if(nod.count()==1){
nod.get(1,&op);
op->getVertices(&vsp);
vsa->vx.vx2[0]=vsp->vx.vx2[0];
mod=true;
}
}
get_bridges(&vsa->vx.vx2[vsa->nv-1],bdg);
if(bdg.count()==0){
get_nodes(&vsa->vx.vx2[vsa->nv-1],nod);
if(nod.count()==1){
nod.get(1,&op);
op->getVertices(&vsp);
vsa->vx.vx2[vsa->nv-1]=vsp->vx.vx2[0];
mod=true;
}
}
if(mod){
oa->setVertices(vsa);
if(report){
set_net_flag(oa,fields[oa->getType()-1],_kEdgeJoined);
}
}
}
return(0);
}
static void check_pids(void *arg)
{
int i;
size_t nr;
struct local_node lnodes[SD_MAX_NODES];
struct local_event *ev;
shm_queue_lock();
nr = get_nodes(lnodes);
for (i = 0; i < nr; i++)
if (!process_exists(lnodes[i].pid)) {
add_event(EVENT_LEAVE, lnodes + i, NULL, 0);
/* unblock blocking event if sender has gone */
ev = shm_queue_peek_block_event();
if (lnode_eq(lnodes + i, &ev->sender)) {
ev->removed = true;
msync(ev, sizeof(*ev), MS_SYNC);
}
}
shm_queue_unlock();
add_timer(arg, PROCESS_CHECK_INTERVAL);
}
void qsearch_fulltree_to_searchtree(FullTree *src, QSearchTree *clt) {
FullNode *map = get_nodes(src);
int node_count = src->node_count;
int leaf_count = (node_count + 2)/2;
int i,j;
// write out resulting tree in clt
for (i = 0; i < leaf_count; ++i) {
g_array_index(clt->leaf_placement, guint32, i) = i;
}
for (i = 0; i < node_count; ++i) {
QSearchNeighborList *lst = g_ptr_array_index(clt->n, i);
GArray *n = lst->n;
// lst->n is GArray
g_array_set_size(n, 0);
for (j = 0; j < 3; ++j) {
int con = map[i].connections[j];
if (con <= i) continue; // no need to write
g_array_append_val(n, con);
}
}
clt->score = (clt->dist_max - src->raw_score) / (clt->dist_max - clt->dist_min);
clt->must_recalculate_paths = TRUE;
clt->f_score_good = TRUE;
}
static void __acrd_leave(struct work *work)
{
struct acrd_leave_info *info = container_of(work, typeof(*info), work);
struct acrd_handle *ah = info->ah;
int i;
size_t nr_nodes;
uint64_t ids[SD_MAX_NODES];
struct sd_node nodes[SD_MAX_NODES];
struct acrd_tx *atx;
pthread_mutex_lock(&queue_lock);
/* unlock if left node is locking one */
atx = acrd_tx_init(ah);
acrd_tx_cmp(atx, LOCK_FILE, &info->left_nodeid,
sizeof(info->left_nodeid), 0);
acrd_tx_del(atx, LOCK_FILE, 0);
acrd_tx_commit(atx, 0);
acrd_tx_close(atx);
/* check the failed node */
nr_nodes = get_nodes(ah, nodes, ids);
for (i = 0; i < nr_nodes; i++) {
if (ids[i] == info->left_nodeid) {
add_event(ah, EVENT_LEAVE, nodes + i, NULL, 0,
NULL);
break;
}
}
pthread_mutex_unlock(&queue_lock);
}
void cache_as_ram_main(unsigned long bist, unsigned long cpu_init_detectedx)
{
static const uint16_t spd_addr [] = {
DIMM0, DIMM2, 0, 0,
DIMM1, DIMM3, 0, 0,
#if CONFIG_MAX_PHYSICAL_CPUS > 1
DIMM4, DIMM6, 0, 0,
DIMM5, DIMM7, 0, 0,
#endif
};
int needs_reset;
unsigned bsp_apicid = 0, nodes;
struct mem_controller ctrl[8];
if (bist == 0)
bsp_apicid = init_cpus(cpu_init_detectedx);
pc87360_enable_serial(SERIAL_DEV, CONFIG_TTYS0_BASE);
console_init();
/* Halt if there was a built in self test failure */
report_bist_failure(bist);
setup_default_resource_map();
needs_reset = setup_coherent_ht_domain();
#if CONFIG_LOGICAL_CPUS
// It is said that we should start core1 after all core0 launched
start_other_cores();
wait_all_other_cores_started(bsp_apicid);
#endif
/* This is needed to be able to call udelay(). It could be moved to
* memreset_setup, since udelay is called in memreset. */
init_timer();
// automatically set that for you, but you might meet tight space
needs_reset |= ht_setup_chains_x();
if (needs_reset) {
print_info("ht reset -\n");
soft_reset();
}
allow_all_aps_stop(bsp_apicid);
nodes = get_nodes();
fill_mem_ctrl(nodes, ctrl, spd_addr);
enable_smbus();
memreset_setup();
sdram_initialize(nodes, ctrl);
post_cache_as_ram();
}
void CServer::dump_libintegra_state()
{
std::cout << std::endl;
std::cout << "Print State:" << std::endl;
std::cout << "************" << std::endl;
std::cout << std::endl;
dump_state( get_nodes(), 0 );
}
int
sys_set_mempolicy(struct tcb *tcp)
{
if (entering(tcp)) {
printxval(policies, tcp->u_arg[0], "MPOL_???");
get_nodes(tcp, tcp->u_arg[1], tcp->u_arg[2], 0);
}
return 0;
}
void qsearch_fulltree_get_children(FullTree *tree, int node, int ancestor, int *child1, int *child2) {
FullNode *map = get_nodes(tree);
int branch = map[node].node_branch[ancestor];
*child1 = map[node].connections[ (3 + branch-1) % 3];
*child2 = map[node].connections[ (branch + 1) % 3];
}
double qsearch_fulltree_sum_distance_org(FullTree *tree, int a, int b) {
FullNode *map = get_nodes(tree);
int branch2b = map[a].node_branch[b];
int branch2a = map[b].node_branch[a];
return npairs( map[a].leaf_count[branch2b] ) * map[a].dist[branch2b] + npairs( map[b].leaf_count[branch2a] ) * map[b].dist[branch2a];
}
// ---------------------------------------------------------------------------
//
// ------------
int bXMapNetClean::check_edges(bArray& loop, int* fields){
_bTrace_("bXMapNetClean::check_edges",true);
bGenericGeoElement *oa;
ivertices *vsa;
bArray arra(sizeof(bGenericGeoElement*));
bArray arrb(sizeof(bGenericGeoElement*));
double dbk=_cfg_prm.dnod;
char msg[__MESSAGE_STRING_LENGTH_MAX__];
char ttl[__MESSAGE_STRING_LENGTH_MAX__];
_cfg_prm.dnod=0;
get_localized_name(ttl,getbundle());
b_message_string(kXMapNetCleanCheckEdgesMessage,msg,getbundle(),0);
bProgressWait wt(ttl,msg,true,true,loop.count());
for(long i=1;i<=loop.count();i++){
if(!wt.set_progress(i)){
break;
}
loop.get(i,&oa);
oa->getVertices(&vsa);
get_edges(&vsa->vx.vx2[0],arra,true);
get_edges(&vsa->vx.vx2[vsa->nv-1],arrb,true);
if((arra.count()==1)&&(arrb.count()==1)){
set_net_flag(oa,fields[oa->getType()-1],_kEdgeAlone);
}
else if((arra.count()==1)||(arrb.count()==1)){
set_net_flag(oa,fields[oa->getType()-1],_kEdgeDeadEnd);
}
get_nodes(&vsa->vx.vx2[0],arra);
get_nodes(&vsa->vx.vx2[vsa->nv-1],arrb);
if((arra.count()==0)||(arrb.count()==0)){
set_net_flag(oa,fields[oa->getType()-1],_kEdgeNotJoined);
}
}
_cfg_prm.dnod=dbk;
return(0);
}
static void set_score(FullTree *tree) {
// calculate the score
tree->raw_score = 0;
FullNode *map = get_nodes(tree);
int i;
for (i = (tree->node_count + 2)/2; i < tree->node_count; ++i) {
tree->raw_score += npairs(map[i].leaf_count[0]) * map[i].dist[0];
tree->raw_score += npairs(map[i].leaf_count[1]) * map[i].dist[1];
tree->raw_score += npairs(map[i].leaf_count[2]) * map[i].dist[2];
}
}
gboolean qsearch_fulltree_can_swap(FullTree *tree, int A, int B) {
FullNode *ctm = get_nodes(tree);
if (A == B) return FALSE; // no point in doing anything
int interiorA = ctm[A].connections[ ctm[A].node_branch[B] ];
int interiorB = ctm[B].connections[ (int) ctm[B].node_branch[A] ];
if (interiorA == interiorB || interiorA == B) return FALSE; // swap does not change score
return TRUE;
}
int
sys_mbind(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
printxval(policies, tcp->u_arg[2], "MPOL_???");
get_nodes(tcp, tcp->u_arg[3], tcp->u_arg[4], 0);
tprints(", ");
printflags(mbindflags, tcp->u_arg[5], "MPOL_???");
}
return 0;
}
vector<int> get_nodes_random(const TreeInterface& t,int n0) {
vector<int> nodes = get_nodes(t,n0);
vector<int> nodes2;
nodes2.insert(nodes2.end(),nodes.begin()+1,nodes.end());
random_shuffle(nodes2);
nodes[1] = nodes2[0];
nodes[2] = nodes2[1];
nodes[3] = nodes2[2];
return nodes;
}
void qsearch_free_fulltree(FullTree *tree) {
g_array_free(get_tmpA(tree), TRUE);
g_array_free(get_tmpB(tree), TRUE);
FullNode *map = get_nodes(tree);
int i;
for (i = 0; i < tree->node_count; ++i) free(map[i].node_branch);
free(map);
free(tree->data);
free(tree);
}
static void shm_queue_notify(void)
{
int i;
size_t nr;
pid_t pids[SD_MAX_NODES];
shm_queue_set_chksum();
nr = get_nodes(NULL, pids);
for (i = 0; i < nr; i++)
kill(pids[i], SIGUSR1);
}
static void shm_queue_notify(void)
{
int i;
size_t nr;
struct local_node lnodes[SD_MAX_NODES];
nr = get_nodes(lnodes);
for (i = 0; i < nr; i++) {
sd_dprintf("send signal to %s", lnode_to_str(lnodes + i));
kill(lnodes[i].pid, SIGUSR1);
}
}
static void add_event(enum local_event_type type, struct local_node *lnode,
void *buf, size_t buf_len)
{
int idx, i;
struct local_node *n;
struct local_event ev = {
.type = type,
.sender = *lnode,
};
ev.buf_len = buf_len;
if (buf)
memcpy(ev.buf, buf, buf_len);
ev.nr_lnodes = get_nodes(ev.lnodes);
switch (type) {
case EVENT_JOIN_REQUEST:
ev.lnodes[ev.nr_lnodes] = *lnode;
ev.nr_lnodes++;
break;
case EVENT_LEAVE:
n = find_lnode(lnode, ev.nr_lnodes, ev.lnodes);
idx = n - ev.lnodes;
ev.nr_lnodes--;
memmove(n, n + 1, sizeof(*n) * (ev.nr_lnodes - idx));
break;
case EVENT_GATEWAY:
n = find_lnode(lnode, ev.nr_lnodes, ev.lnodes);
n->gateway = true;
break;
case EVENT_NOTIFY:
case EVENT_BLOCK:
break;
case EVENT_UPDATE_NODE:
n = find_lnode(lnode, ev.nr_lnodes, ev.lnodes);
n->node = lnode->node;
break;
case EVENT_JOIN_RESPONSE:
abort();
}
sd_dprintf("type = %d, sender = %s", ev.type, lnode_to_str(&ev.sender));
for (i = 0; i < ev.nr_lnodes; i++)
sd_dprintf("%d: %s", i, lnode_to_str(ev.lnodes + i));
shm_queue_push(&ev);
shm_queue_notify();
}
static int add_event(struct acrd_handle *ah, enum acrd_event_type type,
struct sd_node *node, void *buf,
size_t buf_len)
{
int idx;
struct sd_node *n;
uint64_t *i;
struct acrd_event ev;
acrd_lock(ah);
ev.type = type;
ev.sender = *node;
ev.buf_len = buf_len;
if (buf)
memcpy(ev.buf, buf, buf_len);
ev.nr_nodes = get_nodes(ah, ev.nodes, ev.ids);
switch (type) {
case EVENT_JOIN_REQUEST:
ev.nodes[ev.nr_nodes] = *node;
ev.ids[ev.nr_nodes] = this_id; /* must be local node */
ev.nr_nodes++;
break;
case EVENT_LEAVE:
n = lfind(node, ev.nodes, &ev.nr_nodes, sizeof(*n),
node_id_cmp);
if (!n)
goto out;
idx = n - ev.nodes;
i = ev.ids + idx;
ev.nr_nodes--;
memmove(n, n + 1, sizeof(*n) * (ev.nr_nodes - idx));
memmove(i, i + 1, sizeof(*i) * (ev.nr_nodes - idx));
break;
case EVENT_NOTIFY:
case EVENT_BLOCK:
break;
case EVENT_JOIN_RESPONSE:
abort();
}
acrd_queue_push(ah, &ev);
out:
acrd_unlock(ah);
return 0;
}
const http_mime_node* http_mime::get_node(const char* name) const
{
get_nodes();
const char* ptr;
std::list<http_mime_node*>::const_iterator cit = mime_nodes_.begin();
for (; cit != mime_nodes_.end(); ++cit)
{
ptr = (*cit)->get_name();
if (ptr && strcmp(ptr, name) == 0)
return *cit;
}
return NULL;
}
static int add_event(enum local_event_type type, struct local_node *lnode,
void *buf, size_t buf_len)
{
struct local_node *n;
struct local_event ev = {
.type = type,
.sender = *lnode,
};
ev.buf_len = buf_len;
if (buf)
memcpy(ev.buf, buf, buf_len);
ev.nr_lnodes = get_nodes(ev.lnodes);
switch (type) {
case EVENT_JOIN:
ev.lnodes[ev.nr_lnodes] = *lnode;
ev.nr_lnodes++;
break;
case EVENT_LEAVE:
xlremove(lnode, ev.lnodes, &ev.nr_lnodes, lnode_cmp);
break;
case EVENT_GATEWAY:
n = xlfind(lnode, ev.lnodes, ev.nr_lnodes, lnode_cmp);
n->gateway = true;
break;
case EVENT_NOTIFY:
case EVENT_BLOCK:
break;
case EVENT_UPDATE_NODE:
n = xlfind(lnode, ev.lnodes, ev.nr_lnodes, lnode_cmp);
n->node = lnode->node;
break;
case EVENT_ACCEPT:
abort();
}
sd_debug("type = %d, sender = %s", ev.type, lnode_to_str(&ev.sender));
for (int i = 0; i < ev.nr_lnodes; i++)
sd_debug("%d: %s", i, lnode_to_str(ev.lnodes + i));
shm_queue_push(&ev);
shm_queue_notify();
return SD_RES_SUCCESS;
}
/* Load a type description.
* A type description is the type AST node contained in square brackets.
* The leading [ must have been loaded before this is called.
*/
static ast_t* get_type(build_parser_t* builder, ast_t* parent)
{
if(parent == NULL)
{
build_error(builder, "Type with no containing node");
return NULL;
}
if(ast_type(parent) != NULL)
{
build_error(builder, "Node has multiple types");
return NULL;
}
return get_nodes(builder, AT_RSQUARE);
}
void FadeCurve::solve_node_positions( )
{
// printf("FadeCurve::solve_node_positions()\n");
// calculate control points values
if (m_mode == 0) { // bended
if (m_type == FadeIn) {
m_controlPoints[1] = QPointF(m_strenghtFactor * (1.0 - m_bendFactor), m_strenghtFactor * m_bendFactor);
m_controlPoints[2] = QPointF(1.0 - (m_strenghtFactor * m_bendFactor), 1.0 - (m_strenghtFactor * (1.0 - m_bendFactor)));
}
if (m_type == FadeOut) {
m_controlPoints[1] = QPointF(m_strenghtFactor * m_bendFactor, m_strenghtFactor * (1.0 - m_bendFactor));
m_controlPoints[2] = QPointF(1.0 - (m_strenghtFactor * (1.0 - m_bendFactor)), 1.0 - (m_strenghtFactor * m_bendFactor));
}
}
if (m_mode == 1) { // s-shape
m_controlPoints[1] = QPointF(m_strenghtFactor * (1.0 - m_bendFactor), m_strenghtFactor * m_bendFactor);
m_controlPoints[2] = QPointF(1.0 - (m_strenghtFactor * (1.0 - m_bendFactor)), 1.0 - (m_strenghtFactor * m_bendFactor));
}
if (m_mode == 2) { // long
if (m_type == FadeIn) {
m_controlPoints[1] = QPointF(m_strenghtFactor * (1.0 - m_bendFactor), m_strenghtFactor * m_bendFactor);
m_controlPoints[2] = QPointF(1.0, 1.0);
}
if (m_type == FadeOut) {
m_controlPoints[1] = QPointF(0.0, 0.0);
m_controlPoints[2] = QPointF(1.0 - (m_strenghtFactor * (1.0 - m_bendFactor)), 1.0 - (m_strenghtFactor * m_bendFactor));
}
}
// calculate curve nodes values
float f = 0.0;
APILinkedList list = get_nodes();
int listsize = list.size();
if (listsize > 0) {
APILinkedListNode* node = list.first()->next;
while (node) {
f += 1.0 / (listsize - 1);
QPointF p = get_curve_point(f);
((CurveNode*)node)->set_relative_when_and_value(p.x(), p.y());
node = node->next;
}
}
set_changed();
}
int ROKEN_LIB_FUNCTION
getaddrinfo(const char *nodename,
const char *servname,
const struct addrinfo *hints,
struct addrinfo **res)
{
int ret;
int port = 0;
int protocol = 0;
int socktype = 0;
*res = NULL;
if (servname == NULL && nodename == NULL)
return EAI_NONAME;
if (hints != NULL
&& hints->ai_family != PF_UNSPEC
&& hints->ai_family != PF_INET
#ifdef HAVE_IPV6
&& hints->ai_family != PF_INET6
#endif
)
return EAI_FAMILY;
if (servname != NULL) {
ret = get_port_protocol_socktype (servname, hints,
&port, &protocol, &socktype);
if (ret)
return ret;
}
if (nodename != NULL) {
ret = get_number (nodename, hints, port, protocol, socktype, res);
if (ret) {
if(hints && hints->ai_flags & AI_NUMERICHOST)
ret = EAI_NONAME;
else
ret = get_nodes (nodename, hints, port, protocol, socktype,
res);
}
} else {
ret = get_null (hints, port, protocol, socktype, res);
}
if (ret)
freeaddrinfo (*res);
return ret;
}
//it is running on core0 of node0
static inline void start_other_cores(void)
{
unsigned nodes;
unsigned nodeid;
if (read_option(multi_core, 0)) {
return; // disable multi_core
}
nodes = get_nodes();
for (nodeid=0; nodeid<nodes; nodeid++) {
if ( get_core_num_in_bsp(nodeid) > 0) {
real_start_other_core(nodeid);
}
}
}
static void add_event(enum local_event_type type,
struct sheepdog_node_list_entry *node, void *buf,
size_t buf_len, void (*block_cb)(void *arg))
{
int idx;
struct sheepdog_node_list_entry *n;
pid_t *p;
struct local_event ev = {
.type = type,
.sender = *node,
};
ev.buf_len = buf_len;
if (buf)
memcpy(ev.buf, buf, buf_len);
ev.nr_nodes = get_nodes(ev.nodes, ev.pids);
switch (type) {
case EVENT_JOIN:
ev.blocked = 1;
ev.nodes[ev.nr_nodes] = *node;
ev.pids[ev.nr_nodes] = getpid(); /* must be local node */
ev.nr_nodes++;
break;
case EVENT_LEAVE:
n = lfind(node, ev.nodes, &ev.nr_nodes, sizeof(*n), node_cmp);
if (!n)
panic("internal error\n");
idx = n - ev.nodes;
p = ev.pids + idx;
ev.nr_nodes--;
memmove(n, n + 1, sizeof(*n) * (ev.nr_nodes - idx));
memmove(p, p + 1, sizeof(*p) * (ev.nr_nodes - idx));
break;
case EVENT_NOTIFY:
ev.blocked = !!block_cb;
ev.block_cb = block_cb;
break;
}
shm_queue_push(&ev);
shm_queue_notify();
}
static bool is_shm_queue_valid(void)
{
int i;
size_t nr;
struct local_node lnodes[SD_MAX_NODES];
nr = get_nodes(lnodes);
if (nr == 0)
return true;
for (i = 0; i < nr; i++)
if (process_exists(lnodes[i].pid))
return true;
return false;
}
int
sys_get_mempolicy(struct tcb *tcp)
{
if (exiting(tcp)) {
int pol;
if (tcp->u_arg[0] == 0)
tprints("NULL");
else if (syserror(tcp) || umove(tcp, tcp->u_arg[0], &pol) < 0)
tprintf("%#lx", tcp->u_arg[0]);
else
printxval(policies, pol, "MPOL_???");
get_nodes(tcp, tcp->u_arg[1], tcp->u_arg[2], syserror(tcp));
tprintf(", %#lx, ", tcp->u_arg[3]);
printflags(mempolicyflags, tcp->u_arg[4], "MPOL_???");
}
return 0;
}
