static void alr_hanlder(int s) { struct at_job *cur = NULL; void *save=NULL; while ((cur = link_each(tim_link, &save))!= NULL){ if (cur->job_sta == AT_INVAL) continue; op_node(cur); } save = NULL; while ((cur = link_each(tim_link, &save))!= NULL) { if (cur->job_sta == AT_INVAL || cur->job_val > 0) continue; clean_node(cur); } #ifdef DEBUG save = NULL; while ((cur = link_each(tim_link, &save))!= NULL) printf("----\njob%d org_time=%d, time = %d, rep = %d\n-----\n",cur->job_num,cur->job_org_val, cur->job_val, cur->job_rep_time); #endif save = NULL; while ((cur = link_each(tim_link,&save))!= NULL) if (cur->job_sta != AT_INVAL) { next_alm = cur->job_val; alarm(next_alm); return; } alarm(0); return; }
/* Create a new extent. All links are null. If CLONEE is non-null, copy the START, END, TX and PLIST fields from it. */ static Lisp_Extent * alloc_extent(Lisp_Extent *clonee) { Lisp_Extent *x = rep_alloc(sizeof(Lisp_Extent)); if(x == 0) { rep_mem_error(); return 0; } x->car = extent_type; x->next = allocated_extents; allocated_extents = x; clean_node(x); if(clonee != 0) { x->start = clonee->start; x->end = clonee->end; x->tx = clonee->tx; x->plist = clonee->plist; x->locals = clonee->locals; } else { x->locals = Qnil; x->plist = Qnil; } assert_invariants (x); return x; }
static void pop_current() { List *tmp; tmp = list; list = list->next; clean_node(tmp); }
NODE* clean_node(NODE* node) { if(node->left!=NULL) { clean_node(node->left); } if(node->right!=NULL) { clean_node(node->right); } if(node!=NULL) { free(node); } return NULL; }
void clean_tree (node_t *root) { node_t *runner = root; int lastjump; // 0 - to left, 1 - to right while ( runner != NULL ) { while ( (runner->rnode != NULL) || (runner->lnode != NULL) ) { while ( runner->rnode != NULL ) { runner = runner->rnode; lastjump = 1; } while ( runner->lnode != NULL ) { runner = runner->lnode; lastjump = 0; } } clean_node (runner); runner = runner->hnode; if ( runner != NULL ) { if ( lastjump == 0 ) runner->lnode = NULL; else runner->rnode = NULL; } }// while }
int main(void) { int result; char input_buffer[256]; printf("Input Text>"); gets(input_buffer); NODE** tree = NULL; tree = &save_sentence(input_buffer); printf("\nProcess:Complete!>%s\n",input_buffer); print_tree(*tree); for(;;) { print_tree(*tree); printf("Delete Sentence>"); scanf("%s",input_buffer); if(strcmp(input_buffer,"Exit")==0) { break; } result = delete_sentence(tree,input_buffer); switch(result) { case DELETE_FAIL: printf("削除失敗:単語が登録されていません\n"); break; case DELETE_OK: printf("削除完了\n"); break; default: break; } } tree = clean_node(*tree); printf("Clean tree:Complete!\n"); return 0; }
/* For two adjacent fragments at the same level, LEFT and RIGHT, attempt to join them into a single fragment. Always absorbs RIGHT into LEFT, never LEFT into RIGHT. */ static void try_to_coalesce(Lisp_Extent *left, Lisp_Extent *right) { if(left->frag_next == right && left->parent == right->parent && PPOS_GREATER_EQUAL_P(&left->end, &right->start)) { /* Yep. These two can be united. */ left->right_sibling = right->right_sibling; left->end = right->end; if(left->parent->last_child == right) left->parent->last_child = left; left->frag_next = right->frag_next; clean_node(right); assert_invariants (left); assert_invariants (right); } }
void test_ksm_merge_across_nodes(unsigned long nr_pages) { char **memory; int i, ret; int num_nodes, *nodes; unsigned long length; unsigned long pagesize; #if HAVE_NUMA_H && HAVE_LINUX_MEMPOLICY_H && HAVE_NUMAIF_H \ && HAVE_MPOL_CONSTANTS unsigned long nmask[MAXNODES / BITS_PER_LONG] = { 0 }; #endif 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, "need NUMA system support"); free(nodes); return; } pagesize = sysconf(_SC_PAGE_SIZE); length = nr_pages * pagesize; memory = malloc(num_nodes * sizeof(char *)); for (i = 0; i < num_nodes; i++) { memory[i] = mmap(NULL, length, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); if (memory[i] == MAP_FAILED) tst_brkm(TBROK|TERRNO, tst_exit, "mmap"); #ifdef HAVE_MADV_MERGEABLE if (madvise(memory[i], length, MADV_MERGEABLE) == -1) tst_brkm(TBROK|TERRNO, tst_exit, "madvise"); #endif #if HAVE_NUMA_H && HAVE_LINUX_MEMPOLICY_H && HAVE_NUMAIF_H \ && HAVE_MPOL_CONSTANTS clean_node(nmask); set_node(nmask, nodes[i]); /* * Use mbind() to make sure each node contains * length size memory. */ ret = mbind(memory[i], length, MPOL_BIND, nmask, MAXNODES, 0); if (ret == -1) tst_brkm(TBROK|TERRNO, tst_exit, "mbind"); #endif memset(memory[i], 10, length); } SAFE_FILE_PRINTF(cleanup, PATH_KSM "sleep_millisecs", "0"); SAFE_FILE_PRINTF(cleanup, PATH_KSM "pages_to_scan", "%ld", nr_pages * num_nodes); /* * merge_across_nodes setting can be changed only when there * are no ksm shared pages in system, so set run 2 to unmerge * pages first, then to 1 after changing merge_across_nodes, * to remerge according to the new setting. */ SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2"); wait_ksmd_done(); tst_resm(TINFO, "Start to test KSM with merge_across_nodes=1"); SAFE_FILE_PRINTF(cleanup, PATH_KSM "merge_across_nodes", "1"); SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1"); group_check(1, 1, nr_pages * num_nodes - 1, 0, 0, 0, nr_pages * num_nodes); SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2"); wait_ksmd_done(); tst_resm(TINFO, "Start to test KSM with merge_across_nodes=0"); SAFE_FILE_PRINTF(cleanup, PATH_KSM "merge_across_nodes", "0"); SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1"); group_check(1, num_nodes, nr_pages * num_nodes - num_nodes, 0, 0, 0, nr_pages * num_nodes); SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "2"); wait_ksmd_done(); }
/* Unlink the single fragment E. */ static void unlink_extent_fragment(Lisp_Extent *e) { if(e->parent == 0) return; if(e->frag_next != 0) e->frag_next->frag_pred = e->frag_pred; if(e->frag_pred != 0) e->frag_pred->frag_next = e->frag_next; assert_invariants (e->frag_next); assert_invariants (e->frag_pred); if(e->first_child != 0) { /* Replace E by its children. */ Lisp_Extent *x; /* Fix positions and parents.. */ for(x = e->first_child; x != 0; x = x->right_sibling) { x->start.row += e->start.row; x->end.row += e->start.row; x->parent = e->parent; assert_invariants (x); } e->first_child->left_sibling = e->left_sibling; if(e->left_sibling != 0) e->left_sibling->right_sibling = e->first_child; else e->parent->first_child = e->first_child; e->last_child->right_sibling = e->right_sibling; if(e->right_sibling != 0) e->right_sibling->left_sibling = e->last_child; else e->parent->last_child = e->last_child; /* Do right before left since try_to_coalesce absorbs leftwards */ if(e->right_sibling != 0) try_to_coalesce(e->last_child, e->right_sibling); if(e->left_sibling != 0) try_to_coalesce(e->left_sibling, e->first_child); assert_invariants (e->left_sibling); assert_invariants (e->right_sibling); assert_invariants (e->first_child); assert_invariants (e->last_child); } else { /* No children, tie the siblings together */ if(e->left_sibling != 0) e->left_sibling->right_sibling = e->right_sibling; else e->parent->first_child = e->right_sibling; if(e->right_sibling != 0) e->right_sibling->left_sibling = e->left_sibling; else e->parent->last_child = e->left_sibling; if(e->left_sibling != 0 && e->right_sibling != 0) try_to_coalesce(e->left_sibling, e->right_sibling); assert_invariants (e->left_sibling); assert_invariants (e->right_sibling); assert_invariants (e->first_child); assert_invariants (e->last_child); } clean_node(e); }