treetrie-2015/main.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>

#include "fasthash.h"
#include "treetrie.h"
#include "critbit.h"
#include "route.h"

static void atom_incref(void *atom_context, tt_arena_t *a, tt_atom_t atom) {
  /* printf("incref %u\n", atom); */
}

static void atom_decref(void *atom_context, tt_arena_t *a, tt_atom_t atom) {
  /* printf("decref %u\n", atom); */
}

int main0(int argc, char *argv[]) {
  tt_arena_t a;
  int i, outer;
  tt_node_ptr_t prev = TT_EMPTY;

  setbuf(stdout, NULL);
  tt_arena_init(&a, NULL, atom_incref, atom_decref);

  for (outer = 0; outer < 10; outer++) {
    /* printf("---------------------------------------- grab/drop of %d\n", prev); */
    tt_grab(&a, prev);
    tt_drop(&a, prev);
    /* tt_arena_flush(&a); */
    /* printf("---------------------------------------- AFTER DROP of %d:\n", prev); */
    /* tt_dump_arena(&a, 1); */
    prev = TT_EMPTY;
    /* printf("======================================== LOOP ITERATION %d\n", outer); */
    /* tt_dump_arena_summary(&a); */
    for (i = 0; i < 1000000; i++) {
      tt_node_ptr_t leaf = tt_cons_leaf(&a, TT_EMPTY, 1001);
      tt_node_ptr_t curr = tt_cons_node(&a, 0, leaf, prev);
      /* tt_dump_arena(&a, 1); */
      prev = curr;
    }
  }

  /* tt_dump_arena(&a, 1); */
  tt_grab(&a, prev);
  tt_drop(&a, prev);
  /* tt_arena_flush(&a); */
  tt_dump_arena_summary(&a);

  tt_arena_done(&a);
  return EXIT_SUCCESS;
}

static int dump_mapping(void *context, tt_atom_t key, tt_node_ptr_t trie) {
  printf(" -- %u --> %u/%u\n", key, tt_ptr_idx(trie), tt_ptr_tag(trie));
  return 1;
}

int main1(int argc, char *argv[]) {
  tt_arena_t a;
  tt_node_ptr_t curr = TT_EMPTY_DICT;
  int i;

  setbuf(stdout, NULL);
  tt_arena_init(&a, NULL, atom_incref, atom_decref);

  /* tt_dump_arena(&a, 1); */
  for (i = 0; i < 1000000; i++) {
    tt_node_ptr_t next = tt_grab(&a, tt_dict_set(&a, curr, i, TT_EMPTY));
    tt_drop(&a, curr);
    curr = next;
    /* printf("\nAfter i=%d...\n", i); */
    /* tt_dump_arena(&a, 1); */
  }

  /* for (i = 0; i < 1000000; i++) { */
  /*   tt_node_ptr_t next = tt_grab(&a, tt_dict_remove(&a, curr, i << 1)); */
  /*   tt_drop(&a, curr); */
  /*   curr = next; */
  /* } */

  /* tt_arena_flush(&a); */
  printf("\nFinal tree node index is %u/%u; dict size is %u\n",
	 tt_ptr_idx(curr),
	 tt_ptr_tag(curr),
	 TT_DICT_SIZE(&a, curr));
  /* tt_dump_arena(&a, 1); */

  /* tt_dict_foreach(&a, curr, NULL, dump_mapping); */

  tt_drop(&a, curr);
  curr = TT_NO_PTR;
  /* tt_arena_flush(&a); */
  /* tt_dump_arena(&a, 1); */
  tt_dump_arena_summary(&a);

  tt_arena_done(&a);
  return EXIT_SUCCESS;
}

