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);
}
