/*
- * Copyright (C) 2009-2010 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2009-2012 Andre Noll <maan@systemlinux.org>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
/** \file buffer_tree.c Buffer tree and buffer pool implementations. */
#include <regex.h>
-#include <stdbool.h>
#include "para.h"
#include "list.h"
*
* \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().
}
/**
- * 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.
*
*
* 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
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
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);
}
/**
* 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)
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);
}
*
* \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)
{
/**
* 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.
*/
}
/** 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.
projects / paraslash.git / blobdiff