#include "error.h"
#include "sched.h"
+/* whead = NULL means area full */
struct btr_pool {
char *name;
char *area_start;
void *context;
};
+/**
+ * Create a new buffer pool.
+ *
+ * \param name The name of the new buffer pool.
+ *
+ * \param area The size in bytes of the pool area.
+ *
+ * \return An opaque pointer to the newly created buffer pool. It must be
+ * passed to btr_pool_free() after it is no longer used to deallocate all
+ * resources.
+ */
struct btr_pool *btr_pool_new(const char *name, size_t area_size)
{
struct btr_pool *btrp;
return btrp;
}
-/* whead = NULL means area full */
-
+/**
+ * Dellocate resources used by a buffer pool.
+ *
+ * \param btrp A pointer obtained via btr_pool_new().
+ */
void btr_pool_free(struct btr_pool *btrp)
{
if (!btrp)
free(btrp);
}
+/**
+ * Return the size of the buffer pool area.
+ *
+ * \param btrp The buffer pool.
+ *
+ * \return The same value which was passed during creation time to
+ * btr_pool_new().
+ */
size_t btr_pool_size(struct btr_pool *btrp)
{
return btrp->area_end - btrp->area_start;
return btr_pool_size(btrp) - btr_pool_filled(btrp);
}
+/*
+ * Return maximal size available for one read. This is
+ * smaller than the value returned by btr_pool_unused().
+ */
size_t btr_pool_available(struct btr_pool *btrp)
{
if (!btrp->whead)
return btrp->rhead - btrp->whead;
}
+/**
+ * Obtain the current write head.
+ *
+ * \param btrp The buffer pool.
+ * \param result The write head is returned here.
+ *
+ * \return The maximal amount of bytes that may be written to the returned
+ * buffer.
+ */
size_t btr_pool_get_buffer(struct btr_pool *btrp, char **result)
{
if (result)
return btr_pool_available(btrp);
}
-void btr_pool_allocate(struct btr_pool *btrp, size_t size)
+/**
+ * Mark a part of the buffer pool area as allocated.
+ *
+ * \param btrp The buffer pool.
+ * \param size The amount of bytes to be allocated.
+ *
+ * This is usually called after the caller wrote to the buffer obtained by
+ * btr_pool_get_buffer().
+ */
+static void btr_pool_allocate(struct btr_pool *btrp, size_t size)
{
char *end;
if (size == 0)
return;
- //PARA_CRIT_LOG("filled: %zu, alloc %zu\n", btr_pool_filled(btrp), size);
assert(size <= btr_pool_available(btrp));
end = btrp->whead + size;
assert(end <= btrp->area_end);
end = btrp->area_start;
}
if (end == btrp->rhead) {
- PARA_DEBUG_LOG("btrp buffer full\n");
+ PARA_DEBUG_LOG("%s btrp buffer full\n", btrp->name);
end = NULL; /* buffer full */
}
btrp->whead = end;
- //PARA_CRIT_LOG("filled: %zu\n", btr_pool_filled(btrp));
}
static void btr_pool_deallocate(struct btr_pool *btrp, size_t size)
{
char *end = btrp->rhead + size;
- //PARA_CRIT_LOG("filled: %zu, dealloc %zu\n", btr_pool_filled(btrp), size);
if (size == 0)
return;
assert(end <= btrp->area_end);
btrp->rhead = end;
if (btrp->rhead == btrp->whead)
btrp->rhead = btrp->whead = btrp->area_start;
- //PARA_CRIT_LOG("filled: %zu\n", btr_pool_filled(btrp));
}
#define FOR_EACH_CHILD(_tn, _btrn) list_for_each_entry((_tn), \
#define FOR_EACH_BUFFER_REF_SAFE(_br, _tmp, _btrn) \
list_for_each_entry_safe((_br), (_tmp), &(_btrn)->input_queue, node)
-/*
- (parent, child):
- (NULL, NULL): new, isolated node.
- (NULL, c): new node becomes root, c must be old root
- (p, NULL): new leaf node
- (p, c): new internal node, ch must be child of p
-
-*/
struct btr_node *btr_new_node(struct btr_node_description *bnd)
{
struct btr_node *btrn = para_malloc(sizeof(*btrn));
btrn->context = bnd->context;
btrn->start.tv_sec = 0;
btrn->start.tv_usec = 0;
- if (bnd->parent)
- list_add_tail(&btrn->node, &bnd->parent->children);
INIT_LIST_HEAD(&btrn->children);
INIT_LIST_HEAD(&btrn->input_queue);
- if (bnd->parent)
- PARA_INFO_LOG("added %s as child of %s\n", bnd->name, bnd->parent->name);
- else
- PARA_INFO_LOG("added %s as btr root\n", bnd->name);
+ if (!bnd->child) {
+ if (bnd->parent) {
+ list_add_tail(&btrn->node, &bnd->parent->children);
+ PARA_INFO_LOG("new leaf node: %s (child of %s)\n",
+ bnd->name, bnd->parent->name);
+ } else
+ PARA_INFO_LOG("added %s as btr root\n", bnd->name);
+ goto out;
+ }
+ if (!bnd->parent) {
+ assert(!bnd->child->parent);
+ PARA_INFO_LOG("new root: %s (was %s)\n",
+ bnd->name, bnd->child->name);
+ btrn->parent = NULL;
+ list_add_tail(&bnd->child->node, &btrn->children);
+ /* link it in */
+ bnd->child->parent = btrn;
+ goto out;
+ }
+ PARA_EMERG_LOG("inserting internal nodes not yet supported.\n");
+ exit(EXIT_FAILURE);
+ assert(bnd->child->parent == bnd->parent);
+out:
return btrn;
}
{
struct btr_buffer *btrb = br->btrb;
- //PARA_CRIT_LOG("dropping buffer reference %p\n", br);
list_del(&br->node);
free(br);
btrb->refcount--;
add_btrb_to_children(btrb, btrn, 0);
}
+/**
+ * Feed data to child nodes of the buffer tree.
+ *
+ * \param btrp The buffer pool.
+ *
+ */
void btr_add_output_pool(struct btr_pool *btrp, size_t size,
struct btr_node *btrn)
{
add_btrb_to_children(btrb, btrn, 0);
}
+/**
+ * Copy data to write head of a buffer pool and feed it to all children nodes.
+ *
+ * \param src The source buffer.
+ * \param n The size of the source buffer in bytes.
+ * \param btrp The destination buffer pool.
+ * \param btrn Add the data as output of this node.
+ *
+ * This is expensive. The caller must make sure the data fits into the buffer
+ * pool area.
+ */
void btr_copy(const void *src, size_t n, struct btr_pool *btrp,
struct btr_node *btrn)
{
}
if (!br->btrb->pool)
break;
- if (result + rv != buf) {
- PARA_DEBUG_LOG("%s: pool merge impossible: %p != %p\n",
- btrn->name, result + rv, buf);
+ if (result + rv != buf)
break;
- }
-// PARA_CRIT_LOG("%s: inplace merge (%zu, %zu)->%zu\n", btrn->name,
-// rv, sz, rv + sz);
-// PARA_CRIT_LOG("%s: inplace merge %p (%zu)\n", btrn->name,
-// result, sz);
rv += sz;
}
if (bufp)
br = get_first_input_br(btrn);
assert(br);
- //PARA_CRIT_LOG("wrap count: %zu\n", br->wrap_count);
if (br->wrap_count == 0) {
/*
* No wrap buffer. Drop buffer references whose buffer
size_t btr_get_input_queue_size(struct btr_node *btrn)
{
struct btr_buffer_reference *br;
- size_t size = 0;
+ size_t size = 0, wrap_consumed = 0;
FOR_EACH_BUFFER_REF(br, btrn) {
- //PARA_CRIT_LOG("size: %zu\n", size);
+ if (br->wrap_count != 0) {
+ wrap_consumed = br->consumed;
+ continue;
+ }
size += br_available_bytes(br);
}
+ assert(wrap_consumed <= size);
+ size -= wrap_consumed;
return size;
}
{
size_t iqs;
- if (!btrn)
- return 0;
+ assert(btrn);
if (type != BTR_NT_LEAF) {
if (btr_no_children(btrn))
return -E_BTR_NO_CHILD;
projects / paraslash.git / blobdiff