static int
node_check(const struct node *n)
{
if (n->left)
return node_check(n->left) + n->item - node_check(n->right);
return n->item;
}
/*
* Do one iteration, must be in a non-static function to ensure that
* the stack frame is released between each invocation, i.e. this
* function must not be inlined.
*/
int
do_one_iteration(int i, int depth)
{
struct node *a, *b;
a = bottom_up_tree(i, depth);
b = bottom_up_tree(-i, depth);
return node_check(a) + node_check(b);
}
int
node_check(const struct node *n)
{
if (n->left)
{
int lc = node_check (n->left);
int rc = node_check (n->right);
return lc + n->i - rc;
}
return n->i;
}
static ret_t
node_check (chula_avl_generic_node_t *node)
{
int32_t left_height;
int32_t right_height;
int32_t balance;
chula_avl_generic_node_t *tmp;
if (node == NULL)
return ret_ok;
if (node->left_child) {
tmp = node_prev (node);
if (tmp->right != node) {
chula_log_error ("AVL Tree inconsistency: Right child");
return ret_error;
}
}
if (node->right_child) {
tmp = node_next (node);
if (tmp->left != node) {
chula_log_error ("AVL Tree inconsistency: Left child");
return ret_error;
}
}
left_height = 0;
right_height = 0;
if (node->left_child)
left_height = node_height (node->left);
if (node->right_child)
right_height = node_height (node->right);
balance = right_height - left_height;
if (balance != node->balance) {
chula_log_error ("AVL Tree inconsistency: Balance");
return ret_error;
}
if (node->left_child)
node_check (node->left);
if (node->right_child)
node_check (node->right);
return ret_ok;
}
static ret_t
node_check (http2d_avl_generic_node_t *node)
{
cint_t left_height;
cint_t right_height;
cint_t balance;
http2d_avl_generic_node_t *tmp;
if (node == NULL)
return ret_ok;
if (node->left_child) {
tmp = node_prev (node);
if (tmp->right != node) {
LOG_ERROR_S (HTTP2D_ERROR_AVL_PREVIOUS);
return ret_error;
}
}
if (node->right_child) {
tmp = node_next (node);
if (tmp->left != node) {
LOG_ERROR_S (HTTP2D_ERROR_AVL_NEXT);
return ret_error;
}
}
left_height = 0;
right_height = 0;
if (node->left_child)
left_height = node_height (node->left);
if (node->right_child)
right_height = node_height (node->right);
balance = right_height - left_height;
if (balance != node->balance) {
LOG_ERROR_S (HTTP2D_ERROR_AVL_BALANCE);
return ret_error;
}
if (node->left_child)
node_check (node->left);
if (node->right_child)
node_check (node->right);
return ret_ok;
}
/**
* Send a message to target node.
*
* @param n the G2 node to which message should be sent
* @param mb the message to sent (ownership taken, will be freed later)
*/
void
g2_node_send(const gnutella_node_t *n, pmsg_t *mb)
{
node_check(n);
g_assert(NODE_TALKS_G2(n));
if (NODE_IS_UDP(n))
mq_udp_node_putq(n->outq, mb, n);
else if (NODE_IS_WRITABLE(n))
mq_tcp_putq(n->outq, mb, NULL);
else
goto drop;
if (GNET_PROPERTY(log_sending_g2)) {
g_debug("%s(): sending %s to %s",
G_STRFUNC, g2_msg_infostr_mb(mb), node_infostr(n));
}
return;
drop:
if (GNET_PROPERTY(log_sending_g2)) {
g_debug("%s(): aborting sending %s to %s",
G_STRFUNC, g2_msg_infostr_mb(mb), node_infostr(n));
}
pmsg_free(mb); /* Cannot send it, free it now */
}
int main() {
int retval;
test_batch_runner *runner = test_batch_runner_new();
version(runner);
constructor(runner);
accessors(runner);
node_check(runner);
iterator(runner);
iterator_delete(runner);
create_tree(runner);
hierarchy(runner);
parser(runner);
render_html(runner);
utf8(runner);
line_endings(runner);
numeric_entities(runner);
test_cplusplus(runner);
test_print_summary(runner);
retval = test_ok(runner) ? 0 : 1;
free(runner);
return retval;
}
/**
* Create new message queue capable of holding `maxsize' bytes, and
* owned by the supplied node.
*
* @param maxsize the overall sum of message size that can be held
* @param n the network node to which the message queue is attached
* @oaram nd the top of the TX stack to use to send out messages
* @param uops user-defined operations
*/
mqueue_t *
mq_udp_make(int maxsize,
gnutella_node_t *n, struct txdriver *nd, const struct mq_uops *uops)
{
mqueue_t *q;
node_check(n);
tx_check(nd);
g_assert(uops != NULL);
g_assert(maxsize > 0);
WALLOC0(q);
q->magic = MQ_MAGIC;
q->node = n;
q->tx_drv = nd;
q->maxsize = maxsize;
q->lowat = maxsize >> 2; /* 25% of max size */
q->hiwat = maxsize >> 1; /* 50% of max size */
q->qwait = slist_new();
q->ops = &mq_udp_ops;
q->cops = mq_get_cops();
q->uops = uops;
q->debug = GNET_PROPERTY_PTR(mq_udp_debug);
tx_srv_register(nd, mq_udp_service, q);
return q;
}
void
stretchdepth_tree(int depth)
{
struct node *stretch_tree = bottom_up_tree(0, depth);
printf("stretch tree of depth %i\t check: %i\n",
depth,
node_check(stretch_tree));
}
/**
* Send a /LNI to node.
*/
void
g2_node_send_lni(gnutella_node_t *n)
{
pmsg_t *mb = g2_build_lni();
node_check(n);
g_assert(!NODE_IS_UDP(n));
g2_node_send(n, mb);
}
/**
* Send a /QHT RESET to node.
*
* @param n the TCP node to which we need to send the /QHT
* @param slots amount of slots in the table (power of 2)
* @param inf_val infinity value (1)
*/
void
g2_node_send_qht_reset(gnutella_node_t *n, int slots, int inf_val)
{
pmsg_t *mb = g2_build_qht_reset(slots, inf_val);
node_check(n);
g_assert(!NODE_IS_UDP(n));
g2_node_send(n, mb);
}
void nodelist_check(NODELIST* nodelist)
{
int i;
assert(nodelist != NULL);
assert(nodelist->count >= 0);
for( i = 0 ; i < nodelist->count ; i++ )
{
node_check(nodelist->items[i]);
}
}
/**
* Send a /QHT RESET to node.
*
* @param n the TCP node to which we need to send the /QHT
* @param seqno the patch sequence number
* @param seqsize the total length of the sequence
* @param compressed whether patch is compressed
* @param bits amount of bits for each entry (1)
* @param buf start of patch data
* @param len length in byte of patch data
*/
void
g2_node_send_qht_patch(gnutella_node_t *n,
int seqno, int seqsize, bool compressed, int bits,
char *buf, int len)
{
pmsg_t *mb = g2_build_qht_patch(seqno, seqsize, compressed, bits, buf, len);
node_check(n);
g_assert(!NODE_IS_UDP(n));
g2_node_send(n, mb);
}
static void node_prepare_for_write(struct dm_block_validator *v,
struct dm_block *b,
size_t block_size)
{
struct node *n = dm_block_data(b);
struct node_header *h = &n->header;
h->blocknr = cpu_to_le64(dm_block_location(b));
h->csum = cpu_to_le32(dm_bm_checksum(&h->flags,
block_size - sizeof(__le32),
BTREE_CSUM_XOR));
BUG_ON(node_check(v, b, 4096));
}
/**
* Generate as many "NH" children to the root as we have neihbouring hubs,
* when the node is firewalled. They can act as "push proxies", as in Gnutella.
*/
static void
g2_build_add_neighbours(g2_tree_t *t)
{
if (GNET_PROPERTY(is_firewalled) || GNET_PROPERTY(is_udp_firewalled)) {
const pslist_t *sl;
PSLIST_FOREACH(node_all_g2_nodes(), sl) {
const gnutella_node_t *n = sl->data;
node_check(n);
g_assert(NODE_TALKS_G2(n));
if (NODE_IS_ESTABLISHED(n) && node_address_known(n))
g2_build_add_host(t, "NH", n->gnet_addr, n->gnet_port);
}
}
}
/*
* Main function with enough stack space to fit the tree used to
* 'stretch' memory. Same space is reused to the long lived tree.
*/
void *
main_thread(void *args_)
{
struct node *long_lived_tree;
struct args *args = args_;
stretchdepth_tree(args->max_depth + 1);
long_lived_tree = bottom_up_tree(0, args->max_depth);
/*
* Calculates all subtrees for every second depth ranging from
* min_depth up to, but not including max_depth
*/
do_trees(args->max_depth & ~1,
args->min_depth,
args->max_depth);
printf("long lived tree of depth %i\t check: %i\n",
args->max_depth,
node_check(long_lived_tree));
return NULL;
}
void FoF::find_friends (const Zbin &zbin, Galaxy &gal, double rfriend) {
//! Function to find galaxies linked to the galaxy in question.
/**< Loop through kd-tree nodes */
for(int j = 0; j < tree.node_list.size(); j++) {
/**< Check if galaxy is compatible with kd-tree node */
if(node_check(gal, tree.node_list[j], rfriend)) {
/**< Loop through node members */
for(int k = 0; k < tree.node_list[j].members.size(); k++) {
/**< Check if galaxies are friends */
int gal_now = tree.node_list[j].members[k].num;
if(friendship(zbin, gal, gal_list[gal_now], rfriend)) {
/**< Create new cluster */
if(!gal.in_cluster[zbin.num])
new_cluster(zbin, gal, gal_list[gal_now]);
/**< Add new member to existing cluster */
else
add_member(zbin, gal_list[gal_now], list_of_clusters[cluster_count]);
}
} // end of node member loop
}
} // end of node loop
}
ret_t
chula_avl_check (chula_avl_generic_t *avl)
{
return node_check (avl->root);
}
/**
* Handle message coming from G2 node.
*/
void
g2_node_handle(gnutella_node_t *n)
{
g2_tree_t *t;
size_t plen;
enum g2_msg type;
node_check(n);
g_assert(NODE_TALKS_G2(n));
t = g2_frame_deserialize(n->data, n->size, &plen, FALSE);
if (NULL == t) {
if (GNET_PROPERTY(g2_debug) > 0 || GNET_PROPERTY(log_bad_g2)) {
g_warning("%s(): cannot deserialize /%s from %s",
G_STRFUNC, g2_msg_raw_name(n->data, n->size), node_infostr(n));
}
if (GNET_PROPERTY(log_bad_g2))
dump_hex(stderr, "G2 Packet", n->data, n->size);
return;
} else if (plen != n->size) {
if (GNET_PROPERTY(g2_debug) > 0 || GNET_PROPERTY(log_bad_g2)) {
g_warning("%s(): consumed %zu bytes but /%s from %s had %u",
G_STRFUNC, plen, g2_msg_raw_name(n->data, n->size),
node_infostr(n), n->size);
}
if (GNET_PROPERTY(log_bad_g2))
dump_hex(stderr, "G2 Packet", n->data, n->size);
hostiles_dynamic_add(n->addr,
"cannot parse incoming messages", HSTL_GIBBERISH);
goto done;
} else if (GNET_PROPERTY(g2_debug) > 19) {
g_debug("%s(): received packet from %s", G_STRFUNC, node_infostr(n));
g2_tfmt_tree_dump(t, stderr, G2FMT_O_PAYLEN);
}
type = g2_msg_name_type(g2_tree_name(t));
switch (type) {
case G2_MSG_PI:
g2_node_handle_ping(n, t);
break;
case G2_MSG_PO:
g2_node_handle_pong(n, t);
break;
case G2_MSG_LNI:
g2_node_handle_lni(n, t);
break;
case G2_MSG_KHL:
g2_node_handle_khl(t);
break;
case G2_MSG_PUSH:
handle_push_request(n, t);
break;
case G2_MSG_Q2:
g2_node_handle_q2(n, t);
break;
case G2_MSG_QA:
case G2_MSG_QKA:
g2_node_handle_rpc_answer(n, t, type);
break;
case G2_MSG_QH2:
search_g2_results(n, t);
break;
default:
g2_node_drop(G_STRFUNC, n, t, "default");
break;
}
done:
g2_tree_free_null(&t);
}
int
main(int argc, char *argv[])
{
apr_pool_t *long_lived_pool;
int min_depth = 4;
int req_depth = (argc == 2 ? atoi(argv[1]) : 10);
int max_depth = (req_depth > min_depth + 2 ? req_depth : min_depth + 2);
int stretch_depth = max_depth+1;
apr_initialize();
/* Alloc then dealloc stretchdepth tree */
{
apr_pool_t *store;
struct node *curr;
apr_pool_create (&store, NULL);
curr = make (0, stretch_depth, store);
printf ("stretch tree of depth %i\t check: %i\n", stretch_depth,
node_check (curr));
apr_pool_destroy (store);
}
apr_pool_create (&long_lived_pool, NULL);
{
struct node *long_lived_tree = make(0, max_depth, long_lived_pool);
/* buffer to store output of each thread */
char *outputstr = (char*) malloc(LINE_SIZE * (max_depth +1) * sizeof(char));
int d;
#pragma omp parallel for
for (d = min_depth; d <= max_depth; d += 2)
{
int iterations = 1 << (max_depth - d + min_depth);
apr_pool_t *store;
int c = 0, i;
apr_pool_create (&store, NULL);
for (i = 1; i <= iterations; ++i)
{
struct node *a, *b;
a = make ( i, d, store);
b = make (-i, d, store);
c += node_check (a) + node_check (b);
apr_pool_clear (store);
}
apr_pool_destroy (store);
/* each thread write to separate location */
sprintf(outputstr + LINE_SIZE * d, "%d\t trees of depth %d\t check: %d\n", (2 * iterations), d, c);
}
/* print all results */
for (d = min_depth; d <= max_depth; d += 2)
printf("%s", outputstr + (d * LINE_SIZE) );
free(outputstr);
printf ("long lived tree of depth %i\t check: %i\n", max_depth,
node_check (long_lived_tree));
return 0;
}
}
ret_t
http2d_avl_check (http2d_avl_generic_t *avl)
{
return node_check (avl->root);
}