int main(int argc, char *argv[]) {
  tt_arena_t a;
  tt_node_ptr_t a_set;
  tt_node_ptr_t b_set;

  setbuf(stdout, NULL);
  tt_arena_init(&a, NULL, atom_incref, atom_decref);

  a_set = tt_grab(&a, tt_dict_singleton(&a, 'A', TT_EMPTY));
  b_set = tt_grab(&a, tt_dict_singleton(&a, 'B', TT_EMPTY));

  printf("\n============================================================ 1\n");
  {
    tt_node_ptr_t A =
      tt_grab(&a,
	      tt_prepend_path(&a, TT_BOS,
			      tt_prepend_path(&a, 'A',
					      tt_prepend_path(&a, TT_EOS,
							      tt_begin_path(&a, a_set)))));
    printf("\nA node: %u/%u\n", tt_ptr_idx(A), tt_ptr_tag(A));
    tt_arena_flush(&a);
    tt_dump_arena_dot("A", A, &a);
    tt_node_ptr_t B =
      tt_grab(&a,
	      tt_prepend_path(&a, TT_BOS,
			      tt_prepend_path(&a, 'B',
					      tt_prepend_path(&a, TT_EOS,
							      tt_begin_path(&a, b_set)))));
    printf("\nB node: %u/%u\n", tt_ptr_idx(B), tt_ptr_tag(B));
    tt_dump_arena_dot("B", B, &a);
    tt_node_ptr_t C = tt_trie_union(&a, A, B);
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpredrop", C, &a);
    tt_drop(&a, A);
    tt_drop(&a, B);
    printf("\nC node: %u/%u\n", tt_ptr_idx(C), tt_ptr_tag(C));
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpostdrop", C, &a);
    putchar('\n');
    tt_dump_routingtable(&a, C, 0);
    tt_drop(&a, C);
  }

  tt_arena_flush(&a);
  tt_dump_arena_dot("after1", TT_NO_PTR, &a);

  printf("\n============================================================ 2\n");
  {
    tt_node_ptr_t A =
      tt_grab(&a,
	      tt_prepend_path(&a, TT_BOS,
			      tt_prepend_path(&a, 'A',
					      tt_prepend_path(&a, TT_EOS,
							      tt_begin_path(&a, a_set)))));
    printf("\nA node: %u/%u\n", tt_ptr_idx(A), tt_ptr_tag(A));
    tt_arena_flush(&a);
    tt_dump_arena_dot("A", A, &a);
    tt_node_ptr_t B =
      tt_grab(&a,
	      tt_prepend_path(&a, TT_BOS,
			      tt_prepend_path(&a, TT_WILD,
					      tt_prepend_path(&a, TT_EOS,
							      tt_begin_path(&a, b_set)))));
    printf("\nB node: %u/%u\n", tt_ptr_idx(B), tt_ptr_tag(B));
    tt_dump_arena_dot("B", B, &a);
    tt_node_ptr_t C = tt_trie_union(&a, A, B);
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpredrop", C, &a);
    tt_drop(&a, A);
    tt_drop(&a, B);
    printf("\nC node: %u/%u\n", tt_ptr_idx(C), tt_ptr_tag(C));
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpostdrop", C, &a);
    putchar('\n');
    tt_dump_routingtable(&a, C, 0);
    tt_drop(&a, C);
  }

  printf("\n============================================================ 3\n");
  {
    tt_node_ptr_t A =
      tt_grab(&a,
	      tt_prepend_path(&a, TT_BOS,
			      tt_prepend_path(&a, 'A',
					      tt_prepend_path(&a, TT_EOS,
							      tt_begin_path(&a, a_set)))));
    printf("\nA node: %u/%u\n", tt_ptr_idx(A), tt_ptr_tag(A));
    tt_arena_flush(&a);
    tt_dump_arena_dot("A", A, &a);
    tt_node_ptr_t B = tt_grab(&a, tt_prepend_path(&a, TT_WILD, tt_begin_path(&a, b_set)));
    printf("\nB node: %u/%u\n", tt_ptr_idx(B), tt_ptr_tag(B));
    tt_dump_arena_dot("B", B, &a);
    tt_node_ptr_t C = tt_trie_union(&a, A, B);
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpredrop", C, &a);
    tt_drop(&a, A);
    tt_drop(&a, B);
    printf("\nC node: %u/%u\n", tt_ptr_idx(C), tt_ptr_tag(C));
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpostdrop", C, &a);
    putchar('\n');
    tt_dump_routingtable(&a, C, 0);
    tt_drop(&a, C);
  }

  printf("\n============================================================ 4\n");
  {
    tt_node_ptr_t A =
      tt_grab(&a,
	      tt_prepend_path(&a, TT_BOS,
			      tt_prepend_path(&a, 'A',
					      tt_prepend_path(&a, TT_EOS,
							      /* NB b_set below */
							      tt_begin_path(&a, b_set)))));
    printf("\nA node: %u/%u\n", tt_ptr_idx(A), tt_ptr_tag(A));
    tt_arena_flush(&a);
    tt_dump_arena_dot("A", A, &a);
    tt_node_ptr_t B = tt_grab(&a, tt_prepend_path(&a, TT_WILD, tt_begin_path(&a, b_set)));
    printf("\nB node: %u/%u\n", tt_ptr_idx(B), tt_ptr_tag(B));
    tt_dump_arena_dot("B", B, &a);
    tt_node_ptr_t C = tt_trie_union(&a, A, B);
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpredrop", C, &a);
    tt_drop(&a, A);
    tt_drop(&a, B);
    printf("\nC node: %u/%u\n", tt_ptr_idx(C), tt_ptr_tag(C));
    tt_arena_flush(&a);
    tt_dump_arena_dot("Cpostdrop", C, &a);
    putchar('\n');
    tt_dump_routingtable(&a, C, 0);
    tt_drop(&a, C);
  }

  tt_arena_flush(&a);
  tt_dump_arena_dot("afterAll", TT_NO_PTR, &a); /* expect a_set and b_set here */

  tt_arena_done(&a);
  return EXIT_SUCCESS;
}