/*
 * heap_add_segment.c
 */
#include <stdlib.h>
#include <string.h>

#include "private.h"
#include "context.h"
#include "lub/bintree.h"

typedef struct {
	const lub_heap_segment_t *segment;
} lub_heap_segment_key_t;

/*--------------------------------------------------------- */
static int
lub_heap_segment_compare(const void *clientnode, const void *clientkey)
{
	const lub_heap_segment_t *segment = clientnode;
	const lub_heap_segment_key_t *key = clientkey;

	return ((long)segment - (long)key->segment);
}

/*--------------------------------------------------------- */
/* we simply use the segment address as the index */
static void
lub_heap_segment_getkey(const void *clientnode, lub_bintree_key_t * key)
{
	lub_heap_segment_key_t clientkey;
	clientkey.segment = clientnode;
	memcpy(key, &clientkey, sizeof(lub_heap_segment_key_t));
}

/*--------------------------------------------------------- */
static void lub_heap_segment_meta_init()
{
	static bool_t initialised = BOOL_FALSE;

	if (BOOL_FALSE == initialised) {
		lub_heap_leak_t *leak = lub_heap_leak_instance();
		initialised = BOOL_TRUE;
		/* initialise the segment tree */
		lub_bintree_init(&leak->m_segment_tree,
				 offsetof(lub_heap_segment_t, bt_node),
				 lub_heap_segment_compare,
				 lub_heap_segment_getkey);
		lub_heap_leak_release(leak);
	}
}

/*--------------------------------------------------------- */
const lub_heap_segment_t *lub_heap_segment_findnext(const void *address)
{
	lub_heap_segment_t *segment;
	lub_heap_segment_key_t key;
	lub_heap_leak_t *leak = lub_heap_leak_instance();
	key.segment = address;

	segment = lub_bintree_findnext(&leak->m_segment_tree, &key);
	lub_heap_leak_release(leak);

	return segment;
}

/*--------------------------------------------------------- */
/*
 * as an optimisation this could be modified to merge 
 * adjacent segments together
 */
void lub_heap_add_segment(lub_heap_t * this, void *start, size_t size)
{
	lub_heap_segment_t *segment;

	/* check for simple adjacent segment as produced by sbrk() type behaviour */
	if (this->first_segment.words) {
		lub_heap_tag_t *tail;
		char *ptr = (char *)&this[1];
		ptr += (this->first_segment.words << 2);
		if (ptr == start) {
			/* simply extend the current first segment */
			this->first_segment.words += (size >> 2);
			tail = &((lub_heap_tag_t *) start)[-1];
			tail->segment = BOOL_FALSE;	/* no longer last block in segment */
			/* convert the new memory into a free block... */
			lub_heap_init_free_block(this, start, size, BOOL_FALSE,
						 BOOL_TRUE);
			/* try and merge with the previous block */
			lub_heap_merge_with_previous(this, start);

			this->stats.segs_bytes += size;

			return;
		}
	}
	/* adjust the size which can be used */
	size -= sizeof(lub_heap_segment_t);

	/* set up the linked list of segments */
	segment = start;

	/* update the stats */
	++this->stats.segs;
	this->stats.segs_bytes += size;
	this->stats.segs_overhead += sizeof(lub_heap_segment_t);

	if (segment != &this->first_segment) {
		/* maintain the list of segments */
		segment->next = this->first_segment.next;
		this->first_segment.next = segment;
	}
	segment->words = (size >> 2);

	lub_heap_init_free_block(this, &segment[1], size, BOOL_TRUE, BOOL_TRUE);

	/* add this segment to the tree */
	lub_heap_segment_meta_init();
	lub_bintree_node_init(&segment->bt_node);
	{
		lub_heap_leak_t *leak = lub_heap_leak_instance();
		lub_bintree_insert(&leak->m_segment_tree, segment);
		lub_heap_leak_release(leak);
	}
}

/*--------------------------------------------------------- */