X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=buffer_tree.c;h=7d79636fac717f4e4cb8559dec698f8204eed34c;hp=9884c2e2ff1b1fc4661bab71b585bede6d2eba6a;hb=869f0e06ec4e15abc9230c1b2d7615da5250802e;hpb=6668ac4a8c7f2a92efb9e6d405d954beff77d230 diff --git a/buffer_tree.c b/buffer_tree.c index 9884c2e2..7d79636f 100644 --- a/buffer_tree.c +++ b/buffer_tree.c @@ -1,12 +1,11 @@ /* - * Copyright (C) 2009-2010 Andre Noll + * Copyright (C) 2009-2012 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) @@ -697,10 +761,10 @@ void btr_remove_node(struct btr_node *btrn) if (!btrn) return; - PARA_NOTICE_LOG("removing btr node %s from buffer tree\n", btrn->name); + PARA_INFO_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); } @@ -761,6 +825,7 @@ void btr_splice_out_node(struct btr_node *btrn) list_move(&ch->node, &btrn->parent->children); } assert(list_empty(&btrn->children)); + btrn->parent = NULL; } /** @@ -768,8 +833,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) { @@ -783,15 +848,6 @@ size_t btr_get_output_queue_size(struct btr_node *btrn) return max_size; } -int btr_exec(struct btr_node *btrn, const char *command, char **value_result) -{ - if (!btrn) - return -ERRNO_TO_PARA_ERROR(EINVAL); - if (!btrn->execute) - return -ERRNO_TO_PARA_ERROR(ENOTSUP); - return btrn->execute(btrn, command, value_result); -} - /** * Execute a inter-node command on a parent node. * @@ -823,7 +879,7 @@ int btr_exec_up(struct btr_node *btrn, const char *command, char **value_result) if (ret < 0) return ret; if (value_result && *value_result) - PARA_NOTICE_LOG("%s(%s): %s\n", command, parent->name, + PARA_INFO_LOG("%s(%s): %s\n", command, parent->name, *value_result); return 1; } @@ -833,8 +889,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. */ @@ -1076,7 +1133,7 @@ struct btr_node *btr_search_node(const char *name, struct btr_node *root) } /** 640K ought to be enough for everybody ;) */ -#define BTRN_MAX_PENDING (640 * 1024) +#define BTRN_MAX_PENDING (96 * 1024) /** * Return the current state of a buffer tree node.