char *whead;
};
-enum btr_buffer_flags {
- /* changes the way the buffer is deallocated */
- BTR_BF_BTR_POOL = 1,
-};
-
struct btr_buffer {
char *buf;
size_t size;
/** The number of references to this buffer. */
int refcount;
+ /* NULL means no buffer pool but a malloced buffer. */
struct btr_pool *pool;
};
return btr_pool_size(btrp) - (btrp->rhead - btrp->whead);
}
+/**
+ * Get the number of unused bytes in the buffer pool.
+ *
+ * \param btrp The pool.
+ *
+ * \return The number of bytes that can currently be allocated.
+ *
+ * Note that in general the returned number of bytes is not available as a
+ * single contiguous buffer. Use btr_pool_available() to obtain the length of
+ * the largest contiguous buffer that can currently be allocated from the
+ * buffer pool.
+ */
size_t btr_pool_unused(struct btr_pool *btrp)
{
return btr_pool_size(btrp) - btr_pool_filled(btrp);
#define FOR_EACH_BUFFER_REF_SAFE(_br, _tmp, _btrn) \
list_for_each_entry_safe((_br), (_tmp), &(_btrn)->input_queue, node)
+/**
+ * Create a new buffer tree node.
+ *
+ * \param bnd Specifies how to create the new node.
+ *
+ * This function always succeeds (or calls exit()). The returned pointer
+ * must be freed using btr_free_node() after it has been removed from
+ * the buffer tree via btr_remove_node().
+ */
struct btr_node *btr_new_node(struct btr_node_description *bnd)
{
struct btr_node *btrn = para_malloc(sizeof(*btrn));
}
}
+/**
+ * Insert a malloced buffer into the buffer tree.
+ *
+ * \param buf The buffer to insert.
+ * \param size The size of \a buf in bytes.
+ * \param btrn Position in the buffer tree to create the output.
+ *
+ * This creates references to \a buf and adds these references to each child of
+ * \a btrn. The buffer will be freed using standard free() once no buffer tree
+ * node is referencing it any more.
+ *
+ * Note that this function must not be used if \a buf was obtained from a
+ * buffer pool. Use btr_add_output_pool() in this case.
+ */
void btr_add_output(char *buf, size_t size, struct btr_node *btrn)
{
struct btr_buffer *btrb;
}
/**
- * Feed data to child nodes of the buffer tree.
+ * Feed data to child nodes of a buffer tree node.
*
* \param btrp The buffer pool.
- *
+ * \param size The number of bytes to be allocated and fed to each child.
+ * \param btrn The node whose children are to be fed.
+ *
+ * This function allocates the amount of bytes from the buffer pool area,
+ * starting at the current value of the write head, and creates buffer
+ * references to the resulting part of the buffer pool area, one for each child
+ * of \a btrn. The references are then fed into the input queue of each child.
*/
void btr_add_output_pool(struct btr_pool *btrp, size_t size,
struct btr_node *btrn)
return 1;
}
-/* Return true if this node has no children. */
-bool btr_no_children(struct btr_node *btrn)
+/*
+ * Find out whether a node is a leaf node.
+ *
+ * \param btrn The node to check.
+ *
+ * \return True if this node has no children. False otherwise.
+ */
+static bool btr_no_children(struct btr_node *btrn)
{
return list_empty(&btrn->children);
}
+/**
+ * Find out whether a node is an orphan node.
+ *
+ * \param btrn The buffer tree node.
+ *
+ * \return True if \a btrn has no parent.
+ *
+ * This function will always return true for the root node. However in case
+ * nodes have been removed from the tree, other nodes may become orphans too.
+ */
bool btr_no_parent(struct btr_node *btrn)
{
return !btrn->parent;
}
/**
- * \return zero if the input buffer queue is empty.
+ * Obtain the next buffer of the input queue of a buffer tree node.
+ *
+ * \param btrn The node whose input queue is to be queried.
+ * \param bufp Result pointer.
+ *
+ * \return The number of bytes that can be read from buf. Zero if the input
+ * buffer queue is empty. In this case the value of \a bufp is undefined.
*/
size_t btr_next_buffer(struct btr_node *btrn, char **bufp)
{
return rv;
}
+/**
+ * Deallocate the given number of bytes from the input queue.
+ *
+ * \param btrn The buffer tree node.
+ * \param numbytes The number of bytes to be deallocated.
+ *
+ * This function must be used to get rid of existing buffer references in the
+ * node's input queue. If no references to a buffer remain, the underlying
+ * buffers are either freed (in the non-buffer tree case) or the read head of
+ * the buffer pool is being advanced.
+ *
+ * Note that \a numbytes may be smaller than the buffer size. In this case the
+ * buffer is not deallocated and subsequent calls to btr_next_buffer() return
+ * the remaining part of the buffer.
+ */
void btr_consume(struct btr_node *btrn, size_t numbytes)
{
struct btr_buffer_reference *br, *tmp;
assert(true);
}
/*
-
- We have a wrap buffer, consume from it. If in total,
- i.e. including previous calls to brt_consume(), less than
- wrap_count has been consumed, there's nothing more we can do.
-
- Otherwise we drop the wrap buffer and consume from subsequent
- buffers of the input queue the correct amount of bytes. This
- is the total number of bytes that have been consumed from the
- wrap buffer.
-*/
+ * We have a wrap buffer, consume from it. If in total, i.e. including
+ * previous calls to brt_consume(), less than wrap_count has been
+ * consumed, there's nothing more we can do.
+ *
+ * Otherwise we drop the wrap buffer and consume from subsequent
+ * buffers of the input queue the correct amount of bytes. This is the
+ * total number of bytes that have been consumed from the wrap buffer.
+ */
PARA_DEBUG_LOG("consuming %zu/%zu bytes from wrap buffer\n", numbytes,
br_available_bytes(br));
list_del(&btrn->node);
}
+/**
+ * Return the amount of available input bytes of a buffer tree node.
+ *
+ * \param btrn The node whose input size should be computed.
+ *
+ * \return The total number of bytes available in the node's input
+ * queue.
+ *
+ * This simply iterates over all buffer references in the input queue and
+ * returns the sum of the sizes of all references.
+ */
size_t btr_get_input_queue_size(struct btr_node *btrn)
{
struct btr_buffer_reference *br;
*
* Iterates over all children of the given node.
*/
-size_t btr_bytes_pending(struct btr_node *btrn)
+static size_t btr_bytes_pending(struct btr_node *btrn)
{
size_t max_size = 0;
struct btr_node *ch;
return btrn->execute(btrn, command, value_result);
}
+/**
+ * Execute a inter-node command.
+ */
int btr_exec_up(struct btr_node *btrn, const char *command, char **value_result)
{
int ret;
para_list_add(&br->node, &btrn->input_queue);
return;
}
- PARA_DEBUG_LOG("increasing wrap buffer, sz1: %zu, sz2: %zu\n", sz1, sz2);
/*
* We already have a wrap buffer, but it is too small. It might be
* partially used.
if (wbr->wrap_count == sz1 && wbr->btrb->size >= sz1 + sz2) /* nothing we can do about it */
return;
sz = sz1 + sz2 - wbr->btrb->size; /* amount of new data */
+ PARA_DEBUG_LOG("increasing wrap buffer %zu -> %zu\n", wbr->btrb->size,
+ wbr->btrb->size + sz);
wbr->btrb->size += sz;
wbr->btrb->buf = para_realloc(wbr->btrb->buf, wbr->btrb->size);
/* copy the new data to the end of the reallocated buffer */
if (i == 2)
break;
}
+ assert(i == 2);
/* make a new btrb that combines the two buffers and a br to it. */
sz = szs[0] + szs[1];
buf = para_malloc(sz);