Ejemplo n.º 1
0
// ---------------------------------------------------------------------
//  is_correct
// ---------------------------------------------------------------------
int is_correct(rlist* in, rlist* out) {
    if (rlist_length(in) != rlist_length(out)) return 0;
    rnode* p;
    for (p = rlist_first(out); p != NULL; p = rlist_next(p))
        if (rlist_next(p) != NULL &&
                rlist_val(p) > rlist_val(rlist_next(p))) return 0;
    return 1;
}
Ejemplo n.º 2
0
// ---------------------------------------------------------------------
// rlist_rnd_batch_ins_rem_updates
// ---------------------------------------------------------------------
size_t rlist_rnd_batch_ins_rem_updates(rlist* list, size_t k,
                                void (*callback)(void*), void* param) {

    int j;
    rnode* node;
    size_t num_changes = 0, num_updates = 0;

    dc_begin_at();

    // cycles through list 3 times...
    for (j = 0; j < 3; j++) {

        // process list head
        if ((rand_pm() % 2)==0) 
             rlist_insert_first(list, rand_pm());
        else rlist_remove_first(list);

        num_changes++;

        // process list tail...
        for (node = rlist_first(list); 
             node != NULL; 
             node = rlist_next(node)) {   

            if ((rand_pm() % 2)==0 || rlist_next(node) == 0)
                 rlist_insert_next(list, node, rand_pm());
            else rlist_remove_next(list, node);

            num_changes++;

            if (num_changes == k) {
                num_changes = 0;
                dc_end_at();
                if (callback) callback(param);
                num_updates++;
                dc_begin_at();
            }
        }
    }

    dc_end_at();
    if (num_changes != 0) {
        if (callback) callback(param);
        num_updates++;
    }

    return num_updates;
}
Ejemplo n.º 3
0
// ---------------------------------------------------------------------
// mapper_delete
// ---------------------------------------------------------------------
void mapper_delete(mapper* m) {
    rnode* node;
    for (node = rlist_first(m->in); 
         node != NULL; 
         node = rlist_next(node)) {

        mnode* c = (mnode*)rlist_param(node);
        dc_del_cons(c->cons);
        free(c);
    }
    rlist_unsubscribe(m->in);
    free(m);
}
Ejemplo n.º 4
0
// ---------------------------------------------------------------------
//  rlist_rem_ins_updates
// ---------------------------------------------------------------------
size_t rlist_rem_ins_updates(rlist* list, 
                             void (*callback)(void*), void* param) {

    rnode* node;
    size_t num_updates = 2;
    if (rlist_first(list) == NULL) return 0;
    int val = rlist_val(rlist_first(list));
    rlist_remove_first(list);
    if (callback) callback(param);
    rlist_insert_first(list, val);
    if (callback) callback(param);
    for (node = rlist_first(list); 
         node != NULL && rlist_next(node) != NULL; 
         node = rlist_next(node)) {

        val = rlist_val(rlist_next(node));
        rlist_remove_next(list, node);
        if (callback) callback(param);
        rlist_insert_next(list, node, val);
        if (callback) callback(param);
        num_updates += 2;
    }
    return num_updates;
}
Ejemplo n.º 5
0
// ---------------------------------------------------------------------
//  rlist_rnd_change_updates
// ---------------------------------------------------------------------
size_t rlist_rnd_change_updates(rlist* list, 
                                 void (*callback)(void*), void* param) {

    rnode* node;
    size_t num_updates = 0;
    for (node = rlist_first(list); 
         node != NULL; 
         node = rlist_next(node)) {
        int val = rlist_val(node);
        dc_begin_at();
        rlist_set_val(node, rand_pm());
        dc_end_at();
        if (callback) callback(param);
        dc_begin_at();
        rlist_set_val(node, val);
        dc_end_at();
        if (callback) callback(param);
        num_updates += 2;
    }
    return num_updates;
}
Ejemplo n.º 6
0
// ---------------------------------------------------------------------
//  rlist_incr_decr_updates
// ---------------------------------------------------------------------
size_t rlist_incr_decr_updates(rlist* list, int delta,
                                 void (*callback)(void*), void* param) {

    rnode* node;
    size_t num_updates = 0;
    for (node = rlist_first(list); 
         node != NULL; 
         node = rlist_next(node)) {
        int val = rlist_val(node);
        dc_begin_at();
        rlist_set_val(node, val+delta);
        dc_end_at();
        if (callback) callback(param);
        dc_begin_at();
        rlist_set_val(node, val);
        dc_end_at();
        if (callback) callback(param);
        num_updates += 2;
    }
    return num_updates;
}
Ejemplo n.º 7
0
// ---------------------------------------------------------------------
// mapper_new
// ---------------------------------------------------------------------
mapper* mapper_new(rlist* in, rlist* out, mapper_map_t map) {

    mapper* m = malloc(sizeof(mapper));
    if (m == NULL) panic("out of memory");
    m->in  = in;
    m->out = out;
    m->map = map;
    rlist_remove_all(out);
    rlist_subscribe(in, m, (rlist_ins_t)ins, (rlist_rem_t)rem);

    dc_begin_at();
    rnode *pred, *node;
    for (pred = NULL, node = rlist_first(in); 
         node != NULL; 
         node = rlist_next(node)) {

        ins(m, pred);
        pred = node;
    }
    dc_end_at();

    return m;
}
Ejemplo n.º 8
0
// ---------------------------------------------------------------------
//  test_large
// ---------------------------------------------------------------------
void test_large(unsigned long long* count) {

    dc_profile init, end;

#if VERBOSE
    dc_profile start;
#endif

    printf("--making initial list of %d items\n", N);
    rlist* in  = rlist_new_rand(N, MAX_VAL);
    rlist* out = rlist_new();

    puts("--making sorter");
    dc_fetch_profile_info(&init);

    sorter* q = _sorter(new)(in, out);
    if (q == NULL) {
        printf("error: cannot initialize sorter\n");
        exit(0);
    }

    dc_fetch_profile_info(&end);
    dc_dump_profile_diff(stdout, &init, &end);
    check_correctness(in, out);

    puts("\n--making ins/rem operations on input list");
    size_t num_updates = 0;
    int val;

    dc_fetch_profile_info(&init);

#if VERBOSE
    dc_fetch_profile_info(&start);
#endif

    val = rlist_val(rlist_first(in));

#if VERBOSE
    printf("<r");
    fflush(stdout);
#endif

#if INS_REM == 1
    rlist_remove_first(in);
#else
    rlist_set_val(rlist_first(in), UPDATE(val));
#endif

#if VERBOSE
    printf("><i");
    fflush(stdout);
#endif

#if INS_REM == 1
    rlist_insert_first(in, val);
#else
    rlist_set_val(rlist_first(in), val);
#endif

    num_updates += 2;

#if VERBOSE
    printf(">");
    fflush(stdout);
    printf("\n");
    dc_fetch_profile_info(&end);
    printf("last session report:\n");
    dc_dump_profile_diff(stdout, &start, &end);
    printf("all sessions report:\n");
    debugging_dump(q, 0, &init, &end);
#endif
    check_correctness(in, out);

    rnode *prev;
    for (prev = rlist_first(in);
            prev != NULL && rlist_next(prev) != NULL;
            prev = rlist_next(prev)) {

#if VERBOSE
        dc_fetch_profile_info(&start);
#endif

        val = rlist_val(rlist_next(prev));

#if VERBOSE
        printf("<r");
        fflush(stdout);
#endif

#if INS_REM == 1
        rlist_remove_next(in, prev);
#else
        rlist_set_val(rlist_next(prev), UPDATE(val));
#endif

#if VERBOSE
        printf("><i");
        fflush(stdout);
#endif

#if INS_REM == 1
        rlist_insert_next(in, prev, val);
#else
        rlist_set_val(rlist_next(prev), val);
#endif

#if VERBOSE
        printf(">");
        fflush(stdout);
        printf("\n");
        dc_fetch_profile_info(&end);
        printf("last session report:\n");
        dc_dump_profile_diff(stdout, &start, &end);
        printf("all sessions report:\n");
        debugging_dump(q, 0, &init, &end);
#endif
        check_correctness(in, out);

        num_updates += 2;
    }

#if VERBOSE == 0
    dc_fetch_profile_info(&end);
    dc_dump_profile_diff(stdout, &init, &end);
#endif

    puts("\n--deleting sorter");
    dc_fetch_profile_info(&init);
    _sorter(delete)(q);
    dc_fetch_profile_info(&end);
    dc_dump_profile_diff(stdout, &init, &end);

    puts("\n--deleting lists");
    dc_fetch_profile_info(&init);
    rlist_delete(in);
    rlist_delete(out);
    dc_fetch_profile_info(&end);
    dc_dump_profile_diff(stdout, &init, &end);
}
Ejemplo n.º 9
0
// ---------------------------------------------------------------------
//  test_small 3
// ---------------------------------------------------------------------
void test_small(unsigned long long* count) {

    dc_profile init, start, end;
    rlist* in  = rlist_new_rand(N, MAX_VAL);
    rlist* out = rlist_new();

    printf("list length=%d\n", rlist_length(in));

    puts("--initial list in/out");
    dump(in, out, count);

    puts("--making sorter");
    sorter* h = _sorter(new)(in, out);
    if (h == NULL) {
        printf("error: cannot initialize sorter\n");
        exit(0);
    }
    dump(in, out, count);
#if DEBUG > 0
    _sorter(dump)(h);
#endif

    puts("\n--making rnd insert operations on input list");
    dc_fetch_profile_info(&init);
    int val;

    rnode *prev;
    size_t num_update, i, j;
    int updates[UPD];

    srand(17);
    for (i=0; i<UPD; i++) updates[i] = rand();

    for (num_update=0; num_update<UPD; num_update++) {
        i = updates[num_update] % rlist_length(in);

        if (i==0) {
            val = rand() % MAX_VAL;
            printf("\n--update %u: insert value %u in position %u\n",
                   num_update+1, val, i+1);
            dc_fetch_profile_info(&start);
            rlist_insert_first(in, val);
            dc_fetch_profile_info(&end);
            debugging_dump(h, 1, &start, &end);
            check_correctness(in, out);
            continue;
        }

        // i>0: update is not on the first item
        prev = rlist_first(in);
        for (j=1; j<i; j++) prev = rlist_next(prev);

        val = rand() % MAX_VAL;
        printf("\n--update %u: insert value %u in position %u\n",
               num_update+1, val, i+1);
        dc_fetch_profile_info(&start);
        rlist_insert_next(in, prev, val);
        dc_fetch_profile_info(&end);
        debugging_dump(h, 1, &start, &end);
        check_correctness(in, out);
    }

    dc_fetch_profile_info(&end);
    printf("\n--sequence report\n");
    debugging_dump(h, 0, &init, &end);
    check_correctness(in, out);

    puts("\n--disposing of sorter");
    _sorter(delete)(h);
    dump(in, out, count);

    puts("\n--deleting lists");
    rlist_delete(in);
    rlist_delete(out);
}
Ejemplo n.º 10
0
// ---------------------------------------------------------------------
//  test_small 1
// ---------------------------------------------------------------------
void test_small(unsigned long long* count) {

    dc_profile init, start, end;
    rlist* in  = rlist_new_rand(N, MAX_VAL);
    rlist* out = rlist_new();

    printf("list length=%d\n", rlist_length(in));

    puts("--initial list in/out");
    dump(in, out, count);

    puts("--making sorter");
    dc_fetch_profile_info(&init);
    sorter* h = _sorter(new)(in, out);
    if (h == NULL) {
        printf("error: cannot initialize sorter\n");
        exit(0);
    }
    dump(in, out, count);
    dc_fetch_profile_info(&end);
    debugging_dump(h, 1, &init, &end);
    check_correctness(in, out);
#if DEBUG > 0
    _sorter(dump)(h);
#endif

    puts("\n--making ins/rem operations on input list");
    size_t num_updates = 0, i = 1;
    dc_fetch_profile_info(&init);
    int val;

    printf("\n--remove item %u of %u\n", i, N);
    dc_fetch_profile_info(&start);
    val = rlist_val(rlist_first(in));
    rlist_remove_first(in);
#if DUMP == 1
    dump(in, out, count);
#endif
    dc_fetch_profile_info(&end);
    debugging_dump(h, 1, &start, &end);
    check_correctness(in, out);

    printf("\n--re-insert %u of %u\n", i, N);
    dc_fetch_profile_info(&start);
    rlist_insert_first(in, val);
#if DUMP == 1
    dump(in, out, count);
#endif
    dc_fetch_profile_info(&end);
    debugging_dump(h, 1, &start, &end);
    check_correctness(in, out);

    rnode *prev;
    i++;
    for (prev = rlist_first(in);
            prev != NULL && rlist_next(prev) != NULL;
            prev = rlist_next(prev), i++) {

        val = rlist_val(rlist_next(prev));

        printf("\n--remove item %u of %u\n", i, N);
        dc_fetch_profile_info(&start);
        rlist_remove_next(in, prev);
#if DUMP == 1
        dump(in, out, count);
#endif
        dc_fetch_profile_info(&end);
        debugging_dump(h, 1, &start, &end);
        check_correctness(in, out);

        printf("\n--re-insert %u of %u\n", i, N);
        dc_fetch_profile_info(&start);
        rlist_insert_next(in, prev, val);
#if DUMP == 1
        dump(in, out, count);
#endif
        dc_fetch_profile_info(&end);
        debugging_dump(h, 1, &start, &end);
        check_correctness(in, out);

        num_updates += 2;
    }

    dc_fetch_profile_info(&end);
    printf("\n--sequence report\n");
    debugging_dump(h, 0, &init, &end);
    check_correctness(in, out);

    puts("\n--disposing of sorter");
    _sorter(delete)(h);
    dump(in, out, count);

    puts("\n--deleting lists");
    rlist_delete(in);
    rlist_delete(out);
}
Ejemplo n.º 11
0
int fdwatch_dispatch(FDWATCH_HANDLE handle, int timeout)
{
	FDWATCH_ITEM* item;
	FDWATCH_ITEM* pool[FD_SETSIZE];
	int count, ret, fdmax;
	fd_set rdfds, wrfds, erfds;

	assert(handle && handle->inuse);
	if(handle==NULL || (!handle->inuse)) return ERR_INVALID_HANDLE;

	//
	FD_ZERO(&rdfds);
	FD_ZERO(&wrfds);
	FD_ZERO(&erfds);
	fdmax = 0;
	count = 0;

	while(1) {
		os_sleep(10);

		os_mutex_lock(&handle->list_mtx);
		item = (FDWATCH_ITEM*)rlist_front(&handle->enable_list);
		while(!rlist_is_head(&handle->enable_list, &item->item) && count<FD_SETSIZE) {
			if((item->flags&FDWATCH_DISABLE)==0) {
				pool[count++] = item;
				if(item->flags&FDWATCH_READ)	{ FD_SET(item->fd, &rdfds); FD_SET(item->fd, &erfds); }
				if(item->flags&FDWATCH_WRITE)	FD_SET(item->fd, &wrfds);
				if(fdmax<item->fd) fdmax = item->fd;
			}
 			item = (FDWATCH_ITEM*)rlist_next(&item->item);
		}
		os_mutex_unlock(&handle->list_mtx);

		if(count>0) break;
		if(timeout!=FDWATCH_INFINITE) {
			os_sleep(timeout);
			return ERR_NOERROR;
		}
		os_sleep(50);
	}

	for(;;) {
		if(timeout!=FDWATCH_INFINITE) {
			struct timeval tv;
			tv.tv_sec	= timeout / 1000;
			tv.tv_usec	= (timeout%1000)*1000;
			ret = select(fdmax+1, &rdfds, &wrfds, &erfds, &tv);
		} else {
			ret = select(fdmax+1, &rdfds, &wrfds, &erfds, NULL);
		}
		if(ret>=0) break;
		if(WSAGetLastError()!=WSAEINTR) {
//			SYSLOG(LOG_ERROR, MODULE_NAME, "fdwatch_loop(SELECT): Failed to select(), errno=%d", errno);
			return ERR_UNKNOWN;
		}
	}

	for(;count>0; count--) {
		int events = 0;
		if(pool[count-1]->flags&FDWATCH_READ && (FD_ISSET(pool[count-1]->fd, &rdfds) || FD_ISSET(pool[count-1]->fd, &erfds))) {
			events |= FDWATCH_READ;
		}
		if(pool[count-1]->flags&FDWATCH_WRITE && FD_ISSET(pool[count-1]->fd, &wrfds)) {
			events |= FDWATCH_WRITE;
		}
		if(events!=0) {
			if(pool[count-1]->flags&FDWATCH_ONCE) pool[count-1]->flags |= FDWATCH_DISABLE;
			pool[count-1]->event(pool[count-1], events);
		}
	}

	return ERR_NOERROR;
}