static void
test_rb(void) {
//rbtree *tr = rb_cnew( 0, 0, 0, 0, 0, 0);
rbtree *tr = rb_new();
char keybuf[100];
size_t valuebuf[] = { 1 };
size_t *vp;
// while (fscanf(stdin, "%s", keybuf) == 1) {
// vp = rb_get(tr, keybuf);
// if (vp)
// *vp += 1;
// else
// rb_add(tr, keybuf, valuebuf);
// }
// this is another faster version
while (fscanf(stdin, "%s", keybuf) == 1) {
vp = rb_fget(tr, keybuf);
*vp += 1;
}
rb_set(tr, "a", valuebuf);
*valuebuf = 123456789;
rb_add(tr, "b", valuebuf);
*valuebuf = 2;
rb_set(tr, "c", valuebuf);
rb_set(tr, "d", valuebuf);
*valuebuf = 987654321;
rb_update(tr,"a",valuebuf);
rb_set(tr, "e", valuebuf);
rb_print(tr);
rb_clear(tr);
rb_clear(tr); //just for test
rb_free(tr);
}
void m_clear(MTrace * m){
if (m->rb1){
rb_clear(m->rb1);
}
if (m->rb2){
rb_clear(m->rb2);
}
m->left_max = NULL;
m->right_min = NULL;
m->cnt1 = m->cnt2 = 0;
}
/* -----------------------------------------------
* brief : free the data space and tree node space
* destory the tree
* you can not use this tree again
* set tree to NULL after call rb_free!!!
* para t: rb tree
* ----------------------------------------------- */
void rb_free(RBTree * t){
if (!t) return ;
rb_clear(t);
free(t->rb_node_space);
free(t->nil);
t->root = t->nil = NULL;
free(t);
}
END_TEST
START_TEST (test_clear)
{
rb_append(rb, sample16, 16);
ck_assert(rb_is_full(rb));
rb_clear(rb);
ck_assert(rb_is_empty(rb));
}
int main()
{
int i, val;
struct node *p;
struct rb_node *rb_node;
RB_DECLARE(rb);
srand( (unsigned int)time(NULL) );
for (i = 0; i < 1024*1024; ++i) {
p = node_alloc(rand()%100 + 100);
rb_insert(&p->rb_node, &rb, compare_link, NULL);
}
#ifndef NDEBUG
printf("height: {%zu, %zu}\n", rb_height_min(&rb), rb_height_max(&rb));
#endif
rb_node = rb_first(&rb);
if (rb_node) {
val = rb_entry(rb_node, struct node, rb_node)->val;
rb_node = rb_next(rb_node);
while (rb_node) {
register int val_new = rb_entry(rb_node, struct node, rb_node)->val;
if (val > val_new) {
printf("error: %d, %d\n", val, val_new);
}
rb_node = rb_next(rb_node);
}
}
rb_node = rb_first(&rb);
printf("1 node_cnt: %d\n", node_cnt);
i = 105;
rb_erase_equal(&rb, compare, destroy, &i, NULL);
printf("2 node_cnt: %d\n", node_cnt);
rb_clear(&rb, destroy, NULL);
printf("3 node_cnt: %d\n", node_cnt);
rb_node = rb_first(&rb);
if (rb_node) {
printf("error: rb_node should be null\n");
}
return 0;
}
int main()
{
int i;
rb_tree_t tree;
rb_node_t *node;
rb_tree_create(&tree, NULL);
for (i = 0; i < MAX; i++)
rb_insert(&tree, i, NULL);
rb_clear(&tree);
for (i = 0; i < MAX; i+=2)
rb_insert(&tree, i, NULL);
for (i = 0; i < MAX; i+=4)
{
node = rb_find(&tree, i);
rb_delete(&tree, node, FALSE);
}
rb_tree_destroy(&tree);
return 0;
}
int buffering_flush(neo4j_iostream_t *stream)
{
struct buffering_iostream *ios = container_of(stream,
struct buffering_iostream, _iostream);
if (ios->delegate == NULL)
{
errno = EPIPE;
return -1;
}
if (!rb_is_empty(ios->sndbuf))
{
struct iovec iov[2];
unsigned int iovcnt = rb_data_iovec(ios->sndbuf, iov,
rb_size(ios->sndbuf));
size_t written;
if (neo4j_ios_writev_all(ios->delegate, iov, iovcnt, &written))
{
rb_discard(ios->sndbuf, written);
return -1;
}
rb_clear(ios->sndbuf);
}
return neo4j_ios_flush(ios->delegate);
}
ICACHE_FLASH_ATTR
void parser_reset(parser *p) {
rb_clear(p->buffer);
p->state = PS_READY_FOR_COMMAND;
}
int main(int argc, char *argv[])
{
irb_tree_t irb_tree;
irb_node_t *node;
unsigned int key;
#if 0
for (int i = 0; i < KEY_POOL_CAPS; ++i) {
add_key:
key = arc4random();
for (int j = i - 1; j >= 0; j--) {
if (key == key_pool[j]) {
goto add_key;
}
}
key_pool[i] = key;
}
#else
unsigned int j = 0;
for (int i = 0; i < KEY_POOL_CAPS; ++i, ++j) {
add_key:
if (arc4random() % 10 == 0) {
++j;
}
key_pool[i] = j;
}
unsigned int a, b;
for (int i = 0; i < 30000; ++i) {
do {
a = arc4random() % KEY_POOL_CAPS;
b = arc4random() % KEY_POOL_CAPS;
} while (a == b);
unsigned int tmp = key_pool[a];
key_pool[a] = key_pool[b];
key_pool[b] = tmp;
}
#endif
printf("Key pool init.\n");
struct timeval rb1,rb2,rb3;
irb_tree_init(&irb_tree, data_compare, data_destroy);
gettimeofday(&rb1, NULL);
for (int i = 0; i < KEY_POOL_CAPS; ++i) {
data_node_t *data = (data_node_t *)malloc(sizeof(*data));
data->key = key_pool[i];
irb_insert(&(data->irb_node), &irb_tree);
}
gettimeofday(&rb2, NULL);
timersub(&rb2, &rb1, &rb3);
printf("IRBT INSERT %ld secs, %ld msecs.\n", rb3.tv_sec, rb3.tv_usec);
printf("Min:%u\n",
irb_entry(irb_first(&irb_tree), data_node_t, irb_node)->key);
printf("Max:%u\n",
irb_entry(irb_last(&irb_tree), data_node_t, irb_node)->key);
gettimeofday(&rb1, NULL);
irb_clear(&irb_tree);
gettimeofday(&rb2, NULL);
timersub(&rb2, &rb1, &rb3);
printf("IRBT CLEAR %ld secs, %ld msecs.\n", rb3.tv_sec, rb3.tv_usec);
rb_tree_t rb_tree;
rb_tree_init(&rb_tree, data_compare2, data_destroy2);
gettimeofday(&rb1, NULL);
for (int i = 0; i < KEY_POOL_CAPS; ++i) {
unsigned int *data = (unsigned int *)malloc(sizeof(unsigned int));
*data = key_pool[i];
rb_insert(data, &rb_tree);
}
gettimeofday(&rb2, NULL);
timersub(&rb2, &rb1, &rb3);
printf("RBT INSERT %ld secs, %ld msecs.\n", rb3.tv_sec, rb3.tv_usec);
printf("Min:%u\n",
*(static_cast<unsigned int *>(rb_first(&rb_tree)->data)));
printf("Max:%u\n",
*(static_cast<unsigned int *>(rb_last(&rb_tree)->data)));
gettimeofday(&rb1, NULL);
rb_clear(&rb_tree);
gettimeofday(&rb2, NULL);
timersub(&rb2, &rb1, &rb3);
printf("RBT CLEAR %ld secs, %ld msecs.\n", rb3.tv_sec, rb3.tv_usec);
std::set<unsigned int> rb_set;
gettimeofday(&rb1, NULL);
for (int i = 0; i < KEY_POOL_CAPS; ++i) {
rb_set.insert(key_pool[i]);
}
gettimeofday(&rb2, NULL);
timersub(&rb2, &rb1, &rb3);
printf("RBSET INSERT %ld secs, %ld msecs.\n", rb3.tv_sec, rb3.tv_usec);
gettimeofday(&rb1, NULL);
rb_set.clear();
gettimeofday(&rb2, NULL);
timersub(&rb2, &rb1, &rb3);
printf("RBSET CLEAR %ld secs, %ld msecs.\n", rb3.tv_sec, rb3.tv_usec);
return 0;
}
int main(int argc, char *argv[])
{
rb_tree_t rb_tree;
rb_node_t *node;
unsigned int key_pool[KEY_POOL_CAPS];
unsigned int key;
for (int i = 0; i < KEY_POOL_CAPS; ++i) {
add_key:
key = arc4random() % 3000;
for (int j = i - 1; j >= 0; j--) {
if (key == key_pool[j]) {
goto add_key;
}
}
key_pool[i] = key;
printf("Add %u into key pool.\n", key_pool[i]);
}
rb_tree_init(&rb_tree, data_compare, data_destroy);
redo:
for (int i = 0; i < KEY_POOL_CAPS; ++i) {
data_node_t *data = (data_node_t *)malloc(sizeof(*data));
data->key = key_pool[i];
if (rb_insert(&(data->rb_node), &rb_tree)) {
printf("Key %u already exist.\n", data->key);
} else {
printf("Add %u into tree.\n", data->key);
}
}
printf("INIT: ************\n");
printf("Min:%u\n",
rb_entry(rb_first(&rb_tree), data_node_t, rb_node)->key);
printf("Max:%u\n",
rb_entry(rb_last(&rb_tree), data_node_t, rb_node)->key);
printf("Trav with rb_next:\n");
node = rb_first(&rb_tree);
while (node) {
printf("%u, ",rb_entry(node, data_node_t, rb_node)->key);
node = rb_next(node);
}
printf("\n");
printf("Trav with rb_prev:\n");
node = rb_last(&rb_tree);
while (node) {
printf("%u, ",rb_entry(node, data_node_t, rb_node)->key);
node = rb_prev(node);
}
printf("\n");
printf("ERASE: ************\n");
data_node_t search_node;
for (int i = 0; i < 5; i++) {
unsigned int j = arc4random() % KEY_POOL_CAPS;
search_node.key = key_pool[j];
rb_node_t *to_remove = rb_find(&(search_node.rb_node), &rb_tree);
if (to_remove) {
printf("Remove %u from tree.\n", search_node.key);
rb_remove(to_remove, &rb_tree);
free(rb_entry(to_remove, data_node_t, rb_node));
} else {
printf("Key %u not in tree.\n", search_node.key);
}
}
printf("PRINT: ************\n");
printf("Min:%u\n",
rb_entry(rb_first(&rb_tree), data_node_t, rb_node)->key);
printf("Max:%u\n",
rb_entry(rb_last(&rb_tree), data_node_t, rb_node)->key);
printf("Trav with rb_next:\n");
node = rb_first(&rb_tree);
while (node) {
printf("%u, ",rb_entry(node, data_node_t, rb_node)->key);
node = rb_next(node);
}
printf("\n");
printf("Trav with rb_prev:\n");
node = rb_last(&rb_tree);
while (node) {
printf("%u, ",rb_entry(node, data_node_t, rb_node)->key);
node = rb_prev(node);
}
printf("\n");
rb_clear(&rb_tree);
printf("PRINT2: ************\n");
node = rb_first(&rb_tree);
if (node) {
printf("Min:%u\n",
rb_entry(node, data_node_t, rb_node)->key);
}
node = rb_last(&rb_tree);
if (node) {
printf("Max:%u\n",
rb_entry(node, data_node_t, rb_node)->key);
}
printf("Trav with rb_next:\n");
node = rb_first(&rb_tree);
while (node) {
printf("%u, ",rb_entry(node, data_node_t, rb_node)->key);
node = rb_next(node);
}
printf("\n");
printf("Trav with rb_prev:\n");
node = rb_last(&rb_tree);
while (node) {
printf("%u, ",rb_entry(node, data_node_t, rb_node)->key);
node = rb_prev(node);
}
printf("\n");
goto redo;
return 0;
}
ssize_t buffering_writev(neo4j_iostream_t *stream,
const struct iovec *iov, unsigned int iovcnt)
{
struct buffering_iostream *ios = container_of(stream,
struct buffering_iostream, _iostream);
if (ios->delegate == NULL)
{
errno = EPIPE;
return -1;
}
if (ios->sndbuf == NULL)
{
return neo4j_ios_writev(ios->delegate, iov, iovcnt);
}
if (iovcnt > IOV_MAX-2)
{
iovcnt = IOV_MAX-2;
}
size_t nbyte = iovlen(iov, iovcnt);
if (nbyte <= rb_space(ios->sndbuf))
{
return rb_appendv(ios->sndbuf, iov, iovcnt);
}
size_t buffered = rb_used(ios->sndbuf);
ALLOC_IOVEC(diov, iovcnt+2);
if (diov == NULL)
{
return -1;
}
unsigned int diovcnt = rb_data_iovec(ios->sndbuf, diov,
rb_size(ios->sndbuf));
memcpy(diov+diovcnt, iov, iovcnt * sizeof(struct iovec));
ssize_t written = neo4j_ios_writev(ios->delegate, diov, diovcnt + iovcnt);
if (written < 0)
{
goto cleanup;
}
if ((size_t)written < buffered)
{
rb_discard(ios->sndbuf, written);
memcpy(diov, iov, iovcnt * sizeof(struct iovec));
diovcnt = iovcnt;
written = 0;
}
else
{
rb_clear(ios->sndbuf);
written -= buffered;
assert((size_t)written <= nbyte);
diovcnt = iov_skip(diov, iov, iovcnt, written);
}
if (diovcnt == 0)
{
written = nbyte;
goto cleanup;
}
written += rb_appendv(ios->sndbuf, diov, diovcnt);
int errsv;
cleanup:
errsv = errno;
FREE_IOVEC(diov);
errno = errsv;
return written;
}
ssize_t buffering_write(neo4j_iostream_t *stream, const void *buf, size_t nbyte)
{
struct buffering_iostream *ios = container_of(stream,
struct buffering_iostream, _iostream);
if (ios->delegate == NULL)
{
errno = EPIPE;
return -1;
}
if (ios->sndbuf == NULL)
{
return neo4j_ios_write(ios->delegate, buf, nbyte);
}
if (nbyte > SSIZE_MAX)
{
nbyte = SSIZE_MAX;
}
if (nbyte <= rb_space(ios->sndbuf))
{
return rb_append(ios->sndbuf, buf, nbyte);
}
size_t buffered = rb_used(ios->sndbuf);
struct iovec iov[3];
unsigned int iovcnt = rb_data_iovec(ios->sndbuf, iov, rb_size(ios->sndbuf));
iov[iovcnt].iov_base = (uint8_t *)(intptr_t)buf;
iov[iovcnt].iov_len = nbyte;
++iovcnt;
ssize_t written = neo4j_ios_writev(ios->delegate, iov, iovcnt);
if (written < 0)
{
return -1;
}
const uint8_t *rbytes;
size_t remaining;
if ((size_t)written < buffered)
{
rb_discard(ios->sndbuf, written);
rbytes = buf;
remaining = nbyte;
written = 0;
}
else
{
rb_clear(ios->sndbuf);
written -= buffered;
assert((size_t)written <= nbyte);
rbytes = (const uint8_t *)buf + written;
remaining = nbyte - written;
}
if (remaining == 0)
{
return nbyte;
}
size_t appended = rb_append(ios->sndbuf, rbytes, remaining);
return (size_t)written + appended;
}
