From a88db0185693b52123f541fb19a79d1d23f563a4 Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Wed, 25 May 2011 14:52:29 -0400 Subject: [PATCH] Use lttng_ prefixed namespace for lttng prio heap Signed-off-by: Mathieu Desnoyers --- lib/Makefile | 2 +- .../{prio_heap.c => lttng_prio_heap.c} | 34 ++++++++--------- .../{prio_heap.h => lttng_prio_heap.h} | 38 +++++++++---------- lib/ringbuffer/frontend_internal.h | 2 +- lib/ringbuffer/frontend_types.h | 4 +- lib/ringbuffer/ring_buffer_iterator.c | 30 +++++++-------- wrapper/prio_heap.h | 1 - 7 files changed, 55 insertions(+), 56 deletions(-) rename lib/prio_heap/{prio_heap.c => lttng_prio_heap.c} (81%) rename lib/prio_heap/{prio_heap.h => lttng_prio_heap.h} (71%) delete mode 100644 wrapper/prio_heap.h diff --git a/lib/Makefile b/lib/Makefile index 12af70c4..9fa49efc 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -7,4 +7,4 @@ lib-ring-buffer-objs := \ ringbuffer/ring_buffer_vfs.o \ ringbuffer/ring_buffer_splice.o \ ringbuffer/ring_buffer_mmap.o \ - prio_heap/prio_heap.o + prio_heap/lttng_prio_heap.o diff --git a/lib/prio_heap/prio_heap.c b/lib/prio_heap/lttng_prio_heap.c similarity index 81% rename from lib/prio_heap/prio_heap.c rename to lib/prio_heap/lttng_prio_heap.c index f6b81580..5bbd0793 100644 --- a/lib/prio_heap/prio_heap.c +++ b/lib/prio_heap/lttng_prio_heap.c @@ -1,5 +1,5 @@ /* - * prio_heap.c + * lttng_prio_heap.c * * Priority heap containing pointers. Based on CLRS, chapter 6. * @@ -17,10 +17,10 @@ */ #include -#include "prio_heap.h" +#include "lttng_prio_heap.h" #ifdef DEBUG_HEAP -void check_heap(const struct ptr_heap *heap) +void lttng_check_heap(const struct lttng_ptr_heap *heap) { size_t i; @@ -54,7 +54,7 @@ size_t right(size_t i) * Copy of heap->ptrs pointer is invalid after heap_grow. */ static -int heap_grow(struct ptr_heap *heap, size_t new_len) +int heap_grow(struct lttng_ptr_heap *heap, size_t new_len) { void **new_ptrs; @@ -73,7 +73,7 @@ int heap_grow(struct ptr_heap *heap, size_t new_len) } static -int heap_set_len(struct ptr_heap *heap, size_t new_len) +int heap_set_len(struct lttng_ptr_heap *heap, size_t new_len) { int ret; @@ -84,7 +84,7 @@ int heap_set_len(struct ptr_heap *heap, size_t new_len) return 0; } -int heap_init(struct ptr_heap *heap, size_t alloc_len, +int lttng_heap_init(struct lttng_ptr_heap *heap, size_t alloc_len, gfp_t gfpmask, int gt(void *a, void *b)) { heap->ptrs = NULL; @@ -98,12 +98,12 @@ int heap_init(struct ptr_heap *heap, size_t alloc_len, return heap_grow(heap, max_t(size_t, 1, alloc_len)); } -void heap_free(struct ptr_heap *heap) +void lttng_heap_free(struct lttng_ptr_heap *heap) { kfree(heap->ptrs); } -static void heapify(struct ptr_heap *heap, size_t i) +static void heapify(struct lttng_ptr_heap *heap, size_t i) { void **ptrs = heap->ptrs; size_t l, r, largest; @@ -126,17 +126,17 @@ static void heapify(struct ptr_heap *heap, size_t i) ptrs[largest] = tmp; i = largest; } - check_heap(heap); + lttng_check_heap(heap); } -void *heap_replace_max(struct ptr_heap *heap, void *p) +void *lttng_heap_replace_max(struct lttng_ptr_heap *heap, void *p) { void *res; if (!heap->len) { (void) heap_set_len(heap, 1); heap->ptrs[0] = p; - check_heap(heap); + lttng_check_heap(heap); return NULL; } @@ -147,7 +147,7 @@ void *heap_replace_max(struct ptr_heap *heap, void *p) return res; } -int heap_insert(struct ptr_heap *heap, void *p) +int lttng_heap_insert(struct lttng_ptr_heap *heap, void *p) { void **ptrs; size_t pos; @@ -164,11 +164,11 @@ int heap_insert(struct ptr_heap *heap, void *p) pos = parent(pos); } ptrs[pos] = p; - check_heap(heap); + lttng_check_heap(heap); return 0; } -void *heap_remove(struct ptr_heap *heap) +void *lttng_heap_remove(struct lttng_ptr_heap *heap) { switch (heap->len) { case 0: @@ -180,10 +180,10 @@ void *heap_remove(struct ptr_heap *heap) /* Shrink, replace the current max by previous last entry and heapify */ heap_set_len(heap, heap->len - 1); /* len changed. previous last entry is at heap->len */ - return heap_replace_max(heap, heap->ptrs[heap->len]); + return lttng_heap_replace_max(heap, heap->ptrs[heap->len]); } -void *heap_cherrypick(struct ptr_heap *heap, void *p) +void *lttng_heap_cherrypick(struct lttng_ptr_heap *heap, void *p) { size_t pos, len = heap->len; @@ -194,7 +194,7 @@ void *heap_cherrypick(struct ptr_heap *heap, void *p) found: if (heap->len == 1) { (void) heap_set_len(heap, 0); - check_heap(heap); + lttng_check_heap(heap); return heap->ptrs[0]; } /* Replace p with previous last entry and heapify. */ diff --git a/lib/prio_heap/prio_heap.h b/lib/prio_heap/lttng_prio_heap.h similarity index 71% rename from lib/prio_heap/prio_heap.h rename to lib/prio_heap/lttng_prio_heap.h index 2b55adf2..ea8dbb8f 100644 --- a/lib/prio_heap/prio_heap.h +++ b/lib/prio_heap/lttng_prio_heap.h @@ -2,7 +2,7 @@ #define _LTTNG_PRIO_HEAP_H /* - * prio_heap.h + * lttng_prio_heap.h * * Priority heap containing pointers. Based on CLRS, chapter 6. * @@ -21,7 +21,7 @@ #include -struct ptr_heap { +struct lttng_ptr_heap { size_t len, alloc_len; void **ptrs; int (*gt)(void *a, void *b); @@ -29,29 +29,29 @@ struct ptr_heap { }; #ifdef DEBUG_HEAP -void check_heap(const struct ptr_heap *heap); +void lttng_check_heap(const struct lttng_ptr_heap *heap); #else static inline -void check_heap(const struct ptr_heap *heap) +void lttng_check_heap(const struct lttng_ptr_heap *heap) { } #endif /** - * heap_maximum - return the largest element in the heap + * lttng_heap_maximum - return the largest element in the heap * @heap: the heap to be operated on * * Returns the largest element in the heap, without performing any modification * to the heap structure. Returns NULL if the heap is empty. */ -static inline void *heap_maximum(const struct ptr_heap *heap) +static inline void *lttng_heap_maximum(const struct lttng_ptr_heap *heap) { - check_heap(heap); + lttng_check_heap(heap); return heap->len ? heap->ptrs[0] : NULL; } /** - * heap_init - initialize the heap + * lttng_heap_init - initialize the heap * @heap: the heap to initialize * @alloc_len: number of elements initially allocated * @gfp: allocation flags @@ -59,18 +59,18 @@ static inline void *heap_maximum(const struct ptr_heap *heap) * * Returns -ENOMEM if out of memory. */ -extern int heap_init(struct ptr_heap *heap, +extern int lttng_heap_init(struct lttng_ptr_heap *heap, size_t alloc_len, gfp_t gfpmask, int gt(void *a, void *b)); /** - * heap_free - free the heap + * lttng_heap_free - free the heap * @heap: the heap to free */ -extern void heap_free(struct ptr_heap *heap); +extern void lttng_heap_free(struct lttng_ptr_heap *heap); /** - * heap_insert - insert an element into the heap + * lttng_heap_insert - insert an element into the heap * @heap: the heap to be operated on * @p: the element to add * @@ -78,19 +78,19 @@ extern void heap_free(struct ptr_heap *heap); * * Returns -ENOMEM if out of memory. */ -extern int heap_insert(struct ptr_heap *heap, void *p); +extern int lttng_heap_insert(struct lttng_ptr_heap *heap, void *p); /** - * heap_remove - remove the largest element from the heap + * lttng_heap_remove - remove the largest element from the heap * @heap: the heap to be operated on * * Returns the largest element in the heap. It removes this element from the * heap. Returns NULL if the heap is empty. */ -extern void *heap_remove(struct ptr_heap *heap); +extern void *lttng_heap_remove(struct lttng_ptr_heap *heap); /** - * heap_cherrypick - remove a given element from the heap + * lttng_heap_cherrypick - remove a given element from the heap * @heap: the heap to be operated on * @p: the element * @@ -98,10 +98,10 @@ extern void *heap_remove(struct ptr_heap *heap); * return NULL. This algorithm has a complexity of O(n), which is higher than * O(log(n)) provided by the rest of this API. */ -extern void *heap_cherrypick(struct ptr_heap *heap, void *p); +extern void *lttng_heap_cherrypick(struct lttng_ptr_heap *heap, void *p); /** - * heap_replace_max - replace the the largest element from the heap + * lttng_heap_replace_max - replace the the largest element from the heap * @heap: the heap to be operated on * @p: the pointer to be inserted as topmost element replacement * @@ -112,6 +112,6 @@ extern void *heap_cherrypick(struct ptr_heap *heap, void *p); * This is the equivalent of calling heap_remove() and then heap_insert(), but * it only rebalances the heap once. It never allocates memory. */ -extern void *heap_replace_max(struct ptr_heap *heap, void *p); +extern void *lttng_heap_replace_max(struct lttng_ptr_heap *heap, void *p); #endif /* _LTTNG_PRIO_HEAP_H */ diff --git a/lib/ringbuffer/frontend_internal.h b/lib/ringbuffer/frontend_internal.h index 281aafd7..3bd5721e 100644 --- a/lib/ringbuffer/frontend_internal.h +++ b/lib/ringbuffer/frontend_internal.h @@ -19,7 +19,7 @@ #include "../../wrapper/ringbuffer/config.h" #include "../../wrapper/ringbuffer/backend_types.h" #include "../../wrapper/ringbuffer/frontend_types.h" -#include "../../wrapper/prio_heap.h" /* For per-CPU read-side iterator */ +#include "../../lib/prio_heap/lttng_prio_heap.h" /* For per-CPU read-side iterator */ /* Buffer offset macros */ diff --git a/lib/ringbuffer/frontend_types.h b/lib/ringbuffer/frontend_types.h index e8c4c5ce..1a3187e6 100644 --- a/lib/ringbuffer/frontend_types.h +++ b/lib/ringbuffer/frontend_types.h @@ -19,7 +19,7 @@ #include #include "../../wrapper/ringbuffer/config.h" #include "../../wrapper/ringbuffer/backend_types.h" -#include "../../wrapper/prio_heap.h" /* For per-CPU read-side iterator */ +#include "../../lib/prio_heap/lttng_prio_heap.h" /* For per-CPU read-side iterator */ /* * A switch is done during tracing or as a final flush after tracing (so it @@ -30,7 +30,7 @@ enum switch_mode { SWITCH_ACTIVE, SWITCH_FLUSH }; /* channel-level read-side iterator */ struct channel_iter { /* Prio heap of buffers. Lowest timestamps at the top. */ - struct ptr_heap heap; /* Heap of struct lib_ring_buffer ptrs */ + struct lttng_ptr_heap heap; /* Heap of struct lib_ring_buffer ptrs */ struct list_head empty_head; /* Empty buffers linked-list head */ int read_open; /* Opened for reading ? */ u64 last_qs; /* Last quiescent state timestamp */ diff --git a/lib/ringbuffer/ring_buffer_iterator.c b/lib/ringbuffer/ring_buffer_iterator.c index 1e60f2c4..df8d485a 100644 --- a/lib/ringbuffer/ring_buffer_iterator.c +++ b/lib/ringbuffer/ring_buffer_iterator.c @@ -120,7 +120,7 @@ static void lib_ring_buffer_get_empty_buf_records(const struct lib_ring_buffer_config *config, struct channel *chan) { - struct ptr_heap *heap = &chan->iter.heap; + struct lttng_ptr_heap *heap = &chan->iter.heap; struct lib_ring_buffer *buf, *tmp; ssize_t len; @@ -155,7 +155,7 @@ void lib_ring_buffer_get_empty_buf_records(const struct lib_ring_buffer_config * */ CHAN_WARN_ON(chan, len < 0); list_del(&buf->iter.empty_node); - CHAN_WARN_ON(chan, heap_insert(heap, buf)); + CHAN_WARN_ON(chan, lttng_heap_insert(heap, buf)); } } } @@ -227,7 +227,7 @@ ssize_t channel_get_next_record(struct channel *chan, { const struct lib_ring_buffer_config *config = chan->backend.config; struct lib_ring_buffer *buf; - struct ptr_heap *heap; + struct lttng_ptr_heap *heap; ssize_t len; if (config->alloc == RING_BUFFER_ALLOC_GLOBAL) { @@ -240,7 +240,7 @@ ssize_t channel_get_next_record(struct channel *chan, /* * get next record for topmost buffer. */ - buf = heap_maximum(heap); + buf = lttng_heap_maximum(heap); if (buf) { len = lib_ring_buffer_get_next_record(chan, buf); /* @@ -252,7 +252,7 @@ ssize_t channel_get_next_record(struct channel *chan, buf->iter.timestamp = 0; list_add(&buf->iter.empty_node, &chan->iter.empty_head); /* Remove topmost buffer from the heap */ - CHAN_WARN_ON(chan, heap_remove(heap) != buf); + CHAN_WARN_ON(chan, lttng_heap_remove(heap) != buf); break; case -ENODATA: /* @@ -260,7 +260,7 @@ ssize_t channel_get_next_record(struct channel *chan, * don't add to list of empty buffer, because it has no * more data to provide, ever. */ - CHAN_WARN_ON(chan, heap_remove(heap) != buf); + CHAN_WARN_ON(chan, lttng_heap_remove(heap) != buf); break; case -EBUSY: CHAN_WARN_ON(chan, 1); @@ -269,15 +269,15 @@ ssize_t channel_get_next_record(struct channel *chan, /* * Reinsert buffer into the heap. Note that heap can be * partially empty, so we need to use - * heap_replace_max(). + * lttng_heap_replace_max(). */ CHAN_WARN_ON(chan, len < 0); - CHAN_WARN_ON(chan, heap_replace_max(heap, buf) != buf); + CHAN_WARN_ON(chan, lttng_heap_replace_max(heap, buf) != buf); break; } } - buf = heap_maximum(heap); + buf = lttng_heap_maximum(heap); if (!buf || buf->iter.timestamp > chan->iter.last_qs) { /* * Deal with buffers previously showing no data. @@ -287,7 +287,7 @@ ssize_t channel_get_next_record(struct channel *chan, lib_ring_buffer_wait_for_qs(config, chan); } - *ret_buf = buf = heap_maximum(heap); + *ret_buf = buf = lttng_heap_maximum(heap); if (buf) { /* * If this warning triggers, you probably need to check your @@ -376,7 +376,7 @@ int channel_iterator_init(struct channel *chan) int cpu, ret; INIT_LIST_HEAD(&chan->iter.empty_head); - ret = heap_init(&chan->iter.heap, + ret = lttng_heap_init(&chan->iter.heap, num_possible_cpus(), GFP_KERNEL, buf_is_higher); if (ret) @@ -426,7 +426,7 @@ void channel_iterator_free(struct channel *chan) const struct lib_ring_buffer_config *config = chan->backend.config; if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) - heap_free(&chan->iter.heap); + lttng_heap_free(&chan->iter.heap); } int lib_ring_buffer_iterator_open(struct lib_ring_buffer *buf) @@ -514,7 +514,7 @@ void lib_ring_buffer_iterator_reset(struct lib_ring_buffer *buf) lib_ring_buffer_put_next_subbuf(buf); buf->iter.state = ITER_GET_SUBBUF; /* Remove from heap (if present). */ - if (heap_cherrypick(&chan->iter.heap, buf)) + if (lttng_heap_cherrypick(&chan->iter.heap, buf)) list_add(&buf->iter.empty_node, &chan->iter.empty_head); buf->iter.timestamp = 0; buf->iter.header_len = 0; @@ -532,7 +532,7 @@ void channel_iterator_reset(struct channel *chan) int cpu; /* Empty heap, put into empty_head */ - while ((buf = heap_remove(&chan->iter.heap)) != NULL) + while ((buf = lttng_heap_remove(&chan->iter.heap)) != NULL) list_add(&buf->iter.empty_node, &chan->iter.empty_head); for_each_channel_cpu(cpu, chan) { @@ -573,7 +573,7 @@ ssize_t channel_ring_buffer_file_read(struct file *filp, read_offset = *ppos; if (config->alloc == RING_BUFFER_ALLOC_PER_CPU && fusionmerge) - buf = heap_maximum(&chan->iter.heap); + buf = lttng_heap_maximum(&chan->iter.heap); CHAN_WARN_ON(chan, !buf); goto skip_get_next; } diff --git a/wrapper/prio_heap.h b/wrapper/prio_heap.h deleted file mode 100644 index b61f4586..00000000 --- a/wrapper/prio_heap.h +++ /dev/null @@ -1 +0,0 @@ -#include "../lib/prio_heap/prio_heap.h" -- 2.34.1