Module: xenomai-3
Branch: next
Commit: 7e3d69ae6c9235289a8984b609ae2400ab950f17
URL:
http://git.xenomai.org/?p=xenomai-3.git;a=commit;h=7e3d69ae6c9235289a8984b609ae2400ab950f17
Author: Philippe Gerum <r...@xenomai.org>
Date: Thu Jun 14 17:15:04 2018 +0200
boilerplate/shavl: remove private memory references from shared data
The node search and comparison function addresses are process-local in
essence, do not share them.
Since some changes in this recent API were required, the few existing
users were converted to use the new API in the process.
---
include/boilerplate/avl-inner.h | 83 ++++++++++++++++++++++---------------
lib/boilerplate/avl.c | 60 +++++++++++++++------------
lib/boilerplate/heapmem.c | 40 +++++++++++++-----
lib/copperplate/heapobj-pshared.c | 40 +++++++++++++-----
4 files changed, 142 insertions(+), 81 deletions(-)
diff --git a/include/boilerplate/avl-inner.h b/include/boilerplate/avl-inner.h
index ced7715..10c9114 100644
--- a/include/boilerplate/avl-inner.h
+++ b/include/boilerplate/avl-inner.h
@@ -72,10 +72,13 @@ __AVL_T(avl_search_t)(const struct __AVL_T(avl) *,
typedef int __AVL_T(avlh_prn_t)(char *, size_t,
const struct __AVL_T(avlh) *const);
-struct __AVL_T(avl) {
- struct __AVL_T(avlh) anchor;
+struct __AVL_T(avl_searchops) {
__AVL_T(avl_search_t) *search;
__AVL_T(avlh_cmp_t) *cmp;
+};
+
+struct __AVL_T(avl) {
+ struct __AVL_T(avlh) anchor;
union {
ptrdiff_t offset;
struct __AVL_T(avlh) *ptr;
@@ -123,8 +126,6 @@ shavl_set_end(struct shavl *const avl, int dir, struct
shavlh *holder)
avl->end[avl_type2index(dir)].offset = (void *)holder - (void *)avl;
}
-#define shavl_searchfn(avl) ((avl)->search)
-#define shavl_cmp(avl) ((avl)->cmp)
#define shavl_count(avl) ((avl)->count)
#define shavl_height(avl) ((avl)->height)
#define shavl_anchor(avl) (&(avl)->anchor)
@@ -202,8 +203,6 @@ avl_set_end(struct avl *const avl, int dir, struct avlh
*holder)
avl_end(avl, dir) = holder;
}
-#define avl_searchfn(avl) ((avl)->search)
-#define avl_cmp(avl) ((avl)->cmp)
#define avl_count(avl) ((avl)->count)
#define avl_height(avl) ((avl)->height)
#define avl_anchor(avl) (&(avl)->anchor)
@@ -280,9 +279,10 @@ avl_set_end(struct avl *const avl, int dir, struct avlh
*holder)
static inline struct __AVL_T(avlh) *
__AVL(search_inner)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *n, int *delta)
+ const struct __AVL_T(avlh) *n, int *delta,
+ const struct __AVL_T(avl_searchops) *ops)
{
- return __AVL(searchfn)(avl)(avl, n, delta, 0);
+ return ops->search(avl, n, delta, 0);
}
static inline
@@ -371,12 +371,13 @@ static inline void __AVLH(init)(struct __AVL_T(avlh)
*const holder)
static inline struct __AVL_T(avlh) *
__AVL(search)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node)
+ const struct __AVL_T(avlh) *node,
+ const struct __AVL_T(avl_searchops) *ops)
{
struct __AVL_T(avlh) *holder;
int delta;
- holder = __AVL(search_inner)(avl, node, &delta);
+ holder = __AVL(search_inner)(avl, node, &delta, ops);
if (!delta)
return holder;
@@ -385,12 +386,13 @@ __AVL(search)(const struct __AVL_T(avl) *const avl,
static inline struct __AVL_T(avlh) *
__AVL(search_nearest)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node, int dir)
+ const struct __AVL_T(avlh) *node, int dir,
+ const struct __AVL_T(avl_searchops) *ops)
{
struct __AVL_T(avlh) *holder;
int delta;
- holder = __AVL(search_inner)(avl, node, &delta);
+ holder = __AVL(search_inner)(avl, node, &delta, ops);
if (!holder || delta != dir)
return holder;
@@ -399,26 +401,29 @@ __AVL(search_nearest)(const struct __AVL_T(avl) *const
avl,
static inline struct __AVL_T(avlh) *
__AVL(search_le)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node)
+ const struct __AVL_T(avlh) *node,
+ const struct __AVL_T(avl_searchops) *ops)
{
- return __AVL(search_nearest)(avl, node, AVL_LEFT);
+ return __AVL(search_nearest)(avl, node, AVL_LEFT, ops);
}
static inline struct __AVL_T(avlh) *
__AVL(search_ge)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node)
+ const struct __AVL_T(avlh) *node,
+ const struct __AVL_T(avl_searchops) *ops)
{
- return __AVL(search_nearest)(avl, node, AVL_RIGHT);
+ return __AVL(search_nearest)(avl, node, AVL_RIGHT, ops);
}
static inline struct __AVL_T(avlh) *
__AVL(search_multi)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node, int dir)
+ const struct __AVL_T(avlh) *node, int dir,
+ const struct __AVL_T(avl_searchops) *ops)
{
struct __AVL_T(avlh) *holder;
int delta;
- holder = __AVL(searchfn)(avl)(avl, node, &delta, dir);
+ holder = ops->search(avl, node, &delta, dir);
if (!delta)
return holder;
@@ -430,63 +435,73 @@ __AVL(search_multi)(const struct __AVL_T(avl) *const avl,
static inline struct __AVL_T(avlh) *
__AVL(search_first)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node)
+ const struct __AVL_T(avlh) *node,
+ const struct __AVL_T(avl_searchops) *ops)
{
- return __AVL(search_multi)(avl, node, AVL_LEFT);
+ return __AVL(search_multi)(avl, node, AVL_LEFT, ops);
}
static inline struct __AVL_T(avlh) *
__AVL(search_last)(const struct __AVL_T(avl) *const avl,
- const struct __AVL_T(avlh) *node)
+ const struct __AVL_T(avlh) *node,
+ const struct __AVL_T(avl_searchops) *ops)
{
- return __AVL(search_multi)(avl, node, AVL_RIGHT);
+ return __AVL(search_multi)(avl, node, AVL_RIGHT, ops);
}
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
-void __AVL(init)(struct __AVL_T(avl) *const avl,
- __AVL_T(avl_search_t) *searchfn, __AVL_T(avlh_cmp_t) *cmp);
+void __AVL(init)(struct __AVL_T(avl) *const avl);
void __AVL(destroy)(struct __AVL_T(avl) *const avl);
int __AVL(insert)(struct __AVL_T(avl) *const avl,
- struct __AVL_T(avlh) *const holder);
+ struct __AVL_T(avlh) *const holder,
+ const struct __AVL_T(avl_searchops) *ops);
int __AVL(insert_front)(struct __AVL_T(avl) *avl,
- struct __AVL_T(avlh) *holder);
+ struct __AVL_T(avlh) *holder,
+ const struct __AVL_T(avl_searchops) *ops);
int __AVL(insert_back)(struct __AVL_T(avl) *avl,
- struct __AVL_T(avlh) *holder);
+ struct __AVL_T(avlh) *holder,
+ const struct __AVL_T(avl_searchops) *ops);
int __AVL(insert_at)(struct __AVL_T(avl) *const avl,
- struct __AVL_T(avlh) *parent, int dir,
+ struct __AVL_T(avlh) *parent, int dir,
struct __AVL_T(avlh) *child);
int __AVL(prepend)(struct __AVL_T(avl) *const avl,
- struct __AVL_T(avlh) *const holder);
+ struct __AVL_T(avlh) *const holder,
+ const struct __AVL_T(avl_searchops) *ops);
int __AVL(append)(struct __AVL_T(avl) *const avl,
- struct __AVL_T(avlh) *const holder);
+ struct __AVL_T(avlh) *const holder,
+ const struct __AVL_T(avl_searchops) *ops);
int __AVL(delete)(struct __AVL_T(avl) *const avl,
struct __AVL_T(avlh) *node);
int __AVL(replace)(struct __AVL_T(avl) *avl,
struct __AVL_T(avlh) *oldh,
- struct __AVL_T(avlh) *newh);
+ struct __AVL_T(avlh) *newh,
+ const struct __AVL_T(avl_searchops) *ops);
struct __AVL_T(avlh) *__AVL(update)(struct __AVL_T(avl) *const avl,
- struct __AVL_T(avlh) *const holder);
+ struct __AVL_T(avlh) *const holder,
+ const struct __AVL_T(avl_searchops) *ops);
struct __AVL_T(avlh) *__AVL(set)(struct __AVL_T(avl) *const avl,
- struct __AVL_T(avlh) *const holder);
+ struct __AVL_T(avlh) *const holder,
+ const struct __AVL_T(avl_searchops) *ops);
void __AVL(clear)(struct __AVL_T(avl) *const avl,
void (*destruct)(struct __AVL_T(avlh) *));
-int __AVL(check)(const struct __AVL_T(avl) *avl);
+int __AVL(check)(const struct __AVL_T(avl) *avl,
+ const struct __AVL_T(avl_searchops) *ops);
void __AVL(dump)(FILE *file, const struct __AVL_T(avl) *const avl,
__AVL_T(avlh_prn_t) *prn, unsigned int indent,
diff --git a/lib/boilerplate/avl.c b/lib/boilerplate/avl.c
index 6f05517..3bf9bf1 100644
--- a/lib/boilerplate/avl.c
+++ b/lib/boilerplate/avl.c
@@ -459,12 +459,13 @@ static int avl_delete_2children(struct __AVL_T (avl) *
const avl,
}
int __AVL(prepend)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
struct __AVL_T (avlh) * const parent = __AVL(head)(avl);
int type = parent == NULL ? AVL_RIGHT : AVL_LEFT;
- if (parent == NULL || __AVL(cmp)(avl)(holder, parent) < 0) {
+ if (parent == NULL || ops->cmp(holder, parent) < 0) {
avl_insert_inner(avl, parent, holder, type);
return 0;
}
@@ -488,12 +489,13 @@ int __AVL(insert_at)(struct __AVL_T(avl) * const avl,
}
int __AVL(insert)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
int delta;
struct __AVL_T (avlh) * parent;
- parent = __AVL(search_inner)(avl, holder, &delta);
+ parent = __AVL(search_inner)(avl, holder, &delta, ops);
if (delta == 0)
return -EBUSY;
@@ -503,35 +505,38 @@ int __AVL(insert)(struct __AVL_T(avl) * const avl,
}
int __AVL(insert_front)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
int delta;
struct __AVL_T (avlh) * parent;
- parent = __AVL(searchfn)(avl)(avl, holder, &delta, AVL_LEFT);
+ parent = ops->search(avl, holder, &delta, AVL_LEFT);
avl_insert_inner(avl, parent, holder, delta ? : AVL_LEFT);
return 0;
}
int __AVL(insert_back)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
int delta;
struct __AVL_T (avlh) * parent;
- parent = __AVL(searchfn)(avl)(avl, holder, &delta, AVL_RIGHT);
+ parent = ops->search(avl, holder, &delta, AVL_RIGHT);
avl_insert_inner(avl, parent, holder, delta ? : AVL_RIGHT);
return 0;
}
int __AVL(append)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
struct __AVL_T (avlh) * const parent = __AVL(tail)(avl);
- if (parent == NULL || __AVL(cmp)(avl)(holder, parent) > 0) {
+ if (parent == NULL || ops->cmp(holder, parent) > 0) {
avl_insert_inner(avl, parent, holder, AVL_RIGHT);
return 0;
}
@@ -544,15 +549,16 @@ int __AVL(append)(struct __AVL_T(avl) * const avl,
* the avl, much faster than remove + add
*/
int __AVL(replace)(struct __AVL_T(avl) * avl, struct __AVL_T(avlh) * oldh,
- struct __AVL_T(avlh) * newh)
+ struct __AVL_T(avlh) * newh,
+ const struct __AVL_T(avl_searchops) * ops)
{
struct __AVL_T (avlh) * prev, *next;
prev = __AVL(prev)(avl, oldh);
next = __AVL(next)(avl, oldh);
- if ((prev && __AVL(cmp)(avl)(newh, prev) < 0)
- || (next && __AVL(cmp)(avl)(newh, next) > 0))
+ if ((prev && ops->cmp(newh, prev) < 0)
+ || (next && ops->cmp(newh, next) > 0))
return -EINVAL;
avlh_replace(avl, oldh, newh);
@@ -565,14 +571,15 @@ int __AVL(replace)(struct __AVL_T(avl) * avl, struct
__AVL_T(avlh) * oldh,
}
struct __AVL_T (avlh) * __AVL(update)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
int delta;
struct __AVL_T (avlh) * const oldh =
- __AVL(search_inner)(avl, holder, &delta);
+ __AVL(search_inner)(avl, holder, &delta, ops);
if (!delta) {
- __AVL(replace)(avl, oldh, holder);
+ __AVL(replace)(avl, oldh, holder, ops);
return oldh;
}
@@ -580,29 +587,27 @@ struct __AVL_T (avlh) * __AVL(update)(struct __AVL_T(avl)
* const avl,
}
struct __AVL_T (avlh) * __AVL(set)(struct __AVL_T(avl) * const avl,
- struct __AVL_T(avlh) * const holder)
+ struct __AVL_T(avlh) * const holder,
+ const struct __AVL_T(avl_searchops) * ops)
{
int delta;
struct __AVL_T (avlh) * const oldh =
- __AVL(search_inner)(avl, holder, &delta);
+ __AVL(search_inner)(avl, holder, &delta, ops);
if (delta) {
avl_insert_inner(avl, oldh, holder, delta);
return NULL;
}
- __AVL(replace)(avl, oldh, holder);
+ __AVL(replace)(avl, oldh, holder, ops);
return oldh;
}
-void __AVL(init)(struct __AVL_T(avl) * const avl,
- __AVL_T(avl_search_t) * searchfn, __AVL_T(avlh_cmp_t) * cmp)
+void __AVL(init)(struct __AVL_T(avl) * const avl)
{
__AVLH(init)(__AVL(anchor)(avl)); /* this must be first. */
- __AVL(cmp)(avl) = cmp;
__AVL(height)(avl) = 0;
__AVL(count)(avl) = 0;
- __AVL(searchfn)(avl) = searchfn;
avl_set_top(avl, NULL);
avl_set_head(avl, NULL);
@@ -611,7 +616,7 @@ void __AVL(init)(struct __AVL_T(avl) * const avl,
void __AVL(destroy)(struct __AVL_T(avl) * const avl)
{
- __AVL(init)(avl, NULL, NULL);
+ __AVL(init)(avl);
}
void __AVL(clear)(struct __AVL_T(avl) * const avl,
@@ -627,7 +632,7 @@ void __AVL(clear)(struct __AVL_T(avl) * const avl,
}
}
- __AVL(init)(avl, NULL, NULL);
+ __AVL(init)(avl);
}
static inline
@@ -745,7 +750,8 @@ check_balance:
return 0;
}
-int __AVL(check)(const struct __AVL_T(avl) * avl)
+int __AVL(check)(const struct __AVL_T(avl) * avl,
+ const struct __AVL_T(avl_searchops) * ops)
{
struct __AVL_T (avlh) * holder = __AVL(gettop)(avl), *last;
int err;
@@ -761,7 +767,7 @@ int __AVL(check)(const struct __AVL_T(avl) * avl)
for (holder = __AVL(gethead)(avl); holder;
holder = __AVL(next)(avl, holder)) {
if (last != NULL)
- if (__AVL(cmp)(avl)(holder, last) < 0) {
+ if (ops->cmp(holder, last) < 0) {
fprintf(stderr, "disordered nodes\n");
return -EINVAL;
}
diff --git a/lib/boilerplate/heapmem.c b/lib/boilerplate/heapmem.c
index 5097d1c..9b5e1a6 100644
--- a/lib/boilerplate/heapmem.c
+++ b/lib/boilerplate/heapmem.c
@@ -40,6 +40,9 @@ enum heapmem_pgtype {
page_list =2
};
+static struct avl_searchops size_search_ops;
+static struct avl_searchops addr_search_ops;
+
static inline uint32_t __attribute__ ((always_inline))
gen_block_mask(int log2size)
{
@@ -148,7 +151,8 @@ find_suitable_range(struct heapmem_extent *ext, size_t size)
struct avlh *node;
lookup.size = size;
- node = avl_search_ge(&ext->size_tree, &lookup.size_node);
+ node = avl_search_ge(&ext->size_tree, &lookup.size_node,
+ &size_search_ops);
if (node == NULL)
return NULL;
@@ -179,7 +183,8 @@ static int reserve_page_range(struct heapmem_extent *ext,
size_t size)
splitr->size -= size;
new = (struct heapmem_range *)((void *)new + splitr->size);
avlh_init(&splitr->size_node);
- avl_insert_back(&ext->size_tree, &splitr->size_node);
+ avl_insert_back(&ext->size_tree, &splitr->size_node,
+ &size_search_ops);
return addr_to_pagenr(ext, new);
}
@@ -189,7 +194,8 @@ find_left_neighbour(struct heapmem_extent *ext, struct
heapmem_range *r)
{
struct avlh *node;
- node = avl_search_le(&ext->addr_tree, &r->addr_node);
+ node = avl_search_le(&ext->addr_tree, &r->addr_node,
+ &addr_search_ops);
if (node == NULL)
return NULL;
@@ -201,7 +207,8 @@ find_right_neighbour(struct heapmem_extent *ext, struct
heapmem_range *r)
{
struct avlh *node;
- node = avl_search_ge(&ext->addr_tree, &r->addr_node);
+ node = avl_search_ge(&ext->addr_tree, &r->addr_node,
+ &addr_search_ops);
if (node == NULL)
return NULL;
@@ -251,17 +258,20 @@ static void release_page_range(struct heapmem_extent *ext,
avl_delete(&ext->addr_tree, &right->addr_node);
else
avl_replace(&ext->addr_tree, &right->addr_node,
- &freed->addr_node);
+ &freed->addr_node, &addr_search_ops);
} else if (!addr_linked) {
avlh_init(&freed->addr_node);
if (left)
- avl_insert(&ext->addr_tree, &freed->addr_node);
+ avl_insert(&ext->addr_tree, &freed->addr_node,
+ &addr_search_ops);
else
- avl_prepend(&ext->addr_tree, &freed->addr_node);
+ avl_prepend(&ext->addr_tree, &freed->addr_node,
+ &addr_search_ops);
}
avlh_init(&freed->size_node);
- avl_insert_back(&ext->size_tree, &freed->size_node);
+ avl_insert_back(&ext->size_tree, &freed->size_node,
+ &size_search_ops);
mark_pages(ext, addr_to_pagenr(ext, page),
size >> HEAPMEM_PAGE_SHIFT, page_free);
}
@@ -575,6 +585,11 @@ static inline int compare_range_by_size(const struct avlh
*l, const struct avlh
}
static DECLARE_AVL_SEARCH(search_range_by_size, compare_range_by_size);
+static struct avl_searchops size_search_ops = {
+ .search = search_range_by_size,
+ .cmp = compare_range_by_size,
+};
+
static inline int compare_range_by_addr(const struct avlh *l, const struct
avlh *r)
{
uintptr_t al = (uintptr_t)l, ar = (uintptr_t)r;
@@ -583,6 +598,11 @@ static inline int compare_range_by_addr(const struct avlh
*l, const struct avlh
}
static DECLARE_AVL_SEARCH(search_range_by_addr, compare_range_by_addr);
+static struct avl_searchops addr_search_ops = {
+ .search = search_range_by_addr,
+ .cmp = compare_range_by_addr,
+};
+
static int add_extent(struct heap_memory *heap, void *mem, size_t size)
{
size_t user_size, overhead;
@@ -651,8 +671,8 @@ static int add_extent(struct heap_memory *heap, void *mem,
size_t size)
* extent. Over time, that range will be split then possibly
* re-merged back as allocations and deallocations take place.
*/
- avl_init(&ext->size_tree, search_range_by_size, compare_range_by_size);
- avl_init(&ext->addr_tree, search_range_by_addr, compare_range_by_addr);
+ avl_init(&ext->size_tree);
+ avl_init(&ext->addr_tree);
release_page_range(ext, ext->membase, user_size);
write_lock_safe(&heap->lock, state);
diff --git a/lib/copperplate/heapobj-pshared.c
b/lib/copperplate/heapobj-pshared.c
index 276e6db..77b4584 100644
--- a/lib/copperplate/heapobj-pshared.c
+++ b/lib/copperplate/heapobj-pshared.c
@@ -52,6 +52,9 @@ enum sheapmem_pgtype {
page_list =2
};
+static struct shavl_searchops size_search_ops;
+static struct shavl_searchops addr_search_ops;
+
/*
* The main heap consists of a shared heap at its core, with
* additional session-wide information.
@@ -201,7 +204,8 @@ find_suitable_range(struct sheapmem_extent *ext, size_t
size)
struct shavlh *node;
lookup.size = size;
- node = shavl_search_ge(&ext->size_tree, &lookup.size_node);
+ node = shavl_search_ge(&ext->size_tree, &lookup.size_node,
+ &size_search_ops);
if (node == NULL)
return NULL;
@@ -232,7 +236,8 @@ static int reserve_page_range(struct sheapmem_extent *ext,
size_t size)
splitr->size -= size;
new = (struct sheapmem_range *)((void *)new + splitr->size);
shavlh_init(&splitr->size_node);
- shavl_insert_back(&ext->size_tree, &splitr->size_node);
+ shavl_insert_back(&ext->size_tree, &splitr->size_node,
+ &size_search_ops);
return addr_to_pagenr(ext, new);
}
@@ -242,7 +247,8 @@ find_left_neighbour(struct sheapmem_extent *ext, struct
sheapmem_range *r)
{
struct shavlh *node;
- node = shavl_search_le(&ext->addr_tree, &r->addr_node);
+ node = shavl_search_le(&ext->addr_tree, &r->addr_node,
+ &addr_search_ops);
if (node == NULL)
return NULL;
@@ -254,7 +260,8 @@ find_right_neighbour(struct sheapmem_extent *ext, struct
sheapmem_range *r)
{
struct shavlh *node;
- node = shavl_search_ge(&ext->addr_tree, &r->addr_node);
+ node = shavl_search_ge(&ext->addr_tree, &r->addr_node,
+ &addr_search_ops);
if (node == NULL)
return NULL;
@@ -304,17 +311,20 @@ static void release_page_range(struct sheapmem_extent
*ext,
shavl_delete(&ext->addr_tree, &right->addr_node);
else
shavl_replace(&ext->addr_tree, &right->addr_node,
- &freed->addr_node);
+ &freed->addr_node, &addr_search_ops);
} else if (!addr_linked) {
shavlh_init(&freed->addr_node);
if (left)
- shavl_insert(&ext->addr_tree, &freed->addr_node);
+ shavl_insert(&ext->addr_tree, &freed->addr_node,
+ &addr_search_ops);
else
- shavl_prepend(&ext->addr_tree, &freed->addr_node);
+ shavl_prepend(&ext->addr_tree, &freed->addr_node,
+ &addr_search_ops);
}
shavlh_init(&freed->size_node);
- shavl_insert_back(&ext->size_tree, &freed->size_node);
+ shavl_insert_back(&ext->size_tree, &freed->size_node,
+ &size_search_ops);
mark_pages(ext, addr_to_pagenr(ext, page),
size >> SHEAPMEM_PAGE_SHIFT, page_free);
}
@@ -629,6 +639,11 @@ static inline int compare_range_by_size(const struct
shavlh *l, const struct sha
}
static DECLARE_SHAVL_SEARCH(search_range_by_size, compare_range_by_size);
+static struct shavl_searchops size_search_ops = {
+ .search = search_range_by_size,
+ .cmp = compare_range_by_size,
+};
+
static inline int compare_range_by_addr(const struct shavlh *l, const struct
shavlh *r)
{
uintptr_t al = (uintptr_t)l, ar = (uintptr_t)r;
@@ -637,6 +652,11 @@ static inline int compare_range_by_addr(const struct
shavlh *l, const struct sha
}
static DECLARE_SHAVL_SEARCH(search_range_by_addr, compare_range_by_addr);
+static struct shavl_searchops addr_search_ops = {
+ .search = search_range_by_addr,
+ .cmp = compare_range_by_addr,
+};
+
static int add_extent(struct shared_heap_memory *heap, void *base,
void *mem, size_t size)
{
@@ -707,8 +727,8 @@ static int add_extent(struct shared_heap_memory *heap, void
*base,
* extent. Over time, that range will be split then possibly
* re-merged back as allocations and deallocations take place.
*/
- shavl_init(&ext->size_tree, search_range_by_size,
compare_range_by_size);
- shavl_init(&ext->addr_tree, search_range_by_addr,
compare_range_by_addr);
+ shavl_init(&ext->size_tree);
+ shavl_init(&ext->addr_tree);
release_page_range(ext, __shref(base, ext->membase), user_size);
write_lock_safe(&heap->lock, state);
_______________________________________________
Xenomai-git mailing list
Xenomai-git@xenomai.org
https://xenomai.org/mailman/listinfo/xenomai-git
