From: Benjamin Gaignard <benjamin.gaignard@linaro.org>
To: linux-kernel@vger.kernel.org, akpm@linux-foundation.org,
ying.huang@intel.com
Cc: Benjamin Gaignard <benjamin.gaignard@stericsson.com>
Subject: [PATCH] genalloc: make possible to use a custom allocation algorithm
Date: Fri, 7 Sep 2012 11:16:33 +0200 [thread overview]
Message-ID: <1347009393-8751-1-git-send-email-benjamin.gaignard@stericsson.com> (raw)
In-Reply-To: <[PATCH] genalloc: add best fit algorithm>
From: Benjamin Gaignard <benjamin.gaignard@stericsson.com>
This patch allow to use another algorithm than the default first-fit one.
For example a custom algorithm could be used to manage alignment requirements.
Add of best-fit algorithm function:
most of the time best-fit is slower then first-fit but memory fragmentation is lower.
Random buffer allocation/free tests don't show any arithmetic relation between
allocation time and fragmentation but best-fit algorithm is sometime able to perform the allocation when first-fit can't.
This new algorithm help to solve fragmentation issues on ESRAM shared by multiple
hardware IP allocating and freeing dynamically memory region of various sizes.
Signed-off-by: Benjamin Gaignard <benjamin.gaignard@stericsson.com>
---
include/linux/genalloc.h | 15 ++++++++
lib/genalloc.c | 86 +++++++++++++++++++++++++++++++++++++++++++---
2 files changed, 97 insertions(+), 4 deletions(-)
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 5e98eeb..b8570a7 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -36,6 +36,10 @@ struct gen_pool {
spinlock_t lock;
struct list_head chunks; /* list of chunks in this pool */
int min_alloc_order; /* minimum allocation order */
+
+ unsigned long (*algo)(unsigned long *, unsigned long,
+ unsigned long, unsigned int, void *);
+ void *data;
};
/*
@@ -78,4 +82,15 @@ extern void gen_pool_for_each_chunk(struct gen_pool *,
void (*)(struct gen_pool *, struct gen_pool_chunk *, void *), void *);
extern size_t gen_pool_avail(struct gen_pool *);
extern size_t gen_pool_size(struct gen_pool *);
+
+extern void gen_pool_set_algo(struct gen_pool *,
+ unsigned long (*)(unsigned long *, unsigned long, unsigned long,
+ unsigned int, void *), void *);
+
+extern unsigned long gen_pool_first_fit(unsigned long *, unsigned long,
+ unsigned long, unsigned int, void *);
+
+extern unsigned long gen_pool_best_fit(unsigned long *, unsigned long,
+ unsigned long, unsigned int, void *);
+
#endif /* __GENALLOC_H__ */
diff --git a/lib/genalloc.c b/lib/genalloc.c
index 6bc04aa..a0d73c8 100644
--- a/lib/genalloc.c
+++ b/lib/genalloc.c
@@ -152,6 +152,8 @@ struct gen_pool *gen_pool_create(int min_alloc_order, int nid)
spin_lock_init(&pool->lock);
INIT_LIST_HEAD(&pool->chunks);
pool->min_alloc_order = min_alloc_order;
+ pool->algo = gen_pool_first_fit;
+ pool->data = NULL;
}
return pool;
}
@@ -255,8 +257,9 @@ EXPORT_SYMBOL(gen_pool_destroy);
* @size: number of bytes to allocate from the pool
*
* Allocate the requested number of bytes from the specified pool.
- * Uses a first-fit algorithm. Can not be used in NMI handler on
- * architectures without NMI-safe cmpxchg implementation.
+ * Uses the pool allocation function (with first-fit algorithm by default).
+ * Can not be used in NMI handler on architectures without
+ * NMI-safe cmpxchg implementation.
*/
unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
{
@@ -280,8 +283,8 @@ unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
end_bit = (chunk->end_addr - chunk->start_addr) >> order;
retry:
- start_bit = bitmap_find_next_zero_area(chunk->bits, end_bit,
- start_bit, nbits, 0);
+ start_bit = pool->algo(chunk->bits, end_bit, start_bit, nbits,
+ pool->data);
if (start_bit >= end_bit)
continue;
remain = bitmap_set_ll(chunk->bits, start_bit, nbits);
@@ -400,3 +403,78 @@ size_t gen_pool_size(struct gen_pool *pool)
return size;
}
EXPORT_SYMBOL_GPL(gen_pool_size);
+
+/**
+ * gen_pool_set_algo - set the allocation algorithm
+ * @pool: pool to change allocation algorithm
+ * @priv: private data to be pass to algorithm function
+ * @algo: custom algorithm function
+ */
+void gen_pool_set_algo(struct gen_pool *pool,
+ unsigned long (*algo)(unsigned long *map, unsigned long size,
+ unsigned long start, unsigned int nr, void *data), void *data)
+{
+ rcu_read_lock();
+
+ pool->algo = algo;
+ if (!pool->algo)
+ pool->algo = gen_pool_first_fit;
+
+ pool->data = data;
+
+ rcu_read_unlock();
+}
+EXPORT_SYMBOL(gen_pool_set_algo);
+
+/**
+ * gen_pool_first_fit - find the first available region
+ * of memory macthing the size requirement (no alignment constraint)
+ * @map: The address to base the search on
+ * @size: The bitmap size in bits
+ * @start: The bitnumber to start searching at
+ * @nr: The number of zeroed bits we're looking for
+ * @data: additional data - unused
+ */
+unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size,
+ unsigned long start, unsigned int nr, void *data)
+{
+ return bitmap_find_next_zero_area(map, size, start, nr, 0);
+}
+EXPORT_SYMBOL(gen_pool_first_fit);
+
+/**
+ * gen_pool_best_fit - find the best fiting region of memory
+ * macthing the size requirement (no alignment constraint)
+ * @map: The address to base the search on
+ * @size: The bitmap size in bits
+ * @start: The bitnumber to start searching at
+ * @nr: The number of zeroed bits we're looking for
+ * @data: additional data - unused
+ *
+ * Iterate over the bitmap to find the smaller region where
+ * allocate the memory.
+ */
+unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
+ unsigned long start, unsigned int nr, void *data)
+{
+ unsigned long start_bit = size;
+ unsigned long len = size + 1;
+ unsigned long index;
+
+ index = bitmap_find_next_zero_area(map, size, start, nr, 0);
+
+ while (index < size) {
+ int next_bit = find_next_bit(map, size, index + nr);
+ if ((next_bit - index) < len) {
+ len = next_bit - index;
+ start_bit = index;
+ if (len == nr)
+ return start_bit;
+ }
+ index = bitmap_find_next_zero_area(map, size,
+ next_bit + 1, nr, 0);
+ }
+
+ return start_bit;
+}
+EXPORT_SYMBOL(gen_pool_best_fit);
--
1.7.10
next parent reply other threads:[~2012-09-07 9:19 UTC|newest]
Thread overview: 9+ messages / expand[flat|nested] mbox.gz Atom feed top
[not found] <[PATCH] genalloc: add best fit algorithm>
2012-09-07 9:16 ` Benjamin Gaignard [this message]
2012-09-07 21:22 ` [PATCH] genalloc: make possible to use a custom allocation algorithm Linus Walleij
2012-09-07 21:27 ` Andrew Morton
2012-09-07 22:20 ` Linus Walleij
2012-09-10 1:34 ` Huang Ying
2012-09-10 7:56 ` Benjamin Gaignard
2012-09-10 8:46 ` Benjamin Gaignard
2012-09-12 18:47 ` Andrew Morton
2012-09-13 12:14 ` Benjamin Gaignard
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1347009393-8751-1-git-send-email-benjamin.gaignard@stericsson.com \
--to=benjamin.gaignard@linaro.org \
--cc=akpm@linux-foundation.org \
--cc=benjamin.gaignard@stericsson.com \
--cc=linux-kernel@vger.kernel.org \
--cc=ying.huang@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).