X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=buffer_tree.c;h=c62cbf13c3bdc4b621bd891d41e1b74fe24d98fe;hp=1b859f520ebf4aa16d0a13df897395d97da423d9;hb=6d9c357ff64e799dfeacda6a176012de10c7f5c1;hpb=ad9154ccd56f318675e19d773c0a848aab7fd574 diff --git a/buffer_tree.c b/buffer_tree.c index 1b859f52..c62cbf13 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" @@ -31,6 +30,8 @@ struct btr_buffer { int refcount; /* NULL means no buffer pool but a malloced buffer. */ struct btr_pool *pool; + /* Only relevant if pool is NULL. */ + bool dont_free; }; struct btr_buffer_reference { @@ -257,6 +258,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(). @@ -318,7 +321,7 @@ static void dealloc_buffer(struct btr_buffer *btrb) { if (btrb->pool) btr_pool_deallocate(btrb->pool, btrb->size); - else + else if (!btrb->dont_free) free(btrb->buf); } @@ -391,6 +394,34 @@ void btr_add_output(char *buf, size_t size, struct btr_node *btrn) add_btrb_to_children(btrb, btrn, 0); } +/** + * Insert a buffer into the buffer tree, non-freeing variant. + * + * \param buf See \ref btr_add_output(). + * \param size See \ref btr_add_output(). + * \param btrn See \ref btr_add_output(). + * + * This is similar to btr_add_output() but additionally sets the \p dont_free + * flag on \a buf. If the refcount for the buffer drops to zero, \a buf will + * not be deallocated if this flag is set. + * + * The \p dont_free bit also prevents the children of \a btrn from modifying + * the buffer contents inplace. Specifically, \ref btr_inplace_ok() returns + * false if there is any buffer in the input queue with the \p dont_free bit + * set. + */ +void btr_add_output_dont_free(const char *buf, size_t size, struct btr_node *btrn) +{ + struct btr_buffer *btrb; + + assert(size != 0); + if (list_empty(&btrn->children)) + return; + btrb = new_btrb((char *)buf, size); + btrb->dont_free = true; + add_btrb_to_children(btrb, btrn, 0); +} + /** * Feed data to child nodes of a buffer tree node. * @@ -543,9 +574,15 @@ bool btr_no_parent(struct btr_node *btrn) */ bool btr_inplace_ok(struct btr_node *btrn) { - if (!btrn->parent) - return true; - return list_is_singular(&btrn->parent->children); + struct btr_buffer_reference *br; + FOR_EACH_BUFFER_REF(br, btrn) { + struct btr_buffer *btrb = br->btrb; + if (btrb->refcount > 1) + return false; + if (btrb->dont_free == true) + return false; + } + return true; } static inline size_t br_available_bytes(struct btr_buffer_reference *br) @@ -561,40 +598,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 +695,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 +726,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,49 +752,50 @@ void btr_consume(struct btr_node *btrn, size_t numbytes) return btr_consume(btrn, sz); } -static void flush_input_queue(struct btr_node *btrn) -{ - struct btr_buffer_reference *br, *tmp; - FOR_EACH_BUFFER_REF_SAFE(br, tmp, btrn) - btr_drop_buffer_reference(br); -} - /** - * Free all resources allocated by btr_new_node(). + * Clear the input queue of a buffer tree node. * - * Like free(3), it is OK to call this with a \p NULL pointer argument. + * \param btrn The node whose input queue should be cleared. */ -void btr_free_node(struct btr_node *btrn) +void btr_drain(struct btr_node *btrn) { - if (!btrn) - return; - free(btrn->name); - free(btrn); + struct btr_buffer_reference *br, *tmp; + + FOR_EACH_BUFFER_REF_SAFE(br, tmp, btrn) + btr_drop_buffer_reference(br); } /** * Remove a node from a buffer tree. * - * \param btrn The node to remove. + * \param btrnp Determines the node to remove. * - * This makes all child nodes of \a btrn orphans and removes \a btrn from the - * list of children of its parent. Moreover, the input queue of \a btrn is - * flushed if it is not empty. + * This orphans all children of the node given by \a btrnp and removes this + * node from the child list of its parent. Moreover, the input queue is flushed + * and the node pointer given by \a btrp is set to \p NULL. * * \sa \ref btr_splice_out_node. */ -void btr_remove_node(struct btr_node *btrn) +void btr_remove_node(struct btr_node **btrnp) { struct btr_node *ch; + struct btr_node *btrn; - if (!btrn) + if (!btrnp) return; - PARA_NOTICE_LOG("removing btr node %s from buffer tree\n", btrn->name); + btrn = *btrnp; + if (!btrn) + goto out; + 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); + free(btrn->name); + free(btrn); +out: + *btrnp = NULL; } /** @@ -761,6 +854,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 +862,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) { @@ -814,7 +908,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; } @@ -824,8 +918,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. */ @@ -1067,7 +1162,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.