static void set_nodes(struct acl_list *tables, unsigned int id, char *nodes) { char *t; t = strchr(nodes, '\n'); *t = '\0'; ++t; delete_node(tables->admins, id); if (nodes[0] != '\0') set_node(tables->admins, id, nodes); nodes = t; t = strchr(nodes, '\n'); *t = '\0'; ++t; delete_node(tables->users, id); if (nodes[0] != '\0') set_node(tables->users, id, nodes); nodes = t; delete_node(tables->guests, id); if (nodes[0] != '\0') set_node(tables->guests, id, nodes); }
struct node *check_node(struct bintree *root,struct node *node,short depth) { short cmp; cmp=bin_compare(root->node->square,node->square); if(cmp<0) { if(!root->lson) { root->lson=set_node(root,node,depth); return NULL; } else return check_node(root->lson,node,depth+1); } else if(cmp>0) { if(!root->rson) { root->rson=set_node(root,node,depth); return NULL; } else return check_node(root->rson,node,depth+1); } return root->node; }
static void set_node(bs_tree_t* tree, bs_tree_node_t* node, void* key, void* value) { int cmp = tree->compare(node->key, key); if(cmp <= 0) { if(node->left) set_node(tree, node->left, key, value); else node->left = create_node(node, key, value); } else { if(node->right) set_node(tree, node->right, key, value); else node->right = create_node(node, key, value); } }
int main(int argc, char *argv[]) { int lc; int size = 128, num = 3, unit = 1; unsigned long nmask[MAXNODES / BITS_PER_LONG] = { 0 }; unsigned int node; tst_parse_opts(argc, argv, ksm_options, ksm_usage); node = get_a_numa_node(tst_exit); set_node(nmask, node); setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { tst_count = 0; check_ksm_options(&size, &num, &unit); if (set_mempolicy(MPOL_BIND, nmask, MAXNODES) == -1) { if (errno != ENOSYS) tst_brkm(TBROK | TERRNO, cleanup, "set_mempolicy"); else tst_brkm(TCONF, cleanup, "set_mempolicy syscall is not " "implemented on your system."); } create_same_memory(size, num, unit); write_cpusets(node); create_same_memory(size, num, unit); } cleanup(); tst_exit(); }
int bs_tree_set(bs_tree_t* tree, void* key, void* value) { if(!tree->root) tree->root = create_node(NULL, key, value); else set_node(tree, tree->root, key, value); }
void create_node(node_p *node, int key, char *str) { node_p temp; temp = malloc(sizeof(node_p)); set_node(temp, key, str); *node = temp; }
// ---------------------------------------------------------------------- void SimpleMovement:: init( Node& v ) throw() { set_node(v); movement_initial_boxes(); }
/* Add a node to the tree */ static void place_node(struct menu *menu, char **row) { GtkTreeIter *parent = parents[indent - 1]; GtkTreeIter *node = parents[indent]; gtk_tree_store_append(tree, node, parent); set_node(node, menu, row); }
///////////////////////////////// // 下面重载的这些是运算符是让deque //从外界看上去维护的是一段连续空间的关键 //////////////////////////////// self& operator++() { ++cur; //切换到下一个元素 if (cur == last) { //如果达到了缓冲区尾端 set_node(node + 1); //就切换至下一节点(也就是缓冲区) cur = first; //的第一个元素 } return *this; }
// 前缀自减, 处理方式类似于前缀自增 // 如果当前迭代器指向元素是当前缓冲区的第一个元素 // 则将迭代器状态调整为前一个缓冲区的最后一个元素 self& operator--() { if (cur == first) { set_node(node - 1); cur = last; } --cur; return *this; }
// ---------------------------------------------------------------------- void SimpleMovement:: init_from( Node& v, NodeMovement& nm ) throw() { set_node(v); movement_update_boxes(); }
static void set_global_mempolicy(int mempolicy) { #if HAVE_NUMA_H && HAVE_LINUX_MEMPOLICY_H && HAVE_NUMAIF_H \ && HAVE_MPOL_CONSTANTS unsigned long nmask[MAXNODES / BITS_PER_LONG] = { 0 }; int num_nodes, *nodes; int ret; if (mempolicy) { ret = get_allowed_nodes_arr(NH_MEMS|NH_CPUS, &num_nodes, &nodes); if (ret != 0) tst_brkm(TBROK|TERRNO, cleanup, "get_allowed_nodes_arr"); if (num_nodes < 2) { tst_resm(TINFO, "mempolicy need NUMA system support"); free(nodes); return; } switch(mempolicy) { case MPOL_BIND: /* bind the second node */ set_node(nmask, nodes[1]); break; case MPOL_INTERLEAVE: case MPOL_PREFERRED: if (num_nodes == 2) { tst_resm(TINFO, "The mempolicy need " "more than 2 numa nodes"); free(nodes); return; } else { /* Using the 2nd,3rd node */ set_node(nmask, nodes[1]); set_node(nmask, nodes[2]); } break; default: tst_brkm(TBROK|TERRNO, cleanup, "Bad mempolicy mode"); } if (set_mempolicy(mempolicy, nmask, MAXNODES) == -1) tst_brkm(TBROK|TERRNO, cleanup, "set_mempolicy"); } #endif }
// ---------------------------------------------------------------------- void ExtIfaceProcessor:: boot() throw() { #ifdef ENABLE_TESTBEDSERVICE set_node( owner_w() ); testbedservice_proc_boot(); #endif }
uint32_t zdd_add_node(uint32_t v, int offlo, int offhi) { int n = freenode; uint32_t adjust(int off) { if (!off) return 0; if (-1 == off) return 1; return n + off; } set_node(n, v, adjust(offlo), adjust(offhi)); return freenode++; }
// ---------------------------------------------------------------------- void ExampleTestbedServiceProcessor:: boot() throw() { // important to call boot of parent! set_node( owner_w() ); TestbedServiceProcessor::testbedservice_proc_boot(); std::cout << "ExampleTestbedServiceProcessor::boot" << std::endl; }
static int fuse_exfat_open(const char* path, struct fuse_file_info* fi) { struct exfat_node* node; int rc; exfat_debug("[%s] %s", __func__, path); rc = exfat_lookup(&ef, &node, path); if (rc != 0) return rc; set_node(fi, node); return 0; }
//------------------------------------------------------------- // Model::open_node() parse a node string //------------------------------------------------------------- NodeIF *Model::open_node(NodeIF *parent,char *fn) { set_node(0); FILE *fp = fopen(fn, "rb"); if(fp != NULL){ int ok=parse(fn); fclose(fp); if(!ok) return 0; return get_node(); } return 0; }
//实现随机存取,迭代器可以直接跳跃n个距离 self& operator+=(difference_type n) { difference_type offset = n + (cur - first); if (offset >= 0 && offset < difference_type(buffer_size())) cur += n; //目标位置在同一缓冲区内 else { //目标位置不在同一缓冲区内 difference_type node_offset = offset > 0 ? offset / difference_type(buffer_size()) : -difference_type((-offset - 1) / buffer_size()) - 1; set_node(node + node_offset); //切换到正确的节点(缓冲区) //切换到正确的元素 cur = first + (offset - node_offset * difference_type(buffer_size())); } return *this; }
//------------------------------------------------------------------------------ Node* add_node(Uint id) { Node* ret = get_node(id); if(ret == NULL){ node_array[node_index].parent_node = 0; node_array[node_index].current_cost = MAX_INT; node_array[node_index].visited = 0; node_array[node_index].page_addr = NULL; id_table[node_index] = id; set_node(id, &node_array[node_index]); ret = &node_array[node_index]; node_index++; return ret; } return ret; }
static int fuse_exfat_create(const char* path, mode_t mode, struct fuse_file_info* fi) { struct exfat_node* node; int rc; exfat_debug("[%s] %s 0%ho", __func__, path, mode); rc = exfat_mknod(&ef, path); if (rc != 0) return rc; rc = exfat_lookup(&ef, &node, path); if (rc != 0) return rc; set_node(fi, node); return 0; }
// construct tree nodes for an sexp, adding them to the list and returning first node int campaign_sexp_tree::load_sub_tree(int index) { int cur; if (index < 0) { cur = allocate_node(-1); set_node(cur, (SEXPT_OPERATOR | SEXPT_VALID), "do-nothing"); // setup a default tree if none return cur; } // assumption: first token is an operator. I require this because it would cause problems // with child/parent relations otherwise, and it should be this way anyway, since the // return type of the whole sexp is boolean, and only operators can satisfy this. Assert(Sexp_nodes[index].subtype == SEXP_ATOM_OPERATOR); cur = get_new_node_position(); load_branch(index, -1); return cur; }
// ---------------------------------------------------------------------- void JumpMovement:: init_from( Node& v, NodeMovement& nm ) throw() { set_node(v); set_position(nm.position()); if ( update_mask_[JumpMovement::X] ) pos_ = Vec( update_pos_[JumpMovement::X], pos_.y(), pos_.z() ); if ( update_mask_[JumpMovement::Y] ) pos_ = Vec( pos_.x(), update_pos_[JumpMovement::Y], pos_.z() ); if ( update_mask_[JumpMovement::Z] ) pos_ = Vec( pos_.x(), pos_.y(), update_pos_[JumpMovement::Z] ); movement_initial_boxes(); }
int insert_content_node(c_list *list, char *index, char *content, unsigned int len){ if(!list) return -1; c_node *tmp = Malloc(sizeof(*tmp)); init_node(tmp); set_node(tmp, index, len); if(!tmp) return -1; tmp->content = Malloc(sizeof(char)*len); memcpy(tmp->content, content,len); pthread_rwlock_wrlock((list->lock)); add_node(tmp, list); pthread_rwlock_unlock((list->lock)); return 0; }
tree_t *build_synthetic_topology_old(int *synt_tab,int id,int depth,int nb_levels){ tree_t *res,**child; int arity=synt_tab[0]; int val,i; res=(tree_t*)malloc(sizeof(tree_t)); val=0; if(depth>=nb_levels) child=NULL; else{ child=(tree_t**)malloc(sizeof(tree_t*)*arity); for(i=0;i<arity;i++){ child[i]=build_synthetic_topology_old(synt_tab+1,i,depth+1,nb_levels); child[i]->parent=res; val+=child[i]->val; } } set_node(res,child,arity,NULL,id,val+speed(depth),child[0]); return res; }
/* Build ring of nodes and edges around the current hex */ static gboolean build_network(Hex * hex, G_GNUC_UNUSED gpointer closure) { gint idx; for (idx = 0; idx < 6; idx++) { Node *node = NULL; Edge *edge = NULL; if (get_cc_hex(hex, idx) != NULL) node = get_cc_hex_node(hex, idx); if (node == NULL && get_cw_hex(hex, idx) != NULL) node = get_cw_hex_node(hex, idx); if (node == NULL) { node = g_malloc0(sizeof(*node)); node->map = hex->map; node->owner = -1; node->x = hex->x; node->y = hex->y; node->pos = idx; } set_node(hex, idx, node); set_node_hex(hex, idx, hex); if (get_op_hex(hex, idx) != NULL) edge = get_op_hex_edge(hex, idx); if (edge == NULL) { edge = g_malloc0(sizeof(*edge)); edge->map = hex->map; edge->owner = -1; edge->x = hex->x; edge->y = hex->y; edge->pos = idx; } set_edge(hex, idx, edge); set_edge_hex(hex, idx, hex); } return FALSE; }
static void testcpuset(void) { int lc; int child, i, status; unsigned long nmask[MAXNODES / BITS_PER_LONG] = { 0 }; char mems[BUFSIZ], buf[BUFSIZ]; read_cpuset_files(CPATH, "cpus", buf); write_cpuset_files(CPATH_NEW, "cpus", buf); read_cpuset_files(CPATH, "mems", mems); write_cpuset_files(CPATH_NEW, "mems", mems); SAFE_FILE_PRINTF(cleanup, CPATH_NEW "/tasks", "%d", getpid()); switch (child = fork()) { case -1: tst_brkm(TBROK | TERRNO, cleanup, "fork"); case 0: for (i = 0; i < nnodes; i++) { if (nodes[i] >= MAXNODES) continue; set_node(nmask, nodes[i]); } if (set_mempolicy(MPOL_BIND, nmask, MAXNODES) == -1) tst_brkm(TBROK | TERRNO, cleanup, "set_mempolicy"); exit(mem_hog_cpuset(ncpus > 1 ? ncpus : 1)); } for (lc = 0; TEST_LOOPING(lc); lc++) { tst_count = 0; snprintf(buf, BUFSIZ, "%d", nodes[0]); write_cpuset_files(CPATH_NEW, "mems", buf); snprintf(buf, BUFSIZ, "%d", nodes[1]); write_cpuset_files(CPATH_NEW, "mems", buf); } if (waitpid(child, &status, WUNTRACED | WCONTINUED) == -1) tst_brkm(TBROK | TERRNO, cleanup, "waitpid"); if (WEXITSTATUS(status) != 0) tst_resm(TFAIL, "child exit status is %d", WEXITSTATUS(status)); }
//------------------------------------------------------------- // Model::parse_node() parse a node string //------------------------------------------------------------- NodeIF *Model::parse_node(NodeIF *parent,char *s){ FILE *fp = File.writeFile(File.system, (char*)"node.spx"); if(!fp) return 0; fprintf(fp,s); fclose(fp); char path[256]; File.getBaseDirectory(path); File.addToPath(path,File.system); File.addToPath(path,"node.spx"); fp=fopen(path,"rb"); if(!fp) return 0; set_node(0); int ok=parse(path); fclose(fp); if(ok) return get_node(); return 0; }
void AutoThrottleWidget::on_at_button_clicked() { emit set_node("/instrumentation/flightdirector/at-on", buttATEnabled->isChecked() ? "1" : "0"); }
void AutoThrottleWidget::on_val_changed(int val) { emit set_node("/autopilot/settings/target-speed-kt", QString::number(val)); }
/* * Update the tree by adding/removing entries * Does not change other nodes */ static void update_tree(struct menu *src, GtkTreeIter * dst) { struct menu *child1; GtkTreeIter iter, tmp; GtkTreeIter *child2 = &iter; gboolean valid; GtkTreeIter *sibling; struct symbol *sym; struct property *prop; struct menu *menu1, *menu2; if (src == &rootmenu) indent = 1; valid = gtk_tree_model_iter_children(model2, child2, dst); for (child1 = src->list; child1; child1 = child1->next) { prop = child1->prompt; sym = child1->sym; reparse: menu1 = child1; if (valid) gtk_tree_model_get(model2, child2, COL_MENU, &menu2, -1); else menu2 = NULL; // force adding of a first child #ifdef DEBUG printf("%*c%s | %s\n", indent, ' ', menu1 ? menu_get_prompt(menu1) : "nil", menu2 ? menu_get_prompt(menu2) : "nil"); #endif if (!menu_is_visible(child1) && !show_all) { // remove node if (gtktree_iter_find_node(dst, menu1) != NULL) { memcpy(&tmp, child2, sizeof(GtkTreeIter)); valid = gtk_tree_model_iter_next(model2, child2); gtk_tree_store_remove(tree2, &tmp); if (!valid) return; // next parent else goto reparse; // next child } else continue; } if (menu1 != menu2) { if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node if (!valid && !menu2) sibling = NULL; else sibling = child2; gtk_tree_store_insert_before(tree2, child2, dst, sibling); set_node(child2, menu1, fill_row(menu1)); if (menu2 == NULL) valid = TRUE; } else { // remove node memcpy(&tmp, child2, sizeof(GtkTreeIter)); valid = gtk_tree_model_iter_next(model2, child2); gtk_tree_store_remove(tree2, &tmp); if (!valid) return; // next parent else goto reparse; // next child } } else if (sym && (sym->flags & SYMBOL_CHANGED)) { set_node(child2, menu1, fill_row(menu1)); } indent++; update_tree(child1, child2); indent--; valid = gtk_tree_model_iter_next(model2, child2); } }