X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=buffer_tree.c;h=3a1f3e23eb75c7efc4df34942e9afdc7eda9af91;hp=3a59f8b5e2e20fa20c94117dd31e2655101936cf;hb=d16fe3df649cb48d5ffa26187da3dad4c3066646;hpb=645175864a613fc539f46ffa4028742aad3b1b30 diff --git a/buffer_tree.c b/buffer_tree.c index 3a59f8b5..3a1f3e23 100644 --- a/buffer_tree.c +++ b/buffer_tree.c @@ -1,12 +1,11 @@ /* - * Copyright (C) 2009-2010 Andre Noll + * Copyright (C) 2009-2011 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file buffer_tree.c Buffer tree and buffer pool implementations. */ #include -#include #include "para.h" #include "list.h" @@ -257,6 +256,8 @@ static void btr_pool_deallocate(struct btr_pool *btrp, size_t size) * * \param bnd Specifies how to create the new node. * + * \return A pointer to the newly allocated node. + * * This function always succeeds (or calls exit()). The returned pointer must * be freed using btr_free_node() after the node has been removed from the * buffer tree via btr_remove_node(). @@ -561,40 +562,95 @@ static size_t btr_get_buffer_by_reference(struct btr_buffer_reference *br, char } /** - * Obtain the next buffer of the input queue of a buffer tree node. + * Obtain the next buffer of the input queue, omitting data. * * \param btrn The node whose input queue is to be queried. + * \param omit Number of bytes to be omitted. * \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. + * If a buffer tree node needs more input data but can not consume the data it + * already has (because it might be needed again later) this function can be + * used instead of btr_next_buffer() to get a reference to the buffer obtained + * by skipping the given number of bytes. Skipped input bytes are not consumed. + * + * With a zero \a omit argument, this function is equivalent to \ref + * btr_next_buffer(). + * + * \return Number of bytes in \a bufp. If there are less than or equal to \a + * omit many bytes available in the input queue of the buffer tree node pointed + * to by \a btrn, the function returns zero and the value of \a bufp is + * undefined. */ -size_t btr_next_buffer(struct btr_node *btrn, char **bufp) +size_t btr_next_buffer_omit(struct btr_node *btrn, size_t omit, char **bufp) { struct btr_buffer_reference *br; + size_t wrap_count, sz, rv = 0; char *buf, *result = NULL; - size_t sz, rv = 0; - FOR_EACH_BUFFER_REF(br, btrn) { + br = get_first_input_br(btrn); + if (!br) + return 0; + wrap_count = br->wrap_count; + if (wrap_count > 0) { /* we have a wrap buffer */ sz = btr_get_buffer_by_reference(br, &buf); - if (!result) { - result = buf; - rv = sz; - if (!br->btrb->pool) - break; - continue; + if (sz > omit) { /* and it's big enough */ + result = buf + omit; + rv = sz - omit; + /* + * Wrap buffers are allocated by malloc(), so the next + * buffer ref will not align nicely, so we return the + * tail of the wrap buffer. + */ + goto out; } - if (!br->btrb->pool) - break; - if (result + rv != buf) - break; - rv += sz; + /* + * The next wrap_count bytes exist twice, in the wrap buffer + * and as a buffer reference in the buffer tree pool. + */ + omit += wrap_count; + } + /* + * For buffer tree pools, the buffers in the list align, i.e. the next + * buffer in the list starts directly at the end of its predecessor. In + * this case we merge adjacent buffers and return one larger buffer + * instead. + */ + FOR_EACH_BUFFER_REF(br, btrn) { + sz = btr_get_buffer_by_reference(br, &buf); + if (result) { + if (result + rv != buf) + goto out; + rv += sz; + } else if (sz > omit) { + result = buf + omit; + rv = sz - omit; + } else + omit -= sz; } + if (!result) + return 0; +out: if (bufp) *bufp = result; return rv; } +/** + * 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. + * + * The call of this function is is equivalent to calling \ref + * btr_next_buffer_omit() with an \a omit value of zero. + */ +size_t btr_next_buffer(struct btr_node *btrn, char **bufp) +{ + return btr_next_buffer_omit(btrn, 0, bufp); +} + /** * Deallocate the given number of bytes from the input queue. * @@ -603,7 +659,7 @@ size_t btr_next_buffer(struct btr_node *btrn, char **bufp) * * 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 + * buffers are either freed (in the non-buffer pool 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 @@ -634,7 +690,7 @@ void btr_consume(struct btr_node *btrn, size_t numbytes) numbytes -= br->btrb->size - br->consumed; btr_drop_buffer_reference(br); } - assert(true); + assert(false); } /* * We have a wrap buffer, consume from it. If in total, i.e. including @@ -660,9 +716,15 @@ void btr_consume(struct btr_node *btrn, size_t numbytes) return btr_consume(btrn, sz); } -static void flush_input_queue(struct btr_node *btrn) +/** + * Clear the input queue of a buffer tree node. + * + * \param btrn The node whose input queue should be cleared. + */ +void btr_drain(struct btr_node *btrn) { struct btr_buffer_reference *br, *tmp; + FOR_EACH_BUFFER_REF_SAFE(br, tmp, btrn) btr_drop_buffer_reference(br); } @@ -670,6 +732,8 @@ static void flush_input_queue(struct btr_node *btrn) /** * Free all resources allocated by btr_new_node(). * + * \param btrn Pointer to a btr node obtained by \ref btr_new_node(). + * * Like free(3), it is OK to call this with a \p NULL pointer argument. */ void btr_free_node(struct btr_node *btrn) @@ -700,7 +764,7 @@ void btr_remove_node(struct btr_node *btrn) PARA_NOTICE_LOG("removing btr node %s from buffer tree\n", btrn->name); FOR_EACH_CHILD(ch, btrn) ch->parent = NULL; - flush_input_queue(btrn); + btr_drain(btrn); if (btrn->parent) list_del(&btrn->node); } @@ -768,8 +832,8 @@ void btr_splice_out_node(struct btr_node *btrn) * * \param btrn The node whose output queue size should be computed. * - * This function iterates over all children of the given node and returns the - * size of the largest input queue. + * \return This function iterates over all children of the given node and + * returns the size of the largest input queue. */ size_t btr_get_output_queue_size(struct btr_node *btrn) { @@ -824,8 +888,9 @@ int btr_exec_up(struct btr_node *btrn, const char *command, char **value_result) /** * Obtain the context of a buffer node tree. * - * The returned pointer equals the context pointer used at creation time of the - * node. + * \param btrn The node whose output queue size should be computed. + * + * \return A pointer to the \a context address specified at node creation time. * * \sa btr_new_node(), struct \ref btr_node_description. */